QMimeData *
SourceFileModel::mimeData(QModelIndexList const &indexes)
const {
auto valuesToStore = QSet<quint64>{};
for (auto const &index : indexes)
if (index.isValid())
valuesToStore << storageValueFromIndex(index);
if (valuesToStore.isEmpty())
return nullptr;
auto data = new QMimeData{};
auto encoded = QByteArray{};
QDataStream stream{&encoded, QIODevice::WriteOnly};
mxinfo(boost::format("mimeData %1% entries\n") % valuesToStore.size());
for (auto const &value : valuesToStore) {
mxinfo(boost::format(" store %|1$08x|\n") % value);
stream << value;
}
data->setData(MIME_TYPE, encoded);
return data;
}
void
avi_reader_c::debug_dump_video_index() {
int num_video_frames = AVI_video_frames(m_avi), i;
mxinfo(boost::format("AVI video index dump: %1% entries; frame rate: %2%\n") % num_video_frames % m_fps);
for (i = 0; num_video_frames > i; ++i)
mxinfo(boost::format(" %1%: %2% bytes\n") % i % AVI_frame_size(m_avi, i));
}
static void
run(options_cptr &options) {
console_kax_analyzer_cptr analyzer;
try {
if (!kax_analyzer_c::probe(options->m_file_name))
mxerror(boost::format("The file '%1%' is not a Matroska file or it could not be found.\n") % options->m_file_name);
analyzer = console_kax_analyzer_cptr(new console_kax_analyzer_c(options->m_file_name));
} catch (mtx::mm_io::exception &ex) {
mxerror(boost::format("The file '%1%' could not be opened for reading and writing: %1.\n") % options->m_file_name % ex);
}
mxinfo(boost::format("%1%\n") % Y("The file is being analyzed."));
analyzer->set_show_progress(options->m_show_progress);
bool ok = false;
try {
ok = analyzer
->set_parse_mode(options->m_parse_mode)
.set_open_mode(MODE_WRITE)
.set_throw_on_error(true)
.process();
} catch (mtx::mm_io::exception &ex) {
mxerror(boost::format(Y("The file '%1%' could not be opened for reading and writing, or a read/write operation on it failed: %2%.\n")) % options->m_file_name % ex);
} catch (...) {
}
if (!ok)
mxerror(Y("This file could not be opened or parsed.\n"));
options->find_elements(analyzer.get());
options->validate();
if (debugging_c::requested("dump_options")) {
mxinfo("\nDumping options after file and element analysis\n\n");
options->dump_info();
}
options->execute(*analyzer);
if (has_content_been_modified(options)) {
mxinfo(Y("The changes are written to the file.\n"));
write_changes(options, analyzer.get());
mxinfo(Y("Done.\n"));
} else
mxinfo(Y("No changes were made.\n"));
mxexit();
}
analyze_header_removal_compressor_c::~analyze_header_removal_compressor_c() {
if (!m_bytes)
mxinfo("Analysis failed: no packet encountered\n");
else if (m_bytes->get_size() == 0)
mxinfo("Analysis complete but no similarities found.\n");
else {
mxinfo(boost::format("Analysis complete. %1% identical byte(s) at the start of each of the %2% packet(s). Hex dump of the content:\n") % m_bytes->get_size() % m_packet_counter);
debugging_c::hexdump(m_bytes->get_buffer(), m_bytes->get_size());
}
}
std::string
translation_c::get_default_ui_locale() {
std::string locale;
#if defined(HAVE_LIBINTL_H)
# if defined(SYS_WINDOWS)
std::string env_var = get_environment_variable("LC_MESSAGES");
if (!env_var.empty() && (-1 != look_up_translation(env_var)))
return env_var;
env_var = get_environment_variable("LANG");
if (!env_var.empty() && (-1 != look_up_translation(env_var)))
return env_var;
char *data;
int len = GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SENGLANGUAGE, NULL, 0);
if (0 < len) {
data = (char *)safemalloc(len);
memset(data, 0, len);
if (0 != GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SENGLANGUAGE, data, len))
locale = data;
safefree(data);
int idx = translation_c::look_up_translation(locale);
if (-1 != idx)
locale = ms_available_translations[idx].get_locale();
}
# else // SYS_WINDOWS
char *data = setlocale(LC_MESSAGES, NULL);
if (NULL != data) {
std::string previous_locale = data;
if (debugging_requested("locale"))
mxinfo(boost::format("[get_default_ui_locale previous %1%]\n") % previous_locale);
setlocale(LC_MESSAGES, "");
data = setlocale(LC_MESSAGES, NULL);
if (NULL != data)
locale = data;
if (debugging_requested("locale"))
mxinfo(boost::format("[get_default_ui_locale new %1%]\n") % locale);
setlocale(LC_MESSAGES, previous_locale.c_str());
} else if (debugging_requested("locale"))
mxinfo(boost::format("[get_default_ui_locale get previous failed]\n"));
# endif // SYS_WINDOWS
#endif // HAVE_LIBINTL_H
return locale;
}
void
avi_reader_c::debug_dump_video_index() {
int num_video_frames = AVI_video_frames(m_avi), i;
mxinfo(boost::format("AVI video index dump: %1% entries; frame rate: %2%\n") % num_video_frames % m_fps);
for (i = 0; num_video_frames > i; ++i) {
int key = 0;
AVI_read_frame(m_avi, nullptr, &key);
mxinfo(boost::format(" %1%: %2% bytes; key: %3%\n") % i % AVI_frame_size(m_avi, i) % key);
}
AVI_set_video_position(m_avi, 0);
}
void
parser_c::dump()
const {
mxinfo(boost::format("MPLS class dump\n"
" ok: %1%\n"
" num_chapters: %2%\n")
% m_ok % m_chapters.size());
for (auto &timecode : m_chapters)
mxinfo(boost::format(" %1%\n") % timecode);
m_header.dump();
m_playlist.dump();
}
void
vc1_info_c::handle_sequence_header_packet(memory_cptr packet) {
std::string checksum = create_checksum_info(packet);
mxinfo(boost::format(Y("Sequence header at %1% size %2%%3%\n")) % m_stream_pos % packet->get_size() % checksum);
m_seqhdr_found = vc1::parse_sequence_header(packet->get_buffer(), packet->get_size(), m_seqhdr);
if (g_opt_sequence_headers) {
if (m_seqhdr_found)
dump_sequence_header(m_seqhdr);
else
mxinfo(Y(" parsing failed\n"));
}
}
void
SourceFileModel::updateSelectionStatus() {
m_nonAppendedSelected = false;
m_appendedSelected = false;
m_additionalPartSelected = false;
auto selectionModel = qobject_cast<QItemSelectionModel *>(QObject::sender());
Q_ASSERT(selectionModel);
Util::withSelectedIndexes(selectionModel, [this](QModelIndex const &selectedIndex) {
auto sourceFile = fromIndex(selectedIndex);
Q_ASSERT(!!sourceFile);
if (sourceFile->isRegular())
m_nonAppendedSelected = true;
else if (sourceFile->isAppended())
m_appendedSelected = true;
else if (sourceFile->isAdditionalPart())
m_additionalPartSelected = true;
});
mxinfo(boost::format("file sel changed nonApp %1% app %2% addPart %3%\n") % m_nonAppendedSelected % m_appendedSelected % m_additionalPartSelected);
}
int
vc1_es_reader_c::probe_file(mm_io_c *in,
uint64_t size) {
try {
if (PROBESIZE > size)
return 0;
in->setFilePointer(0, seek_beginning);
memory_cptr buf = memory_c::alloc(READ_SIZE);
int num_read = in->read(buf->get_buffer(), READ_SIZE);
if (4 > num_read)
return 0;
uint32_t marker = get_uint32_be(buf->get_buffer());
if ((VC1_MARKER_SEQHDR != marker) && (VC1_MARKER_ENTRYPOINT != marker) && (VC1_MARKER_FRAME != marker))
return 0;
vc1::es_parser_c parser;
parser.add_bytes(buf->get_buffer(), num_read);
return parser.is_sequence_header_available();
} catch (...) {
mxinfo(Y("have an xcptn\n"));
}
return 0;
}
int
dirac_es_reader_c::probe_file(mm_io_c *in,
uint64_t size) {
try {
if (PROBESIZE > size)
return 0;
in->setFilePointer(0, seek_beginning);
memory_cptr buf = memory_c::alloc(READ_SIZE);
int num_read = in->read(buf->get_buffer(), READ_SIZE);
if (4 > num_read)
return 0;
uint32_t marker = get_uint32_be(buf->get_buffer());
if (DIRAC_SYNC_WORD != marker)
return 0;
dirac::es_parser_c parser;
parser.add_bytes(buf->get_buffer(), num_read);
return parser.is_sequence_header_available();
} catch (...) {
mxinfo("have an xcptn\n");
}
return 0;
}
EbmlElement *
kax_file_c::read_one_element() {
if (m_segment_end && (m_in->getFilePointer() >= m_segment_end))
return nullptr;
int upper_lvl_el = 0;
EbmlElement *l1 = m_es->FindNextElement(EBML_CLASS_CONTEXT(KaxSegment), upper_lvl_el, 0xFFFFFFFFL, true);
if (!l1)
return nullptr;
const EbmlCallbacks *callbacks = find_ebml_callbacks(EBML_INFO(KaxSegment), EbmlId(*l1));
if (!callbacks)
callbacks = &EBML_CLASS_CALLBACK(KaxSegment);
EbmlElement *l2 = nullptr;
try {
l1->Read(*m_es.get(), EBML_INFO_CONTEXT(*callbacks), upper_lvl_el, l2, true);
} catch (libebml::CRTError &e) {
mxdebug_if(m_debug_resync, boost::format("exception reading element data: %1% (%2%)\n") % e.what() % e.getError());
m_in->setFilePointer(l1->GetElementPosition() + 1);
delete l1;
return nullptr;
}
unsigned long element_size = get_element_size(l1);
if (m_debug_resync)
mxinfo(boost::format("kax_file::read_one_element(): read element at %1% calculated size %2% stored size %3%\n")
% l1->GetElementPosition() % element_size % (l1->IsFiniteSize() ? (boost::format("%1%") % l1->ElementSize()).str() : std::string("unknown")));
m_in->setFilePointer(l1->GetElementPosition() + element_size, seek_beginning);
return l1;
}
static void
display_update_element_result(const EbmlCallbacks &callbacks,
kax_analyzer_c::update_element_result_e result) {
mxinfo(boost::format(Y("Updating the '%1%' element failed. Reason:\n")) % callbacks.DebugName);
switch (result) {
case kax_analyzer_c::uer_error_segment_size_for_element:
mxerror(Y("The element was written at the end of the file, but the segment size could not be updated. Therefore the element will not be visible. "
"The process will be aborted. The file has been changed!"));
break;
case kax_analyzer_c::uer_error_segment_size_for_meta_seek:
mxerror(Y("The meta seek element was written at the end of the file, but the segment size could not be updated. Therefore the element will not be visible. "
"The process will be aborted. The file has been changed!"));
break;
case kax_analyzer_c::uer_error_meta_seek:
mxerror(Y("The Matroska file was modified, but the meta seek entry could not be updated. This means that players might have a hard time finding this element. "
"Please use your favorite player to check this file.\n"));
break;
default:
mxerror(Y("An unknown error occured. The file has been modified."));
}
}
void
wav_reader_c::dump_headers() {
mxinfo(boost::format("File '%1%' wave_header dump\n"
" riff:\n"
" id: %2%%3%%4%%5%\n"
" len: %6%\n"
" wave_id: %7%%8%%9%%10%\n"
" common:\n"
" wFormatTag: %|11$04x|\n"
" wChannels: %12%\n"
" dwSamplesPerSec: %13%\n"
" dwAvgBytesPerSec: %14%\n"
" wBlockAlign: %15%\n"
" wBitsPerSample: %16%\n"
" actual format_tag: %17%\n")
% m_ti.m_fname
% char(m_wheader.riff.id[0]) % char(m_wheader.riff.id[1]) % char(m_wheader.riff.id[2]) % char(m_wheader.riff.id[3])
% get_uint32_le(&m_wheader.riff.len)
% char(m_wheader.riff.wave_id[0]) % char(m_wheader.riff.wave_id[1]) % char(m_wheader.riff.wave_id[2]) % char(m_wheader.riff.wave_id[3])
% get_uint16_le(&m_wheader.common.wFormatTag)
% get_uint16_le(&m_wheader.common.wChannels)
% get_uint32_le(&m_wheader.common.dwSamplesPerSec)
% get_uint32_le(&m_wheader.common.dwAvgBytesPerSec)
% get_uint16_le(&m_wheader.common.wBlockAlign)
% get_uint16_le(&m_wheader.common.wBitsPerSample)
% m_format_tag);
}
EbmlElement *
kax_file_c::read_next_level1_element(uint32_t wanted_id,
bool report_cluster_timecode) {
try {
auto element = read_next_level1_element_internal(wanted_id);
if (report_cluster_timecode && (-1 != m_timecode_scale))
mxinfo(boost::format(Y("The first cluster timecode after the resync is %1%.\n"))
% format_timecode(FindChildValue<KaxClusterTimecode>(static_cast<KaxCluster *>(element)) * m_timecode_scale));
return element;
} catch (mtx::mm_io::exception &e) {
mxwarn(boost::format("%1% %2% %3%\n")
% (boost::format(Y("%1%: an exception occurred (message: %2%; type: %3%).")) % "kax_file_c::read_next_level1_element()" % (boost::format("%1% / %2%") % e.what() % e.error()) % typeid(e).name())
% Y("This usually indicates a damaged file structure.") % Y("The file will not be processed further."));
} catch (std::exception &e) {
mxwarn(boost::format("%1% %2% %3%\n")
% (boost::format(Y("%1%: an exception occurred (message: %2%; type: %3%).")) % "kax_file_c::read_next_level1_element()" % e.what() % typeid(e).name())
% Y("This usually indicates a damaged file structure.") % Y("The file will not be processed further."));
} catch (...) {
mxwarn(boost::format("%1% %2% %3%\n")
% (boost::format(Y("%1%: an unknown exception occurred.")) % "kax_file_c::read_next_level1_element()")
% Y("This usually indicates a damaged file structure.") % Y("The file will not be processed further."));
}
return nullptr;
}
void
vc1_info_c::dump_frame_header(vc1::frame_header_t &frame_header) {
mxinfo(boost::format(Y(" Frame header dump:\n"
" fcm: %1% (%2%)\n"
" frame_type: %3%\n"
" tf_counter: %4%\n"
" repeat_frame: %5%\n"
" top_field_first_flag: %6%\n"
" repeat_first_field_flag: %7%\n"))
% frame_header.fcm
% ( frame_header.fcm == 0x00 ? Y("progressive")
: frame_header.fcm == 0x10 ? Y("frame-interlace")
: frame_header.fcm == 0x11 ? Y("field-interlace")
: Y("unknown"))
% ( frame_header.frame_type == vc1::FRAME_TYPE_I ? Y("I")
: frame_header.frame_type == vc1::FRAME_TYPE_P ? Y("P")
: frame_header.frame_type == vc1::FRAME_TYPE_B ? Y("B")
: frame_header.frame_type == vc1::FRAME_TYPE_BI ? Y("BI")
: frame_header.frame_type == vc1::FRAME_TYPE_P_SKIPPED ? Y("P (skipped)")
: Y("unknown"))
% frame_header.tf_counter
% frame_header.repeat_frame
% frame_header.top_field_first_flag
% frame_header.repeat_first_field_flag);
}
void
translation_c::set_active_translation(const std::string &locale) {
int idx = look_up_translation(locale);
ms_active_translation_idx = std::max(idx, 0);
if (debugging_c::requested("locale"))
mxinfo(boost::format("[translation_c::set_active_translation() active_translation_idx %1% for locale %2%]\n") % ms_active_translation_idx % locale);
}
void
SourceFileModel::dumpSourceFiles(QString const &label)
const {
auto dumpIt = [](std::string const &prefix, SourceFilePtr const &sourceFile) {
mxinfo(boost::format("%1%%2%\n") % prefix % sourceFile->m_fileName);
};
mxinfo(boost::format("Dumping source files %1%\n") % label);
for (auto const &sourceFile : *m_sourceFiles) {
dumpIt(" ", sourceFile);
for (auto const &additionalPart : sourceFile->m_additionalParts)
dumpIt(" () ", additionalPart);
for (auto const &appendedSourceFile : sourceFile->m_appendedFiles)
dumpIt(" + ", appendedSourceFile);
}
}
void
vc1_info_c::handle_frame_packet(memory_cptr packet) {
std::string checksum = create_checksum_info(packet);
mxinfo(boost::format(Y("Frame at %1% size %2%%3%\n")) % m_stream_pos % packet->get_size() % checksum);
if (!g_opt_frames)
return;
if (!m_seqhdr_found) {
mxinfo(Y(" No sequence header found yet; parsing not possible\n"));
return;
}
vc1::frame_header_t frame_header;
if (vc1::parse_frame_header(packet->get_buffer(), packet->get_size(), frame_header, m_seqhdr))
dump_frame_header(frame_header);
}
void
vc1_info_c::handle_entrypoint_packet(memory_cptr packet) {
std::string checksum = create_checksum_info(packet);
mxinfo(boost::format(Y("Entrypoint at %1% size %2%%3%\n")) % m_stream_pos % packet->get_size() % checksum);
if (!g_opt_entrypoints)
return;
if (!m_seqhdr_found) {
mxinfo(Y(" No sequence header found yet; parsing not possible\n"));
return;
}
vc1::entrypoint_t entrypoint;
if (vc1::parse_entrypoint(packet->get_buffer(), packet->get_size(), entrypoint, m_seqhdr))
dump_entrypoint(entrypoint);
}
void
mxverb_fn(unsigned int level,
const std::string &file_name,
const std::string &message) {
if (verbose < level)
return;
mxinfo((boost::format(Y("'%1%': %2%")) % file_name % message).str());
}
void
header_t::dump()
const {
mxinfo(boost::format(" header dump\n"
" type_indicator1 & 2: %1% / %2%\n"
" playlist / chapter / ext pos: %3% / %4% / %5%\n")
% type_indicator1 % type_indicator2
% playlist_pos % chapter_pos % ext_pos);
}
void
xtr_tta_c::finish_file() {
m_out.reset();
mm_io_cptr in;
try {
in = mm_file_io_c::open(m_temp_file_name);
} catch (mtx::mm_io::exception &ex) {
mxerror(boost::format(Y("The temporary file '%1%' could not be opened for reading: %2%.\n")) % m_temp_file_name % ex);
}
try {
m_out = mm_write_buffer_io_c::open(m_file_name, 5 * 1024 * 1024);
} catch (mtx::mm_io::exception &ex) {
mxerror(boost::format(Y("The file '%1%' could not be opened for writing: %2%.\n")) % m_file_name % ex);
}
tta_file_header_t tta_header;
memcpy(tta_header.signature, "TTA1", 4);
if (3 != m_bps)
put_uint16_le(&tta_header.audio_format, 1);
else
put_uint16_le(&tta_header.audio_format, 3);
put_uint16_le(&tta_header.channels, m_channels);
put_uint16_le(&tta_header.bits_per_sample, m_bps);
put_uint32_le(&tta_header.sample_rate, m_sfreq);
if (0 >= m_previous_duration)
m_previous_duration = (int64_t)(TTA_FRAME_TIME * m_sfreq) * 1000000000ll;
put_uint32_le(&tta_header.data_length, (uint32_t)(m_sfreq * (TTA_FRAME_TIME * (m_frame_sizes.size() - 1) + (double)m_previous_duration / 1000000000.0l)));
put_uint32_le(&tta_header.crc, 0xffffffff ^ mtx::checksum::calculate_as_uint(mtx::checksum::algorithm_e::crc32_ieee_le, &tta_header, sizeof(tta_file_header_t) - 4, 0xffffffff));
m_out->write(&tta_header, sizeof(tta_file_header_t));
unsigned char *buffer = (unsigned char *)safemalloc(m_frame_sizes.size() * 4);
size_t k;
for (k = 0; m_frame_sizes.size() > k; ++k)
put_uint32_le(buffer + 4 * k, m_frame_sizes[k]);
m_out->write(buffer, m_frame_sizes.size() * 4);
m_out->write_uint32_le(0xffffffff ^ mtx::checksum::calculate_as_uint(mtx::checksum::algorithm_e::crc32_ieee_le, buffer, m_frame_sizes.size() * 4, 0xffffffff));
safefree(buffer);
mxinfo(boost::format(Y("\nThe temporary TTA file for track ID %1% is being copied into the final TTA file. This may take some time.\n")) % m_tid);
buffer = (unsigned char *)safemalloc(128000);
int nread;
do {
nread = in->read(buffer, 128000);
m_out->write(buffer, nread);
} while (nread == 128000);
m_out.reset();
unlink(m_temp_file_name.c_str());
}
void
wav_reader_c::scan_chunks() {
wav_chunk_t new_chunk;
bool debug_chunks = debugging_c::requested("wav_reader|wav_reader_chunks");
try {
int64_t file_size = m_in->get_size();
while (true) {
new_chunk.pos = m_in->getFilePointer();
if (m_in->read(new_chunk.id, 4) != 4)
return;
new_chunk.len = m_in->read_uint32_le();
if (debug_chunks)
mxinfo(boost::format("wav_reader_c::scan_chunks() new chunk at %1% type %2% length %3%\n")
% new_chunk.pos % get_displayable_string(new_chunk.id, 4) % new_chunk.len);
if (!strncasecmp(new_chunk.id, "data", 4))
m_bytes_in_data_chunks += new_chunk.len;
else if (!m_chunks.empty() && !strncasecmp(m_chunks.back().id, "data", 4) && (file_size > 0x100000000ll)) {
wav_chunk_t &previous_chunk = m_chunks.back();
int64_t this_chunk_len = file_size - previous_chunk.pos - sizeof(struct chunk_struct);
m_bytes_in_data_chunks -= previous_chunk.len;
m_bytes_in_data_chunks += this_chunk_len;
previous_chunk.len = this_chunk_len;
if (debug_chunks)
mxinfo(boost::format("wav_reader_c::scan_chunks() hugh data chunk with wrong length at %1%; re-calculated from file size; new length %2%\n")
% previous_chunk.pos % previous_chunk.len);
break;
}
m_chunks.push_back(new_chunk);
m_in->setFilePointer(new_chunk.len, seek_current);
}
} catch (...) {
}
}
void
mxverb_tid(unsigned int level,
const std::string &file_name,
int64_t track_id,
const std::string &message) {
if (verbose < level)
return;
mxinfo((boost::format(Y("'%1%' track %2%: %3%")) % file_name % track_id % message).str());
}
version_number_t::version_number_t(const std::string &s)
: valid(false)
{
memset(parts, 0, 5 * sizeof(unsigned int));
if (debugging_requested("version_check"))
mxinfo(boost::format("version check: Parsing %1%\n") % s);
// Match the following:
// 4.4.0
// 4.4.0.5 build 123
// 4.4.0-build20101201-123
// mkvmerge v4.4.0
// * Optional prefix "mkvmerge v"
// * At least three digits separated by dots
// * Optional fourth digit separated by a dot
// * Optional build number that can have two forms:
// - " build nnn"
// - "-buildYYYYMMDD-nnn" (date is ignored)
static boost::regex s_version_number_re("^ (?: mkv[a-z]+ \\s+ v)?" // Optional prefix mkv... v
"(\\d+) \\. (\\d+) \\. (\\d+)" // Three digitss separated by dots; $1 - $3
"(?: \\. (\\d+) )?" // Optional fourth digit separated by a dot; $4
"(?:" // Optional build number including its prefix
" (?: \\s* build \\s*" // Build number prefix: either " build " or...
" | - build \\d{8} - )" // ... "-buildYYYYMMDD-"
" (\\d+)" // The build number itself; $5
")?",
boost::regex::perl | boost::regex::mod_x);
boost::smatch matches;
if (!boost::regex_search(s, matches, s_version_number_re))
return;
size_t idx;
for (idx = 1; 5 >= idx; ++idx)
if (!matches[idx].str().empty())
parse_number(matches[idx].str(), parts[idx - 1]);
valid = true;
if (debugging_requested("version_check"))
mxinfo(boost::format("version check: parse OK; result: %1%\n") % to_string());
}
static void
show_help() {
mxinfo("mpls_dump [options] input_file_name\n"
"\n"
"General options:\n"
"\n"
" -h, --help This help text\n"
" -V, --version Print version information\n");
mxexit(0);
}
void
parser_c::dump() {
mxinfo(boost::format("Parser dump:\n"
" sequence_info_start: %1%\n"
" program_info_start: %2%\n")
% m_sequence_info_start % m_program_info_start);
for (auto &program : m_programs)
program->dump();
}
EbmlElement *
kax_file_c::resync_to_level1_element(uint32_t wanted_id) {
try {
return resync_to_level1_element_internal(wanted_id);
} catch (...) {
if (m_debug_resync)
mxinfo("kax_file::resync_to_level1_element(): exception\n");
return nullptr;
}
}
void
vc1_info_c::dump_sequence_header(vc1::sequence_header_t &seqhdr) {
static const char *profile_names[4] = { "Simple", "Main", "Complex", "Advanced" };
mxinfo(boost::format(Y(" Sequence header dump:\n"
" profile: %1% (%2%)\n"
" level: %3%\n"
" chroma_format: %4%\n"
" frame_rtq_postproc: %5%\n"
" bit_rtq_postproc: %6%\n"
" postproc_flag: %7%\n"
" pixel_width: %8%\n"
" pixel_height: %9%\n"
" pulldown_flag: %10%\n"
" interlace_flag: %11%\n"
" tf_counter_flag: %12%\n"
" f_inter_p_flag: %13%\n"
" psf_mode_flag: %14%\n"
" display_info_flag: %15%\n"
" display_width: %16%\n"
" display_height: %17%\n"
" aspect_ratio_flag: %18%\n"
" aspect_ratio_width: %19%\n"
" aspect_ratio_height: %20%\n"
" framerate_flag: %21%\n"
" framerate_num: %22%\n"
" framerate_den: %23%\n"
" hrd_param_flag: %24%\n"
" hrd_num_leaky_buckets: %25%\n"))
% seqhdr.profile % profile_names[seqhdr.profile]
% seqhdr.level
% seqhdr.chroma_format
% seqhdr.frame_rtq_postproc
% seqhdr.bit_rtq_postproc
% seqhdr.postproc_flag
% seqhdr.pixel_width
% seqhdr.pixel_height
% seqhdr.pulldown_flag
% seqhdr.interlace_flag
% seqhdr.tf_counter_flag
% seqhdr.f_inter_p_flag
% seqhdr.psf_mode_flag
% seqhdr.display_info_flag
% seqhdr.display_width
% seqhdr.display_height
% seqhdr.aspect_ratio_flag
% seqhdr.aspect_ratio_width
% seqhdr.aspect_ratio_height
% seqhdr.framerate_flag
% seqhdr.framerate_num
% seqhdr.framerate_den
% seqhdr.hrd_param_flag
% seqhdr.hrd_num_leaky_buckets);
}
