/*
General reader. Read a page and hand it over for processing.
*/
file_status_e
ogm_reader_c::read(generic_packetizer_c *,
bool) {
// Some tracks may contain huge gaps. We don't want to suck in the complete
// file.
if (get_queued_bytes() > 20 * 1024 * 1024)
return FILE_STATUS_HOLDING;
ogg_page og;
do {
// Make sure we have a page that we can work with.
if (read_page(&og) == FILE_STATUS_DONE)
return flush_packetizers();
// Is this the first page of a new stream? No, so process it normally.
if (!ogg_page_bos(&og))
process_page(&og);
} while (ogg_page_bos(&og));
size_t i;
// Are there streams that have not finished yet?
for (i = 0; i < sdemuxers.size(); i++)
if (!sdemuxers[i]->eos && sdemuxers[i]->in_use)
return FILE_STATUS_MOREDATA;
// No, we're done with this file.
return flush_packetizers();
}
file_status_e
wav_reader_c::read(generic_packetizer_c *,
bool) {
if (!m_demuxer)
return FILE_STATUS_DONE;
int64_t requested_bytes = std::min(m_remaining_bytes_in_current_data_chunk, m_demuxer->get_preferred_input_size());
unsigned char *buffer = m_demuxer->get_buffer();
int64_t num_read;
num_read = m_in->read(buffer, requested_bytes);
if (0 >= num_read)
return flush_packetizers();
m_demuxer->process(num_read);
m_remaining_bytes_in_current_data_chunk -= num_read;
if (!m_remaining_bytes_in_current_data_chunk) {
m_cur_data_chunk_idx = find_chunk("data", m_cur_data_chunk_idx + 1, false);
if (-1 == m_cur_data_chunk_idx)
return flush_packetizers();
m_in->setFilePointer(m_chunks[m_cur_data_chunk_idx].pos + sizeof(struct chunk_struct), seek_beginning);
m_remaining_bytes_in_current_data_chunk = m_chunks[m_cur_data_chunk_idx].len;
}
return FILE_STATUS_MOREDATA;
}
file_status_e
ivf_reader_c::read(generic_packetizer_c *,
bool) {
size_t remaining_bytes = m_size - m_in->getFilePointer();
ivf::frame_header_t header;
if ((sizeof(ivf::frame_header_t) > remaining_bytes) || (m_in->read(&header, sizeof(ivf::frame_header_t)) != sizeof(ivf::frame_header_t)))
return flush_packetizers();
remaining_bytes -= sizeof(ivf::frame_header_t);
uint32_t frame_size = get_uint32_le(&header.frame_size);
if (remaining_bytes < frame_size) {
m_in->setFilePointer(0, seek_end);
return flush_packetizers();
}
memory_cptr buffer = memory_c::alloc(frame_size);
if (m_in->read(buffer->get_buffer(), frame_size) < frame_size) {
m_in->setFilePointer(0, seek_end);
return flush_packetizers();
}
int64_t timestamp = get_uint64_le(&header.timestamp) * 1000000000ull * m_frame_rate_den / m_frame_rate_num;
mxverb(3, boost::format("r_ivf.cpp: key %5% header.ts %1% num %2% den %3% res %4%\n") % get_uint64_le(&header.timestamp) % m_frame_rate_num % m_frame_rate_den % timestamp % ivf::is_keyframe(buffer));
PTZR0->process(new packet_t(buffer, timestamp));
return FILE_STATUS_MOREDATA;
}
file_status_e
vc1_es_reader_c::read(generic_packetizer_c *,
bool) {
if (m_in->getFilePointer() >= m_size)
return flush_packetizers();
int num_read = m_in->read(m_buffer->get_buffer(), READ_SIZE);
if (0 < num_read)
PTZR0->process(new packet_t(new memory_c(m_buffer->get_buffer(), num_read)));
return ((READ_SIZE != num_read) || (m_in->getFilePointer() >= m_size)) ? flush_packetizers() : FILE_STATUS_MOREDATA;
}
file_status_e
mpeg_es_reader_c::read(generic_packetizer_c *,
bool) {
int64_t bytes_to_read = std::min(static_cast<uint64_t>(READ_SIZE), m_size - m_in->getFilePointer());
if (0 >= bytes_to_read)
return flush_packetizers();
memory_cptr chunk = memory_c::alloc(bytes_to_read);
int64_t num_read = m_in->read(chunk, bytes_to_read);
if (0 < num_read) {
chunk->set_size(num_read);
PTZR0->process(new packet_t(chunk));
}
return bytes_to_read > num_read ? flush_packetizers() : FILE_STATUS_MOREDATA;
}
file_status_e
dts_reader_c::read(generic_packetizer_c *,
bool) {
size_t num_read = m_in->read(m_buf[m_cur_buf], READ_SIZE);
if (m_dts14_to_16)
num_read &= ~0xf;
if (0 >= num_read)
return flush_packetizers();
int num_to_output = decode_buffer(num_read);
PTZR0->process(new packet_t(new memory_c(m_buf[m_cur_buf], num_to_output, false)));
return ((num_read < READ_SIZE) || m_in->eof()) ? flush_packetizers() : FILE_STATUS_MOREDATA;
}
file_status_e
ssa_reader_c::read(generic_packetizer_c *,
bool) {
if (!m_subs->empty())
m_subs->process((textsubs_packetizer_c *)PTZR0);
return m_subs->empty() ? flush_packetizers() : FILE_STATUS_MOREDATA;
}
file_status_e
flac_reader_c::read(generic_packetizer_c *,
bool) {
if (current_block == blocks.end())
return flush_packetizers();
memory_cptr buf = memory_c::alloc(current_block->len);
m_in->setFilePointer(current_block->filepos);
if (m_in->read(buf, current_block->len) != current_block->len)
return flush_packetizers();
unsigned int samples_here = mtx::flac::get_num_samples(buf->get_buffer(), current_block->len, stream_info);
PTZR0->process(new packet_t(buf, samples * 1000000000 / sample_rate));
samples += samples_here;
current_block++;
return (current_block == blocks.end()) ? flush_packetizers() : FILE_STATUS_MOREDATA;
}
file_status_e
mp3_reader_c::read(generic_packetizer_c *,
bool) {
int nread = m_in->read(m_chunk->get_buffer(), CHUNK_SIZE);
if (0 >= nread)
return flush_packetizers();
PTZR0->process(new packet_t(new memory_c(m_chunk->get_buffer(), nread, false)));
return FILE_STATUS_MOREDATA;
}
file_status_e
dts_reader_c::read(generic_packetizer_c *,
bool) {
auto chunks_end = m_chunks.end();
if (m_current_chunk == chunks_end)
return flush_packetizers();
auto bytes_to_read = std::min<int64_t>(m_current_chunk->data_end - std::min(m_in->getFilePointer(), m_current_chunk->data_end), READ_SIZE);
if (m_dts14_to_16)
bytes_to_read &= ~0xf;
auto num_read = m_in->read(m_buf[m_cur_buf], bytes_to_read);
if (0 >= num_read)
return flush_packetizers();
int num_to_output = decode_buffer(num_read);
PTZR0->process(new packet_t(new memory_c(m_buf[m_cur_buf], num_to_output, false)));
if (m_in->eof() || (num_read < bytes_to_read))
return flush_packetizers();
if (m_in->getFilePointer() < m_current_chunk->data_end)
return FILE_STATUS_MOREDATA;
++m_current_chunk;
while ((m_current_chunk != chunks_end) && (m_current_chunk->type != chunk_type_e::strmdata))
++m_current_chunk;
if (m_current_chunk == chunks_end)
return flush_packetizers();
m_in->setFilePointer(m_current_chunk->data_start);
return FILE_STATUS_MOREDATA;
}
file_status_e
pgssup_reader_c::read(generic_packetizer_c *,
bool) {
try {
if (m_debug)
mxinfo(boost::format("pgssup_reader_c::read(): ---------- start read at %1%\n") % m_in->getFilePointer());
if (PGSSUP_FILE_MAGIC != m_in->read_uint16_be())
return flush_packetizers();
uint64_t timestamp = static_cast<uint64_t>(m_in->read_uint32_be()) * 100000Lu / 9;
m_in->skip(4);
memory_cptr frame = memory_c::alloc(3);
if (3 != m_in->read(frame->get_buffer(), 3))
return flush_packetizers();
unsigned int segment_size = get_uint16_be(frame->get_buffer() + 1);
frame->resize(3 + segment_size);
if (segment_size != m_in->read(frame->get_buffer() + 3, segment_size))
return flush_packetizers();
if (m_debug)
mxinfo(boost::format("pgssup_reader_c::read(): type %|1$02x| size %2% at %3%\n") % static_cast<unsigned int>(frame->get_buffer()[0]) % segment_size % (m_in->getFilePointer() - 10 - 3));
PTZR0->process(new packet_t(frame, timestamp));
} catch (...) {
if (m_debug)
mxinfo("pgssup_reader_c::read(): exception\n");
return flush_packetizers();
}
return FILE_STATUS_MOREDATA;
}
file_status_e
tta_reader_c::read(generic_packetizer_c *,
bool) {
if (seek_points.size() <= pos)
return flush_packetizers();
unsigned char *buf = (unsigned char *)safemalloc(seek_points[pos]);
int nread = m_in->read(buf, seek_points[pos]);
if (0 >= nread)
return flush_packetizers();
pos++;
memory_cptr mem(new memory_c(buf, nread, true));
if (seek_points.size() <= pos) {
double samples_left = (double)get_uint32_le(&header.data_length) - (seek_points.size() - 1) * TTA_FRAME_TIME * get_uint32_le(&header.sample_rate);
mxverb(2, boost::format("tta: samples_left %1%\n") % samples_left);
PTZR0->process(new packet_t(mem, -1, irnd(samples_left * 1000000000.0l / get_uint32_le(&header.sample_rate))));
} else
PTZR0->process(new packet_t(mem));
return seek_points.size() <= pos ? flush_packetizers() : FILE_STATUS_MOREDATA;
}
file_status_e
avi_reader_c::read(generic_packetizer_c *ptzr,
bool) {
if ((-1 != m_vptzr) && (PTZR(m_vptzr) == ptzr))
return read_video();
for (auto &demuxer : m_audio_demuxers)
if ((-1 != demuxer.m_ptzr) && (PTZR(demuxer.m_ptzr) == ptzr))
return read_audio(demuxer);
for (auto &subs_demuxer : m_subtitle_demuxers)
if ((-1 != subs_demuxer.m_ptzr) && (PTZR(subs_demuxer.m_ptzr) == ptzr))
return read_subtitles(subs_demuxer);
return flush_packetizers();
}
file_status_e
hevc_es_reader_c::read(generic_packetizer_c *,
bool) {
if (m_in->getFilePointer() >= m_size)
return FILE_STATUS_DONE;
int num_read = m_in->read(m_buffer->get_buffer(), READ_SIZE);
if (0 < num_read)
PTZR0->process(new packet_t(new memory_c(m_buffer->get_buffer(), num_read)));
return (0 != num_read) && (m_in->getFilePointer() < m_size) ? FILE_STATUS_MOREDATA : flush_packetizers();
}
file_status_e
aac_reader_c::read(generic_packetizer_c *,
bool) {
int remaining_bytes = m_size - m_in->getFilePointer();
int read_len = std::min(INITCHUNKSIZE, remaining_bytes);
int num_read = m_in->read(m_chunk, read_len);
if (0 < num_read)
PTZR0->process(new packet_t(new memory_c(*m_chunk, num_read, false)));
return (0 != num_read) && (0 < (remaining_bytes - num_read)) ? FILE_STATUS_MOREDATA : flush_packetizers();
}
file_status_e
ac3_reader_c::read(generic_packetizer_c *,
bool) {
uint64_t remaining_bytes = m_size - m_in->getFilePointer();
uint64_t read_len = std::min(static_cast<uint64_t>(AC3_READ_SIZE), remaining_bytes);
int num_read = m_in->read(m_chunk->get_buffer(), read_len);
if (0 < num_read)
PTZR0->process(new packet_t(new memory_c(m_chunk->get_buffer(), num_read, false)));
return (0 != num_read) && (0 < (remaining_bytes - num_read)) ? FILE_STATUS_MOREDATA : flush_packetizers();
}
