void
ogm_reader_c::create_packetizer(int64_t tid) {
ogm_demuxer_cptr dmx;
generic_packetizer_c *ptzr;
if ((0 > tid) || (sdemuxers.size() <= static_cast<size_t>(tid)))
return;
dmx = sdemuxers[tid];
if (!dmx->in_use)
return;
m_ti.m_private_data = nullptr;
m_ti.m_private_size = 0;
m_ti.m_id = tid;
m_ti.m_language = dmx->language;
m_ti.m_track_name = dmx->title;
ptzr = dmx->create_packetizer();
if (ptzr)
dmx->ptzr = add_packetizer(ptzr);
m_ti.m_language.clear();
m_ti.m_track_name.clear();
}
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
avi_reader_c::create_mpeg4_p10_packetizer() {
try {
mpeg4_p10_es_video_packetizer_c *ptzr = new mpeg4_p10_es_video_packetizer_c(this, m_ti);
m_vptzr = add_packetizer(ptzr);
ptzr->set_video_pixel_dimensions(AVI_video_width(m_avi), AVI_video_height(m_avi));
if (0 != m_fps)
ptzr->set_container_default_field_duration(1000000000ll / m_fps / 2);
uint32_t extra_data_size = get_uint32_le(&m_avi->bitmap_info_header->bi_size) - sizeof(alBITMAPINFOHEADER);
if (0 < extra_data_size) {
memory_cptr avc_extra_nalus = mpeg4::p10::avcc_to_nalus(reinterpret_cast<unsigned char *>(m_avi->bitmap_info_header + 1), extra_data_size);
if (avc_extra_nalus)
ptzr->add_extra_data(avc_extra_nalus);
}
set_avc_nal_size_size(ptzr);
show_packetizer_info(0, ptzr);
} catch (...) {
mxerror_tid(m_ti.m_fname, 0, Y("Could not extract the decoder specific config data (AVCC) from this AVC/h.264 track.\n"));
}
}
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
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
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
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
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
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
avi_reader_c::create_vp8_packetizer() {
m_ti.m_private_data.reset();
m_vptzr = add_packetizer(new vpx_video_packetizer_c(this, m_ti, ivf::VP8));
PTZR(m_vptzr)->set_track_default_duration(1000000000ll / m_fps);
PTZR(m_vptzr)->set_video_pixel_width(AVI_video_width(m_avi));
PTZR(m_vptzr)->set_video_pixel_height(AVI_video_height(m_avi));
show_packetizer_info(0, PTZR(m_vptzr));
}
void
avi_reader_c::create_mpeg1_2_packetizer() {
std::shared_ptr<M2VParser> m2v_parser(new M2VParser);
m2v_parser->SetProbeMode();
if (m_ti.m_private_data && (m_ti.m_private_data->get_size() < sizeof(alBITMAPINFOHEADER)))
m2v_parser->WriteData(m_ti.m_private_data->get_buffer() + sizeof(alBITMAPINFOHEADER), m_ti.m_private_data->get_size() - sizeof(alBITMAPINFOHEADER));
unsigned int frame_number = 0;
unsigned int state = m2v_parser->GetState();
while ((frame_number < std::min(m_max_video_frames, 100u)) && (MPV_PARSER_STATE_FRAME != state)) {
++frame_number;
int size = AVI_frame_size(m_avi, frame_number - 1);
if (0 == size)
continue;
AVI_set_video_position(m_avi, frame_number - 1);
memory_cptr buffer = memory_c::alloc(size);
int key = 0;
int num_read = AVI_read_frame(m_avi, reinterpret_cast<char *>(buffer->get_buffer()), &key);
if (0 >= num_read)
continue;
m2v_parser->WriteData(buffer->get_buffer(), num_read);
state = m2v_parser->GetState();
}
AVI_set_video_position(m_avi, 0);
if (MPV_PARSER_STATE_FRAME != state)
mxerror_tid(m_ti.m_fname, 0, Y("Could not extract the sequence header from this MPEG-1/2 track.\n"));
MPEG2SequenceHeader seq_hdr = m2v_parser->GetSequenceHeader();
std::shared_ptr<MPEGFrame> frame(m2v_parser->ReadFrame());
if (!frame)
mxerror_tid(m_ti.m_fname, 0, Y("Could not extract the sequence header from this MPEG-1/2 track.\n"));
int display_width = ((0 >= seq_hdr.aspectRatio) || (1 == seq_hdr.aspectRatio)) ? seq_hdr.width : static_cast<int>(seq_hdr.height * seq_hdr.aspectRatio);
MPEGChunk *raw_seq_hdr = m2v_parser->GetRealSequenceHeader();
if (raw_seq_hdr)
m_ti.m_private_data = memory_c::clone(raw_seq_hdr->GetPointer(), raw_seq_hdr->GetSize());
else
m_ti.m_private_data.reset();
m_vptzr = add_packetizer(new mpeg1_2_video_packetizer_c(this, m_ti, m2v_parser->GetMPEGVersion(), seq_hdr.frameOrFieldRate,
seq_hdr.width, seq_hdr.height, display_width, seq_hdr.height, false));
show_packetizer_info(0, PTZR(m_vptzr));
}
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_srt_packetizer(int idx) {
avi_subs_demuxer_t &demuxer = m_subtitle_demuxers[idx];
int id = idx + 1 + AVI_audio_tracks(m_avi);
srt_parser_c *parser = new srt_parser_c(demuxer.m_text_io.get(), m_ti.m_fname, id);
demuxer.m_subs = subtitles_cptr(parser);
parser->parse();
bool is_utf8 = demuxer.m_text_io->get_byte_order() != BO_NONE;
demuxer.m_ptzr = add_packetizer(new textsubs_packetizer_c(this, m_ti, MKV_S_TEXTUTF8, true, is_utf8));
show_packetizer_info(id, PTZR(demuxer.m_ptzr));
}
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
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);
}
void
avi_reader_c::create_ssa_packetizer(int idx) {
avi_subs_demuxer_t &demuxer = m_subtitle_demuxers[idx];
int id = idx + 1 + AVI_audio_tracks(m_avi);
ssa_parser_c *parser = new ssa_parser_c(this, demuxer.m_text_io.get(), m_ti.m_fname, id);
demuxer.m_subs = subtitles_cptr(parser);
charset_converter_cptr cc_utf8 = map_has_key(m_ti.m_sub_charsets, id) ? charset_converter_c::init(m_ti.m_sub_charsets[id])
: map_has_key(m_ti.m_sub_charsets, -1) ? charset_converter_c::init(m_ti.m_sub_charsets[-1])
: demuxer.m_text_io->get_byte_order() != BO_NONE ? charset_converter_c::init("UTF-8")
: g_cc_local_utf8;
parser->set_charset_converter(cc_utf8);
parser->set_attachment_id_base(g_attachments.size());
parser->parse();
m_ti.m_private_data = memory_c::clone(parser->get_global());
demuxer.m_ptzr = add_packetizer(new textsubs_packetizer_c(this, m_ti, parser->is_ass() ? MKV_S_TEXTASS : MKV_S_TEXTSSA, false, false));
show_packetizer_info(id, PTZR(demuxer.m_ptzr));
}
void
avi_reader_c::create_standard_video_packetizer() {
m_vptzr = add_packetizer(new video_for_windows_packetizer_c(this, m_ti, m_fps, m_video_width, m_video_height));
show_packetizer_info(0, PTZR(m_vptzr));
}
void
avi_reader_c::add_audio_demuxer(int aid) {
for (auto &demuxer : m_audio_demuxers)
if (demuxer.m_aid == aid) // Demuxer already added?
return;
AVI_set_audio_track(m_avi, aid);
if (AVI_read_audio_chunk(m_avi, nullptr) < 0) {
mxwarn(boost::format(Y("Could not find an index for audio track %1% (avilib error message: %2%). Skipping track.\n")) % (aid + 1) % AVI_strerror());
return;
}
avi_demuxer_t demuxer;
generic_packetizer_c *packetizer = nullptr;
alWAVEFORMATEX *wfe = m_avi->wave_format_ex[aid];
uint32_t audio_format = AVI_audio_format(m_avi);
demuxer.m_aid = aid;
demuxer.m_ptzr = -1;
demuxer.m_samples_per_second = AVI_audio_rate(m_avi);
demuxer.m_channels = AVI_audio_channels(m_avi);
demuxer.m_bits_per_sample = AVI_audio_bits(m_avi);
m_ti.m_id = aid + 1; // ID for this audio track.
auto stream_header = &m_avi->stream_headers[aid];
auto dw_scale = static_cast<int64_t>(get_uint32_le(&stream_header->dw_scale));
auto dw_rate = static_cast<int64_t>(get_uint32_le(&stream_header->dw_rate));
auto dw_sample_size = static_cast<int64_t>(get_uint32_le(&stream_header->dw_sample_size));
m_ti.m_avi_audio_data_rate = dw_scale ? dw_rate * dw_sample_size / dw_scale : 0;
if ((0xfffe == audio_format) && (get_uint16_le(&wfe->cb_size) >= (sizeof(alWAVEFORMATEXTENSION)))) {
alWAVEFORMATEXTENSIBLE *ext = reinterpret_cast<alWAVEFORMATEXTENSIBLE *>(wfe);
audio_format = get_uint32_le(&ext->extension.guid.data1);
} else if (get_uint16_le(&wfe->cb_size) > 0)
m_ti.m_private_data = memory_c::clone(wfe + 1, get_uint16_le(&wfe->cb_size));
else
m_ti.m_private_data.reset();
demuxer.m_codec = codec_c::look_up_audio_format(audio_format);
if (demuxer.m_codec.is(codec_c::type_e::A_PCM))
packetizer = new pcm_packetizer_c(this, m_ti, demuxer.m_samples_per_second, demuxer.m_channels, demuxer.m_bits_per_sample, 0x0003 == audio_format ? pcm_packetizer_c::ieee_float : pcm_packetizer_c::little_endian_integer);
else if (demuxer.m_codec.is(codec_c::type_e::A_MP2) || demuxer.m_codec.is(codec_c::type_e::A_MP3))
packetizer = new mp3_packetizer_c(this, m_ti, demuxer.m_samples_per_second, demuxer.m_channels, false);
else if (demuxer.m_codec.is(codec_c::type_e::A_AC3))
packetizer = new ac3_packetizer_c(this, m_ti, demuxer.m_samples_per_second, demuxer.m_channels, 0);
else if (demuxer.m_codec.is(codec_c::type_e::A_DTS))
packetizer = create_dts_packetizer(aid);
else if (demuxer.m_codec.is(codec_c::type_e::A_AAC))
packetizer = create_aac_packetizer(aid, demuxer);
else if (demuxer.m_codec.is(codec_c::type_e::A_VORBIS))
packetizer = create_vorbis_packetizer(aid);
else
mxerror_tid(m_ti.m_fname, aid + 1, boost::format(Y("Unknown/unsupported audio format 0x%|1$04x| for this audio track.\n")) % audio_format);
packetizer->enable_avi_audio_sync(true);
show_packetizer_info(aid + 1, packetizer);
demuxer.m_ptzr = add_packetizer(packetizer);
m_audio_demuxers.push_back(demuxer);
int i, maxchunks = AVI_audio_chunks(m_avi);
for (i = 0; i < maxchunks; i++) {
auto size = AVI_audio_size(m_avi, i);
if (size < AVI_MAX_AUDIO_CHUNK_SIZE)
m_bytes_to_process += size;
}
}
void
avi_reader_c::add_audio_demuxer(int aid) {
for (auto &demuxer : m_audio_demuxers)
if (demuxer.m_aid == aid) // Demuxer already added?
return;
AVI_set_audio_track(m_avi, aid);
if (AVI_read_audio_chunk(m_avi, nullptr) < 0) {
mxwarn(boost::format(Y("Could not find an index for audio track %1% (avilib error message: %2%). Skipping track.\n")) % (aid + 1) % AVI_strerror());
return;
}
avi_demuxer_t demuxer;
generic_packetizer_c *packetizer = nullptr;
alWAVEFORMATEX *wfe = m_avi->wave_format_ex[aid];
uint32_t audio_format = AVI_audio_format(m_avi);
demuxer.m_aid = aid;
demuxer.m_ptzr = -1;
demuxer.m_samples_per_second = AVI_audio_rate(m_avi);
demuxer.m_channels = AVI_audio_channels(m_avi);
demuxer.m_bits_per_sample = AVI_audio_bits(m_avi);
m_ti.m_id = aid + 1; // ID for this audio track.
m_ti.m_avi_block_align = get_uint16_le(&wfe->n_block_align);
m_ti.m_avi_avg_bytes_per_sec = get_uint32_le(&wfe->n_avg_bytes_per_sec);
m_ti.m_avi_samples_per_chunk = get_uint32_le(&m_avi->stream_headers[aid].dw_scale);
m_ti.m_avi_sample_scale = get_uint32_le(&m_avi->stream_headers[aid].dw_rate);
m_ti.m_avi_samples_per_sec = demuxer.m_samples_per_second;
if ((0xfffe == audio_format) && (get_uint16_le(&wfe->cb_size) >= (sizeof(alWAVEFORMATEXTENSION)))) {
alWAVEFORMATEXTENSIBLE *ext = reinterpret_cast<alWAVEFORMATEXTENSIBLE *>(wfe);
audio_format = get_uint32_le(&ext->extension.guid.data1);
} else if (get_uint16_le(&wfe->cb_size) > 0)
m_ti.m_private_data = memory_c::clone(wfe + 1, get_uint16_le(&wfe->cb_size));
else
m_ti.m_private_data.reset();
switch(audio_format) {
case 0x0001: // raw PCM audio
case 0x0003: // raw PCM audio (float)
packetizer = new pcm_packetizer_c(this, m_ti, demuxer.m_samples_per_second, demuxer.m_channels, demuxer.m_bits_per_sample, 0x0003 == audio_format ? pcm_packetizer_c::ieee_float : pcm_packetizer_c::little_endian_integer);
break;
case 0x0050: // MP2
case 0x0055: // MP3
packetizer = new mp3_packetizer_c(this, m_ti, demuxer.m_samples_per_second, demuxer.m_channels, false);
break;
case 0x2000: // AC3
packetizer = new ac3_packetizer_c(this, m_ti, demuxer.m_samples_per_second, demuxer.m_channels, 0);
break;
case 0x2001: // DTS
packetizer = create_dts_packetizer(aid);
break;
case 0x00ff:
case 0x706d: // AAC
packetizer = create_aac_packetizer(aid, demuxer);
break;
case 0x566f: // Vorbis
packetizer = create_vorbis_packetizer(aid);
break;
default:
mxerror_tid(m_ti.m_fname, aid + 1, boost::format(Y("Unknown/unsupported audio format 0x%|1$04x| for this audio track.\n")) % audio_format);
}
show_packetizer_info(aid + 1, packetizer);
demuxer.m_ptzr = add_packetizer(packetizer);
m_audio_demuxers.push_back(demuxer);
int i, maxchunks = AVI_audio_chunks(m_avi);
for (i = 0; i < maxchunks; i++)
m_bytes_to_process += AVI_audio_size(m_avi, i);
}
void
avi_reader_c::create_standard_video_packetizer() {
m_vptzr = add_packetizer(new video_packetizer_c(this, m_ti, nullptr, m_fps, AVI_video_width(m_avi), AVI_video_height(m_avi)));
show_packetizer_info(0, PTZR(m_vptzr));
}
void
avi_reader_c::create_mpeg4_p2_packetizer() {
m_vptzr = add_packetizer(new mpeg4_p2_video_packetizer_c(this, m_ti, m_fps, AVI_video_width(m_avi), AVI_video_height(m_avi), false));
show_packetizer_info(0, PTZR(m_vptzr));
}