EbmlElement *
empty_ebml_master(EbmlElement *e) {
EbmlMaster *m;
m = dynamic_cast<EbmlMaster *>(e);
if (!m)
return e;
while (m->ListSize() > 0) {
delete (*m)[0];
m->Remove(0);
}
return m;
}
ebml_master_cptr
kax_analyzer_c::read_all(const EbmlCallbacks &callbacks) {
reopen_file();
ebml_master_cptr master;
EbmlStream es(*m_file);
size_t i;
for (i = 0; m_data.size() > i; ++i) {
kax_analyzer_data_c &data = *m_data[i].get();
if (EBML_INFO_ID(callbacks) != data.m_id)
continue;
m_file->setFilePointer(data.m_pos);
int upper_lvl_el = 0;
EbmlElement *element = es.FindNextElement(EBML_CLASS_CONTEXT(KaxSegment), upper_lvl_el, 0xFFFFFFFFL, true);
if (!element)
continue;
if (EbmlId(*element) != EBML_INFO_ID(callbacks)) {
delete element;
continue;
}
EbmlElement *l2 = nullptr;
element->Read(*m_stream, EBML_INFO_CONTEXT(callbacks), upper_lvl_el, l2, true);
if (!master)
master = ebml_master_cptr(static_cast<EbmlMaster *>(element));
else {
EbmlMaster *src = static_cast<EbmlMaster *>(element);
while (src->ListSize() > 0) {
master->PushElement(*(*src)[0]);
src->Remove(0);
}
delete element;
}
}
if (master && (master->ListSize() == 0))
master.reset();
return master;
}
/** \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;
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.
GetChildAs<KaxChapterTimeStart, EbmlUInteger>(*atom) = start_tc;
if (-1 != end_tc)
GetChildAs<KaxChapterTimeEnd, EbmlUInteger>(*atom) = 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);
}
}
/** \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;
}