Aegisub/src/ass_file.cpp

356 lines
10 KiB
C++
Raw Permalink Normal View History

// Copyright (c) 2014, Thomas Goyne <plorkyeran@aegisub.org>
2006-01-16 22:02:54 +01:00
//
// Permission to use, copy, modify, and distribute this software for any
// purpose with or without fee is hereby granted, provided that the above
// copyright notice and this permission notice appear in all copies.
2006-01-16 22:02:54 +01:00
//
// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
2006-01-16 22:02:54 +01:00
//
// Aegisub Project http://www.aegisub.org/
#include "ass_file.h"
#include "ass_attachment.h"
#include "ass_dialogue.h"
#include "ass_info.h"
#include "ass_style.h"
#include "ass_style_storage.h"
#include "options.h"
#include <algorithm>
#include <boost/algorithm/string/case_conv.hpp>
#include <boost/algorithm/string/predicate.hpp>
#include <boost/filesystem/path.hpp>
#include <cassert>
2014-09-06 18:16:44 +02:00
#include <unordered_map>
#include <unordered_set>
AssFile::AssFile() { }
2006-01-16 22:02:54 +01:00
AssFile::~AssFile() {
Styles.clear_and_dispose([](AssStyle *e) { delete e; });
Events.clear_and_dispose([](AssDialogue *e) { delete e; });
2006-01-16 22:02:54 +01:00
}
void AssFile::LoadDefault(bool include_dialogue_line, std::string const& style_catalog) {
2014-03-08 01:16:38 +01:00
Info.emplace_back("Title", "Default Aegisub file");
Info.emplace_back("ScriptType", "v4.00+");
Info.emplace_back("WrapStyle", "0");
Info.emplace_back("ScaledBorderAndShadow", "yes");
if (!OPT_GET("Subtitle/Default Resolution/Auto")->GetBool()) {
2014-03-08 01:16:38 +01:00
Info.emplace_back("PlayResX", std::to_string(OPT_GET("Subtitle/Default Resolution/Width")->GetInt()));
Info.emplace_back("PlayResY", std::to_string(OPT_GET("Subtitle/Default Resolution/Height")->GetInt()));
2006-01-16 22:02:54 +01:00
}
2014-03-08 01:16:38 +01:00
Info.emplace_back("YCbCr Matrix", "None");
// Add default style
Styles.push_back(*new AssStyle);
// Add/replace any catalog styles requested
if (AssStyleStorage::CatalogExists(style_catalog)) {
AssStyleStorage catalog;
catalog.LoadCatalog(style_catalog);
catalog.ReplaceIntoFile(*this);
}
if (include_dialogue_line)
Events.push_back(*new AssDialogue);
2006-01-16 22:02:54 +01:00
}
2014-03-08 01:16:38 +01:00
AssFile::AssFile(const AssFile &from)
: Info(from.Info)
2014-03-08 02:13:23 +01:00
, Attachments(from.Attachments)
, Extradata(from.Extradata)
, next_extradata_id(from.next_extradata_id)
2014-03-08 01:16:38 +01:00
{
2014-03-08 01:44:49 +01:00
Styles.clone_from(from.Styles,
[](AssStyle const& e) { return new AssStyle(e); },
[](AssStyle *e) { delete e; });
Events.clone_from(from.Events,
[](AssDialogue const& e) { return new AssDialogue(e); },
[](AssDialogue *e) { delete e; });
}
void AssFile::swap(AssFile& from) throw() {
Info.swap(from.Info);
Styles.swap(from.Styles);
Events.swap(from.Events);
Attachments.swap(from.Attachments);
Extradata.swap(from.Extradata);
std::swap(Properties, from.Properties);
std::swap(next_extradata_id, from.next_extradata_id);
}
2013-10-27 15:15:39 +01:00
AssFile& AssFile::operator=(AssFile from) {
swap(from);
return *this;
2006-01-16 22:02:54 +01:00
}
EntryList<AssDialogue>::iterator AssFile::iterator_to(AssDialogue& line) {
using l = EntryList<AssDialogue>;
bool in_list = !l::node_algorithms::inited(l::value_traits::to_node_ptr(line));
return in_list ? Events.iterator_to(line) : Events.end();
}
void AssFile::InsertAttachment(agi::fs::path const& filename) {
2013-06-13 00:54:19 +02:00
AssEntryGroup group = AssEntryGroup::GRAPHIC;
auto ext = boost::to_lower_copy(filename.extension().string());
if (ext == ".ttf" || ext == ".ttc" || ext == ".pfb")
2013-06-13 00:54:19 +02:00
group = AssEntryGroup::FONT;
2014-03-08 02:13:23 +01:00
Attachments.emplace_back(filename, group);
}
std::string AssFile::GetScriptInfo(std::string const& key) const {
for (auto const& info : Info) {
if (boost::iequals(key, info.Key()))
return info.Value();
2006-01-16 22:02:54 +01:00
}
return "";
2006-01-16 22:02:54 +01:00
}
int AssFile::GetScriptInfoAsInt(std::string const& key) const {
return atoi(GetScriptInfo(key).c_str());
2006-01-16 22:02:54 +01:00
}
void AssFile::SetScriptInfo(std::string const& key, std::string const& value) {
2014-03-08 01:16:38 +01:00
for (auto it = Info.begin(); it != Info.end(); ++it) {
if (boost::iequals(key, it->Key())) {
if (value.empty())
2014-03-08 01:16:38 +01:00
Info.erase(it);
else
2014-03-08 01:16:38 +01:00
it->SetValue(value);
2006-01-16 22:02:54 +01:00
return;
}
}
if (!value.empty())
2014-03-08 01:16:38 +01:00
Info.emplace_back(key, value);
2006-01-16 22:02:54 +01:00
}
void AssFile::GetResolution(int &sw, int &sh) const {
sw = GetScriptInfoAsInt("PlayResX");
sh = GetScriptInfoAsInt("PlayResY");
// Gabest logic: default is 384x288, assume 1280x1024 if either height or
// width are that, otherwise assume 4:3 if only heigh or width are set.
// Why 1280x1024? Who the fuck knows. Clearly just Gabest trolling everyone.
if (sw == 0 && sh == 0) {
sw = 384;
sh = 288;
}
else if (sw == 0)
sw = sh == 1024 ? 1280 : sh * 4 / 3;
else if (sh == 0)
sh = sw == 1280 ? 1024 : sw * 3 / 4;
}
2012-12-30 01:32:36 +01:00
std::vector<std::string> AssFile::GetStyles() const {
std::vector<std::string> styles;
for (auto& style : Styles)
styles.push_back(style.name);
2006-01-16 22:02:54 +01:00
return styles;
}
2012-12-30 01:32:36 +01:00
AssStyle *AssFile::GetStyle(std::string const& name) {
for (auto& style : Styles) {
if (boost::iequals(style.name, name))
return &style;
2006-01-16 22:02:54 +01:00
}
return nullptr;
2006-01-16 22:02:54 +01:00
}
int AssFile::Commit(wxString const& desc, int type, int amend_id, AssDialogue *single_line) {
if (type == COMMIT_NEW || (type & COMMIT_DIAG_ADDREM) || (type & COMMIT_ORDER)) {
int i = 0;
for (auto& event : Events)
event.Row = i++;
}
AnnouncePreCommit(type, single_line);
PushState({desc, &amend_id, single_line});
2006-01-16 22:02:54 +01:00
AnnounceCommit(type, single_line);
2006-01-16 22:02:54 +01:00
return amend_id;
}
2007-01-26 01:47:42 +01:00
bool AssFile::CompStart(AssDialogue const& lft, AssDialogue const& rgt) {
return lft.Start < rgt.Start;
}
bool AssFile::CompEnd(AssDialogue const& lft, AssDialogue const& rgt) {
return lft.End < rgt.End;
}
bool AssFile::CompStyle(AssDialogue const& lft, AssDialogue const& rgt) {
return lft.Style < rgt.Style;
2007-01-26 01:47:42 +01:00
}
bool AssFile::CompActor(AssDialogue const& lft, AssDialogue const& rgt) {
return lft.Actor < rgt.Actor;
}
bool AssFile::CompEffect(AssDialogue const& lft, AssDialogue const& rgt) {
return lft.Effect < rgt.Effect;
}
bool AssFile::CompLayer(AssDialogue const& lft, AssDialogue const& rgt) {
return lft.Layer < rgt.Layer;
}
2022-08-23 16:11:23 +02:00
bool AssFile::CompText(AssDialogue const& lft, AssDialogue const& rgt) {
return lft.Text < rgt.Text;
}
bool AssFile::CompTextStripped(AssDialogue const& lft, AssDialogue const& rgt) {
return lft.GetStrippedText() < rgt.GetStrippedText();
}
2006-01-16 22:02:54 +01:00
void AssFile::Sort(CompFunc comp, std::set<AssDialogue*> const& limit) {
Sort(Events, comp, limit);
}
void AssFile::Sort(EntryList<AssDialogue> &lst, CompFunc comp, std::set<AssDialogue*> const& limit) {
if (limit.empty()) {
lst.sort(comp);
return;
}
// Sort each selected block separately, leaving everything else untouched
for (auto begin = lst.begin(); begin != lst.end(); ++begin) {
if (!limit.count(&*begin)) continue;
auto end = begin;
while (end != lst.end() && limit.count(&*end)) ++end;
// sort doesn't support only sorting a sublist, so move them to a temp list
EntryList<AssDialogue> tmp;
tmp.splice(tmp.begin(), lst, begin, end);
tmp.sort(comp);
lst.splice(end, tmp);
begin = --end;
}
}
uint32_t AssFile::AddExtradata(std::string const& key, std::string const& value) {
for (auto const& data : Extradata) {
// perform brute-force deduplication by simple key and value comparison
2014-09-06 18:16:44 +02:00
if (key == data.key && value == data.value) {
return data.id;
}
}
Extradata.push_back(ExtradataEntry{next_extradata_id, 0, key, value});
return next_extradata_id++; // return old value, then post-increment
}
void AssFile::SetExtradataValue(AssDialogue& line, std::string const& key, std::string const& value, bool del) {
std::vector<uint32_t> id_list = line.ExtradataIds;
std::vector<bool> to_erase(id_list.size());
bool dirty = false;
bool found = false;
std::vector<ExtradataEntry> entry_list = GetExtradata(id_list);
for (int i = entry_list.size() - 1; i >= 0; i--) {
if (entry_list[i].key == key) {
if (!del && entry_list[i].value == value) {
found = true;
} else {
to_erase[i] = true;
dirty = true;
}
}
}
// The key is already set, we don't need to change anything
if (found && !dirty)
return;
for (int i = id_list.size() - 1; i >= 0; i--) {
if (to_erase[i])
id_list.erase(id_list.begin() + i, id_list.begin() + i + 1);
}
if (!del && !found)
id_list.push_back(AddExtradata(key, value));
line.ExtradataIds = id_list;
}
2014-09-06 18:16:44 +02:00
namespace {
struct extradata_id_cmp {
bool operator()(ExtradataEntry const& e, uint32_t id) {
return e.id < id;
}
bool operator()(uint32_t id, ExtradataEntry const& e) {
return id < e.id;
}
};
template<typename ExtradataType, typename Func>
void enumerate_extradata(ExtradataType&& extradata, std::vector<uint32_t> const& id_list, Func&& f) {
auto begin = extradata.begin(), end = extradata.end();
for (auto id : id_list) {
2014-09-06 18:16:44 +02:00
auto it = lower_bound(begin, end, id, extradata_id_cmp{});
if (it != end) {
f(*it);
begin = it;
}
}
2014-09-06 18:16:44 +02:00
}
template<typename K, typename V>
using reference_map = std::unordered_map<std::reference_wrapper<const K>, V, std::hash<K>, std::equal_to<K>>;
}
std::vector<ExtradataEntry> AssFile::GetExtradata(std::vector<uint32_t> const& id_list) const {
std::vector<ExtradataEntry> result;
enumerate_extradata(Extradata, id_list, [&](ExtradataEntry const& e) {
result.push_back(e);
});
return result;
}
void AssFile::CleanExtradata() {
2014-09-06 18:16:44 +02:00
if (Extradata.empty()) return;
std::unordered_set<uint32_t> ids_used;
for (auto& line : Events) {
2014-09-06 18:16:44 +02:00
if (line.ExtradataIds.get().empty()) continue;
// Find the ID for each unique key in the line
2014-09-06 18:16:44 +02:00
reference_map<std::string, uint32_t> keys_used;
enumerate_extradata(Extradata, line.ExtradataIds.get(), [&](ExtradataEntry const& e) {
keys_used[e.key] = e.id;
});
for (auto const& used : keys_used)
ids_used.insert(used.second);
// If any keys were duplicated or missing, update the id list
if (keys_used.size() != line.ExtradataIds.get().size()) {
std::vector<uint32_t> ids;
ids.reserve(keys_used.size());
for (auto const& used : keys_used)
ids.push_back(used.second);
std::sort(begin(ids), end(ids));
line.ExtradataIds = std::move(ids);
}
}
for (ExtradataEntry &e : Extradata) {
if (ids_used.count(e.id))
e.expiration_counter = 0;
else
e.expiration_counter++;
}
2014-09-06 18:16:44 +02:00
if (ids_used.size() != Extradata.size()) {
// Erase all no-longer-used extradata entries
Extradata.erase(std::remove_if(begin(Extradata), end(Extradata), [&](ExtradataEntry const& e) {
return e.expiration_counter >= 10;
2014-09-06 18:16:44 +02:00
}), end(Extradata));
}
}