void BenchmarkPlayback::DemuxNextSample() {
MOZ_ASSERT(OnThread());
RefPtr<Benchmark> ref(mGlobalState);
RefPtr<MediaTrackDemuxer::SamplesPromise> promise =
mTrackDemuxer->GetSamples();
promise->Then(
Thread(), __func__,
[this, ref](RefPtr<MediaTrackDemuxer::SamplesHolder> aHolder) {
mSamples.AppendElements(std::move(aHolder->mSamples));
if (ref->mParameters.mStopAtFrame &&
mSamples.Length() == ref->mParameters.mStopAtFrame.ref()) {
InitDecoder(std::move(*mTrackDemuxer->GetInfo()));
} else {
Dispatch(
NS_NewRunnableFunction("BenchmarkPlayback::DemuxNextSample",
[this, ref]() { DemuxNextSample(); }));
}
},
[this, ref](const MediaResult& aError) {
switch (aError.Code()) {
case NS_ERROR_DOM_MEDIA_END_OF_STREAM:
InitDecoder(std::move(*mTrackDemuxer->GetInfo()));
break;
default:
Error(aError);
break;
}
});
}
void
BenchmarkPlayback::DemuxNextSample()
{
MOZ_ASSERT(OnThread());
RefPtr<Benchmark> ref(mMainThreadState);
RefPtr<MediaTrackDemuxer::SamplesPromise> promise = mTrackDemuxer->GetSamples();
promise->Then(
Thread(), __func__,
[this, ref](RefPtr<MediaTrackDemuxer::SamplesHolder> aHolder) {
mSamples.AppendElements(Move(aHolder->mSamples));
if (ref->mParameters.mStopAtFrame &&
mSamples.Length() == (size_t)ref->mParameters.mStopAtFrame.ref()) {
InitDecoder(Move(*mTrackDemuxer->GetInfo()));
} else {
Dispatch(NS_NewRunnableFunction([this, ref]() { DemuxNextSample(); }));
}
},
[this, ref](DemuxerFailureReason aReason) {
switch (aReason) {
case DemuxerFailureReason::END_OF_STREAM:
InitDecoder(Move(*mTrackDemuxer->GetInfo()));
break;
default:
MainThreadShutdown();
}
});
}
STDMETHODIMP CDecAvcodec::Flush()
{
if (m_pAVCtx) {
avcodec_flush_buffers(m_pAVCtx);
}
if (m_pParser) {
av_parser_close(m_pParser);
m_pParser = av_parser_init(m_nCodecId);
}
m_CurrentThread = 0;
m_rtStartCache = AV_NOPTS_VALUE;
m_bWaitingForKeyFrame = TRUE;
m_h264RandomAccess.flush(m_pAVCtx->thread_count);
m_nBFramePos = 0;
m_tcBFrameDelay[0].rtStart = m_tcBFrameDelay[0].rtStop = AV_NOPTS_VALUE;
m_tcBFrameDelay[1].rtStart = m_tcBFrameDelay[1].rtStop = AV_NOPTS_VALUE;
if (!m_bDXVA && !(m_pCallback->GetDecodeFlags() & LAV_VIDEO_DEC_FLAG_DVD) && (m_nCodecId == AV_CODEC_ID_H264 || m_nCodecId == AV_CODEC_ID_MPEG2VIDEO)) {
InitDecoder(m_nCodecId, &m_pCallback->GetInputMediaType());
}
return __super::Flush();
}
nsRefPtr<MediaDataDecoder::InitPromise>
FFmpegAudioDecoder<LIBAV_VER>::Init()
{
nsresult rv = InitDecoder();
return rv == NS_OK ? InitPromise::CreateAndResolve(TrackInfo::kAudioTrack, __func__)
: InitPromise::CreateAndReject(DecoderFailureReason::INIT_ERROR, __func__);
}
RefPtr<MediaDataDecoder::InitPromise>
FFmpegAudioDecoder<LIBAV_VER>::Init()
{
nsresult rv = InitDecoder();
return rv == NS_OK ? InitPromise::CreateAndResolve(TrackInfo::kAudioTrack, __func__)
: InitPromise::CreateAndReject(NS_ERROR_DOM_MEDIA_FATAL_ERR, __func__);
}
RefPtr<MediaDataDecoder::InitPromise>
FFmpegVideoDecoder<LIBAV_VER>::Init()
{
if (NS_FAILED(InitDecoder())) {
return InitPromise::CreateAndReject(NS_ERROR_DOM_MEDIA_FATAL_ERR, __func__);
}
return InitPromise::CreateAndResolve(TrackInfo::kVideoTrack, __func__);
}
RefPtr<MediaDataDecoder::InitPromise>
FFmpegVideoDecoder<LIBAV_VER>::Init()
{
if (NS_FAILED(InitDecoder())) {
return InitPromise::CreateAndReject(DecoderFailureReason::INIT_ERROR, __func__);
}
return InitPromise::CreateAndResolve(TrackInfo::kVideoTrack, __func__);
}
nsresult Init() override {
mSurfaceTexture = AndroidSurfaceTexture::Create();
if (!mSurfaceTexture) {
NS_WARNING("Failed to create SurfaceTexture for video decode\n");
return NS_ERROR_FAILURE;
}
return InitDecoder(mSurfaceTexture->JavaSurface());
}
RefPtr<MediaDataDecoder::InitPromise>
FFmpegAudioDecoder<LIBAV_VER>::Init()
{
MediaResult rv = InitDecoder();
return NS_SUCCEEDED(rv)
? InitPromise::CreateAndResolve(TrackInfo::kAudioTrack, __func__)
: InitPromise::CreateAndReject(rv, __func__);
}
long CWelsDecoder::Initialize (const SDecodingParam* pParam) {
if (pParam == NULL) {
IWelsTrace::WelsVTrace (m_pTrace, IWelsTrace::WELS_LOG_INFO, "CWelsDecoder::Initialize(), invalid input argument.");
return cmInitParaError;
}
// H.264 decoder initialization,including memory allocation,then open it ready to decode
InitDecoder();
DecoderConfigParam (m_pDecContext, pParam);
return cmResultSuccess;
}
long CWelsDecoder::Initialize (void_t* pParam, const INIT_TYPE keInitType) {
if (pParam == NULL || keInitType != INIT_TYPE_PARAMETER_BASED) {
IWelsTrace::WelsVTrace (m_pTrace, IWelsTrace::WELS_LOG_INFO, "CWelsDecoder::Initialize(), invalid input argument.");
return cmInitParaError;
}
// H.264 decoder initialization,including memory allocation,then open it ready to decode
InitDecoder();
DecoderConfigParam (m_pDecContext, pParam);
return cmResultSuccess;
}
RefPtr<InitPromise> Init() override
{
mSurfaceTexture = AndroidSurfaceTexture::Create();
if (!mSurfaceTexture) {
NS_WARNING("Failed to create SurfaceTexture for video decode\n");
return InitPromise::CreateAndReject(NS_ERROR_DOM_MEDIA_FATAL_ERR, __func__);
}
if (NS_FAILED(InitDecoder(mSurfaceTexture->JavaSurface()))) {
return InitPromise::CreateAndReject(NS_ERROR_DOM_MEDIA_FATAL_ERR, __func__);
}
return InitPromise::CreateAndResolve(TrackInfo::kVideoTrack, __func__);
}
Error VorbisLMC::CanDecode()
{
Error err;
if (!m_bInit)
{
err = InitDecoder();
if (err != kError_NoErr)
return err;
}
return kError_NoErr;
}
RefPtr<MediaDataDecoder::InitPromise>
FFmpegH264Decoder<LIBAV_VER>::Init()
{
if (NS_FAILED(InitDecoder())) {
return InitPromise::CreateAndReject(DecoderFailureReason::INIT_ERROR, __func__);
}
mCodecContext->get_buffer = AllocateBufferCb;
mCodecContext->release_buffer = ReleaseBufferCb;
mCodecContext->width = mImage.width;
mCodecContext->height = mImage.height;
return InitPromise::CreateAndResolve(TrackInfo::kVideoTrack, __func__);
}
RefPtr<MediaDataDecoder::InitPromise>
MediaCodecDataDecoder::Init()
{
nsresult rv = InitDecoder(nullptr);
TrackInfo::TrackType type =
(mType == MediaData::AUDIO_DATA ? TrackInfo::TrackType::kAudioTrack
: TrackInfo::TrackType::kVideoTrack);
return NS_SUCCEEDED(rv) ?
InitPromise::CreateAndResolve(type, __func__) :
InitPromise::CreateAndReject(
MediaDataDecoder::DecoderFailureReason::INIT_ERROR, __func__);
}
int32_t CWelsDecoder::ResetDecoder() {
// TBC: need to be modified when context and trace point are null
if (m_pDecContext != NULL && m_pWelsTrace != NULL) {
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO, "ResetDecoder(), context error code is %d",
m_pDecContext->iErrorCode);
SDecodingParam sPrevParam;
memcpy (&sPrevParam, m_pDecContext->pParam, sizeof (SDecodingParam));
WELS_VERIFY_RETURN_PROC_IF (cmInitParaError, InitDecoder (&sPrevParam), UninitDecoder());
} else if (m_pWelsTrace != NULL) {
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_ERROR, "ResetDecoder() failed as decoder context null");
}
return ERR_INFO_UNINIT;
}
long CWelsDecoder::Initialize (const SDecodingParam* pParam) {
if (m_pWelsTrace == NULL) {
return cmMallocMemeError;
}
if (pParam == NULL) {
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO, "CWelsDecoder::Initialize(), invalid input argument.");
return cmInitParaError;
}
// H.264 decoder initialization,including memory allocation,then open it ready to decode
InitDecoder();
DecoderConfigParam (m_pDecContext, pParam);
return cmResultSuccess;
}
long CWelsDecoder::Initialize (const SDecodingParam* pParam) {
int iRet = ERR_NONE;
if (m_pWelsTrace == NULL) {
return cmMallocMemeError;
}
if (pParam == NULL) {
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_ERROR, "CWelsDecoder::Initialize(), invalid input argument.");
return cmInitParaError;
}
// H.264 decoder initialization,including memory allocation,then open it ready to decode
iRet = InitDecoder (pParam);
if (iRet)
return iRet;
return cmResultSuccess;
}
void *CreateDecoder()
{
struct decoder_handle *hdec;
InitDecoder();
hdec = malloc(sizeof(struct decoder_handle));
if(!hdec) return NULL;
hdec->tag = 'HDEC';
hdec->c = avcodec_alloc_context();
if(!hdec->c) goto c2;
//if(h264_decoder.capabilities & CODEC_CAP_TRUNCATED)
// hdec->c->flags |= CODEC_FLAG_TRUNCATED;
if(avcodec_open(hdec->c, &h264_decoder) < 0)
{
av_free(hdec->c);
return NULL;
}
{
H264Context *h = hdec->c->priv_data;
MpegEncContext *s = &h->s;
s->dsp.idct_permutation_type = 1;
dsputil_init(&s->dsp, hdec->c);
}
hdec->picture = avcodec_alloc_frame();
if(!hdec->picture) goto c1;
return hdec;
//av_free(picture);
c1:
av_free(hdec->c);
c2:
free(hdec);
return NULL;
}
Error VorbisLMC::ExtractMediaInfo()
{
Error err;
float totalSeconds;
MediaInfoEvent *pMIE;
vorbis_info *vi;
if (!m_bInit)
{
err = InitDecoder();
if (err != kError_NoErr)
return err;
}
totalSeconds = ov_time_total(&m_vf, 0);
vi = ov_info(&m_vf, -1);
pMIE = new MediaInfoEvent(m_pPmi->Url(), totalSeconds);
if (!pMIE)
return kError_OutOfMemory;
VorbisInfoEvent *mie = new VorbisInfoEvent(ov_bitrate(&m_vf, 0),
vi->channels,
vi->rate,
1. / (float)iFramesPerSecond);
if (mie)
{
pMIE->AddChildEvent((Event *) mie);
mie = NULL;
}
else
{
return kError_OutOfMemory;
}
if (m_pTarget)
m_pTarget->AcceptEvent(pMIE);
return kError_NoErr;
}
void VorbisLMC::DecodeWork()
{
void *pOutBuffer;
Error Err;
int32 iValue;
int32 section, ret;
OutputInfo *info;
vorbis_info *vi;
uint32 bytesCopied, bytesPerFrame;
int bitrateLoops = 0;
assert(m_pPmi);
assert(m_pPmo);
m_pSleepSem->Wait();
m_pPmi->Wake();
Err = CanDecode();
if (Err == kError_Interrupt)
return;
if (Err != kError_NoErr)
{
m_pContext->log->Error("CanDecode returned false.\n");
if (m_decodeInfo.sendInfo)
{
ReportStatus(szCannotDecode);
m_pTarget->AcceptEvent(new Event(INFO_DoneOutputtingDueToError));
}
else
((EventBuffer *)m_pOutputBuffer)->AcceptEvent(new PMOErrorEvent());
return;
}
Err = ExtractMediaInfo();
if (Err == kError_Interrupt)
return;
if (IsError(Err))
{
m_pContext->log->Error("ExtractMediaInfo failed: %d\n", Err);
if (m_decodeInfo.sendInfo)
{
ReportStatus(szCannotDecode);
m_pTarget->AcceptEvent(new Event(INFO_DoneOutputtingDueToError));
}
else
((EventBuffer *)m_pOutputBuffer)->AcceptEvent(new PMOErrorEvent());
return;
}
if (!m_bInit)
{
Err = InitDecoder();
if (Err == kError_Interrupt)
return;
if (IsError(Err))
{
m_pContext->log->Error("Initializing the decoder failed: %d\n", Err);
ReportError("Initializing the decoder failed.");
return;
}
}
m_pContext->prefs->GetPrefInt32(kDecoderThreadPriorityPref, &iValue);
m_decoderThread->SetPriority(iValue);
bytesCopied = 0;
bytesPerFrame = 1;
for (m_frameCounter = 0; !m_bExit;)
{
if (m_bPause)
{
m_pPauseSem->Wait();
if (m_bExit)
break;
}
if (m_newPos >= 0)
{
ov_time_seek(&m_vf, (double)(m_newPos / iFramesPerSecond));
m_frameCounter = m_newPos - 1;
m_newPos = -1;
bytesCopied = bytesPerFrame;
}
if (bytesCopied >= bytesPerFrame)
{
m_frameCounter += bytesCopied / bytesPerFrame;
bytesCopied %= bytesPerFrame;
((EventBuffer *)m_pOutputBuffer)->AcceptEvent(
new PMOTimeInfoEvent(m_frameCounter));
bitrateLoops++;
if (bitrateLoops == iBitrateLoopsPerUpdate && m_decodeInfo.sendInfo)
{
int b;
b = ov_bitrate_instant(&m_vf),
vi = ov_info(&m_vf, -1);
VorbisInfoEvent *mie = new VorbisInfoEvent(b,
vi->channels,
vi->rate,
1. / (float)iFramesPerSecond);
m_pTarget->AcceptEvent(mie);
bitrateLoops = 0;
}
}
Err = m_pOutputBuffer->BeginWrite(pOutBuffer, iDecodeBlockSize);
if (Err == kError_Interrupt)
{
break;
}
if (Err == kError_BufferTooSmall)
{
if (Sleep())
break;
continue;
}
if (Err != kError_NoErr)
{
ReportError(szFailWrite);
m_pContext->log->Error("LMC: Cannot write to eventbuffer: %s (%d)\n",
m_szError, Err);
break;
}
section = -1;
ret = ov_read(&m_vf, (char *)pOutBuffer, iDecodeBlockSize,
0, 2, 1, §ion);
if (ret == 0)
{
m_pOutputBuffer->EndWrite(0);
break;
}
if (section != m_section)
{
vi = ov_info(&m_vf, -1);
info = new OutputInfo;
info->bits_per_sample = 16;
info->number_of_channels = m_channels = vi->channels;
info->samples_per_second = m_rate = vi->rate;
info->samples_per_frame = vi->rate / iFramesPerSecond;
info->max_buffer_size = 16384;
m_frameCounter = 0;
bytesCopied = 0;
bytesPerFrame = (vi->rate / iFramesPerSecond) *
sizeof(ogg_int16_t) * vi->channels;
m_section = section;
m_pOutputBuffer->EndWrite(0);
((EventBuffer *)m_pOutputBuffer)->AcceptEvent(new PMOInitEvent(info));
((EventBuffer *)m_pOutputBuffer)->AcceptEvent(
new PMOTimeInfoEvent(m_frameCounter));
Err = m_pOutputBuffer->BeginWrite(pOutBuffer, iDecodeBlockSize);
if (Err != kError_NoErr)
{
assert(0);
}
vorbis_comment *comment;
comment = ov_comment(&m_vf, -1);
if (comment)
{
PlaylistItem *plItem = m_pContext->plm->GetCurrentItem();
if (plItem)
{
MetaData mdata = plItem->GetMetaData();
string iso;
char *temp;
temp = vorbis_comment_query(comment, "title", 0);
if (temp)
{
iso = ConvertToISO(temp);
mdata.SetTitle(iso);
}
temp = vorbis_comment_query(comment, "artist", 0);
if (temp)
{
iso = ConvertToISO(temp);
mdata.SetArtist(iso);
}
temp = vorbis_comment_query(comment, "album", 0);
if (temp)
{
iso = ConvertToISO(temp);
mdata.SetAlbum(iso);
}
temp = vorbis_comment_query(comment, "tracknumber", 0);
if (temp)
mdata.SetTrack(atoi(temp));
plItem->SetMetaData(&mdata);
m_pContext->target->AcceptEvent(
new PlaylistCurrentItemInfoEvent(plItem,
m_pContext->plm));
}
}
}
if(ret <0)
ret=0; // hole/error in data - we can safely ignore this
m_pOutputBuffer->EndWrite(ret);
bytesCopied += ret;
}
((EventBuffer *)m_pOutputBuffer)->AcceptEvent(new PMOQuitEvent());
ov_clear(&m_vf);
return;
}
nsresult
SoftwareWebMVideoDecoder::Init(unsigned int aWidth, unsigned int aHeight)
{
return InitDecoder(aWidth, aHeight);
}
nsresult MediaCodecDataDecoder::Init()
{
return InitDecoder(nullptr);
}