void
avi_reader_c::read_headers() {
try {
if (!avi_reader_c::probe_file(m_in.get(), m_size))
throw mtx::input::invalid_format_x();
} catch (mtx::mm_io::exception &) {
throw mtx::input::open_x();
}
show_demuxer_info();
if (!(m_avi = AVI_open_input_file(m_in.get(), 1)))
throw mtx::input::invalid_format_x();
m_fps = AVI_frame_rate(m_avi);
m_max_video_frames = AVI_video_frames(m_avi);
m_video_width = std::abs(AVI_video_width(m_avi));
m_video_height = std::abs(AVI_video_height(m_avi));
verify_video_track();
parse_subtitle_chunks();
if (debugging_c::requested("avi_dump_video_index"))
debug_dump_video_index();
}
void
ssa_reader_c::read_headers() {
mm_text_io_cptr text_in;
try {
text_in = std::shared_ptr<mm_text_io_c>(new mm_text_io_c(m_in.get(), false));
} catch (...) {
throw mtx::input::open_x();
}
if (!ssa_reader_c::probe_file(text_in.get(), 0))
throw mtx::input::invalid_format_x();
charset_converter_cptr cc_utf8 = mtx::includes(m_ti.m_sub_charsets, 0) ? charset_converter_c::init(m_ti.m_sub_charsets[ 0])
: mtx::includes(m_ti.m_sub_charsets, -1) ? charset_converter_c::init(m_ti.m_sub_charsets[-1])
: text_in->get_byte_order() != BO_NONE ? charset_converter_c::init("UTF-8")
: g_cc_local_utf8;
m_ti.m_id = 0;
m_subs = ssa_parser_cptr(new ssa_parser_c(this, text_in.get(), m_ti.m_fname, 0));
m_subs->set_charset_converter(cc_utf8);
m_subs->parse();
show_demuxer_info();
}
void
dts_reader_c::read_headers() {
try {
m_in->setFilePointer(m_current_chunk->data_start);
auto bytes_to_read = std::min<int64_t>(m_current_chunk->data_size, READ_SIZE);
if (m_in->read(m_buf[m_cur_buf], bytes_to_read) != bytes_to_read)
throw mtx::input::header_parsing_x();
m_in->setFilePointer(m_current_chunk->data_start);
} catch (...) {
throw mtx::input::open_x();
}
mtx::dts::detect(m_buf[m_cur_buf], READ_SIZE, m_dts14_to_16, m_swap_bytes);
mxdebug_if(m_debug, boost::format("DTS: 14->16 %1% swap %2%\n") % m_dts14_to_16 % m_swap_bytes);
decode_buffer(READ_SIZE);
int pos = mtx::dts::find_header(reinterpret_cast<const unsigned char *>(m_buf[m_cur_buf]), READ_SIZE, m_dtsheader);
if (0 > pos)
throw mtx::input::header_parsing_x();
m_ti.m_id = 0; // ID for this track.
m_codec.set_specialization(m_dtsheader.get_codec_specialization());
show_demuxer_info();
}
void
flac_reader_c::read_headers() {
if (g_identifying)
return;
show_demuxer_info();
if (!parse_file())
throw mtx::input::header_parsing_x();
try {
uint32_t block_size = 0;
for (current_block = blocks.begin(); (current_block != blocks.end()) && (FLAC_BLOCK_TYPE_HEADERS == current_block->type); current_block++)
block_size += current_block->len;
m_header = memory_c::alloc(block_size);
block_size = 0;
for (current_block = blocks.begin(); (current_block != blocks.end()) && (FLAC_BLOCK_TYPE_HEADERS == current_block->type); current_block++) {
m_in->setFilePointer(current_block->filepos);
if (m_in->read(m_header->get_buffer() + block_size, current_block->len) != current_block->len)
mxerror(Y("flac_reader: Could not read a header packet.\n"));
block_size += current_block->len;
}
} catch (mtx::exception &) {
mxerror(Y("flac_reader: could not initialize the FLAC packetizer.\n"));
}
}
void
hevc_es_reader_c::read_headers() {
try {
mtx::hevc::es_parser_c parser;
parser.ignore_nalu_size_length_errors();
int num_read, i;
for (i = 0; MAX_PROBE_BUFFERS > i; ++i) {
num_read = m_in->read(m_buffer->get_buffer(), READ_SIZE);
if (0 == num_read)
throw mtx::exception();
parser.add_bytes(m_buffer->get_buffer(), num_read);
if (parser.headers_parsed())
break;
}
if (parser.headers_parsed())
parser.flush();
m_width = parser.get_width();
m_height = parser.get_height();
m_in->setFilePointer(0, seek_beginning);
} catch (...) {
throw mtx::input::open_x();
}
show_demuxer_info();
}
void
usf_reader_c::read_headers() {
try {
auto doc = mtx::xml::load_file(m_in->get_file_name(), pugi::parse_default | pugi::parse_declaration | pugi::parse_doctype | pugi::parse_pi | pugi::parse_comments);
parse_metadata(doc);
parse_subtitles(doc);
create_codec_private(doc);
for (auto track : m_tracks) {
brng::stable_sort(track->m_entries);
track->m_current_entry = track->m_entries.begin();
if (!m_longest_track || (m_longest_track->m_entries.size() < track->m_entries.size()))
m_longest_track = track;
if ((m_default_language != "") && (track->m_language == ""))
track->m_language = m_default_language;
}
} catch (mtx::xml::exception &ex) {
throw mtx::input::extended_x(ex.what());
} catch (mtx::mm_io::exception &) {
throw mtx::input::open_x();
}
show_demuxer_info();
}
void
wav_reader_c::create_demuxer() {
m_ti.m_id = 0; // ID for this track.
if (0x2000 == m_format_tag) {
m_demuxer = wav_demuxer_cptr(new wav_ac3acm_demuxer_c(this, &m_wheader));
if (!m_demuxer->probe(m_in))
m_demuxer.reset();
}
if (!m_demuxer) {
m_demuxer = wav_demuxer_cptr(new wav_dts_demuxer_c(this, &m_wheader));
if (!m_demuxer->probe(m_in))
m_demuxer.reset();
}
if (!m_demuxer) {
m_demuxer = wav_demuxer_cptr(new wav_ac3wav_demuxer_c(this, &m_wheader));
if (!m_demuxer->probe(m_in))
m_demuxer.reset();
}
if (!m_demuxer && ((0x0001 == m_format_tag) || (0x0003 == m_format_tag)))
m_demuxer = wav_demuxer_cptr(new wav_pcm_demuxer_c(this, &m_wheader, 0x00003 == m_format_tag));
show_demuxer_info();
}
void
mp3_reader_c::read_headers() {
try {
int pos = find_valid_headers(*m_in, 2 * 1024 * 1024, 5);
if (0 > pos)
throw mtx::input::header_parsing_x();
m_in->setFilePointer(pos, seek_beginning);
m_in->read(m_chunk->get_buffer(), 4);
decode_mp3_header(m_chunk->get_buffer(), &m_mp3header);
m_in->setFilePointer(pos, seek_beginning);
show_demuxer_info();
if ((0 < pos) && verbose)
mxwarn_fn(m_ti.m_fname, boost::format(Y("Skipping %1% bytes at the beginning (no valid MP3 header found).\n")) % pos);
m_ti.m_id = 0; // ID for this track.
} catch (mtx::mm_io::exception &) {
throw mtx::input::open_x();
}
}
void
dts_reader_c::read_headers() {
try {
if (m_in->read(m_buf[m_cur_buf], READ_SIZE) != READ_SIZE)
throw mtx::input::header_parsing_x();
m_in->setFilePointer(0, seek_beginning);
} catch (...) {
throw mtx::input::open_x();
}
detect_dts(m_buf[m_cur_buf], READ_SIZE, m_dts14_to_16, m_swap_bytes);
mxdebug_if(m_debug, boost::format("DTS: 14->16 %1% swap %2%\n") % m_dts14_to_16 % m_swap_bytes);
decode_buffer(READ_SIZE);
int pos = find_dts_header(reinterpret_cast<const unsigned char *>(m_buf[m_cur_buf]), READ_SIZE, &m_dtsheader);
if (0 > pos)
throw mtx::input::header_parsing_x();
m_ti.m_id = 0; // ID for this track.
show_demuxer_info();
}
void
ac3_reader_c::read_headers() {
try {
int tag_size_start = skip_id3v2_tag(*m_in);
int tag_size_end = id3_tag_present_at_end(*m_in);
if (0 > tag_size_start)
tag_size_start = 0;
if (0 < tag_size_end)
m_size -= tag_size_end;
size_t init_read_len = std::min(m_size - tag_size_start, static_cast<uint64_t>(AC3_READ_SIZE));
if (m_in->read(m_chunk->get_buffer(), init_read_len) != init_read_len)
throw mtx::input::header_parsing_x();
m_in->setFilePointer(tag_size_start, seek_beginning);
ac3::parser_c parser;
parser.add_bytes(m_chunk->get_buffer(), init_read_len);
if (!parser.frame_available())
throw mtx::input::header_parsing_x();
m_ac3header = parser.get_frame();
} catch (mtx::mm_io::exception &) {
throw mtx::input::open_x();
}
m_ti.m_id = 0; // ID for this track.
show_demuxer_info();
}
void
truehd_reader_c::read_headers() {
try {
int tag_size_start = skip_id3v2_tag(*m_in);
int tag_size_end = id3_tag_present_at_end(*m_in);
if (0 > tag_size_start)
tag_size_start = 0;
if (0 < tag_size_end)
m_size -= tag_size_end;
size_t init_read_len = std::min(m_size - tag_size_start, static_cast<uint64_t>(TRUEHD_READ_SIZE));
if (m_in->read(m_chunk->get_buffer(), init_read_len) != init_read_len)
throw mtx::input::header_parsing_x();
m_in->setFilePointer(tag_size_start, seek_beginning);
truehd_parser_c parser;
parser.add_data(m_chunk->get_buffer(), init_read_len);
auto found_truehd = false;
auto found_ac3 = false;
while (parser.frame_available() && (!found_truehd || !found_ac3)) {
auto frame = parser.get_next_frame();
if (frame->is_ac3()) {
if (!found_ac3) {
found_ac3 = true;
m_ac3_header = frame->m_ac3_header;
}
continue;
}
if (!frame->is_sync())
continue;
m_header = frame;
found_truehd = true;
}
m_ti.m_id = 0; // ID for this track.
show_demuxer_info();
} catch (mtx::mm_io::exception &) {
throw mtx::input::open_x();
}
}
void
ogm_reader_c::read_headers() {
if (!ogm_reader_c::probe_file(m_in.get(), m_size))
throw mtx::input::invalid_format_x();
ogg_sync_init(&oy);
show_demuxer_info();
if (read_headers_internal() <= 0)
throw mtx::input::header_parsing_x();
handle_stream_comments();
}
void
mpeg_ts_reader_c::read_headers() {
try {
size_t size_to_probe = std::min(m_size, static_cast<uint64_t>(TS_PIDS_DETECT_SIZE));
auto probe_buffer = memory_c::alloc(size_to_probe);
m_detected_packet_size = detect_packet_size(m_in.get(), size_to_probe);
m_in->setFilePointer(0);
mxverb(3, boost::format("mpeg_ts: Starting to build PID list. (packet size: %1%)\n") % m_detected_packet_size);
mpeg_ts_track_ptr PAT(new mpeg_ts_track_c(*this));
PAT->type = PAT_TYPE;
tracks.push_back(PAT);
unsigned char buf[TS_MAX_PACKET_SIZE]; // maximum TS packet size + 1
bool done = m_in->eof();
while (!done) {
if (m_in->read(buf, m_detected_packet_size) != static_cast<unsigned int>(m_detected_packet_size))
break;
if (buf[0] != 0x47) {
if (resync(m_in->getFilePointer() - m_detected_packet_size))
continue;
break;
}
parse_packet(buf);
done = PAT_found && PMT_found && (0 == es_to_process);
done |= m_in->eof() || (m_in->getFilePointer() >= TS_PIDS_DETECT_SIZE);
}
} catch (...) {
}
mxverb(3, boost::format("mpeg_ts: Detection done on %1% bytes\n") % m_in->getFilePointer());
m_in->setFilePointer(0, seek_beginning); // rewind file for later remux
for (auto &track : tracks) {
track->pes_payload->remove(track->pes_payload->get_size());
track->processed = false;
track->data_ready = false;
track->pes_payload_size = 0;
// track->timecode_offset = -1;
}
parse_clip_info_file();
process_chapter_entries();
show_demuxer_info();
}
void
aac_reader_c::read_headers() {
try {
int tag_size_start = skip_id3v2_tag(*m_in);
int tag_size_end = id3_tag_present_at_end(*m_in);
if (0 > tag_size_start)
tag_size_start = 0;
if (0 < tag_size_end)
m_size -= tag_size_end;
size_t init_read_len = std::min(m_size - tag_size_start, static_cast<uint64_t>(INITCHUNKSIZE));
if (m_in->read(m_chunk, init_read_len) != init_read_len)
throw mtx::input::header_parsing_x();
m_in->setFilePointer(tag_size_start, seek_beginning);
if (find_aac_header(*m_chunk, init_read_len, &m_aacheader, m_emphasis_present) < 0)
throw mtx::input::header_parsing_x();
guess_adts_version();
m_ti.m_id = 0; // ID for this track.
int detected_profile = m_aacheader.profile;
if (24000 >= m_aacheader.sample_rate)
m_aacheader.profile = AAC_PROFILE_SBR;
if ( (map_has_key(m_ti.m_all_aac_is_sbr, 0) && m_ti.m_all_aac_is_sbr[ 0])
|| (map_has_key(m_ti.m_all_aac_is_sbr, -1) && m_ti.m_all_aac_is_sbr[-1]))
m_aacheader.profile = AAC_PROFILE_SBR;
if ( (map_has_key(m_ti.m_all_aac_is_sbr, 0) && !m_ti.m_all_aac_is_sbr[ 0])
|| (map_has_key(m_ti.m_all_aac_is_sbr, -1) && !m_ti.m_all_aac_is_sbr[-1]))
m_aacheader.profile = detected_profile;
if ( map_has_key(m_ti.m_all_aac_is_sbr, 0)
|| map_has_key(m_ti.m_all_aac_is_sbr, -1))
m_sbr_status_set = true;
} catch (...) {
throw mtx::input::open_x();
}
show_demuxer_info();
}
void
real_reader_c::read_headers() {
file = rmff_open_file_with_io(reinterpret_cast<const char *>(m_in.get()), RMFF_OPEN_MODE_READING, &mm_io_file_io);
if (!file) {
if (RMFF_ERR_NOT_RMFF == rmff_last_error)
throw mtx::input::invalid_format_x();
else
throw mtx::input::open_x();
}
m_in->setFilePointer(0, seek_beginning);
done = false;
show_demuxer_info();
parse_headers();
get_information_from_data();
}
void
tta_reader_c::read_headers() {
if (g_identifying)
return;
try {
int tag_size = skip_id3v2_tag(*m_in);
if (0 > tag_size)
mxerror_fn(m_ti.m_fname, boost::format(Y("tta_reader: tag_size < 0 in the c'tor. %1%\n")) % BUGMSG);
m_size -= tag_size;
if (m_in->read(&header, sizeof(tta_file_header_t)) != sizeof(tta_file_header_t))
mxerror_fn(m_ti.m_fname, Y("The file header is too short.\n"));
uint64_t seek_sum = m_in->getFilePointer() + 4 - tag_size;
m_size -= id3_tag_present_at_end(*m_in);
uint32_t seek_point;
do {
seek_point = m_in->read_uint32_le();
seek_sum += seek_point + 4;
seek_points.push_back(seek_point);
} while (seek_sum < m_size);
mxverb(2,
boost::format("tta: ch %1% bps %2% sr %3% dl %4% seek_sum %5% size %6% num %7%\n")
% get_uint16_le(&header.channels) % get_uint16_le(&header.bits_per_sample)
% get_uint32_le(&header.sample_rate) % get_uint32_le(&header.data_length)
% seek_sum % m_size % seek_points.size());
if (seek_sum != m_size)
mxerror_fn(m_ti.m_fname, Y("The seek table in this TTA file seems to be broken.\n"));
m_in->skip(4);
pos = 0;
m_ti.m_id = 0; // ID for this track.
} catch (...) {
throw mtx::input::open_x();
}
show_demuxer_info();
}
void
ivf_reader_c::read_headers() {
try {
ivf::file_header_t header;
m_in->read(&header, sizeof(ivf::file_header_t));
m_width = get_uint16_le(&header.width);
m_height = get_uint16_le(&header.height);
m_frame_rate_num = get_uint32_le(&header.frame_rate_num);
m_frame_rate_den = get_uint32_le(&header.frame_rate_den);
m_ti.m_id = 0; // ID for this track.
} catch (...) {
throw mtx::input::open_x();
}
show_demuxer_info();
}
void
vc1_es_reader_c::read_headers() {
try {
vc1::es_parser_c parser;
int num_read = m_in->read(m_buffer->get_buffer(), READ_SIZE);
parser.add_bytes(m_buffer->get_buffer(), num_read);
if (!parser.is_sequence_header_available())
throw false;
parser.get_sequence_header(m_seqhdr);
m_in->setFilePointer(0, seek_beginning);
} catch (...) {
throw mtx::input::open_x();
}
show_demuxer_info();
}
void
mpeg_es_reader_c::read_headers() {
try {
M2VParser parser;
// Let's find the first frame. We need its information like
// resolution, MPEG version etc.
parser.SetProbeMode();
if (!read_frame(parser, *m_in, 1024 * 1024))
throw mtx::input::header_parsing_x();
m_in->setFilePointer(0);
MPEG2SequenceHeader seq_hdr = parser.GetSequenceHeader();
version = parser.GetMPEGVersion();
interlaced = !seq_hdr.progressiveSequence;
width = seq_hdr.width;
height = seq_hdr.height;
frame_rate = seq_hdr.progressiveSequence ? seq_hdr.frameOrFieldRate : seq_hdr.frameOrFieldRate * 2.0f;
aspect_ratio = seq_hdr.aspectRatio;
if ((0 >= aspect_ratio) || (1 == aspect_ratio))
dwidth = width;
else
dwidth = (int)(height * aspect_ratio);
dheight = height;
MPEGChunk *raw_seq_hdr = parser.GetRealSequenceHeader();
if (raw_seq_hdr) {
m_ti.m_private_data = (unsigned char *)safememdup(raw_seq_hdr->GetPointer(), raw_seq_hdr->GetSize());
m_ti.m_private_size = raw_seq_hdr->GetSize();
}
mxverb(2, boost::format("mpeg_es_reader: version %1% width %2% height %3% FPS %4% AR %5%\n") % version % width % height % frame_rate % aspect_ratio);
} catch (mtx::mm_io::exception &) {
throw mtx::input::open_x();
}
show_demuxer_info();
}
void
pgssup_reader_c::read_headers() {
m_ti.m_id = 0; // ID for this track.
show_demuxer_info();
}
