void MatroskaImport::AddChapterAtom(KaxChapterAtom *atom, Track chapterTrack)
{
KaxChapterAtom *subChapter = FindChild<KaxChapterAtom>(*atom);
bool addThisChapter = true;
// since QuickTime only supports linear chapter tracks (no nesting), only add chapter leaves
if (subChapter && subChapter->GetSize() > 0) {
while (subChapter && subChapter->GetSize() > 0) {
KaxChapterFlagHidden &hideChapter = GetChild<KaxChapterFlagHidden>(*subChapter);
if (!uint8_t(hideChapter)) {
AddChapterAtom(subChapter, chapterTrack);
addThisChapter = false;
}
subChapter = &GetNextChild(*atom, *subChapter);
}
}
if (addThisChapter) {
// add the chapter to the track if it has no children
KaxChapterTimeStart & startTime = GetChild<KaxChapterTimeStart>(*atom);
KaxChapterDisplay & chapDisplay = GetChild<KaxChapterDisplay>(*atom);
KaxChapterString & chapString = GetChild<KaxChapterString>(chapDisplay);
MediaHandler mh = GetMediaHandler(GetTrackMedia(chapterTrack));
TimeValue start = UInt64(startTime) / timecodeScale;
if (start > movieDuration) {
Codecprintf(NULL, "MKV: Chapter time is beyond the end of the file\n");
return;
}
Rect bounds = {0, 0, 0, 0};
TimeValue inserted;
OSErr err = TextMediaAddTextSample(mh,
const_cast<Ptr>(UTFstring(chapString).GetUTF8().c_str()),
UTFstring(chapString).GetUTF8().size(),
0, 0, 0, NULL, NULL,
teCenter, &bounds, dfClipToTextBox,
0, 0, 0, NULL, 1, &inserted);
if (err)
Codecprintf(NULL, "MKV: Error adding text sample %d\n", err);
else {
InsertMediaIntoTrack(chapterTrack, start, inserted, 1, fixed1);
}
}
}
static int64_t
get_chapter_index(int idx,
KaxChapterAtom &atom) {
size_t i;
std::string sidx = (boost::format("INDEX %|1$02d|") % idx).str();
for (i = 0; i < atom.ListSize(); i++)
if ((EbmlId(*atom[i]) == EBML_ID(KaxChapterAtom)) &&
(get_chapter_name(*static_cast<KaxChapterAtom *>(atom[i])) == sidx))
return get_chapter_start(*static_cast<KaxChapterAtom *>(atom[i]));
return -1;
}
static int64_t
get_chapter_index(int idx,
KaxChapterAtom &atom) {
size_t i;
std::string sidx = (boost::format("INDEX %|1$02d|") % idx).str();
for (i = 0; i < atom.ListSize(); i++)
if ( Is<KaxChapterAtom>(atom[i])
&& (mtx::chapters::get_name(*static_cast<KaxChapterAtom *>(atom[i])) == sidx))
return mtx::chapters::get_start(*static_cast<KaxChapterAtom *>(atom[i]));
return -1;
}
void
ebml_chapters_converter_c::fix_atom(KaxChapterAtom &atom)
const {
for (auto element : atom)
if (dynamic_cast<KaxChapterAtom *>(element))
fix_atom(*static_cast<KaxChapterAtom *>(element));
if (!FindChild<KaxChapterTimeStart>(atom))
throw conversion_x{Y("<ChapterAtom> is missing the <ChapterTimeStart> child.")};
if (!FindChild<KaxChapterUID>(atom)) {
KaxChapterUID *cuid = new KaxChapterUID;
*static_cast<EbmlUInteger *>(cuid) = create_unique_number(UNIQUE_CHAPTER_IDS);
atom.PushElement(*cuid);
}
KaxChapterTrack *ctrack = FindChild<KaxChapterTrack>(atom);
if (ctrack && !FindChild<KaxChapterTrackNumber>(ctrack))
throw conversion_x{Y("<ChapterTrack> is missing the <ChapterTrackNumber> child.")};
KaxChapterDisplay *cdisplay = FindChild<KaxChapterDisplay>(atom);
if (cdisplay)
fix_display(*cdisplay);
}
/** \brief Remove all chapter atoms that are outside of a time range
All chapter atoms that lie completely outside the timecode range
given with <tt>[min_tc..max_tc]</tt> are deleted. This is the workhorse
for ::select_chapters_in_timeframe
Chapters which start before the window but end inside or after the window
are kept as well, and their start timecode is adjusted.
Its parameters don't have to be checked for validity.
\param min_tc The minimum timecode to accept.
\param max_tc The maximum timecode to accept.
\param offset This value is subtracted from both the start and end timecode
for each chapter after the decision whether or not to keep it has been
made.
\param m The master containing the elements to check.
*/
static void
remove_entries(int64_t min_tc,
int64_t max_tc,
int64_t offset,
EbmlMaster &m) {
if (0 == m.ListSize())
return;
struct chapter_entry_t {
bool remove, spans, is_atom;
int64_t start, end;
chapter_entry_t()
: remove(false)
, spans(false)
, is_atom(false)
, start(0)
, end(-1)
{
}
} *entries = new chapter_entry_t[m.ListSize()];
unsigned int last_atom_at = 0;
bool last_atom_found = false;
// Determine whether or not an entry has to be removed. Also retrieve
// the start and end timecodes.
size_t i;
for (i = 0; m.ListSize() > i; ++i) {
KaxChapterAtom *atom = dynamic_cast<KaxChapterAtom *>(m[i]);
if (!atom)
continue;
last_atom_at = i;
last_atom_found = true;
entries[i].is_atom = true;
KaxChapterTimeStart *cts = static_cast<KaxChapterTimeStart *>(atom->FindFirstElt(EBML_INFO(KaxChapterTimeStart), false));
if (cts)
entries[i].start = uint64(*cts);
KaxChapterTimeEnd *cte = static_cast<KaxChapterTimeEnd *>(atom->FindFirstElt(EBML_INFO(KaxChapterTimeEnd), false));
if (cte)
entries[i].end = uint64(*cte);
}
// We can return if we don't have a single atom to work with.
if (!last_atom_found)
return;
for (i = 0; m.ListSize() > i; ++i) {
KaxChapterAtom *atom = dynamic_cast<KaxChapterAtom *>(m[i]);
if (!atom)
continue;
// Calculate the end timestamps and determine whether or not an entry spans
// several segments.
if (-1 == entries[i].end) {
if (i == last_atom_at)
entries[i].end = 1LL << 62;
else {
int next_atom = i + 1;
while (!entries[next_atom].is_atom)
++next_atom;
entries[i].end = entries[next_atom].start;
}
}
if ( (entries[i].start < min_tc)
|| ((max_tc >= 0) && (entries[i].start > max_tc)))
entries[i].remove = true;
if (entries[i].remove && (entries[i].start < min_tc) && (entries[i].end > min_tc))
entries[i].spans = true;
mxverb(3,
boost::format("remove_chapters: entries[%1%]: remove %2% spans %3% start %4% end %5%\n")
% i % entries[i].remove % entries[i].spans % entries[i].start % entries[i].end);
// Spanning entries must be kept, and their start timecode must be
// adjusted. Entries that are to be deleted will be deleted later and
// have to be skipped for now.
if (entries[i].remove && !entries[i].spans)
continue;
KaxChapterTimeStart *cts = static_cast<KaxChapterTimeStart *>(atom->FindFirstElt(EBML_INFO(KaxChapterTimeStart), false));
KaxChapterTimeEnd *cte = static_cast<KaxChapterTimeEnd *>(atom->FindFirstElt(EBML_INFO(KaxChapterTimeEnd), false));
if (entries[i].spans)
*static_cast<EbmlUInteger *>(cts) = min_tc;
*static_cast<EbmlUInteger *>(cts) = uint64(*cts) - offset;
if (cte) {
int64_t end_tc = uint64(*cte);
if ((max_tc >= 0) && (end_tc > max_tc))
end_tc = max_tc;
end_tc -= offset;
*static_cast<EbmlUInteger *>(cte) = end_tc;
}
EbmlMaster *m2 = dynamic_cast<EbmlMaster *>(m[i]);
if (m2)
remove_entries(min_tc, max_tc, offset, *m2);
}
// Now really delete those entries.
i = m.ListSize();
while (0 < i) {
--i;
if (entries[i].remove && !entries[i].spans) {
delete m[i];
m.Remove(i);
}
}
delete []entries;
}
/** \brief Merge all chapter atoms sharing the same UID
If two or more chapters with the same UID are encountered on the same
level then those are merged into a single chapter. The start timecode
is the minimum start timecode of all the chapters, and the end timecode
is the maximum end timecode of all the chapters.
The parameters do not have to be checked for validity.
\param master The master containing the elements to check.
*/
void
merge_chapter_entries(EbmlMaster &master) {
size_t master_idx;
// Iterate over all children of the atomaster.
for (master_idx = 0; master.ListSize() > master_idx; ++master_idx) {
// Not every child is a chapter atomaster. Skip those.
KaxChapterAtom *atom = dynamic_cast<KaxChapterAtom *>(master[master_idx]);
if (!atom)
continue;
int64_t uid = get_chapter_uid(*atom);
if (-1 == uid)
continue;
// First get the start and end time, if present.
int64_t start_tc = get_chapter_start(*atom, 0);
int64_t end_tc = get_chapter_end(*atom);
mxverb(3, boost::format("chapters: merge_entries: looking for %1% with %2%, %3%\n") % uid % start_tc % end_tc);
// Now iterate over all remaining atoms and find those with the same
// UID.
size_t merge_idx = master_idx + 1;
while (true) {
KaxChapterAtom *merge_this = nullptr;
for (; master.ListSize() > merge_idx; ++merge_idx) {
KaxChapterAtom *cmp_atom = dynamic_cast<KaxChapterAtom *>(master[merge_idx]);
if (!cmp_atom)
continue;
if (get_chapter_uid(*cmp_atom) == uid) {
merge_this = cmp_atom;
break;
}
}
// If we haven't found an atom with the same UID then we're done here.
if (!merge_this)
break;
// Do the merger! First get the start and end timecodes if present.
int64_t merge_start_tc = get_chapter_start(*merge_this, 0);
int64_t merge_end_tc = get_chapter_end(*merge_this);
// Then compare them to the ones we have for the soon-to-be merged
// chapter and assign accordingly.
if (merge_start_tc < start_tc)
start_tc = merge_start_tc;
if ((-1 == end_tc) || (merge_end_tc > end_tc))
end_tc = merge_end_tc;
// Move all chapter atoms from the merged entry into the target
// entry so that they will be merged recursively as well.
auto merge_child_idx = 0u;
auto num_children = merge_this->ListSize();
while (merge_child_idx < num_children) {
if (Is<KaxChapterAtom>((*merge_this)[merge_child_idx])) {
atom->PushElement(*(*merge_this)[merge_child_idx]);
merge_this->Remove(merge_child_idx);
--num_children;
} else
++merge_child_idx;
}
mxverb(3, boost::format("chapters: merge_entries: found one at %1% with %2%, %3%; merged to %4%, %5%\n") % merge_idx % merge_start_tc % merge_end_tc % start_tc % end_tc);
// Finally remove the entry itself.
delete master[merge_idx];
master.Remove(merge_idx);
}
// Assign the start and end timecode to the chapter. Only assign an
// end timecode if one was present in at least one of the merged
// chapter atoms.
GetChild<KaxChapterTimeStart>(*atom).SetValue(start_tc);
if (-1 != end_tc)
GetChild<KaxChapterTimeEnd>(*atom).SetValue(end_tc);
}
// Recusively merge atoms.
for (master_idx = 0; master.ListSize() > master_idx; ++master_idx) {
EbmlMaster *merge_master = dynamic_cast<EbmlMaster *>(master[master_idx]);
if (merge_master)
merge_chapter_entries(*merge_master);
}
}
ComponentResult MatroskaImport::ReadChapters(KaxChapters &chapterEntries)
{
KaxEditionEntry & edition = GetChild<KaxEditionEntry>(chapterEntries);
UInt32 emptyDataRefExtension[2];
if (seenChapters)
return noErr;
chapterTrack = NewMovieTrack(theMovie, 0, 0, kNoVolume);
if (chapterTrack == NULL) {
Codecprintf(NULL, "MKV: Error creating chapter track %d\n", GetMoviesError());
return GetMoviesError();
}
// we use a handle data reference here because I don't see any way to add textual
// sample references (TextMediaAddTextSample() will behave the same as AddSample()
// in that it modifies the original file if that's the data reference of the media)
Handle dataRef = NewHandleClear(sizeof(Handle) + 1);
emptyDataRefExtension[0] = EndianU32_NtoB(sizeof(UInt32)*2);
emptyDataRefExtension[1] = EndianU32_NtoB(kDataRefExtensionInitializationData);
PtrAndHand(&emptyDataRefExtension[0], dataRef, sizeof(emptyDataRefExtension));
Media chapterMedia = NewTrackMedia(chapterTrack, TextMediaType, GetMovieTimeScale(theMovie),
dataRef, HandleDataHandlerSubType);
if (chapterMedia == NULL) {
OSErr err = GetMoviesError();
Codecprintf(NULL, "MKV: Error creating chapter media %d\n", err);
DisposeMovieTrack(chapterTrack);
return err;
}
// Name the chapter track "Chapters" for easy distinguishing
QTMetaDataRef trackMetaData;
OSErr err = QTCopyTrackMetaData(chapterTrack, &trackMetaData);
if (err == noErr) {
OSType key = kUserDataName;
string chapterName("Chapters");
QTMetaDataAddItem(trackMetaData, kQTMetaDataStorageFormatUserData,
kQTMetaDataKeyFormatUserData, (UInt8 *)&key, sizeof(key),
(UInt8 *)chapterName.c_str(), chapterName.size(),
kQTMetaDataTypeUTF8, NULL);
QTMetaDataRelease(trackMetaData);
}
BeginMediaEdits(chapterMedia);
// tell the text media handler the upcoming text samples are
// encoded in Unicode with a byte order mark (BOM)
MediaHandler mediaHandler = GetMediaHandler(chapterMedia);
SInt32 dataPtr = kTextEncodingUnicodeDefault;
TextMediaSetTextSampleData(mediaHandler, &dataPtr, kTXNTextEncodingAttribute);
KaxChapterAtom *chapterAtom = FindChild<KaxChapterAtom>(edition);
while (chapterAtom && chapterAtom->GetSize() > 0) {
AddChapterAtom(chapterAtom, chapterTrack);
chapterAtom = &GetNextChild<KaxChapterAtom>(edition, *chapterAtom);
}
EndMediaEdits(chapterMedia);
SetTrackEnabled(chapterTrack, false);
seenChapters = true;
return noErr;
}
