void
avi_reader_c::create_packetizer(int64_t tid) {
m_ti.m_private_data.reset();
if ((0 == tid) && demuxing_requested('v', 0) && (-1 == m_vptzr) && m_video_track_ok)
create_video_packetizer();
else if ((0 != tid) && (tid <= AVI_audio_tracks(m_avi)) && demuxing_requested('a', tid))
add_audio_demuxer(tid - 1);
}
void
wav_reader_c::create_packetizer(int64_t) {
if (!demuxing_requested('a', 0) || (NPTZR() != 0) || !m_demuxer)
return;
add_packetizer(m_demuxer->create_packetizer());
}
void
tta_reader_c::create_packetizer(int64_t) {
if (!demuxing_requested('a', 0) || (NPTZR() != 0))
return;
add_packetizer(new tta_packetizer_c(this, m_ti, get_uint16_le(&header.channels), get_uint16_le(&header.bits_per_sample), get_uint32_le(&header.sample_rate)));
show_packetizer_info(0, PTZR0);
}
void
flac_reader_c::create_packetizer(int64_t) {
if (!demuxing_requested('a', 0) || (NPTZR() != 0))
return;
add_packetizer(new flac_packetizer_c(this, m_ti, m_header->get_buffer(), m_header->get_size()));
show_packetizer_info(0, PTZR0);
}
void
ac3_reader_c::create_packetizer(int64_t) {
if (!demuxing_requested('a', 0) || (NPTZR() != 0))
return;
add_packetizer(new ac3_packetizer_c(this, m_ti, m_ac3header.m_sample_rate, m_ac3header.m_channels, m_ac3header.m_bs_id));
show_packetizer_info(0, PTZR0);
}
void
mp3_reader_c::create_packetizer(int64_t) {
if (!demuxing_requested('a', 0) || (NPTZR() != 0))
return;
add_packetizer(new mp3_packetizer_c(this, m_ti, m_mp3header.sampling_frequency, m_mp3header.channels, false));
show_packetizer_info(0, PTZR0);
}
void
vc1_es_reader_c::create_packetizer(int64_t) {
if (!demuxing_requested('v', 0) || (NPTZR() != 0))
return;
add_packetizer(new vc1_video_packetizer_c(this, m_ti));
show_packetizer_info(0, PTZR0);
}
void
ssa_reader_c::create_packetizer(int64_t) {
if (!demuxing_requested('s', 0) || (NPTZR() != 0))
return;
m_ti.m_private_data = memory_c::clone(m_subs->get_global());
add_packetizer(new textsubs_packetizer_c(this, m_ti, m_subs->is_ass() ? MKV_S_TEXTASS : MKV_S_TEXTSSA, false, false));
show_packetizer_info(0, PTZR0);
}
void
hevc_es_reader_c::create_packetizer(int64_t) {
if (!demuxing_requested('v', 0) || (NPTZR() != 0))
return;
add_packetizer(new hevc_es_video_packetizer_c(this, m_ti));
PTZR0->set_video_pixel_dimensions(m_width, m_height);
show_packetizer_info(0, PTZR0);
}
void
real_reader_c::parse_headers() {
if (rmff_read_headers(file) != RMFF_ERR_OK)
return;
int ndx;
for (ndx = 0; ndx < file->num_tracks; ndx++) {
rmff_track_t *track = file->tracks[ndx];
if ((RMFF_TRACK_TYPE_UNKNOWN == track->type) || (get_uint32_be(&track->mdpr_header.type_specific_size) == 0))
continue;
if ((RMFF_TRACK_TYPE_VIDEO == track->type) && !demuxing_requested('v', track->id))
continue;
if ((RMFF_TRACK_TYPE_AUDIO == track->type) && !demuxing_requested('a', track->id))
continue;
if ((NULL == track->mdpr_header.mime_type)
||
( strcmp(track->mdpr_header.mime_type, "audio/x-pn-realaudio")
&& strcmp(track->mdpr_header.mime_type, "video/x-pn-realvideo")))
continue;
unsigned char *ts_data = track->mdpr_header.type_specific_data;
uint32_t ts_size = get_uint32_be(&track->mdpr_header.type_specific_size);
real_demuxer_cptr dmx(new real_demuxer_t(track));
if (RMFF_TRACK_TYPE_VIDEO == track->type) {
dmx->rvp = (real_video_props_t *)track->mdpr_header.type_specific_data;
memcpy(dmx->fourcc, &dmx->rvp->fourcc2, 4);
dmx->fourcc[4] = 0;
dmx->width = get_uint16_be(&dmx->rvp->width);
dmx->height = get_uint16_be(&dmx->rvp->height);
uint32_t i = get_uint32_be(&dmx->rvp->fps);
dmx->fps = (float)((i & 0xffff0000) >> 16) + ((float)(i & 0x0000ffff)) / 65536.0;
dmx->private_data = (unsigned char *)safememdup(ts_data, ts_size);
dmx->private_size = ts_size;
demuxers.push_back(dmx);
} else if (RMFF_TRACK_TYPE_AUDIO == track->type) {
void
dts_reader_c::create_packetizer(int64_t) {
if (!demuxing_requested('a', 0) || (NPTZR() != 0))
return;
add_packetizer(new dts_packetizer_c(this, m_ti, m_dtsheader));
show_packetizer_info(0, PTZR0);
if (m_debug)
m_dtsheader.print();
}
void
pgssup_reader_c::create_packetizer(int64_t) {
if (!demuxing_requested('s', 0) || (NPTZR() != 0))
return;
pgs_packetizer_c *ptzr = new pgs_packetizer_c(this, m_ti);
ptzr->set_aggregate_packets(true);
add_packetizer(ptzr);
show_packetizer_info(0, ptzr);
}
void
mpeg_es_reader_c::create_packetizer(int64_t) {
generic_packetizer_c *m2vpacketizer;
if (!demuxing_requested('v', 0) || (NPTZR() != 0))
return;
m2vpacketizer = new mpeg1_2_video_packetizer_c(this, m_ti, version, frame_rate, width, height, dwidth, dheight, false);
add_packetizer(m2vpacketizer);
m2vpacketizer->set_video_interlaced_flag(interlaced);
show_packetizer_info(0, m2vpacketizer);
}
void
usf_reader_c::create_packetizer(int64_t tid) {
if ((0 > tid) || (m_tracks.size() <= static_cast<size_t>(tid)))
return;
auto track = m_tracks[tid];
if (!demuxing_requested('s', tid) || (-1 != track->m_ptzr))
return;
m_ti.m_private_data = memory_c::clone(m_private_data);
m_ti.m_language = track->m_language;
track->m_ptzr = add_packetizer(new textsubs_packetizer_c(this, m_ti, MKV_S_TEXTUSF, false, true));
show_packetizer_info(tid, PTZR(track->m_ptzr));
}
void
avi_reader_c::create_subs_packetizer(int idx) {
if (!demuxing_requested('s', 1 + AVI_audio_tracks(m_avi) + idx))
return;
m_ti.m_private_data.reset();
avi_subs_demuxer_t &demuxer = m_subtitle_demuxers[idx];
demuxer.m_text_io = mm_text_io_cptr(new mm_text_io_c(new mm_mem_io_c(demuxer.m_subtitles->get_buffer(), demuxer.m_subtitles->get_size())));
if (avi_subs_demuxer_t::TYPE_SRT == demuxer.m_type)
create_srt_packetizer(idx);
else if (avi_subs_demuxer_t::TYPE_SSA == demuxer.m_type)
create_ssa_packetizer(idx);
}
void
ivf_reader_c::create_packetizer(int64_t) {
if (!demuxing_requested('v', 0) || (NPTZR() != 0))
return;
vp8_video_packetizer_c *packetizer = new vp8_video_packetizer_c(this, m_ti);
add_packetizer(packetizer);
packetizer->set_video_pixel_width(m_width);
packetizer->set_video_pixel_height(m_height);
uint64_t default_duration = 1000000000ll * m_frame_rate_den / m_frame_rate_num;
if (default_duration >= 1000000)
packetizer->set_track_default_duration(default_duration);
show_packetizer_info(0, packetizer);
}
void
truehd_reader_c::create_packetizer(int64_t tid) {
if (!demuxing_requested('a', tid))
return;
m_ti.m_id = tid;
if (0 == tid) {
m_truehd_ptzr = add_packetizer(new truehd_packetizer_c(this, m_ti, m_header->m_codec, m_header->m_sampling_rate, m_header->m_channels));
show_packetizer_info(0, PTZR(m_truehd_ptzr));
m_converter.set_packetizer(PTZR(m_truehd_ptzr));
} else if ((1 == tid) && m_ac3_header.m_valid) {
m_ac3_ptzr = add_packetizer(new ac3_packetizer_c(this, m_ti, m_ac3_header.m_sample_rate, m_ac3_header.m_channels, m_ac3_header.m_bs_id, true));
show_packetizer_info(m_ti.m_id, PTZR(m_ac3_ptzr));
m_converter.set_ac3_packetizer(PTZR(m_ac3_ptzr));
}
}
void
aac_reader_c::create_packetizer(int64_t) {
if (!demuxing_requested('a', 0) || (NPTZR() != 0))
return;
if (!m_sbr_status_set)
mxwarn(Y("AAC files may contain HE-AAC / AAC+ / SBR AAC audio. "
"This can NOT be detected automatically. Therefore you have to "
"specifiy '--aac-is-sbr 0' manually for this input file if the "
"file actually contains SBR AAC. The file will be muxed in the "
"WRONG way otherwise. Also read mkvmerge's documentation.\n"));
generic_packetizer_c *aacpacketizer = new aac_packetizer_c(this, m_ti, m_aacheader.id, m_aacheader.profile, m_aacheader.sample_rate, m_aacheader.channels, m_emphasis_present);
add_packetizer(aacpacketizer);
if (AAC_PROFILE_SBR == m_aacheader.profile)
aacpacketizer->set_audio_output_sampling_freq(m_aacheader.sample_rate * 2);
show_packetizer_info(0, aacpacketizer);
}
/*
The page is the beginning of a new stream. Check the contents for known
stream headers. If it is a known stream and the user has requested that
it should be extracted then allocate a new packetizer based on the
stream type and store the needed data in a new ogm_demuxer_c.
*/
void
ogm_reader_c::handle_new_stream(ogg_page *og) {
ogg_stream_state os;
ogg_packet op;
if (ogg_stream_init(&os, ogg_page_serialno(og))) {
mxwarn_fn(m_ti.m_fname, boost::format(Y("ogg_stream_init for stream number %1% failed. Will try to continue and ignore this stream.\n")) % sdemuxers.size());
return;
}
// Read the first page and get its first packet.
ogg_stream_pagein(&os, og);
ogg_stream_packetout(&os, &op);
ogm_demuxer_c *dmx = nullptr;
/*
* Check the contents for known stream headers. This one is the
* standard Vorbis header.
*/
if ((7 <= op.bytes) && !strncmp((char *)&op.packet[1], "vorbis", 6))
dmx = new ogm_a_vorbis_demuxer_c(this);
else if ((7 <= op.bytes) && !strncmp((char *)&op.packet[1], "theora", 6))
dmx = new ogm_v_theora_demuxer_c(this);
else if ((8 <= op.bytes) && !memcmp(&op.packet[1], "kate\0\0\0", 7))
dmx = new ogm_s_kate_demuxer_c(this);
// FLAC
else if ( ((4 <= op.bytes) && !strncmp(reinterpret_cast<char *>(&op.packet[0]), "fLaC", 4))
|| ((5 <= op.bytes) && !strncmp(reinterpret_cast<char *>(&op.packet[1]), "FLAC", 4) && (0x7f == op.packet[0]))) {
#if !defined(HAVE_FLAC_FORMAT_H)
if (demuxing_requested('a', sdemuxers.size()))
mxerror_fn(m_ti.m_fname, Y("mkvmerge has not been compiled with FLAC support but handling of this stream has been requested.\n"));
else {
dmx = new ogm_demuxer_c(this);
dmx->stype = OGM_STREAM_TYPE_A_FLAC;
dmx->in_use = true;
}
#else
dmx = new ogm_a_flac_demuxer_c(this, 0x7f == op.packet[0] ? ofm_post_1_1_1 : ofm_pre_1_1_1);
#endif
} else if ((static_cast<size_t>(op.bytes) >= sizeof(vp8_ogg_header_t)) && (0x4f == op.packet[0]) && (get_uint32_be(&op.packet[1]) == 0x56503830))
dmx = new ogm_v_vp8_demuxer_c(this, op);
else if (((*op.packet & PACKET_TYPE_BITS ) == PACKET_TYPE_HEADER) && (op.bytes >= ((int)sizeof(stream_header) + 1))) {
// The new stream headers introduced by OggDS (see ogmstreams.h).
stream_header *sth = (stream_header *)(op.packet + 1);
char buf[5];
buf[4] = 0;
if (!strncmp(sth->streamtype, "video", 5)) {
memcpy(buf, (char *)sth->subtype, 4);
if (mpeg4::p10::is_avc_fourcc(buf) && !hack_engaged(ENGAGE_ALLOW_AVC_IN_VFW_MODE))
dmx = new ogm_v_avc_demuxer_c(this);
else
dmx = new ogm_v_mscomp_demuxer_c(this);
} else if (!strncmp(sth->streamtype, "audio", 5)) {
memcpy(buf, (char *)sth->subtype, 4);
uint32_t codec_id = strtol(buf, (char **)nullptr, 16);
if (0x0001 == codec_id)
dmx = new ogm_a_pcm_demuxer_c(this);
else if ((0x0050 == codec_id) || (0x0055 == codec_id))
dmx = new ogm_a_mp3_demuxer_c(this);
else if (0x2000 == codec_id)
dmx = new ogm_a_ac3_demuxer_c(this);
else if (0x00ff == codec_id)
dmx = new ogm_a_aac_demuxer_c(this);
else
mxwarn_fn(m_ti.m_fname, boost::format(Y("Unknown audio stream type 0x%|1$04x|. Stream ID %2% will be ignored.\n")) % codec_id % sdemuxers.size());
} else if (!strncmp(sth->streamtype, "text", 4))
dmx = new ogm_s_text_demuxer_c(this);
}
/*
* The old OggDS headers (see MPlayer's source, libmpdemux/demux_ogg.c)
* are not supported.
*/
if (!dmx)
dmx = new ogm_demuxer_c(this);
std::string type = dmx->get_type();
dmx->serialno = ogg_page_serialno(og);
dmx->track_id = sdemuxers.size();
dmx->in_use = (type != "unknown") && demuxing_requested(type[0], dmx->track_id);
dmx->packet_data.push_back(memory_cptr(new memory_c((unsigned char *)safememdup(op.packet, op.bytes), op.bytes, true)));
memcpy(&dmx->os, &os, sizeof(ogg_stream_state));
sdemuxers.push_back(ogm_demuxer_cptr(dmx));
dmx->initialize();
}