Aegisub/aegisub/src/subtitle_format.cpp

// Copyright (c) 2006, Rodrigo Braz Monteiro
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
//   * Redistributions of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//   * Redistributions in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//   * Neither the name of the Aegisub Group nor the names of its contributors
//     may be used to endorse or promote products derived from this software
//     without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
// Aegisub Project http://www.aegisub.org/
//
// $Id$

/// @file subtitle_format.cpp
/// @brief Base class for subtitle format handlers
/// @ingroup subtitle_io
///

#include "config.h"

#ifndef AGI_PRE
#include <wx/intl.h>
#include <wx/choicdlg.h> // Keep this last so wxUSE_CHOICEDLG is set.
#endif

#include "ass_dialogue.h"
#include "ass_file.h"
#include "subtitle_format.h"
#include "subtitle_format_ass.h"
#include "subtitle_format_encore.h"
#include "subtitle_format_microdvd.h"
#include "subtitle_format_mkv.h"
#include "subtitle_format_srt.h"
#include "subtitle_format_transtation.h"
#include "subtitle_format_ttxt.h"
#include "subtitle_format_txt.h"
#include "utils.h"
#include "video_context.h"

using namespace std::tr1::placeholders;

SubtitleFormat::SubtitleFormat(wxString const& name)
: name(name)
, isCopy(0)
, Line(0)
{
	formats.push_back(this);
}

SubtitleFormat::~SubtitleFormat() {
	formats.remove(this);
}

void SubtitleFormat::SetTarget(AssFile *file) {
	ClearCopy();
	Line = file ? &file->Line : 0;
	assFile = file;
}

bool SubtitleFormat::CanReadFile(wxString const& filename) const {
	return GetReadWildcards().Index(filename.AfterLast('.'), false) != wxNOT_FOUND;
}

bool SubtitleFormat::CanWriteFile(wxString const& filename) const {
	return GetWriteWildcards().Index(filename.AfterLast('.'), false) != wxNOT_FOUND;
}

void SubtitleFormat::CreateCopy() {
	SetTarget(new AssFile(*assFile));
	isCopy = true;
}

void SubtitleFormat::ClearCopy() {
	if (isCopy) {
		delete assFile;
		assFile = NULL;
		isCopy = false;
	}
}

void SubtitleFormat::Clear() {
	assFile->Clear();
}

void SubtitleFormat::LoadDefault(bool defline) {
	assFile->LoadDefault(defline);
}

void SubtitleFormat::AddLine(wxString data, wxString group, int &version, wxString *outgroup) {
	assFile->AddLine(data, group, version, outgroup);
}

/// @brief Ask the user to enter the FPS 
FractionalTime SubtitleFormat::AskForFPS(bool showSMPTE) {
	wxArrayString choices;
	bool drop = false;
	
	// Video FPS
	VideoContext *context = VideoContext::Get();
	bool vidLoaded = context->TimecodesLoaded();
	if (vidLoaded) {
		wxString vidFPS;
		if (context->FPS().IsVFR())
			vidFPS = "VFR";
		else
			vidFPS = wxString::Format("%.3f", context->FPS().FPS());
		choices.Add(wxString::Format(_("From video (%s)"), vidFPS));
	}
	
	// Standard FPS values
	choices.Add(_("15.000 FPS"));
	choices.Add(_("23.976 FPS (Decimated NTSC)"));
	choices.Add(_("24.000 FPS (FILM)"));
	choices.Add(_("25.000 FPS (PAL)"));
	choices.Add(_("29.970 FPS (NTSC)"));
	if (showSMPTE)
		choices.Add(_("29.970 FPS (NTSC with SMPTE dropframe)"));
	choices.Add(_("30.000 FPS"));
	choices.Add(_("50.000 FPS (PAL x2)"));
	choices.Add(_("59.940 FPS (NTSC x2)"));
	choices.Add(_("60.000 FPS"));
	choices.Add(_("119.880 FPS (NTSC x4)"));
	choices.Add(_("120.000 FPS"));

	using agi::vfr::Framerate;
	Framerate fps;
	// Ask
	int choice = wxGetSingleChoiceIndex(_("Please choose the appropriate FPS for the subtitles:"), _("FPS"), choices);
	if (choice == -1)
		return FractionalTime(fps);

	// Get FPS from choice
	if (vidLoaded) choice--;
	// dropframe was displayed, that means all choices >4 are bumped up by 1
	if (!showSMPTE && choice > 4) ++choice;

	switch (choice) {
		case -1: fps = context->FPS();                      break; // VIDEO
		case 0:  fps = Framerate(15, 1);                    break;
		case 1:  fps = Framerate(24000, 1001);              break;
		case 2:  fps = Framerate(24, 1);                    break;
		case 3:  fps = Framerate(25, 1);                    break;
		case 4:  fps = Framerate(30000, 1001);              break;
		case 5:  fps = Framerate(30000, 1001); drop = true; break;
		case 6:  fps = Framerate(30, 1);                    break;
		case 7:  fps = Framerate(50, 1);                    break;
		case 8:  fps = Framerate(60000, 1001);              break;
		case 9:  fps = Framerate(60, 1);                    break;
		case 10: fps = Framerate(120000, 1001);             break;
		case 11: fps = Framerate(120, 1);                   break;
	}

	return FractionalTime(fps, drop);
}

void SubtitleFormat::SortLines() {
	AssFile::Sort(*Line);
}

void SubtitleFormat::StripTags() {
	for (std::list<AssEntry*>::iterator cur = Line->begin(); cur != Line->end(); ++cur) {
		if (AssDialogue *current = dynamic_cast<AssDialogue*>(*cur)) {
			current->StripTags();
		}
	}
}

void SubtitleFormat::ConvertNewlines(wxString const& newline, bool mergeLineBreaks) {
	for (std::list<AssEntry*>::iterator cur = Line->begin(); cur != Line->end(); ++cur) {
		if (AssDialogue *current = dynamic_cast<AssDialogue*>(*cur)) {
			current->Text.Replace("\\h", " ");
			current->Text.Replace("\\n", newline);
			current->Text.Replace("\\N", newline);
			if (mergeLineBreaks) {
				while (current->Text.Replace(newline+newline, newline));
			}
		}
	}
}

void SubtitleFormat::StripComments() {
	for (std::list<AssEntry*>::iterator it = Line->begin(); it != Line->end(); ) {
		AssDialogue *diag = dynamic_cast<AssDialogue*>(*it);
		if (!diag || (!diag->Comment && diag->Text.size()))
			++it;
		else {
			delete *it;
			Line->erase(it++);
		}
	}
}

void SubtitleFormat::StripNonDialogue() {
	for (std::list<AssEntry*>::iterator it = Line->begin(); it != Line->end(); ) {
		if (dynamic_cast<AssDialogue*>(*it))
			++it;
		else {
			delete *it;
			Line->erase(it++);
		}
	}
}

static bool dialog_start_lt(AssEntry *pos, AssDialogue *to_insert) {
	AssDialogue *diag = dynamic_cast<AssDialogue*>(pos);
	return diag && diag->Start > to_insert->Start;
}

/// @brief Split and merge lines so there are no overlapping lines 
///
/// Algorithm described at http://devel.aegisub.org/wiki/Technical/SplitMerge
void SubtitleFormat::RecombineOverlaps() {
	std::list<AssEntry*>::iterator cur, next = Line->begin();
	cur = next++;

	for (; next != Line->end(); cur = next++) {
		AssDialogue *prevdlg = dynamic_cast<AssDialogue*>(*cur);
		AssDialogue *curdlg = dynamic_cast<AssDialogue*>(*next);

		if (!curdlg || !prevdlg) continue;
		if (prevdlg->End <= curdlg->Start) continue;

		// Use names like in the algorithm description and prepare for erasing
		// old dialogues from the list
		std::list<AssEntry*>::iterator prev = cur;
		cur = next;
		next++;

		// std::list::insert() inserts items before the given iterator, so
		// we need 'next' for inserting. 'prev' and 'cur' can safely be erased
		// from the list now.
		Line->erase(prev);
		Line->erase(cur);

		//Is there an A part before the overlap?
		if (curdlg->Start > prevdlg->Start) {
			// Produce new entry with correct values
			AssDialogue *newdlg = dynamic_cast<AssDialogue*>(prevdlg->Clone());
			newdlg->Start = prevdlg->Start;
			newdlg->End = curdlg->Start;
			newdlg->Text = prevdlg->Text;

			Line->insert(find_if(next, Line->end(), bind(dialog_start_lt, _1, newdlg)), newdlg);
		}

		// Overlapping A+B part
		{
			AssDialogue *newdlg = dynamic_cast<AssDialogue*>(prevdlg->Clone());
			newdlg->Start = curdlg->Start;
			newdlg->End = (prevdlg->End < curdlg->End) ? prevdlg->End : curdlg->End;
			// Put an ASS format hard linewrap between lines
			newdlg->Text = curdlg->Text + "\\N" + prevdlg->Text;

			Line->insert(find_if(next, Line->end(), bind(dialog_start_lt, _1, newdlg)), newdlg);
		}

		// Is there an A part after the overlap?
		if (prevdlg->End > curdlg->End) {
			// Produce new entry with correct values
			AssDialogue *newdlg = dynamic_cast<AssDialogue*>(prevdlg->Clone());
			newdlg->Start = curdlg->End;
			newdlg->End = prevdlg->End;
			newdlg->Text = prevdlg->Text;

			Line->insert(find_if(next, Line->end(), bind(dialog_start_lt, _1, newdlg)), newdlg);
		}

		// Is there a B part after the overlap?
		if (curdlg->End > prevdlg->End) {
			// Produce new entry with correct values
			AssDialogue *newdlg = dynamic_cast<AssDialogue*>(prevdlg->Clone());
			newdlg->Start = prevdlg->End;
			newdlg->End = curdlg->End;
			newdlg->Text = curdlg->Text;

			Line->insert(find_if(next, Line->end(), bind(dialog_start_lt, _1, newdlg)), newdlg);
		}

		next--;
	}
}

/// @brief Merge identical lines that follow each other 
void SubtitleFormat::MergeIdentical() {
	std::list<AssEntry*>::iterator cur, next = Line->begin();
	cur = next++;
	
	for (; next != Line->end(); cur = next++) {
		AssDialogue *curdlg = dynamic_cast<AssDialogue*>(*cur);
		AssDialogue *nextdlg = dynamic_cast<AssDialogue*>(*next);
		
		if (curdlg && nextdlg && curdlg->End == nextdlg->Start && curdlg->Text == nextdlg->Text) {
			// Merge timing
			nextdlg->Start = std::min(nextdlg->Start, curdlg->Start);
			nextdlg->End = std::max(nextdlg->End, curdlg->End);
			
			// Remove duplicate line
			delete *cur;
			Line->erase(cur);
		}
	}
}

std::list<SubtitleFormat*> SubtitleFormat::formats;

void SubtitleFormat::LoadFormats() {
	if (formats.empty()) {
		new ASSSubtitleFormat();
		new EncoreSubtitleFormat();
		new MKVSubtitleFormat();
		new MicroDVDSubtitleFormat();
		new SRTSubtitleFormat();
		new TTXTSubtitleFormat();
		new TXTSubtitleFormat();
		new TranStationSubtitleFormat();
	}
}

void SubtitleFormat::DestroyFormats() {
	for (std::list<SubtitleFormat*>::iterator it = formats.begin(); it != formats.end(); )
		delete *it++;
}

template<class Cont, class Pred>
SubtitleFormat *find_or_null(Cont &container, Pred pred) {
	typename Cont::iterator it = find_if(container.begin(), container.end(), pred);
	if (it == container.end())
		return 0;
	return *it;
}

SubtitleFormat *SubtitleFormat::GetReader(wxString const& filename) {
	LoadFormats();
	return find_or_null(formats, bind(&SubtitleFormat::CanReadFile, _1, filename));
}

SubtitleFormat *SubtitleFormat::GetWriter(wxString const& filename) {
	LoadFormats();
	return find_or_null(formats, bind(&SubtitleFormat::CanWriteFile, _1, filename));
}

wxString SubtitleFormat::GetWildcards(int mode) {
	LoadFormats();

	wxArrayString all;
	wxString final;

	std::list<SubtitleFormat*>::iterator curIter;
	for (curIter=formats.begin();curIter!=formats.end();curIter++) {
		SubtitleFormat *format = *curIter;
		wxArrayString cur = mode == 0 ? format->GetReadWildcards() : format->GetWriteWildcards();
		if (cur.empty()) continue;

		for_each(cur.begin(), cur.end(), bind(&wxString::Prepend, _1, "*."));
		copy(cur.begin(), cur.end(), std::back_inserter(all));
		final += "|" + format->GetName() + " (" + wxJoin(cur, ',') + ")|" + wxJoin(cur, ';');
	}

	final.Prepend(_("All Supported Formats") + " (" + wxJoin(all, ',') + ")|" + wxJoin(all, ';'));

	return final;
}