#include "ReadStream.h" #include "avm_output.h" #include #include #include #ifdef HAVE_MEMALIGN #include // memalign #endif // HAVE_MEMALIGN AVM_BEGIN_NAMESPACE; #define __MODULE__ "reader" StreamPacket::StreamPacket(size_t bsize, void* mem) : memory((uint8_t*)mem), size(bsize), read(0), flags(0), timestamp(NO_TIMESTAMP), refcount(1) { if (!memory && size > 0) { #ifdef HAVE_MEMALIGN memory = (uint8_t*) memalign(16, size + 16); #else memory = (uint8_t*) malloc(size + 16); #endif } } StreamPacket::~StreamPacket() { //printf("******** Destroy stream packet %d\n", size); assert(refcount == 0); free(memory); } size_t StreamPacket::Read(void* to, size_t read_size) { if (read_size > GetSize()) read_size = GetSize(); if (to) memcpy(to, GetData(), read_size); read += read_size; return read_size; } IStream::~IStream() {} ReadStream::ReadStream(IMediaReadStream* stream) : m_pStream(stream), m_pPacket(0), m_iEof(0), rem_size(0), rem_local(0), rem_limit(0), m_uiLastPos(0), m_dLastTime(0.) { assert(m_pStream != 0); //assert(m_pStream->GetLength() < 0x7fffffff); m_uiFormatSize = m_pStream->GetFormat(); m_pFormat = new char[m_uiFormatSize]; m_pStream->GetFormat(m_pFormat, m_uiFormatSize); const char* tname; switch (GetType()) { case Video: tname = "video"; break; case Audio: tname = "audio"; break; default: tname = "unknown"; break; } AVM_WRITE(__MODULE__, "Initialized %s stream (chunk tblsz: %d, fmtsz: %" PRIsz ")\n", tname, m_pStream->GetLength(), m_uiFormatSize); } ReadStream::~ReadStream() { delete[] m_pFormat; if (m_pPacket) m_pPacket->Release(); } bool ReadStream::Eof() const { //printf("EOF %d %d\n", m_iEof, GetType()); return (m_iEof > 1); //AVM_WRITE(__MODULE__, "EOF %d Pos: %d Len: %d\n", m_iEof, GetPos(), m_pStream->GetLength()); //if (GetType() == IStream::Audio) // AVM_WRITE(__MODULE__, "%p EOF %d Pos: %f Len: %f t:%d\n", this, m_iEof, GetTime(), m_pStream->GetLengthTime(), GetType()); // using delta difference as comparing two doubles might have some epsilon problems if (m_iEof > 1 || (m_pStream->GetLengthTime() - GetTime()) < 0.001) { //AVM_WRITE(__MODULE__, "EOF\n"); return true; } return false; } void ReadStream::Flush() { m_iEof = 0; if (!m_pPacket) { rem_size = rem_local = 0; ReadPacket(); } } int ReadStream::GetFrameFlags(int* flags) const { int f = (m_pPacket && m_pPacket->GetFlags()) ? KEYFRAME : 0; if (flags) *flags = f; return f; } double ReadStream::GetFrameTime() const { return m_pStream->GetFrameTime(); } size_t ReadStream::GetHeader(void* pheader, size_t s) const { return m_pStream->GetHeader(pheader, s); } framepos_t ReadStream::GetLength() const { return m_pStream->GetLength(); } double ReadStream::GetLengthTime() const { return m_pStream->GetLengthTime(); } framepos_t ReadStream::GetPos() const { return m_uiLastPos; } framepos_t ReadStream::GetNextKeyFrame(framepos_t pos) const { AVM_WRITE(__MODULE__, 3, "GetNextKeyFrame() %d\n", pos); return m_pStream->GetNextKeyFrame((pos == ERR) ? GetPos() : pos); } framepos_t ReadStream::GetPrevKeyFrame(framepos_t pos) const { AVM_WRITE(__MODULE__, 3, "GetPrevKeyFrame() %d\n", pos); return m_pStream->GetPrevKeyFrame((pos == ERR) ? GetPos() : pos); } StreamInfo* ReadStream::GetStreamInfo() const { return m_pStream->GetStreamInfo(); } double ReadStream::GetTime(framepos_t pos) const { return (pos == ERR) ? m_dLastTime : m_pStream->GetTime(pos); } ReadStream::StreamType ReadStream::GetType() const { return m_pStream->GetType(); } int ReadStream::ReadDirect(void* buffer, size_t bufsize, size_t samples, size_t& samples_read, size_t& bytes_read, int* flags) { //printf("ReadDirect remsize:%d remlimit:%d bufsize:%d %p\n", (int)rem_size, (int)rem_limit, (int)bufsize, m_pPacket); if (!rem_size) { if (!m_iEof) ReadPacket(); if (!m_pPacket) { m_iEof++; return -1; } //printf("ReadDirect IN2 %d, %d\n", m_pPacket->read, m_pPacket->size); if (m_pPacket->GetSize()) { if (rem_limit < m_pPacket->GetSize()) { rem_limit = m_pPacket->GetSize(); rem_buffer.reserve(rem_limit + PADDING); } rem_flags = m_pPacket->GetFlags(); rem_local = 0; rem_size = m_pPacket->Read(&rem_buffer[rem_local], m_pPacket->GetSize()); ReadPacket(); } } //printf("ReadDirect b:%d r:%d\n", bufsize, rem_size); if (buffer) { bytes_read = (bufsize > rem_size) ? rem_size : bufsize; memcpy(buffer, &rem_buffer[rem_local], bytes_read); rem_local += bytes_read; rem_size -= bytes_read; samples_read = bytes_read; } else { // without buffer return size of available data bytes_read = rem_size; samples_read = rem_size; } size_t ssize = m_pStream->GetSampleSize(); if (ssize > 1) samples_read /= ssize; if (flags) *flags = rem_flags; //printf("ReadDirect br:%d sr:%d ssize:%d flg:%d\n", bytes_read, samples_read, ssize, rem_flags); return 0; } StreamPacket* ReadStream::ReadPacket() { //printf("READPACKET %d %f\n", GetType(), m_dLastTime); if (m_pPacket && !m_pPacket->GetSize()) { m_pPacket->Release(); m_pPacket = 0; } if (!m_pPacket) m_pPacket = m_pStream->ReadPacket(); if (m_pPacket) { if (m_pPacket->GetTimestamp() != StreamPacket::NO_TIMESTAMP) { m_uiLastPos = m_pPacket->GetPos(); m_dLastTime = m_pPacket->GetTime(); } } else { double t = m_pStream->GetTime(); AVM_WRITE(__MODULE__, 2, "FailedPacket GetTime %f\n", t); if (t != m_dLastTime) { m_dLastTime = t; m_uiLastPos++;// = ERR; } } //printf("ReadPacket type:%d tm:%f sz:%d\n", GetType(), m_dLastTime, m_pPacket ? m_pPacket->size : 0); return m_pPacket; } int ReadStream::Seek(framepos_t pos) { AVM_WRITE(__MODULE__, 2, "Seek(%d)\n", pos); int hr = m_pStream->Seek(pos); if (hr == 0) { if (m_pPacket) //m_pPacket->read = m_pPacket->size; m_pPacket->Release(); m_pPacket = 0; Flush(); } return hr; } int ReadStream::SeekTime(double timepos) { AVM_WRITE(__MODULE__, 2, "SeekTime(%f) (%f)\n", timepos, m_dLastTime); int hr = m_pStream->SeekTime(timepos); if (hr == 0) { if (m_pPacket) m_pPacket->Release(); m_pPacket = 0; Flush(); } return hr; } framepos_t ReadStream::SeekToKeyFrame(framepos_t pos) { return (Seek(pos) == 0) ? GetPos() : ERR; } double ReadStream::SeekTimeToKeyFrame(double timepos) { return (SeekTime(timepos) == 0) ? GetTime() : -1.0; } int ReadStream::SkipFrame() { AVM_WRITE(__MODULE__, 2, "SkipFrame()\n"); if (m_pPacket) m_pPacket->Release(); m_pPacket = 0; Flush(); return m_pPacket ? 0 : -1; } int ReadStream::SkipTo(double pos) { AVM_WRITE(__MODULE__, 2, "SkipTo()\n"); int hr = m_pStream->SkipTo(pos); if (hr == 0) { if (m_pPacket) m_pPacket->Release(); m_pPacket = 0; Flush(); } return hr; } framepos_t ReadStream::SeekToNextKeyFrame() { AVM_WRITE(__MODULE__, 3, "SeekToNextKeyFrame()\n"); framepos_t newpos = GetNextKeyFrame(); if (newpos == ERR) { // try to iterate to next keyframe in this case int kf; while (SkipFrame() == 0 && !GetFrameFlags(&kf)) ; } else Seek(newpos); return GetPos(); } framepos_t ReadStream::SeekToPrevKeyFrame() { AVM_WRITE(__MODULE__, 3, "SeekToPrevKeyFrame() (lp:%d)\n", m_uiLastPos); framepos_t newpos = GetPrevKeyFrame(); if (newpos == ERR) { double t = GetTime(); if (t > 20.) { SeekTimeToKeyFrame(t - 20); // just a wilde guess return GetPos(); } newpos = 0; } Seek(newpos); return GetPos(); } size_t ReadStream::GetAudioFormat(void* bi, size_t size) const { AVM_WRITE(__MODULE__, "WARNING: GetAudioFormat() for non-audio stream\n"); return 0; } size_t ReadStream::GetVideoFormat(void* bi, size_t size) const { AVM_WRITE(__MODULE__, "WARNING: GetVideoFormat() for non-video stream\n"); return 0; } IAudioDecoder* ReadStream::GetAudioDecoder() const { AVM_WRITE(__MODULE__, "WARNING: Getting audio decoder for non-audio stream\n"); return 0; } IVideoDecoder* ReadStream::GetVideoDecoder() const { AVM_WRITE(__MODULE__, "WARNING: Getting video decoder for non-video stream\n"); return 0; } CImage* ReadStream::GetFrame(bool readframe) { AVM_WRITE(__MODULE__, "WARNING: GetFrame() called for non-video stream\n"); return 0; } size_t ReadStream::GetFrameSize() const { AVM_WRITE(__MODULE__, "WARNING: GetFrameSize() called for non-video stream\n"); return 0; } int ReadStream::ReadFrame(bool render) { AVM_WRITE(__MODULE__, "WARNING: ReadFrame() called for non-video stream\n"); return -1; } int ReadStream::ReadFrames(void* buffer, size_t bufsize, size_t samples, size_t& samples_read, size_t& bytes_read) { AVM_WRITE(__MODULE__, "WARNING: ReadFrames() called for non-audio stream\n"); return -1; } int ReadStream::SetOutputFormat(void* bi, size_t size) { AVM_WRITE(__MODULE__, "WARNING: SetOutputFormat() called\n"); return -1; } #undef __MODULE__ AVM_END_NAMESPACE;