unsigned int CDVDAudio::AddPackets(const DVDAudioFrame &audioframe)
{
m_bAbort = false;
CSingleLock lock (m_critSection);
if(!m_pAudioStream)
return 0;
CAESyncInfo info = m_pAudioStream->GetSyncInfo();
if (info.state == CAESyncInfo::SYNC_INSYNC)
{
unsigned int newTime = info.errortime;
if (newTime != m_syncErrorTime)
{
m_syncErrorTime = info.errortime;
m_syncError = info.error / 1000 * DVD_TIME_BASE;
m_resampleRatio = info.rr;
}
}
else
{
m_syncErrorTime = 0;
m_syncError = 0.0;
}
//Calculate a timeout when this definitely should be done
double timeout;
timeout = DVD_SEC_TO_TIME(m_pAudioStream->GetDelay()) + audioframe.duration;
timeout += DVD_SEC_TO_TIME(1.0);
timeout += CDVDClock::GetAbsoluteClock();
unsigned int total = audioframe.nb_frames;
unsigned int frames = audioframe.nb_frames;
unsigned int offset = 0;
do
{
double pts = (offset == 0) ? audioframe.pts / DVD_TIME_BASE * 1000 : 0.0;
unsigned int copied = m_pAudioStream->AddData(audioframe.data, offset, frames, pts);
offset += copied;
frames -= copied;
if (frames <= 0)
break;
if (copied == 0 && timeout < CDVDClock::GetAbsoluteClock())
{
CLog::Log(LOGERROR, "CDVDAudio::AddPacketsRenderer - timeout adding data to renderer");
break;
}
lock.Leave();
Sleep(1);
lock.Enter();
} while (!m_bAbort);
m_playingPts = audioframe.pts + audioframe.duration - GetDelay();
m_timeOfPts = CDVDClock::GetAbsoluteClock();
return total - frames;
}
void CVideoPlayerSubtitle::Process(double pts, double offset)
{
CSingleLock lock(m_section);
if (m_pSubtitleFileParser)
{
if(pts == DVD_NOPTS_VALUE)
return;
if (pts + DVD_SEC_TO_TIME(1) < m_lastPts)
{
m_pOverlayContainer->Clear();
m_pSubtitleFileParser->Reset();
}
if(m_pOverlayContainer->GetSize() >= 5)
return;
CDVDOverlay* pOverlay = m_pSubtitleFileParser->Parse(pts);
// add all overlays which fit the pts
while(pOverlay)
{
pOverlay->iPTSStartTime -= offset;
if(pOverlay->iPTSStopTime != 0.0)
pOverlay->iPTSStopTime -= offset;
m_pOverlayContainer->Add(pOverlay);
pOverlay->Release();
pOverlay = m_pSubtitleFileParser->Parse(pts);
}
m_lastPts = pts;
}
}
bool CDVDDemuxVobsub::ParseTimestamp(SState& state, char* line)
{
if(state.id < 0)
return false;
int h,m,s,ms;
STimestamp timestamp;
while(*line == ' ') line++;
if(sscanf(line, "%d:%d:%d:%d, filepos:%" PRIx64, &h, &m, &s, &ms, ×tamp.pos) != 5)
return false;
timestamp.id = state.id;
timestamp.pts = DVD_SEC_TO_TIME(state.delay + h*3600.0 + m*60.0 + s + ms*0.001);
m_Timestamps.push_back(timestamp);
return true;
}
OMXPacket *OMXReader::Read()
{
assert(!IsEof());
AVPacket pkt;
OMXPacket *m_omx_pkt = NULL;
int result = -1;
if(!m_pFormatContext)
return NULL;
Lock();
// assume we are not eof
if(m_pFormatContext->pb)
m_pFormatContext->pb->eof_reached = 0;
// keep track if ffmpeg doesn't always set these
pkt.size = 0;
pkt.data = NULL;
pkt.stream_index = MAX_OMX_STREAMS;
result = m_dllAvFormat.av_read_frame(m_pFormatContext, &pkt);
if (result < 0)
{
m_eof = true;
//FlushRead();
//m_dllAvCodec.av_free_packet(&pkt);
UnLock();
return NULL;
}
else if (pkt.size < 0 || pkt.stream_index >= MAX_OMX_STREAMS)
{
// XXX, in some cases ffmpeg returns a negative packet size
if(m_pFormatContext->pb && !m_pFormatContext->pb->eof_reached)
{
CLog::Log(LOGERROR, "OMXReader::Read no valid packet");
//FlushRead();
}
m_dllAvCodec.av_free_packet(&pkt);
m_eof = true;
UnLock();
return NULL;
}
AVStream *pStream = m_pFormatContext->streams[pkt.stream_index];
/* only read packets for active streams */
/*
if(!IsActive(pkt.stream_index))
{
m_dllAvCodec.av_free_packet(&pkt);
UnLock();
return NULL;
}
*/
// lavf sometimes bugs out and gives 0 dts/pts instead of no dts/pts
// since this could only happens on initial frame under normal
// circomstances, let's assume it is wrong all the time
if(pkt.dts == 0)
pkt.dts = AV_NOPTS_VALUE;
if(pkt.pts == 0)
pkt.pts = AV_NOPTS_VALUE;
if(m_bMatroska && pStream->codec && pStream->codec->codec_type == AVMEDIA_TYPE_VIDEO)
{ // matroska can store different timestamps
// for different formats, for native stored
// stuff it is pts, but for ms compatibility
// tracks, it is really dts. sadly ffmpeg
// sets these two timestamps equal all the
// time, so we select it here instead
if(pStream->codec->codec_tag == 0)
pkt.dts = AV_NOPTS_VALUE;
else
pkt.pts = AV_NOPTS_VALUE;
}
// we need to get duration slightly different for matroska embedded text subtitels
if(m_bMatroska && pStream->codec->codec_id == CODEC_ID_TEXT && pkt.convergence_duration != 0)
pkt.duration = pkt.convergence_duration;
if(m_bAVI && pStream->codec && pStream->codec->codec_type == AVMEDIA_TYPE_VIDEO)
{
// AVI's always have borked pts, specially if m_pFormatContext->flags includes
// AVFMT_FLAG_GENPTS so always use dts
pkt.pts = AV_NOPTS_VALUE;
}
m_omx_pkt = AllocPacket(pkt.size);
/* oom error allocation av packet */
if(!m_omx_pkt)
{
m_eof = true;
m_dllAvCodec.av_free_packet(&pkt);
UnLock();
return NULL;
}
m_omx_pkt->codec_type = pStream->codec->codec_type;
/* copy content into our own packet */
m_omx_pkt->size = pkt.size;
if (pkt.data)
memcpy(m_omx_pkt->data, pkt.data, m_omx_pkt->size);
m_omx_pkt->stream_index = pkt.stream_index;
GetHints(pStream, &m_omx_pkt->hints);
//m_omx_pkt->dts = ConvertTimestamp(pkt.dts, pStream->time_base.den, pStream->time_base.num);
//m_omx_pkt->pts = ConvertTimestamp(pkt.pts, pStream->time_base.den, pStream->time_base.num);
m_omx_pkt->dts = ConvertTimestamp(pkt.dts, &pStream->time_base);
m_omx_pkt->pts = ConvertTimestamp(pkt.pts, &pStream->time_base);
m_omx_pkt->duration = DVD_SEC_TO_TIME((double)pkt.duration * pStream->time_base.num / pStream->time_base.den);
// used to guess streamlength
if (m_omx_pkt->dts != DVD_NOPTS_VALUE && (m_omx_pkt->dts > m_iCurrentPts || m_iCurrentPts == DVD_NOPTS_VALUE))
m_iCurrentPts = m_omx_pkt->dts;
// check if stream has passed full duration, needed for live streams
if(pkt.dts != (int64_t)AV_NOPTS_VALUE)
{
int64_t duration;
duration = pkt.dts;
if(pStream->start_time != (int64_t)AV_NOPTS_VALUE)
duration -= pStream->start_time;
if(duration > pStream->duration)
{
pStream->duration = duration;
duration = m_dllAvUtil.av_rescale_rnd(pStream->duration, (int64_t)pStream->time_base.num * AV_TIME_BASE,
pStream->time_base.den, AV_ROUND_NEAR_INF);
if ((m_pFormatContext->duration == (int64_t)AV_NOPTS_VALUE)
|| (m_pFormatContext->duration != (int64_t)AV_NOPTS_VALUE && duration > m_pFormatContext->duration))
m_pFormatContext->duration = duration;
}
}
m_dllAvCodec.av_free_packet(&pkt);
UnLock();
return m_omx_pkt;
}
bool OMXPlayerAudio::Decode(DemuxPacket *pkt, bool bDropPacket, bool bTrickPlay)
{
if(!pkt || m_bad_state || !m_pAudioCodec)
return false;
if(pkt->dts != DVD_NOPTS_VALUE)
m_audioClock = pkt->dts;
bool settings_changed = false;
const uint8_t *data_dec = pkt->pData;
int data_len = pkt->iSize;
if (bTrickPlay)
{
settings_changed = true;
}
else if(m_format.m_dataFormat != AE_FMT_RAW && !bDropPacket)
{
double dts = pkt->dts, pts=pkt->pts;
while(!m_bStop && data_len > 0)
{
int len = m_pAudioCodec->Decode((BYTE *)data_dec, data_len, dts, pts);
if( (len < 0) || (len > data_len) )
{
m_pAudioCodec->Reset();
break;
}
data_dec+= len;
data_len -= len;
uint8_t *decoded;
int decoded_size = m_pAudioCodec->GetData(&decoded, dts, pts);
if(decoded_size <=0)
continue;
int ret = 0;
m_audioStats.AddSampleBytes(decoded_size);
if(CodecChange())
{
m_DecoderOpen = OpenDecoder();
if(!m_DecoderOpen)
return false;
}
while(!m_bStop)
{
// discard if flushing as clocks may be stopped and we'll never submit it
if(m_flush)
break;
if(m_omxAudio.GetSpace() < (unsigned int)decoded_size)
{
Sleep(10);
continue;
}
if(!bDropPacket)
{
ret = m_omxAudio.AddPackets(decoded, decoded_size, dts, pts, m_pAudioCodec->GetFrameSize(), settings_changed);
if(ret != decoded_size)
{
CLog::Log(LOGERROR, "error ret %d decoded_size %d\n", ret, decoded_size);
}
}
break;
}
}
}
else if(!bDropPacket)
{
if(CodecChange())
{
m_DecoderOpen = OpenDecoder();
if(!m_DecoderOpen)
return false;
}
while(!m_bStop)
{
if(m_flush)
break;
if(m_omxAudio.GetSpace() < (unsigned int)pkt->iSize)
{
Sleep(10);
continue;
}
if(!bDropPacket)
{
m_omxAudio.AddPackets(pkt->pData, pkt->iSize, m_audioClock, m_audioClock, 0, settings_changed);
}
m_audioStats.AddSampleBytes(pkt->iSize);
break;
}
}
if(bDropPacket || bTrickPlay)
m_stalled = false;
// signal to our parent that we have initialized
if (m_syncState == IDVDStreamPlayer::SYNC_STARTING && !bDropPacket && settings_changed)
{
m_syncState = IDVDStreamPlayer::SYNC_WAITSYNC;
SStartMsg msg;
msg.player = VideoPlayer_AUDIO;
msg.cachetotal = DVD_SEC_TO_TIME(m_omxAudio.GetCacheTotal());
msg.cachetime = DVD_SEC_TO_TIME(m_omxAudio.GetCacheTime());
msg.timestamp = m_audioClock;
m_messageParent.Put(new CDVDMsgType<SStartMsg>(CDVDMsg::PLAYER_STARTED, msg));
}
return true;
}
void CVideoPlayerAudio::Process()
{
CLog::Log(LOGNOTICE, "running thread: CVideoPlayerAudio::Process()");
DVDAudioFrame audioframe;
m_audioStats.Start();
while (!m_bStop)
{
CDVDMsg* pMsg;
int timeout = (int)(1000 * m_dvdAudio.GetCacheTime()) + 100;
// read next packet and return -1 on error
int priority = 1;
//Do we want a new audio frame?
if (m_syncState == IDVDStreamPlayer::SYNC_STARTING || /* when not started */
ALLOW_AUDIO(m_speed) || /* when playing normally */
m_speed < DVD_PLAYSPEED_PAUSE || /* when rewinding */
(m_speed > DVD_PLAYSPEED_NORMAL && m_audioClock < m_pClock->GetClock())) /* when behind clock in ff */
priority = 0;
if (m_syncState == IDVDStreamPlayer::SYNC_WAITSYNC)
priority = 1;
// consider stream stalled if queue is empty
// we can't sync audio to clock with an empty queue
if (ALLOW_AUDIO(m_speed) && !m_stalled)
{
timeout = 0;
}
MsgQueueReturnCode ret = m_messageQueue.Get(&pMsg, timeout, priority);
if (MSGQ_IS_ERROR(ret))
{
CLog::Log(LOGERROR, "Got MSGQ_ABORT or MSGO_IS_ERROR return true");
break;
}
else if (ret == MSGQ_TIMEOUT)
{
// Flush as the audio output may keep looping if we don't
if (ALLOW_AUDIO(m_speed) && !m_stalled && m_syncState == IDVDStreamPlayer::SYNC_INSYNC)
{
// while AE sync is active, we still have time to fill buffers
if (m_syncTimer.IsTimePast())
{
CLog::Log(LOGNOTICE, "CVideoPlayerAudio::Process - stream stalled");
m_stalled = true;
}
}
if (timeout == 0)
Sleep(10);
continue;
}
// handle messages
if (pMsg->IsType(CDVDMsg::GENERAL_SYNCHRONIZE))
{
if(((CDVDMsgGeneralSynchronize*)pMsg)->Wait( 100, SYNCSOURCE_AUDIO ))
CLog::Log(LOGDEBUG, "CVideoPlayerAudio - CDVDMsg::GENERAL_SYNCHRONIZE");
else
m_messageQueue.Put(pMsg->Acquire(), 1); // push back as prio message, to process other prio messages
}
else if (pMsg->IsType(CDVDMsg::GENERAL_RESYNC))
{ //player asked us to set internal clock
double pts = static_cast<CDVDMsgDouble*>(pMsg)->m_value;
CLog::Log(LOGDEBUG, "CVideoPlayerAudio - CDVDMsg::GENERAL_RESYNC(%f)", pts);
m_audioClock = pts + m_dvdAudio.GetDelay();
if (m_speed != DVD_PLAYSPEED_PAUSE)
m_dvdAudio.Resume();
m_syncState = IDVDStreamPlayer::SYNC_INSYNC;
m_syncTimer.Set(3000);
}
else if (pMsg->IsType(CDVDMsg::GENERAL_RESET))
{
if (m_pAudioCodec)
m_pAudioCodec->Reset();
m_syncState = IDVDStreamPlayer::SYNC_STARTING;
}
else if (pMsg->IsType(CDVDMsg::GENERAL_FLUSH))
{
bool sync = static_cast<CDVDMsgBool*>(pMsg)->m_value;
m_dvdAudio.Flush();
m_stalled = true;
m_audioClock = 0;
if (sync)
{
m_syncState = IDVDStreamPlayer::SYNC_STARTING;
m_dvdAudio.Pause();
}
if (m_pAudioCodec)
m_pAudioCodec->Reset();
}
else if (pMsg->IsType(CDVDMsg::GENERAL_EOF))
{
CLog::Log(LOGDEBUG, "CVideoPlayerAudio - CDVDMsg::GENERAL_EOF");
}
else if (pMsg->IsType(CDVDMsg::PLAYER_SETSPEED))
{
double speed = static_cast<CDVDMsgInt*>(pMsg)->m_value;
if (ALLOW_AUDIO(speed))
{
if (speed != m_speed)
{
if (m_syncState == IDVDStreamPlayer::SYNC_INSYNC)
m_dvdAudio.Resume();
}
}
else
{
m_dvdAudio.Pause();
}
m_speed = speed;
}
else if (pMsg->IsType(CDVDMsg::AUDIO_SILENCE))
{
m_silence = static_cast<CDVDMsgBool*>(pMsg)->m_value;
CLog::Log(LOGDEBUG, "CVideoPlayerAudio - CDVDMsg::AUDIO_SILENCE(%f, %d)"
, m_audioClock, m_silence);
}
else if (pMsg->IsType(CDVDMsg::GENERAL_STREAMCHANGE))
{
CDVDMsgAudioCodecChange* msg(static_cast<CDVDMsgAudioCodecChange*>(pMsg));
OpenStream(msg->m_hints, msg->m_codec);
msg->m_codec = NULL;
}
else if (pMsg->IsType(CDVDMsg::DEMUXER_PACKET))
{
DemuxPacket* pPacket = ((CDVDMsgDemuxerPacket*)pMsg)->GetPacket();
bool bPacketDrop = ((CDVDMsgDemuxerPacket*)pMsg)->GetPacketDrop();
int consumed = m_pAudioCodec->Decode(pPacket->pData, pPacket->iSize, pPacket->dts, pPacket->pts);
if (consumed < 0)
{
CLog::Log(LOGERROR, "CVideoPlayerAudio::DecodeFrame - Decode Error. Skipping audio packet (%d)", consumed);
m_pAudioCodec->Reset();
pMsg->Release();
continue;
}
m_audioStats.AddSampleBytes(pPacket->iSize);
UpdatePlayerInfo();
// loop while no error and decoder produces output
while (!m_bStop)
{
// get decoded data and the size of it
m_pAudioCodec->GetData(audioframe);
if (audioframe.nb_frames == 0)
{
if (consumed >= pPacket->iSize)
break;
int ret = m_pAudioCodec->Decode(pPacket->pData+consumed, pPacket->iSize-consumed, DVD_NOPTS_VALUE, DVD_NOPTS_VALUE);
if (ret < 0)
{
CLog::Log(LOGERROR, "CVideoPlayerAudio::DecodeFrame - Decode Error. Skipping audio packet (%d)", ret);
m_pAudioCodec->Reset();
break;
}
consumed += ret;
continue;
}
audioframe.hasTimestamp = true;
if (audioframe.pts == DVD_NOPTS_VALUE)
{
audioframe.pts = m_audioClock;
audioframe.hasTimestamp = false;
}
else
{
m_audioClock = audioframe.pts;
}
//Drop when not playing normally
if (!ALLOW_AUDIO(m_speed) && m_syncState == IDVDStreamPlayer::SYNC_INSYNC)
{
break;
}
if (audioframe.format.m_sampleRate && m_streaminfo.samplerate != (int) audioframe.format.m_sampleRate)
{
// The sample rate has changed or we just got it for the first time
// for this stream. See if we should enable/disable passthrough due
// to it.
m_streaminfo.samplerate = audioframe.format.m_sampleRate;
if (SwitchCodecIfNeeded())
{
break;
}
}
// demuxer reads metatags that influence channel layout
if (m_streaminfo.codec == AV_CODEC_ID_FLAC && m_streaminfo.channellayout)
audioframe.format.m_channelLayout = CAEUtil::GetAEChannelLayout(m_streaminfo.channellayout);
// we have succesfully decoded an audio frame, setup renderer to match
if (!m_dvdAudio.IsValidFormat(audioframe))
{
if(m_speed)
m_dvdAudio.Drain();
m_dvdAudio.Destroy();
if (!m_dvdAudio.Create(audioframe, m_streaminfo.codec, m_setsynctype == SYNC_RESAMPLE))
CLog::Log(LOGERROR, "%s - failed to create audio renderer", __FUNCTION__);
if (m_syncState == IDVDStreamPlayer::SYNC_INSYNC)
m_dvdAudio.Resume();
m_streaminfo.channels = audioframe.format.m_channelLayout.Count();
m_messageParent.Put(new CDVDMsg(CDVDMsg::PLAYER_AVCHANGE));
}
// Zero out the frame data if we are supposed to silence the audio
if (m_silence)
{
int size = audioframe.nb_frames * audioframe.framesize / audioframe.planes;
for (unsigned int i=0; i<audioframe.planes; i++)
memset(audioframe.data[i], 0, size);
}
SetSyncType(audioframe.passthrough);
if (!bPacketDrop)
{
OutputPacket(audioframe);
// signal to our parent that we have initialized
if(m_syncState == IDVDStreamPlayer::SYNC_STARTING)
{
double cachetotal = DVD_SEC_TO_TIME(m_dvdAudio.GetCacheTotal());
double cachetime = m_dvdAudio.GetDelay();
if (cachetime >= cachetotal * 0.5)
{
m_syncState = IDVDStreamPlayer::SYNC_WAITSYNC;
m_stalled = false;
SStartMsg msg;
msg.player = VideoPlayer_AUDIO;
msg.cachetotal = cachetotal;
msg.cachetime = cachetime;
msg.timestamp = audioframe.hasTimestamp ? audioframe.pts : DVD_NOPTS_VALUE;
m_messageParent.Put(new CDVDMsgType<SStartMsg>(CDVDMsg::PLAYER_STARTED, msg));
}
}
}
// guess next pts
m_audioClock += audioframe.duration;
int ret = m_pAudioCodec->Decode(nullptr, 0, DVD_NOPTS_VALUE, DVD_NOPTS_VALUE);
if (ret < 0)
{
CLog::Log(LOGERROR, "CVideoPlayerAudio::DecodeFrame - Decode Error. Skipping audio packet (%d)", ret);
m_pAudioCodec->Reset();
break;
}
} // while decoder produces output
} // demuxer packet
pMsg->Release();
}
}
DemuxPacket* CDVDDemuxFFmpeg::Read()
{
AVPacket pkt;
DemuxPacket* pPacket = NULL;
// on some cases where the received packet is invalid we will need to return an empty packet (0 length) otherwise the main loop (in CDVDPlayer)
// would consider this the end of stream and stop.
bool bReturnEmpty = false;
Lock();
if (m_pFormatContext)
{
// assume we are not eof
if(m_pFormatContext->pb)
m_pFormatContext->pb->eof_reached = 0;
// timeout reads after 100ms
g_urltimeout = GetTickCount() + 100;
//g_urltimeout = 0;
int result = 0;
try
{
result = m_dllAvFormat.av_read_frame(m_pFormatContext, &pkt);
}
catch(const win32_exception &e)
{
e.writelog(__FUNCTION__);
result = AVERROR(EFAULT);
}
g_urltimeout = 0;
if (result == AVERROR(EINTR) || result == AVERROR(EAGAIN))
{
// timeout, probably no real error, return empty packet
bReturnEmpty = true;
}
else if (result < 0)
{
Flush();
}
else
{
// XXX, in some cases ffmpeg returns a negative packet size
if (pkt.size < 0 || pkt.stream_index >= MAX_STREAMS)
{
CLog::Log(LOGERROR, "CDVDDemuxFFmpeg::Read() no valid packet");
bReturnEmpty = true;
}
else
{
AVStream *stream = m_pFormatContext->streams[pkt.stream_index];
if (m_pFormatContext->nb_programs)
{
/* check so packet belongs to selected program */
for (unsigned int i = 0; i < m_pFormatContext->programs[m_program]->nb_stream_indexes; i++)
{
if(pkt.stream_index == (int)m_pFormatContext->programs[m_program]->stream_index[i])
{
pPacket = CDVDDemuxUtils::AllocateDemuxPacket(pkt.size);
break;
}
}
if (!pPacket)
bReturnEmpty = true;
}
else
pPacket = CDVDDemuxUtils::AllocateDemuxPacket(pkt.size);
if (pPacket)
{
// lavf sometimes bugs out and gives 0 dts/pts instead of no dts/pts
// since this could only happens on initial frame under normal
// circomstances, let's assume it is wrong all the time
if(pkt.dts == 0)
pkt.dts = AV_NOPTS_VALUE;
if(pkt.pts == 0)
pkt.pts = AV_NOPTS_VALUE;
if(m_bMatroska && stream->codec && stream->codec->codec_type == CODEC_TYPE_VIDEO)
{ // matroska can store different timestamps
// for different formats, for native stored
// stuff it is pts, but for ms compatibility
// tracks, it is really dts. sadly ffmpeg
// sets these two timestamps equal all the
// time, so we select it here instead
if(stream->codec->codec_tag == 0)
pkt.dts = AV_NOPTS_VALUE;
else
pkt.pts = AV_NOPTS_VALUE;
}
// copy contents into our own packet
pPacket->iSize = pkt.size;
// maybe we can avoid a memcpy here by detecting where pkt.destruct is pointing too?
if (pkt.data)
memcpy(pPacket->pData, pkt.data, pPacket->iSize);
pPacket->pts = ConvertTimestamp(pkt.pts, stream->time_base.den, stream->time_base.num);
pPacket->dts = ConvertTimestamp(pkt.dts, stream->time_base.den, stream->time_base.num);
pPacket->duration = DVD_SEC_TO_TIME((double)pkt.duration * stream->time_base.num / stream->time_base.den);
// used to guess streamlength
if (pPacket->dts != DVD_NOPTS_VALUE && (pPacket->dts > m_iCurrentPts || m_iCurrentPts == DVD_NOPTS_VALUE))
m_iCurrentPts = pPacket->dts;
// check if stream has passed full duration, needed for live streams
if(pkt.dts != (int64_t)AV_NOPTS_VALUE)
{
int64_t duration;
duration = pkt.dts;
if(stream->start_time != (int64_t)AV_NOPTS_VALUE)
duration -= stream->start_time;
if(duration > stream->duration)
{
stream->duration = duration;
duration = m_dllAvUtil.av_rescale_rnd(stream->duration, stream->time_base.num * AV_TIME_BASE, stream->time_base.den, AV_ROUND_NEAR_INF);
if(m_pFormatContext->duration == (int64_t)AV_NOPTS_VALUE && m_pFormatContext->file_size > 0
|| m_pFormatContext->duration != (int64_t)AV_NOPTS_VALUE && duration > m_pFormatContext->duration)
m_pFormatContext->duration = duration;
}
}
// check if stream seem to have grown since start
if(m_pFormatContext->file_size > 0 && m_pFormatContext->pb)
{
if(m_pFormatContext->pb->pos > m_pFormatContext->file_size)
m_pFormatContext->file_size = m_pFormatContext->pb->pos;
}
pPacket->iStreamId = pkt.stream_index; // XXX just for now
}
}
av_free_packet(&pkt);
}
}
Unlock();
if (bReturnEmpty && !pPacket)
{
pPacket = CDVDDemuxUtils::AllocateDemuxPacket(0);
if(pPacket)
{
pPacket->dts = DVD_NOPTS_VALUE;
pPacket->pts = DVD_NOPTS_VALUE;
pPacket->iStreamId = -1;
}
}
if (!pPacket) return NULL;
// check streams, can we make this a bit more simple?
if (pPacket && pPacket->iStreamId >= 0 && pPacket->iStreamId <= MAX_STREAMS)
{
if (!m_streams[pPacket->iStreamId] ||
m_streams[pPacket->iStreamId]->pPrivate != m_pFormatContext->streams[pPacket->iStreamId] ||
m_streams[pPacket->iStreamId]->codec != m_pFormatContext->streams[pPacket->iStreamId]->codec->codec_id)
{
// content has changed, or stream did not yet exist
AddStream(pPacket->iStreamId);
}
// we already check for a valid m_streams[pPacket->iStreamId] above
else if (m_streams[pPacket->iStreamId]->type == STREAM_AUDIO)
{
if (((CDemuxStreamAudio*)m_streams[pPacket->iStreamId])->iChannels != m_pFormatContext->streams[pPacket->iStreamId]->codec->channels ||
((CDemuxStreamAudio*)m_streams[pPacket->iStreamId])->iSampleRate != m_pFormatContext->streams[pPacket->iStreamId]->codec->sample_rate)
{
// content has changed
AddStream(pPacket->iStreamId);
}
}
else if (m_streams[pPacket->iStreamId]->type == STREAM_VIDEO)
{
if (((CDemuxStreamVideo*)m_streams[pPacket->iStreamId])->iWidth != m_pFormatContext->streams[pPacket->iStreamId]->codec->width ||
((CDemuxStreamVideo*)m_streams[pPacket->iStreamId])->iHeight != m_pFormatContext->streams[pPacket->iStreamId]->codec->height)
{
// content has changed
AddStream(pPacket->iStreamId);
}
}
}
return pPacket;
}
bool CVideoPlayerAudio::ProcessDecoderOutput(DVDAudioFrame &audioframe)
{
if (audioframe.nb_frames <= audioframe.framesOut)
{
m_pAudioCodec->GetData(audioframe);
if (audioframe.nb_frames == 0)
{
return false;
}
audioframe.hasTimestamp = true;
if (audioframe.pts == DVD_NOPTS_VALUE)
{
audioframe.pts = m_audioClock;
audioframe.hasTimestamp = false;
}
else
{
m_audioClock = audioframe.pts;
}
if (audioframe.format.m_sampleRate && m_streaminfo.samplerate != (int) audioframe.format.m_sampleRate)
{
// The sample rate has changed or we just got it for the first time
// for this stream. See if we should enable/disable passthrough due
// to it.
m_streaminfo.samplerate = audioframe.format.m_sampleRate;
if (SwitchCodecIfNeeded())
{
audioframe.nb_frames = 0;
return false;
}
}
// demuxer reads metatags that influence channel layout
if (m_streaminfo.codec == AV_CODEC_ID_FLAC && m_streaminfo.channellayout)
audioframe.format.m_channelLayout = CAEUtil::GetAEChannelLayout(m_streaminfo.channellayout);
// we have successfully decoded an audio frame, setup renderer to match
if (!m_audioSink.IsValidFormat(audioframe))
{
if(m_speed)
m_audioSink.Drain();
m_audioSink.Destroy();
if (!m_audioSink.Create(audioframe, m_streaminfo.codec, m_setsynctype == SYNC_RESAMPLE))
CLog::Log(LOGERROR, "%s - failed to create audio renderer", __FUNCTION__);
if (m_syncState == IDVDStreamPlayer::SYNC_INSYNC)
m_audioSink.Resume();
}
SetSyncType(audioframe.passthrough);
}
{
double syncerror = m_audioSink.GetSyncError();
if (m_synctype == SYNC_DISCON && fabs(syncerror) > DVD_MSEC_TO_TIME(10))
{
double correction = m_pClock->ErrorAdjust(syncerror, "CVideoPlayerAudio::OutputPacket");
if (correction != 0)
{
m_audioSink.SetSyncErrorCorrection(-correction);
}
}
}
int framesOutput = m_audioSink.AddPackets(audioframe);
// guess next pts
m_audioClock += audioframe.duration * ((double)framesOutput / audioframe.nb_frames);
audioframe.framesOut += framesOutput;
// signal to our parent that we have initialized
if(m_syncState == IDVDStreamPlayer::SYNC_STARTING)
{
double cachetotal = DVD_SEC_TO_TIME(m_audioSink.GetCacheTotal());
double cachetime = m_audioSink.GetDelay();
if (cachetime >= cachetotal * 0.5)
{
m_syncState = IDVDStreamPlayer::SYNC_WAITSYNC;
m_stalled = false;
SStartMsg msg;
msg.player = VideoPlayer_AUDIO;
msg.cachetotal = cachetotal;
msg.cachetime = cachetime;
msg.timestamp = audioframe.hasTimestamp ? audioframe.pts : DVD_NOPTS_VALUE;
m_messageParent.Put(new CDVDMsgType<SStartMsg>(CDVDMsg::PLAYER_STARTED, msg));
m_streaminfo.channels = audioframe.format.m_channelLayout.Count();
m_processInfo.SetAudioChannels(audioframe.format.m_channelLayout);
m_processInfo.SetAudioSampleRate(audioframe.format.m_sampleRate);
m_processInfo.SetAudioBitsPerSample(audioframe.bits_per_sample);
m_messageParent.Put(new CDVDMsg(CDVDMsg::PLAYER_AVCHANGE));
}
}
return true;
}
void CVideoPlayerAudio::Process()
{
CLog::Log(LOGNOTICE, "running thread: CVideoPlayerAudio::Process()");
DVDAudioFrame audioframe;
m_audioStats.Start();
while (!m_bStop)
{
int result = DecodeFrame(audioframe);
//Drop when not playing normally
if (!ALLOW_AUDIO(m_speed) && m_syncState == IDVDStreamPlayer::SYNC_INSYNC)
{
result |= DECODE_FLAG_DROP;
}
UpdatePlayerInfo();
if (result & DECODE_FLAG_ERROR)
{
CLog::Log(LOGDEBUG, "CVideoPlayerAudio::Process - Decode Error");
continue;
}
if (result & DECODE_FLAG_TIMEOUT)
{
// Flush as the audio output may keep looping if we don't
if (ALLOW_AUDIO(m_speed) && !m_stalled && m_syncState == IDVDStreamPlayer::SYNC_INSYNC)
{
m_stalled = true;
}
continue;
}
if (result & DECODE_FLAG_ABORT)
{
CLog::Log(LOGDEBUG, "CVideoPlayerAudio::Process - Abort received, exiting thread");
break;
}
if (audioframe.nb_frames == 0)
continue;
// demuxer reads metatags that influence channel layout
if (m_streaminfo.codec == AV_CODEC_ID_FLAC && m_streaminfo.channellayout)
audioframe.format.m_channelLayout = CAEUtil::GetAEChannelLayout(m_streaminfo.channellayout);
// we have succesfully decoded an audio frame, setup renderer to match
if (!m_dvdAudio.IsValidFormat(audioframe))
{
if(m_speed)
m_dvdAudio.Drain();
m_dvdAudio.Destroy();
if(!m_dvdAudio.Create(audioframe, m_streaminfo.codec, m_setsynctype == SYNC_RESAMPLE))
CLog::Log(LOGERROR, "%s - failed to create audio renderer", __FUNCTION__);
if (m_syncState == IDVDStreamPlayer::SYNC_INSYNC)
m_dvdAudio.Resume();
m_streaminfo.channels = audioframe.format.m_channelLayout.Count();
g_dataCacheCore.SignalAudioInfoChange();
}
// Zero out the frame data if we are supposed to silence the audio
if (m_silence)
{
int size = audioframe.nb_frames * audioframe.framesize / audioframe.planes;
for (unsigned int i=0; i<audioframe.planes; i++)
memset(audioframe.data[i], 0, size);
}
if(!(result & DECODE_FLAG_DROP))
{
SetSyncType(audioframe.passthrough);
OutputPacket(audioframe);
}
// signal to our parent that we have initialized
if(m_syncState == IDVDStreamPlayer::SYNC_STARTING && !(result & DECODE_FLAG_DROP))
{
double cachetotal = DVD_SEC_TO_TIME(m_dvdAudio.GetCacheTotal());
double cachetime = m_dvdAudio.GetDelay();
if (cachetime >= cachetotal * 0.5)
{
m_syncState = IDVDStreamPlayer::SYNC_WAITSYNC;
m_stalled = false;
SStartMsg msg;
msg.player = VideoPlayer_AUDIO;
msg.cachetotal = cachetotal;
msg.cachetime = cachetime;
msg.timestamp = m_audioClock;
m_messageParent.Put(new CDVDMsgType<SStartMsg>(CDVDMsg::PLAYER_STARTED, msg));
}
}
}
}
void CVideoPlayerVideo::Process()
{
CLog::Log(LOGNOTICE, "running thread: video_thread");
double pts = 0;
double frametime = (double)DVD_TIME_BASE / m_fFrameRate;
bool bRequestDrop = false;
int iDropDirective;
bool onlyPrioMsgs = false;
m_videoStats.Start();
m_droppingStats.Reset();
m_iDroppedFrames = 0;
m_rewindStalled = false;
m_outputSate = OUTPUT_NORMAL;
while (!m_bStop)
{
int iQueueTimeOut = (int)(m_stalled ? frametime : frametime * 10) / 1000;
int iPriority = 0;
if (m_syncState == IDVDStreamPlayer::SYNC_WAITSYNC)
iPriority = 1;
if (m_paused)
iPriority = 1;
if (onlyPrioMsgs)
{
iPriority = 1;
iQueueTimeOut = 1;
}
CDVDMsg* pMsg;
MsgQueueReturnCode ret = GetMessage(&pMsg, iQueueTimeOut, iPriority);
onlyPrioMsgs = false;
if (MSGQ_IS_ERROR(ret))
{
CLog::Log(LOGERROR, "Got MSGQ_ABORT or MSGO_IS_ERROR return true");
break;
}
else if (ret == MSGQ_TIMEOUT)
{
if (m_outputSate == OUTPUT_AGAIN &&
m_picture.videoBuffer)
{
m_outputSate = OutputPicture(&m_picture);
if (m_outputSate == OUTPUT_AGAIN)
{
onlyPrioMsgs = true;
continue;
}
}
// don't ask for a new frame if we can't deliver it to renderer
else if ((m_speed != DVD_PLAYSPEED_PAUSE ||
m_processInfo.IsFrameAdvance() ||
m_syncState != IDVDStreamPlayer::SYNC_INSYNC) && !m_paused)
{
if (ProcessDecoderOutput(frametime, pts))
{
onlyPrioMsgs = true;
continue;
}
}
// if we only wanted priority messages, this isn't a stall
if (iPriority)
continue;
//Okey, start rendering at stream fps now instead, we are likely in a stillframe
if (!m_stalled)
{
// squeeze pictures out
while (!m_bStop && m_pVideoCodec)
{
m_pVideoCodec->SetCodecControl(DVD_CODEC_CTRL_DRAIN);
if (!ProcessDecoderOutput(frametime, pts))
break;
}
CLog::Log(LOGINFO, "CVideoPlayerVideo - Stillframe detected, switching to forced %f fps", m_fFrameRate);
m_stalled = true;
pts += frametime * 4;
}
// Waiting timed out, output last picture
if (m_picture.videoBuffer)
{
m_picture.pts = pts;
m_outputSate = OutputPicture(&m_picture);
pts += frametime;
}
continue;
}
if (pMsg->IsType(CDVDMsg::GENERAL_SYNCHRONIZE))
{
if (static_cast<CDVDMsgGeneralSynchronize*>(pMsg)->Wait(100, SYNCSOURCE_VIDEO))
{
CLog::Log(LOGDEBUG, "CVideoPlayerVideo - CDVDMsg::GENERAL_SYNCHRONIZE");
}
else
SendMessage(pMsg->Acquire(), 1); /* push back as prio message, to process other prio messages */
m_droppingStats.Reset();
}
else if (pMsg->IsType(CDVDMsg::GENERAL_RESYNC))
{
pts = static_cast<CDVDMsgDouble*>(pMsg)->m_value;
m_syncState = IDVDStreamPlayer::SYNC_INSYNC;
m_droppingStats.Reset();
m_rewindStalled = false;
m_renderManager.ShowVideo(true);
CLog::Log(LOGDEBUG, "CVideoPlayerVideo - CDVDMsg::GENERAL_RESYNC(%f)", pts);
}
else if (pMsg->IsType(CDVDMsg::VIDEO_SET_ASPECT))
{
CLog::Log(LOGDEBUG, "CVideoPlayerVideo - CDVDMsg::VIDEO_SET_ASPECT");
m_fForcedAspectRatio = static_cast<float>(*static_cast<CDVDMsgDouble*>(pMsg));
}
else if (pMsg->IsType(CDVDMsg::GENERAL_RESET))
{
if(m_pVideoCodec)
m_pVideoCodec->Reset();
if (m_picture.videoBuffer)
{
m_picture.videoBuffer->Release();
m_picture.videoBuffer = nullptr;
}
m_packets.clear();
m_droppingStats.Reset();
m_syncState = IDVDStreamPlayer::SYNC_STARTING;
m_renderManager.ShowVideo(false);
m_rewindStalled = false;
}
else if (pMsg->IsType(CDVDMsg::GENERAL_FLUSH)) // private message sent by (CVideoPlayerVideo::Flush())
{
bool sync = static_cast<CDVDMsgBool*>(pMsg)->m_value;
if(m_pVideoCodec)
m_pVideoCodec->Reset();
if (m_picture.videoBuffer)
{
m_picture.videoBuffer->Release();
m_picture.videoBuffer = nullptr;
}
m_packets.clear();
pts = 0;
m_rewindStalled = false;
m_ptsTracker.Flush();
//we need to recalculate the framerate
//! @todo this needs to be set on a streamchange instead
ResetFrameRateCalc();
m_droppingStats.Reset();
m_stalled = true;
if (sync)
{
m_syncState = IDVDStreamPlayer::SYNC_STARTING;
m_renderManager.ShowVideo(false);
}
m_renderManager.DiscardBuffer();
}
else if (pMsg->IsType(CDVDMsg::PLAYER_SETSPEED))
{
m_speed = static_cast<CDVDMsgInt*>(pMsg)->m_value;
if (m_pVideoCodec)
m_pVideoCodec->SetSpeed(m_speed);
m_droppingStats.Reset();
}
else if (pMsg->IsType(CDVDMsg::GENERAL_STREAMCHANGE))
{
CDVDMsgVideoCodecChange* msg(static_cast<CDVDMsgVideoCodecChange*>(pMsg));
while (!m_bStop && m_pVideoCodec)
{
m_pVideoCodec->SetCodecControl(DVD_CODEC_CTRL_DRAIN);
bool cont = ProcessDecoderOutput(frametime, pts);
if (!cont)
break;
}
OpenStream(msg->m_hints, msg->m_codec);
msg->m_codec = NULL;
if (m_picture.videoBuffer)
{
m_picture.videoBuffer->Release();
m_picture.videoBuffer = nullptr;
}
}
else if (pMsg->IsType(CDVDMsg::VIDEO_DRAIN))
{
while (!m_bStop && m_pVideoCodec)
{
m_pVideoCodec->SetCodecControl(DVD_CODEC_CTRL_DRAIN);
if (!ProcessDecoderOutput(frametime, pts))
break;
}
}
else if (pMsg->IsType(CDVDMsg::GENERAL_PAUSE))
{
m_paused = static_cast<CDVDMsgBool*>(pMsg)->m_value;
CLog::Log(LOGDEBUG, "CVideoPlayerVideo - CDVDMsg::GENERAL_PAUSE: %d", m_paused);
}
else if (pMsg->IsType(CDVDMsg::PLAYER_REQUEST_STATE))
{
SStateMsg msg;
msg.player = VideoPlayer_VIDEO;
msg.syncState = m_syncState;
m_messageParent.Put(new CDVDMsgType<SStateMsg>(CDVDMsg::PLAYER_REPORT_STATE, msg));
}
else if (pMsg->IsType(CDVDMsg::DEMUXER_PACKET))
{
DemuxPacket* pPacket = static_cast<CDVDMsgDemuxerPacket*>(pMsg)->GetPacket();
bool bPacketDrop = static_cast<CDVDMsgDemuxerPacket*>(pMsg)->GetPacketDrop();
if (m_stalled)
{
CLog::Log(LOGINFO, "CVideoPlayerVideo - Stillframe left, switching to normal playback");
m_stalled = false;
}
bRequestDrop = false;
iDropDirective = CalcDropRequirement(pts);
if ((iDropDirective & DROP_VERYLATE) &&
m_bAllowDrop &&
!bPacketDrop)
{
bRequestDrop = true;
}
if (iDropDirective & DROP_DROPPED)
{
m_iDroppedFrames++;
m_ptsTracker.Flush();
}
if (m_messageQueue.GetDataSize() == 0 || m_speed < 0)
{
bRequestDrop = false;
m_iDroppedRequest = 0;
m_iLateFrames = 0;
}
int codecControl = 0;
if (iDropDirective & DROP_BUFFER_LEVEL)
codecControl |= DVD_CODEC_CTRL_HURRY;
if (m_speed > DVD_PLAYSPEED_NORMAL)
codecControl |= DVD_CODEC_CTRL_NO_POSTPROC;
if (bPacketDrop)
codecControl |= DVD_CODEC_CTRL_DROP;
if (bRequestDrop)
codecControl |= DVD_CODEC_CTRL_DROP_ANY;
if (!m_renderManager.Supports(RENDERFEATURE_ROTATION))
codecControl |= DVD_CODEC_CTRL_ROTATE;
m_pVideoCodec->SetCodecControl(codecControl);
if (m_pVideoCodec->AddData(*pPacket))
{
// buffer packets so we can recover should decoder flush for some reason
if (m_pVideoCodec->GetConvergeCount() > 0)
{
m_packets.emplace_back(pMsg, 0);
if (m_packets.size() > m_pVideoCodec->GetConvergeCount() ||
m_packets.size() * frametime > DVD_SEC_TO_TIME(10))
m_packets.pop_front();
}
m_videoStats.AddSampleBytes(pPacket->iSize);
if (ProcessDecoderOutput(frametime, pts))
{
onlyPrioMsgs = true;
}
}
else
{
SendMessageBack(pMsg->Acquire());
onlyPrioMsgs = true;
}
}
// all data is used by the decoder, we can safely free it now
pMsg->Release();
}
}
