/* 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(); }