diff --git a/config/external/moz.build b/config/external/moz.build index 60fdd7b70f..1d33bcf3c8 100644 --- a/config/external/moz.build +++ b/config/external/moz.build @@ -30,7 +30,6 @@ if CONFIG['MOZ_WEBM_ENCODER']: external_dirs += ['media/libvpx'] if CONFIG['MOZ_AV1']: - external_dirs += ['media/libaom'] external_dirs += ['media/libdav1d'] external_dirs += ['media/libpng'] diff --git a/dom/media/platforms/agnostic/AOMDecoder.cpp b/dom/media/platforms/agnostic/AOMDecoder.cpp deleted file mode 100644 index 1a6aca483f..0000000000 --- a/dom/media/platforms/agnostic/AOMDecoder.cpp +++ /dev/null @@ -1,348 +0,0 @@ -/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ -/* This Source Code Form is subject to the terms of the Mozilla Public - * License, v. 2.0. If a copy of the MPL was not distributed with this - * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ - -#include "AOMDecoder.h" -#include "MediaResult.h" -#include "TimeUnits.h" -#include "aom/aomdx.h" -#include "aom/aom_image.h" -#include "gfx2DGlue.h" -#include "mozilla/PodOperations.h" -#include "mozilla/SyncRunnable.h" -#include "nsError.h" -#include "prsystem.h" - -#include - -#undef LOG -#define LOG(arg, ...) MOZ_LOG(sPDMLog, mozilla::LogLevel::Debug, ("AOMDecoder(%p)::%s: " arg, this, __func__, ##__VA_ARGS__)) - -namespace mozilla { - -using namespace gfx; -using namespace layers; - -AOMDecoder::AOMDecoder(const CreateDecoderParams& aParams) - : mImageContainer(aParams.mImageContainer) - , mTaskQueue(aParams.mTaskQueue) - , mCallback(aParams.mCallback) - , mIsFlushing(false) - , mInfo(aParams.VideoConfig()) -{ - PodZero(&mCodec); -} - -AOMDecoder::~AOMDecoder() -{ -} - -void -AOMDecoder::Shutdown() -{ - aom_codec_destroy(&mCodec); -} - -RefPtr -AOMDecoder::Init() -{ - int decode_threads = 2; - - aom_codec_iface_t* dx = aom_codec_av1_dx(); - if (mInfo.mDisplay.width >= 2048) { - decode_threads = 8; - } - else if (mInfo.mDisplay.width >= 1024) { - decode_threads = 4; - } - decode_threads = std::min(decode_threads, PR_GetNumberOfProcessors()); - - aom_codec_dec_cfg_t config; - PodZero(&config); - config.threads = decode_threads; - config.w = config.h = 0; // set after decode - config.allow_lowbitdepth = true; - - aom_codec_flags_t flags = 0; - - if (!dx || aom_codec_dec_init(&mCodec, dx, &config, flags)) { - return InitPromise::CreateAndReject(NS_ERROR_DOM_MEDIA_FATAL_ERR, __func__); - } - return InitPromise::CreateAndResolve(TrackInfo::kVideoTrack, __func__); -} - -void -AOMDecoder::Flush() -{ - MOZ_ASSERT(mCallback->OnReaderTaskQueue()); - mIsFlushing = true; - nsCOMPtr r = NS_NewRunnableFunction([this] () { - // nothing to do for now. - }); - SyncRunnable::DispatchToThread(mTaskQueue, r); - mIsFlushing = false; -} - -// Ported from third_party/aom/tools_common.c. -static aom_codec_err_t -highbd_img_downshift(aom_image_t *dst, aom_image_t *src, int down_shift) { - int plane; - if (dst->d_w != src->d_w || dst->d_h != src->d_h) - return AOM_CODEC_INVALID_PARAM; - if (dst->x_chroma_shift != src->x_chroma_shift) - return AOM_CODEC_INVALID_PARAM; - if (dst->y_chroma_shift != src->y_chroma_shift) - return AOM_CODEC_INVALID_PARAM; - if (dst->fmt != (src->fmt & ~AOM_IMG_FMT_HIGHBITDEPTH)) - return AOM_CODEC_INVALID_PARAM; - if (down_shift < 0) - return AOM_CODEC_INVALID_PARAM; - switch (dst->fmt) { - case AOM_IMG_FMT_I420: - case AOM_IMG_FMT_I422: - case AOM_IMG_FMT_I444: - break; - default: - return AOM_CODEC_INVALID_PARAM; - } - switch (src->fmt) { - case AOM_IMG_FMT_I42016: - case AOM_IMG_FMT_I42216: - case AOM_IMG_FMT_I44416: - break; - default: - // We don't support anything that's not 16 bit - return AOM_CODEC_UNSUP_BITSTREAM; - } - for (plane = 0; plane < 3; plane++) { - int w = src->d_w; - int h = src->d_h; - int x, y; - if (plane) { - w = (w + src->x_chroma_shift) >> src->x_chroma_shift; - h = (h + src->y_chroma_shift) >> src->y_chroma_shift; - } - for (y = 0; y < h; y++) { - uint16_t *p_src = - (uint16_t *)(src->planes[plane] + y * src->stride[plane]); - uint8_t *p_dst = - dst->planes[plane] + y * dst->stride[plane]; - for (x = 0; x < w; x++) *p_dst++ = (*p_src++ >> down_shift) & 0xFF; - } - } - return AOM_CODEC_OK; -} - -// UniquePtr dtor wrapper for aom_image_t. -struct AomImageFree { - void operator()(aom_image_t* img) { aom_img_free(img); } -}; - -MediaResult -AOMDecoder::DoDecode(MediaRawData* aSample) -{ - MOZ_ASSERT(mTaskQueue->IsCurrentThreadIn()); - -#if defined(DEBUG) - NS_ASSERTION(IsKeyframe(*aSample) == aSample->mKeyframe, - "AOM Decode Keyframe error sample->mKeyframe and si.si_kf out of sync"); -#endif - - if (aom_codec_err_t r = aom_codec_decode(&mCodec, aSample->Data(), aSample->Size(), nullptr)) { - LOG("AOM Decode error: %s", aom_codec_err_to_string(r)); - return MediaResult( - NS_ERROR_DOM_MEDIA_DECODE_ERR, - RESULT_DETAIL("AOM error decoding AV1 sample: %s", aom_codec_err_to_string(r))); - } - - aom_codec_iter_t iter = nullptr; - aom_image_t *img; - UniquePtr img8; - - while ((img = aom_codec_get_frame(&mCodec, &iter))) { - // Track whether the underlying buffer is 8 or 16 bits per channel. - bool highbd = bool(img->fmt & AOM_IMG_FMT_HIGHBITDEPTH); - if (highbd) { - // Downsample images with more than 8 bits per channel. - aom_img_fmt_t fmt8 = static_cast(img->fmt ^ AOM_IMG_FMT_HIGHBITDEPTH); - img8.reset(aom_img_alloc(NULL, fmt8, img->d_w, img->d_h, 16)); - if (img8 == nullptr) { - LOG("Couldn't allocate bitdepth reduction target!"); - return MediaResult( - NS_ERROR_OUT_OF_MEMORY, - RESULT_DETAIL("Couldn't allocate conversion buffer for AV1 frame")); - } - if (aom_codec_err_t r = highbd_img_downshift(img8.get(), img, img->bit_depth - 8)) { - return MediaResult( - NS_ERROR_DOM_MEDIA_DECODE_ERR, - RESULT_DETAIL("Error converting AV1 frame to 8 bits: %s", - aom_codec_err_to_string(r))); - } - // img normally points to storage owned by mCodec, so it is not freed. - // To copy out the contents of img8 we can overwrite img with an alias. - // Since img is assigned at the start of the while loop and img8 is held - // outside that loop, the alias won't outlive the storage it points to. - img = img8.get(); - highbd = false; - } - - NS_ASSERTION(img->fmt == AOM_IMG_FMT_I420 || - img->fmt == AOM_IMG_FMT_I42016 || - img->fmt == AOM_IMG_FMT_I444 || - img->fmt == AOM_IMG_FMT_I44416, - "AV1 image format not I420 or I444"); - - // Chroma shifts are rounded down as per the decoding examples in the SDK - VideoData::YCbCrBuffer b; - b.mPlanes[0].mData = img->planes[0]; - b.mPlanes[0].mStride = img->stride[0]; - b.mPlanes[0].mHeight = img->d_h; - b.mPlanes[0].mWidth = img->d_w; - b.mPlanes[0].mOffset = 0; - b.mPlanes[0].mSkip = highbd ? 1 : 0; - - b.mPlanes[1].mData = img->planes[1]; - b.mPlanes[1].mStride = img->stride[1]; - b.mPlanes[1].mOffset = 0; - b.mPlanes[1].mSkip = highbd ? 1 : 0; - - b.mPlanes[2].mData = img->planes[2]; - b.mPlanes[2].mStride = img->stride[2]; - b.mPlanes[2].mOffset = 0; - b.mPlanes[2].mSkip = highbd ? 1 : 0; - - if (img->fmt == AOM_IMG_FMT_I420 || - img->fmt == AOM_IMG_FMT_I42016) { - b.mPlanes[1].mHeight = (img->d_h + 1) >> img->y_chroma_shift; - b.mPlanes[1].mWidth = (img->d_w + 1) >> img->x_chroma_shift; - - b.mPlanes[2].mHeight = (img->d_h + 1) >> img->y_chroma_shift; - b.mPlanes[2].mWidth = (img->d_w + 1) >> img->x_chroma_shift; - } else if (img->fmt == AOM_IMG_FMT_I444) { - b.mPlanes[1].mHeight = img->d_h; - b.mPlanes[1].mWidth = img->d_w; - - b.mPlanes[2].mHeight = img->d_h; - b.mPlanes[2].mWidth = img->d_w; - } else { - LOG("AOM Unknown image format"); - return MediaResult(NS_ERROR_DOM_MEDIA_DECODE_ERR, - RESULT_DETAIL("AOM Unknown image format")); - } - - switch (img->mc) { - case AOM_CICP_MC_BT_601: - b.mYUVColorSpace = YUVColorSpace::BT601; - break; - case AOM_CICP_MC_BT_709: - b.mYUVColorSpace = YUVColorSpace::BT709; - break; - case AOM_CICP_MC_IDENTITY: - b.mYUVColorSpace = YUVColorSpace::IDENTITY; - break; - default: - LOG("Unhandled colorspace %d", img->mc); - break; - } - b.mColorRange = img->range == AOM_CR_FULL_RANGE ? ColorRange::FULL - : ColorRange::LIMITED; - - RefPtr v = - VideoData::CreateAndCopyData(mInfo, - mImageContainer, - aSample->mOffset, - aSample->mTime, - aSample->mDuration, - b, - aSample->mKeyframe, - aSample->mTimecode, - mInfo.ScaledImageRect(img->d_w, - img->d_h)); - - if (!v) { - LOG("Image allocation error source %ux%u display %ux%u picture %ux%u", - img->d_w, img->d_h, mInfo.mDisplay.width, mInfo.mDisplay.height, - mInfo.mImage.width, mInfo.mImage.height); - return MediaResult(NS_ERROR_OUT_OF_MEMORY, __func__); - } - mCallback->Output(v); - } - return NS_OK; -} - -void -AOMDecoder::ProcessDecode(MediaRawData* aSample) -{ - MOZ_ASSERT(mTaskQueue->IsCurrentThreadIn()); - if (mIsFlushing) { - return; - } - MediaResult rv = DoDecode(aSample); - if (NS_FAILED(rv)) { - mCallback->Error(rv); - } else { - mCallback->InputExhausted(); - } -} - -void -AOMDecoder::Input(MediaRawData* aSample) -{ - MOZ_ASSERT(mCallback->OnReaderTaskQueue()); - mTaskQueue->Dispatch(NewRunnableMethod>( - this, &AOMDecoder::ProcessDecode, aSample)); -} - -void -AOMDecoder::ProcessDrain() -{ - MOZ_ASSERT(mTaskQueue->IsCurrentThreadIn()); - mCallback->DrainComplete(); -} - -void -AOMDecoder::Drain() -{ - MOZ_ASSERT(mCallback->OnReaderTaskQueue()); - mTaskQueue->Dispatch(NewRunnableMethod(this, &AOMDecoder::ProcessDrain)); -} - -/* static */ -bool -AOMDecoder::IsAV1(const nsACString& aMimeType) -{ - return aMimeType.EqualsLiteral("video/webm; codecs=av1") || - aMimeType.EqualsLiteral("video/av1"); -} - -/* static */ -bool -AOMDecoder::IsKeyframe(Span aBuffer) { - aom_codec_stream_info_t info; - PodZero(&info); - - aom_codec_peek_stream_info(aom_codec_av1_dx(), - aBuffer.Elements(), - aBuffer.Length(), - &info); - - return bool(info.is_kf); -} - -/* static */ -nsIntSize -AOMDecoder::GetFrameSize(Span aBuffer) { - aom_codec_stream_info_t info; - PodZero(&info); - - aom_codec_peek_stream_info(aom_codec_av1_dx(), - aBuffer.Elements(), - aBuffer.Length(), - &info); - - return nsIntSize(info.w, info.h); -} - -} // namespace mozilla -#undef LOG diff --git a/dom/media/platforms/agnostic/AgnosticDecoderModule.cpp b/dom/media/platforms/agnostic/AgnosticDecoderModule.cpp index 10432ad493..a1ba164289 100644 --- a/dom/media/platforms/agnostic/AgnosticDecoderModule.cpp +++ b/dom/media/platforms/agnostic/AgnosticDecoderModule.cpp @@ -13,7 +13,7 @@ #include "TheoraDecoder.h" #ifdef MOZ_AV1 -#include "AOMDecoder.h" +#include "Dav1dDecoder.h" #endif namespace mozilla { @@ -30,7 +30,7 @@ AgnosticDecoderModule::SupportsMimeType(const nsACString& aMimeType, TheoraDecoder::IsTheora(aMimeType); #ifdef MOZ_AV1 if (MediaPrefs::AV1Enabled()) { - supports |= AOMDecoder::IsAV1(aMimeType); + supports |= Dav1dDecoder::IsAV1(aMimeType); } #endif MOZ_LOG(sPDMLog, LogLevel::Debug, ("Agnostic decoder %s requested type", @@ -47,9 +47,9 @@ AgnosticDecoderModule::CreateVideoDecoder(const CreateDecoderParams& aParams) m = new VPXDecoder(aParams); } #ifdef MOZ_AV1 - else if (AOMDecoder::IsAV1(aParams.mConfig.mMimeType) && + else if (Dav1dDecoder::IsAV1(aParams.mConfig.mMimeType) && MediaPrefs::AV1Enabled()) { - m = new AOMDecoder(aParams); + m = new Dav1dDecoder(aParams); } #endif else if (TheoraDecoder::IsTheora(aParams.mConfig.mMimeType)) { diff --git a/dom/media/platforms/agnostic/Dav1dDecoder.cpp b/dom/media/platforms/agnostic/Dav1dDecoder.cpp new file mode 100644 index 0000000000..9a94374251 --- /dev/null +++ b/dom/media/platforms/agnostic/Dav1dDecoder.cpp @@ -0,0 +1,376 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "Dav1dDecoder.h" +#include "MediaResult.h" +#include "TimeUnits.h" +#include "dav1d/dav1d.h" +#include "mozilla/CheckedInt.h" +#include "mozilla/PodOperations.h" +#include "mozilla/SyncRunnable.h" +#include "mozilla/UniquePtr.h" +#include "mozilla/UniquePtrExtensions.h" +#include "nsError.h" +#include "prsystem.h" + +#include +#include +#include + +#undef LOG +#define LOG(arg, ...) MOZ_LOG(sPDMLog, mozilla::LogLevel::Debug, ("Dav1dDecoder(%p)::%s: " arg, this, __func__, ##__VA_ARGS__)) + +namespace mozilla { + +using namespace gfx; +using namespace layers; + +Dav1dDecoder::Dav1dDecoder(const CreateDecoderParams& aParams) + : mImageContainer(aParams.mImageContainer) + , mTaskQueue(aParams.mTaskQueue) + , mCallback(aParams.mCallback) + , mIsFlushing(false) + , mDecoder(nullptr) + , mInfo(aParams.VideoConfig()) +{ +} + +Dav1dDecoder::~Dav1dDecoder() +{ +} + +void +Dav1dDecoder::Shutdown() +{ + if (mDecoder) { + dav1d_close(&mDecoder); + } +} + +RefPtr +Dav1dDecoder::Init() +{ + int decodeThreads = 2; + if (mInfo.mDisplay.width >= 2048) { + decodeThreads = 8; + } else if (mInfo.mDisplay.width >= 1024) { + decodeThreads = 4; + } + decodeThreads = std::min(decodeThreads, PR_GetNumberOfProcessors()); + + Dav1dSettings settings; + dav1d_default_settings(&settings); + settings.n_threads = decodeThreads; + settings.logger.callback = nullptr; + + if (dav1d_open(&mDecoder, &settings) < 0) { + return InitPromise::CreateAndReject(NS_ERROR_DOM_MEDIA_FATAL_ERR, __func__); + } + return InitPromise::CreateAndResolve(TrackInfo::kVideoTrack, __func__); +} + +void +Dav1dDecoder::Flush() +{ + MOZ_ASSERT(mCallback->OnReaderTaskQueue()); + mIsFlushing = true; + nsCOMPtr r = NS_NewRunnableFunction([this] () { + if (mDecoder) { + dav1d_flush(mDecoder); + } + }); + SyncRunnable::DispatchToThread(mTaskQueue, r); + mIsFlushing = false; +} + +static bool +GetPlaneSize(int aWidth, int aHeight, size_t* aSize) +{ + CheckedInt size = aWidth; + size *= aHeight; + if (!size.isValid()) { + return false; + } + *aSize = size.value(); + return true; +} + +static void +DownshiftPlane(uint8_t* aDst, int aDstStride, const uint8_t* aSrc, + ptrdiff_t aSrcStride, int aWidth, int aHeight, int aShift) +{ + for (int y = 0; y < aHeight; y++) { + const uint16_t* src = + reinterpret_cast(aSrc + y * aSrcStride); + uint8_t* dst = aDst + y * aDstStride; + for (int x = 0; x < aWidth; x++) { + dst[x] = (src[x] >> aShift) & 0xff; + } + } +} + +MediaResult +Dav1dDecoder::OutputPicture(const Dav1dPicture& aPicture) +{ + const int width = aPicture.p.w; + const int height = aPicture.p.h; + if (width <= 0 || height <= 0) { + return MediaResult(NS_ERROR_DOM_MEDIA_DECODE_ERR, + RESULT_DETAIL("dav1d returned invalid AV1 picture size")); + } + + int chromaWidth = width; + int chromaHeight = height; + switch (aPicture.p.layout) { + case DAV1D_PIXEL_LAYOUT_I420: + chromaWidth = (width + 1) >> 1; + chromaHeight = (height + 1) >> 1; + break; + case DAV1D_PIXEL_LAYOUT_I422: + chromaWidth = (width + 1) >> 1; + chromaHeight = height; + break; + case DAV1D_PIXEL_LAYOUT_I444: + break; + default: + return MediaResult(NS_ERROR_DOM_MEDIA_DECODE_ERR, + RESULT_DETAIL("dav1d returned unsupported AV1 pixel layout: %d", + int(aPicture.p.layout))); + } + + const int planeWidths[3] = { width, chromaWidth, chromaWidth }; + const int planeHeights[3] = { height, chromaHeight, chromaHeight }; + const ptrdiff_t srcStrides[3] = { + aPicture.stride[0], + aPicture.stride[1], + aPicture.stride[1] + }; + uint8_t* planeData[3] = { + static_cast(aPicture.data[0]), + static_cast(aPicture.data[1]), + static_cast(aPicture.data[2]) + }; + uint32_t planeStrides[3] = { 0, 0, 0 }; + UniquePtr downshifted[3]; + + if (aPicture.p.bpc > 8) { + const int shift = aPicture.p.bpc - 8; + for (int plane = 0; plane < 3; plane++) { + size_t planeSize; + if (!GetPlaneSize(planeWidths[plane], planeHeights[plane], &planeSize)) { + return MediaResult(NS_ERROR_OUT_OF_MEMORY, + RESULT_DETAIL("AV1 downshift plane size overflow")); + } + downshifted[plane] = MakeUniqueFallible(planeSize); + if (!downshifted[plane]) { + return MediaResult(NS_ERROR_OUT_OF_MEMORY, + RESULT_DETAIL("Couldn't allocate AV1 conversion buffer")); + } + DownshiftPlane(downshifted[plane].get(), planeWidths[plane], + planeData[plane], srcStrides[plane], + planeWidths[plane], planeHeights[plane], shift); + planeData[plane] = downshifted[plane].get(); + planeStrides[plane] = planeWidths[plane]; + } + } else { + for (int plane = 0; plane < 3; plane++) { + CheckedInt stride(srcStrides[plane]); + if (srcStrides[plane] < 0 || !stride.isValid()) { + return MediaResult(NS_ERROR_DOM_MEDIA_DECODE_ERR, + RESULT_DETAIL("dav1d returned invalid AV1 stride")); + } + planeStrides[plane] = stride.value(); + } + } + + VideoData::YCbCrBuffer b; + for (int plane = 0; plane < 3; plane++) { + b.mPlanes[plane].mData = planeData[plane]; + b.mPlanes[plane].mStride = planeStrides[plane]; + b.mPlanes[plane].mHeight = planeHeights[plane]; + b.mPlanes[plane].mWidth = planeWidths[plane]; + b.mPlanes[plane].mOffset = 0; + b.mPlanes[plane].mSkip = 0; + } + + if (aPicture.seq_hdr) { + switch (aPicture.seq_hdr->mtrx) { + case DAV1D_MC_BT601: + case DAV1D_MC_BT470BG: + b.mYUVColorSpace = YUVColorSpace::BT601; + break; + case DAV1D_MC_BT709: + b.mYUVColorSpace = YUVColorSpace::BT709; + break; + case DAV1D_MC_IDENTITY: + b.mYUVColorSpace = YUVColorSpace::IDENTITY; + break; + default: + LOG("Unhandled colorspace %d", aPicture.seq_hdr->mtrx); + break; + } + b.mColorRange = aPicture.seq_hdr->color_range ? ColorRange::FULL + : ColorRange::LIMITED; + } + + const int64_t time = + aPicture.m.timestamp == INT64_MIN ? 0 : aPicture.m.timestamp; + const int64_t duration = aPicture.m.duration; + const int64_t offset = aPicture.m.offset; + const bool keyframe = + aPicture.frame_hdr && + aPicture.frame_hdr->frame_type == DAV1D_FRAME_TYPE_KEY; + + RefPtr v = + VideoData::CreateAndCopyData(mInfo, + mImageContainer, + offset, + time, + duration, + b, + keyframe, + time, + mInfo.ScaledImageRect(width, height)); + + if (!v) { + LOG("Image allocation error source %dx%d display %ux%u picture %ux%u", + width, height, mInfo.mDisplay.width, mInfo.mDisplay.height, + mInfo.mImage.width, mInfo.mImage.height); + return MediaResult(NS_ERROR_OUT_OF_MEMORY, __func__); + } + mCallback->Output(v); + return NS_OK; +} + +MediaResult +Dav1dDecoder::DrainOutput() +{ + while (true) { + Dav1dPicture picture; + PodZero(&picture); + const int res = dav1d_get_picture(mDecoder, &picture); + if (res == DAV1D_ERR(EAGAIN)) { + return NS_OK; + } + if (res < 0) { + return MediaResult(NS_ERROR_DOM_MEDIA_DECODE_ERR, + RESULT_DETAIL("dav1d error getting AV1 picture: %d", + res)); + } + + MediaResult rv = OutputPicture(picture); + dav1d_picture_unref(&picture); + if (NS_FAILED(rv)) { + return rv; + } + } +} + +MediaResult +Dav1dDecoder::DoDecode(MediaRawData* aSample) +{ + MOZ_ASSERT(mTaskQueue->IsCurrentThreadIn()); + + Dav1dData data; + PodZero(&data); + uint8_t* dst = dav1d_data_create(&data, aSample->Size()); + if (!dst) { + return MediaResult(NS_ERROR_OUT_OF_MEMORY, + RESULT_DETAIL("Couldn't allocate dav1d AV1 input buffer")); + } + memcpy(dst, aSample->Data(), aSample->Size()); + data.m.timestamp = aSample->mTime; + data.m.duration = aSample->mDuration; + data.m.offset = aSample->mOffset; + data.m.size = aSample->Size(); + + while (data.sz) { + const int res = dav1d_send_data(mDecoder, &data); + if (res == DAV1D_ERR(EAGAIN)) { + MediaResult rv = DrainOutput(); + if (NS_FAILED(rv)) { + dav1d_data_unref(&data); + return rv; + } + continue; + } + if (res < 0) { + dav1d_data_unref(&data); + return MediaResult(NS_ERROR_DOM_MEDIA_DECODE_ERR, + RESULT_DETAIL("dav1d error decoding AV1 sample: %d", + res)); + } + } + + dav1d_data_unref(&data); + return DrainOutput(); +} + +void +Dav1dDecoder::ProcessDecode(MediaRawData* aSample) +{ + MOZ_ASSERT(mTaskQueue->IsCurrentThreadIn()); + if (mIsFlushing) { + return; + } + MediaResult rv = DoDecode(aSample); + if (NS_FAILED(rv)) { + mCallback->Error(rv); + } else { + mCallback->InputExhausted(); + } +} + +void +Dav1dDecoder::Input(MediaRawData* aSample) +{ + MOZ_ASSERT(mCallback->OnReaderTaskQueue()); + mTaskQueue->Dispatch(NewRunnableMethod>( + this, &Dav1dDecoder::ProcessDecode, aSample)); +} + +void +Dav1dDecoder::ProcessDrain() +{ + MOZ_ASSERT(mTaskQueue->IsCurrentThreadIn()); + MediaResult rv = DrainOutput(); + if (NS_FAILED(rv)) { + mCallback->Error(rv); + } else { + mCallback->DrainComplete(); + } +} + +void +Dav1dDecoder::Drain() +{ + MOZ_ASSERT(mCallback->OnReaderTaskQueue()); + mTaskQueue->Dispatch(NewRunnableMethod(this, &Dav1dDecoder::ProcessDrain)); +} + +/* static */ +bool +Dav1dDecoder::IsAV1(const nsACString& aMimeType) +{ + return aMimeType.EqualsLiteral("video/webm; codecs=av1") || + aMimeType.EqualsLiteral("video/av1"); +} + +/* static */ +nsIntSize +Dav1dDecoder::GetFrameSize(Span aBuffer) +{ + Dav1dSequenceHeader seqHdr; + PodZero(&seqHdr); + if (dav1d_parse_sequence_header(&seqHdr, + aBuffer.Elements(), + aBuffer.Length()) < 0) { + return nsIntSize(0, 0); + } + return nsIntSize(seqHdr.max_width, seqHdr.max_height); +} + +} // namespace mozilla +#undef LOG diff --git a/dom/media/platforms/agnostic/AOMDecoder.h b/dom/media/platforms/agnostic/Dav1dDecoder.h similarity index 69% rename from dom/media/platforms/agnostic/AOMDecoder.h rename to dom/media/platforms/agnostic/Dav1dDecoder.h index 73b3be67c7..e8b1c6aee3 100644 --- a/dom/media/platforms/agnostic/AOMDecoder.h +++ b/dom/media/platforms/agnostic/Dav1dDecoder.h @@ -3,21 +3,23 @@ * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ -#if !defined(AOMDecoder_h_) -#define AOMDecoder_h_ +#if !defined(Dav1dDecoder_h_) +#define Dav1dDecoder_h_ #include "PlatformDecoderModule.h" #include "mozilla/Span.h" #include -#include "aom/aom_decoder.h" + +typedef struct Dav1dContext Dav1dContext; +typedef struct Dav1dPicture Dav1dPicture; namespace mozilla { -class AOMDecoder : public MediaDataDecoder +class Dav1dDecoder : public MediaDataDecoder { public: - explicit AOMDecoder(const CreateDecoderParams& aParams); + explicit Dav1dDecoder(const CreateDecoderParams& aParams); RefPtr Init() override; void Input(MediaRawData* aSample) override; @@ -26,23 +28,22 @@ public: void Shutdown() override; const char* GetDescriptionName() const override { - return "libaom (AV1) video decoder"; + return "dav1d (AV1) video decoder"; } // Return true if aMimeType is a one of the strings used // by our demuxers to identify AV1 streams. static bool IsAV1(const nsACString& aMimeType); - // Return true if a sample is a keyframe. - static bool IsKeyframe(Span aBuffer); - - // Return the frame dimensions for a sample. + // Return the frame dimensions from a sequence header, when one is present. static nsIntSize GetFrameSize(Span aBuffer); private: - ~AOMDecoder(); + ~Dav1dDecoder(); void ProcessDecode(MediaRawData* aSample); MediaResult DoDecode(MediaRawData* aSample); + MediaResult DrainOutput(); + MediaResult OutputPicture(const Dav1dPicture& aPicture); void ProcessDrain(); const RefPtr mImageContainer; @@ -50,12 +51,11 @@ private: MediaDataDecoderCallback* mCallback; Atomic mIsFlushing; - // AOM decoder state - aom_codec_ctx_t mCodec; + Dav1dContext* mDecoder; const VideoInfo& mInfo; }; } // namespace mozilla -#endif // AOMDecoder_h_ +#endif // Dav1dDecoder_h_ diff --git a/dom/media/platforms/moz.build b/dom/media/platforms/moz.build index 2997ffa8d7..6e8e1bcf30 100644 --- a/dom/media/platforms/moz.build +++ b/dom/media/platforms/moz.build @@ -58,10 +58,10 @@ if CONFIG['MOZ_FFMPEG']: if CONFIG['MOZ_AV1']: EXPORTS += [ - 'agnostic/AOMDecoder.h', + 'agnostic/Dav1dDecoder.h', ] UNIFIED_SOURCES += [ - 'agnostic/AOMDecoder.cpp', + 'agnostic/Dav1dDecoder.cpp', ] if CONFIG['MOZ_APPLEMEDIA']: diff --git a/dom/media/webm/WebMDecoder.cpp b/dom/media/webm/WebMDecoder.cpp index da534b1cf5..24f02a43a2 100644 --- a/dom/media/webm/WebMDecoder.cpp +++ b/dom/media/webm/WebMDecoder.cpp @@ -4,9 +4,6 @@ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ #include "mozilla/Preferences.h" -#ifdef MOZ_AV1 -#include "AOMDecoder.h" -#endif #include "MediaPrefs.h" #include "MediaDecoderStateMachine.h" #include "WebMDemuxer.h" @@ -136,4 +133,3 @@ WebMDecoder::GetMozDebugReaderData(nsAString& aString) } } // namespace mozilla - diff --git a/dom/media/webm/WebMDemuxer.cpp b/dom/media/webm/WebMDemuxer.cpp index fc98db4d77..5a53339a58 100644 --- a/dom/media/webm/WebMDemuxer.cpp +++ b/dom/media/webm/WebMDemuxer.cpp @@ -1278,3 +1278,1286 @@ WebMTrackDemuxer::GetEvictionOffset(const media::TimeUnit& aTime) #undef WEBM_DEBUG } // namespace mozilla +======= +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "nsError.h" +#include "MediaDecoderStateMachine.h" +#include "AbstractMediaDecoder.h" +#include "MediaResource.h" +#ifdef MOZ_AV1 +#include "Dav1dDecoder.h" +#endif +#include "OpusDecoder.h" +#include "VPXDecoder.h" +#include "WebMDemuxer.h" +#include "WebMBufferedParser.h" +#include "gfx2DGlue.h" +#include "mozilla/Atomics.h" +#include "mozilla/EndianUtils.h" +#include "mozilla/Maybe.h" +#include "mozilla/SharedThreadPool.h" +#include "MediaDataDemuxer.h" +#include "nsAutoPtr.h" +#include "nsAutoRef.h" +#include "NesteggPacketHolder.h" +#include "XiphExtradata.h" +#include "prprf.h" // leaving it for PR_vsnprintf() +#include "mozilla/Sprintf.h" + +#include +#include +#include + +#define WEBM_DEBUG(arg, ...) MOZ_LOG(gMediaDemuxerLog, mozilla::LogLevel::Debug, ("WebMDemuxer(%p)::%s: " arg, this, __func__, ##__VA_ARGS__)) +extern mozilla::LazyLogModule gMediaDemuxerLog; + +namespace mozilla { + +using namespace gfx; + +LazyLogModule gNesteggLog("Nestegg"); + +// How far ahead will we look when searching future keyframe. In microseconds. +// This value is based on what appears to be a reasonable value as most webm +// files encountered appear to have keyframes located < 4s. +#define MAX_LOOK_AHEAD 10000000 + +static Atomic sStreamSourceID(0u); + +// Functions for reading and seeking using WebMDemuxer required for +// nestegg_io. The 'user data' passed to these functions is the +// demuxer. +static int webmdemux_read(void* aBuffer, size_t aLength, void* aUserData) +{ + MOZ_ASSERT(aUserData); + MOZ_ASSERT(aLength < UINT32_MAX); + WebMDemuxer::NestEggContext* context = + reinterpret_cast(aUserData); + uint32_t count = aLength; + if (context->IsMediaSource()) { + int64_t length = context->GetEndDataOffset(); + int64_t position = context->GetResource()->Tell(); + MOZ_ASSERT(position <= context->GetResource()->GetLength()); + MOZ_ASSERT(position <= length); + if (length >= 0 && count + position > length) { + count = length - position; + } + MOZ_ASSERT(count <= aLength); + } + uint32_t bytes = 0; + nsresult rv = + context->GetResource()->Read(static_cast(aBuffer), count, &bytes); + bool eof = bytes < aLength; + return NS_FAILED(rv) ? -1 : eof ? 0 : 1; +} + +static int webmdemux_seek(int64_t aOffset, int aWhence, void* aUserData) +{ + MOZ_ASSERT(aUserData); + WebMDemuxer::NestEggContext* context = reinterpret_cast(aUserData); + nsresult rv = context->GetResource()->Seek(aWhence, aOffset); + return NS_SUCCEEDED(rv) ? 0 : -1; +} + +static int64_t webmdemux_tell(void* aUserData) +{ + MOZ_ASSERT(aUserData); + WebMDemuxer::NestEggContext* context = reinterpret_cast(aUserData); + return context->GetResource()->Tell(); +} + +static void webmdemux_log(nestegg* aContext, + unsigned int aSeverity, + char const* aFormat, ...) +{ + if (!MOZ_LOG_TEST(gNesteggLog, LogLevel::Debug)) { + return; + } + + va_list args; + char msg[256]; + const char* sevStr; + + switch(aSeverity) { + case NESTEGG_LOG_DEBUG: + sevStr = "DBG"; + break; + case NESTEGG_LOG_INFO: + sevStr = "INF"; + break; + case NESTEGG_LOG_WARNING: + sevStr = "WRN"; + break; + case NESTEGG_LOG_ERROR: + sevStr = "ERR"; + break; + case NESTEGG_LOG_CRITICAL: + sevStr = "CRT"; + break; + default: + sevStr = "UNK"; + break; + } + + va_start(args, aFormat); + + SprintfLiteral(msg, "%p [Nestegg-%s] ", aContext, sevStr); + PR_vsnprintf(msg+strlen(msg), sizeof(msg)-strlen(msg), aFormat, args); + MOZ_LOG(gNesteggLog, LogLevel::Debug, (msg)); + + va_end(args); +} + +WebMDemuxer::NestEggContext::~NestEggContext() +{ + if (mContext) { + nestegg_destroy(mContext); + } +} + +int +WebMDemuxer::NestEggContext::Init() +{ + nestegg_io io; + io.read = webmdemux_read; + io.seek = webmdemux_seek; + io.tell = webmdemux_tell; + io.userdata = this; + + // While reading the metadata, we do not really care about which nestegg + // context is being used so long that they are both initialised. + // For reading the metadata however, we will use mVideoContext. + return nestegg_init(&mContext, io, &webmdemux_log, + mParent->IsMediaSource() ? mResource.GetLength() : -1); +} + +WebMDemuxer::WebMDemuxer(MediaResource* aResource) + : WebMDemuxer(aResource, false) +{ +} + +WebMDemuxer::WebMDemuxer(MediaResource* aResource, + bool aIsMediaSource, + Maybe aFrameEndTimeBeforeRecreateDemuxer) + : mVideoContext(this, aResource) + , mAudioContext(this, aResource) + , mBufferedState(nullptr) + , mInitData(nullptr) + , mVideoTrack(0) + , mAudioTrack(0) + , mSeekPreroll(0) + , mAudioCodec(-1) + , mVideoCodec(-1) + , mHasVideo(false) + , mHasAudio(false) + , mNeedReIndex(true) + , mLastWebMBlockOffset(-1) + , mIsMediaSource(aIsMediaSource) +{ + MOZ_ASSERT_IF(!aIsMediaSource, + aFrameEndTimeBeforeRecreateDemuxer.isNothing()); + if (aIsMediaSource && aFrameEndTimeBeforeRecreateDemuxer) { + mVideoFrameEndTimeBeforeReset = aFrameEndTimeBeforeRecreateDemuxer; + WEBM_DEBUG("Set mVideoFrameEndTimeBeforeReset=%" PRId64, + mVideoFrameEndTimeBeforeReset.value()); + } +} + +WebMDemuxer::~WebMDemuxer() +{ + Reset(TrackInfo::kVideoTrack); + Reset(TrackInfo::kAudioTrack); +} + +RefPtr +WebMDemuxer::Init() +{ + InitBufferedState(); + + if (NS_FAILED(ReadMetadata())) { + return InitPromise::CreateAndReject(NS_ERROR_DOM_MEDIA_METADATA_ERR, __func__); + } + + if (!GetNumberTracks(TrackInfo::kAudioTrack) && + !GetNumberTracks(TrackInfo::kVideoTrack)) { + return InitPromise::CreateAndReject(NS_ERROR_DOM_MEDIA_METADATA_ERR, __func__); + } + + return InitPromise::CreateAndResolve(NS_OK, __func__); +} + +void +WebMDemuxer::InitBufferedState() +{ + MOZ_ASSERT(!mBufferedState); + mBufferedState = new WebMBufferedState; +} + +bool +WebMDemuxer::HasTrackType(TrackInfo::TrackType aType) const +{ + return !!GetNumberTracks(aType); +} + +uint32_t +WebMDemuxer::GetNumberTracks(TrackInfo::TrackType aType) const +{ + switch(aType) { + case TrackInfo::kAudioTrack: + return mHasAudio ? 1 : 0; + case TrackInfo::kVideoTrack: + return mHasVideo ? 1 : 0; + default: + return 0; + } +} + +UniquePtr +WebMDemuxer::GetTrackInfo(TrackInfo::TrackType aType, + size_t aTrackNumber) const +{ + switch(aType) { + case TrackInfo::kAudioTrack: + return mInfo.mAudio.Clone(); + case TrackInfo::kVideoTrack: + return mInfo.mVideo.Clone(); + default: + return nullptr; + } +} + +already_AddRefed +WebMDemuxer::GetTrackDemuxer(TrackInfo::TrackType aType, uint32_t aTrackNumber) +{ + if (GetNumberTracks(aType) <= aTrackNumber) { + return nullptr; + } + RefPtr e = + new WebMTrackDemuxer(this, aType, aTrackNumber); + mDemuxers.AppendElement(e); + + return e.forget(); +} + +nsresult +WebMDemuxer::Reset(TrackInfo::TrackType aType) +{ + if (aType == TrackInfo::kVideoTrack) { + mVideoPackets.Reset(); + } else { + mAudioPackets.Reset(); + } + return NS_OK; +} + +nsresult +WebMDemuxer::ReadMetadata() +{ + int r = mVideoContext.Init(); + if (r == -1) { + return NS_ERROR_FAILURE; + } + if (mAudioContext.Init() == -1) { + return NS_ERROR_FAILURE; + } + + // For reading the metadata we can only use the video resource/context. + MediaResourceIndex& resource = Resource(TrackInfo::kVideoTrack); + nestegg* context = Context(TrackInfo::kVideoTrack); + + { + // Check how much data nestegg read and force feed it to BufferedState. + RefPtr buffer = resource.MediaReadAt(0, resource.Tell()); + if (!buffer) { + return NS_ERROR_FAILURE; + } + mBufferedState->NotifyDataArrived(buffer->Elements(), buffer->Length(), 0); + if (mBufferedState->GetInitEndOffset() < 0) { + return NS_ERROR_FAILURE; + } + MOZ_ASSERT(mBufferedState->GetInitEndOffset() <= resource.Tell()); + } + mInitData = resource.MediaReadAt(0, mBufferedState->GetInitEndOffset()); + if (!mInitData || + mInitData->Length() != size_t(mBufferedState->GetInitEndOffset())) { + return NS_ERROR_FAILURE; + } + + unsigned int ntracks = 0; + r = nestegg_track_count(context, &ntracks); + if (r == -1) { + return NS_ERROR_FAILURE; + } + + for (unsigned int track = 0; track < ntracks; ++track) { + int id = nestegg_track_codec_id(context, track); + if (id == -1) { + return NS_ERROR_FAILURE; + } + int type = nestegg_track_type(context, track); + if (type == NESTEGG_TRACK_VIDEO && !mHasVideo) { + nestegg_video_params params; + r = nestegg_track_video_params(context, track, ¶ms); + if (r == -1) { + return NS_ERROR_FAILURE; + } + mVideoCodec = nestegg_track_codec_id(context, track); + switch(mVideoCodec) { + case NESTEGG_CODEC_VP8: + mInfo.mVideo.mMimeType = "video/webm; codecs=vp8"; + break; + case NESTEGG_CODEC_VP9: + mInfo.mVideo.mMimeType = "video/webm; codecs=vp9"; + break; + case NESTEGG_CODEC_AV1: + mInfo.mVideo.mMimeType = "video/webm; codecs=av1"; + break; + case NESTEGG_CODEC_AVC1: { + mInfo.mVideo.mMimeType = "video/webm; codecs=avc1"; + + unsigned char* data = 0; + size_t length = 0; + r = nestegg_track_codec_data(context, track, 0, &data, &length); + if (r == -1) { + return NS_ERROR_FAILURE; + } + + mInfo.mVideo.mExtraData = new MediaByteBuffer(length); + mInfo.mVideo.mExtraData->AppendElements(data, length); + break; + } + default: + NS_WARNING("Unknown WebM video codec"); + return NS_ERROR_FAILURE; + } + // Picture region, taking into account cropping, before scaling + // to the display size. + unsigned int cropH = params.crop_right + params.crop_left; + unsigned int cropV = params.crop_bottom + params.crop_top; + nsIntRect pictureRect(params.crop_left, + params.crop_top, + params.width - cropH, + params.height - cropV); + + // If the cropping data appears invalid then use the frame data + if (pictureRect.width <= 0 || + pictureRect.height <= 0 || + pictureRect.x < 0 || + pictureRect.y < 0) { + pictureRect.x = 0; + pictureRect.y = 0; + pictureRect.width = params.width; + pictureRect.height = params.height; + } + + // Validate the container-reported frame and pictureRect sizes. This + // ensures that our video frame creation code doesn't overflow. + nsIntSize displaySize(params.display_width, params.display_height); + nsIntSize frameSize(params.width, params.height); + if (!IsValidVideoRegion(frameSize, pictureRect, displaySize)) { + // Video track's frame sizes will overflow. Ignore the video track. + continue; + } + + mVideoTrack = track; + mHasVideo = true; + + mInfo.mVideo.mDisplay = displaySize; + mInfo.mVideo.mImage = frameSize; + mInfo.mVideo.SetImageRect(pictureRect); + mInfo.mVideo.SetAlpha(params.alpha_mode); + + switch (params.stereo_mode) { + case NESTEGG_VIDEO_MONO: + mInfo.mVideo.mStereoMode = StereoMode::MONO; + break; + case NESTEGG_VIDEO_STEREO_LEFT_RIGHT: + mInfo.mVideo.mStereoMode = StereoMode::LEFT_RIGHT; + break; + case NESTEGG_VIDEO_STEREO_BOTTOM_TOP: + mInfo.mVideo.mStereoMode = StereoMode::BOTTOM_TOP; + break; + case NESTEGG_VIDEO_STEREO_TOP_BOTTOM: + mInfo.mVideo.mStereoMode = StereoMode::TOP_BOTTOM; + break; + case NESTEGG_VIDEO_STEREO_RIGHT_LEFT: + mInfo.mVideo.mStereoMode = StereoMode::RIGHT_LEFT; + break; + } + uint64_t duration = 0; + r = nestegg_duration(context, &duration); + if (!r) { + mInfo.mVideo.mDuration = media::TimeUnit::FromNanoseconds(duration).ToMicroseconds(); + } + mInfo.mVideo.mCrypto = GetTrackCrypto(TrackInfo::kVideoTrack, track); + if (mInfo.mVideo.mCrypto.mValid) { + mCrypto.AddInitData(NS_LITERAL_STRING("webm"), mInfo.mVideo.mCrypto.mKeyId); + } + } else if (type == NESTEGG_TRACK_AUDIO && !mHasAudio) { + nestegg_audio_params params; + r = nestegg_track_audio_params(context, track, ¶ms); + if (r == -1) { + return NS_ERROR_FAILURE; + } + + mAudioTrack = track; + mHasAudio = true; + mAudioCodec = nestegg_track_codec_id(context, track); + if (mAudioCodec == NESTEGG_CODEC_VORBIS) { + mInfo.mAudio.mMimeType = "audio/vorbis"; + } else if (mAudioCodec == NESTEGG_CODEC_OPUS) { + mInfo.mAudio.mMimeType = "audio/opus"; + OpusDataDecoder::AppendCodecDelay(mInfo.mAudio.mCodecSpecificConfig, + media::TimeUnit::FromNanoseconds(params.codec_delay).ToMicroseconds()); + } else if (mAudioCodec == NESTEGG_CODEC_AAC) { + mInfo.mAudio.mMimeType = "audio/mp4a-latm"; + } + mSeekPreroll = params.seek_preroll; + mInfo.mAudio.mRate = params.rate; + mInfo.mAudio.mChannels = params.channels; + + unsigned int nheaders = 0; + r = nestegg_track_codec_data_count(context, track, &nheaders); + if (r == -1) { + return NS_ERROR_FAILURE; + } + + AutoTArray headers; + AutoTArray headerLens; + for (uint32_t header = 0; header < nheaders; ++header) { + unsigned char* data = 0; + size_t length = 0; + r = nestegg_track_codec_data(context, track, header, &data, &length); + if (r == -1) { + return NS_ERROR_FAILURE; + } + headers.AppendElement(data); + headerLens.AppendElement(length); + } + + // Vorbis has 3 headers, convert to Xiph extradata format to send them to + // the demuxer. + // TODO: This is already the format WebM stores them in. Would be nice + // to avoid having libnestegg split them only for us to pack them again, + // but libnestegg does not give us an API to access this data directly. + if (nheaders > 1) { + if (!XiphHeadersToExtradata(mInfo.mAudio.mCodecSpecificConfig, + headers, headerLens)) { + return NS_ERROR_FAILURE; + } + } + else { + mInfo.mAudio.mCodecSpecificConfig->AppendElements(headers[0], + headerLens[0]); + } + uint64_t duration = 0; + r = nestegg_duration(context, &duration); + if (!r) { + mInfo.mAudio.mDuration = media::TimeUnit::FromNanoseconds(duration).ToMicroseconds(); + } + mInfo.mAudio.mCrypto = GetTrackCrypto(TrackInfo::kAudioTrack, track); + if (mInfo.mAudio.mCrypto.mValid) { + mCrypto.AddInitData(NS_LITERAL_STRING("webm"), mInfo.mAudio.mCrypto.mKeyId); + } + } + } + return NS_OK; +} + +bool +WebMDemuxer::IsSeekable() const +{ + return Context(TrackInfo::kVideoTrack) && + nestegg_has_cues(Context(TrackInfo::kVideoTrack)); +} + +bool +WebMDemuxer::IsSeekableOnlyInBufferedRanges() const +{ + return Context(TrackInfo::kVideoTrack) && + !nestegg_has_cues(Context(TrackInfo::kVideoTrack)); +} + +void +WebMDemuxer::EnsureUpToDateIndex() +{ + if (!mNeedReIndex || !mInitData) { + return; + } + AutoPinned resource( + Resource(TrackInfo::kVideoTrack).GetResource()); + MediaByteRangeSet byteRanges; + nsresult rv = resource->GetCachedRanges(byteRanges); + if (NS_FAILED(rv) || !byteRanges.Length()) { + return; + } + mBufferedState->UpdateIndex(byteRanges, resource); + + mNeedReIndex = false; + + if (!mIsMediaSource) { + return; + } + mLastWebMBlockOffset = mBufferedState->GetLastBlockOffset(); + MOZ_ASSERT(mLastWebMBlockOffset <= resource->GetLength()); +} + +void +WebMDemuxer::NotifyDataArrived() +{ + WEBM_DEBUG(""); + mNeedReIndex = true; +} + +void +WebMDemuxer::NotifyDataRemoved() +{ + mBufferedState->Reset(); + if (mInitData) { + mBufferedState->NotifyDataArrived(mInitData->Elements(), mInitData->Length(), 0); + } + mNeedReIndex = true; +} + +UniquePtr +WebMDemuxer::GetCrypto() +{ + return mCrypto.IsEncrypted() ? MakeUnique(mCrypto) : nullptr; +} + +CryptoTrack +WebMDemuxer::GetTrackCrypto(TrackInfo::TrackType aType, size_t aTrackNumber) { + const int WEBM_IV_SIZE = 16; + const unsigned char * contentEncKeyId; + size_t contentEncKeyIdLength; + CryptoTrack crypto; + nestegg* context = Context(aType); + + int r = nestegg_track_content_enc_key_id(context, aTrackNumber, &contentEncKeyId, &contentEncKeyIdLength); + + if (r == -1) { + WEBM_DEBUG("nestegg_track_content_enc_key_id failed r=%d", r); + return crypto; + } + + uint32_t i; + nsTArray initData; + for (i = 0; i < contentEncKeyIdLength; i++) { + initData.AppendElement(contentEncKeyId[i]); + } + + if (!initData.IsEmpty()) { + crypto.mValid = true; + // crypto.mMode is not used for WebMs + crypto.mIVSize = WEBM_IV_SIZE; + crypto.mKeyId = Move(initData); + } + + return crypto; +} + +nsresult +WebMDemuxer::GetNextPacket(TrackInfo::TrackType aType, MediaRawDataQueue *aSamples) +{ + if (mIsMediaSource) { + // To ensure mLastWebMBlockOffset is properly up to date. + EnsureUpToDateIndex(); + } + + RefPtr holder; + nsresult rv = NextPacket(aType, holder); + + if (NS_FAILED(rv)) { + return rv; + } + + int r = 0; + unsigned int count = 0; + r = nestegg_packet_count(holder->Packet(), &count); + if (r == -1) { + return NS_ERROR_DOM_MEDIA_DEMUXER_ERR; + } + int64_t tstamp = holder->Timestamp(); + int64_t duration = holder->Duration(); + int64_t defaultDuration = holder->DefaultDuration(); + if (aType == TrackInfo::TrackType::kVideoTrack) { + WEBM_DEBUG("GetNextPacket(video): tstamp=%" PRId64 ", duration=%" PRId64, ", defaultDuration=%" PRId64, + tstamp, duration, defaultDuration); + } + + // The end time of this frame is the start time of the next frame. Fetch + // the timestamp of the next packet for this track. If we've reached the + // end of the resource, use the file's duration as the end time of this + // video frame. + int64_t next_tstamp = INT64_MIN; + if (aType == TrackInfo::kAudioTrack) { + RefPtr next_holder; + rv = NextPacket(aType, next_holder); + if (NS_FAILED(rv) && rv != NS_ERROR_DOM_MEDIA_END_OF_STREAM) { + return rv; + } + if (next_holder) { + next_tstamp = next_holder->Timestamp(); + PushAudioPacket(next_holder); + } else if (duration >= 0) { + next_tstamp = tstamp + duration; + } else if (!mIsMediaSource || + (mIsMediaSource && mLastAudioFrameTime.isSome())) { + next_tstamp = tstamp; + next_tstamp += tstamp - mLastAudioFrameTime.refOr(0); + } else { + PushAudioPacket(holder); + } + mLastAudioFrameTime = Some(tstamp); + } else if (aType == TrackInfo::kVideoTrack) { + RefPtr next_holder; + rv = NextPacket(aType, next_holder); + if (NS_FAILED(rv) && rv != NS_ERROR_DOM_MEDIA_END_OF_STREAM) { + return rv; + } + if (next_holder) { + next_tstamp = next_holder->Timestamp(); + PushVideoPacket(next_holder); + } else if (duration >= 0) { + next_tstamp = tstamp + duration; + } else if (!mIsMediaSource || + (mIsMediaSource && mLastVideoFrameTime.isSome())) { + next_tstamp = tstamp; + next_tstamp += tstamp - mLastVideoFrameTime.refOr(0); + } else if (defaultDuration >= 0) { + next_tstamp = tstamp + defaultDuration; + } else if (mVideoFrameEndTimeBeforeReset) { + WEBM_DEBUG("Setting next timestamp to be %" PRId64 " us", + mVideoFrameEndTimeBeforeReset.value()); + next_tstamp = mVideoFrameEndTimeBeforeReset.ref(); + } else { + PushVideoPacket(holder); + } + mLastVideoFrameTime = Some(tstamp); + } + + if (mIsMediaSource && next_tstamp == INT64_MIN) { + return NS_ERROR_DOM_MEDIA_END_OF_STREAM; + } + + int64_t discardPadding = 0; + if (aType == TrackInfo::kAudioTrack) { + (void) nestegg_packet_discard_padding(holder->Packet(), &discardPadding); + } + + int packetEncryption = nestegg_packet_encryption(holder->Packet()); + + for (uint32_t i = 0; i < count; ++i) { + unsigned char* data; + size_t length; + r = nestegg_packet_data(holder->Packet(), i, &data, &length); + if (r == -1) { + WEBM_DEBUG("nestegg_packet_data failed r=%d", r); + return NS_ERROR_DOM_MEDIA_DEMUXER_ERR; + } + unsigned char* alphaData; + size_t alphaLength = 0; + // Check packets for alpha information if file has declared alpha frames + // may be present. + if (mInfo.mVideo.HasAlpha()) { + r = nestegg_packet_additional_data(holder->Packet(), + 1, + &alphaData, + &alphaLength); + if (r == -1) { + WEBM_DEBUG( + "nestegg_packet_additional_data failed to retrieve alpha data r=%d", + r); + } + } + bool isKeyframe = false; + if (aType == TrackInfo::kAudioTrack) { + isKeyframe = true; + } else if (aType == TrackInfo::kVideoTrack) { + if (packetEncryption == NESTEGG_PACKET_HAS_SIGNAL_BYTE_ENCRYPTED) { + // Packet is encrypted, can't peek, use packet info + isKeyframe = nestegg_packet_has_keyframe(holder->Packet()) == NESTEGG_PACKET_HAS_KEYFRAME_TRUE; + } else { + auto sample = MakeSpan(data, length); + switch (mVideoCodec) { + case NESTEGG_CODEC_VP8: + isKeyframe = VPXDecoder::IsKeyframe(sample, VPXDecoder::Codec::VP8); + break; + case NESTEGG_CODEC_VP9: + isKeyframe = VPXDecoder::IsKeyframe(sample, VPXDecoder::Codec::VP9); + break; +#ifdef MOZ_AV1 + case NESTEGG_CODEC_AV1: + isKeyframe = nestegg_packet_has_keyframe(holder->Packet()) == NESTEGG_PACKET_HAS_KEYFRAME_TRUE; + break; +#endif + case NESTEGG_CODEC_AVC1: + isKeyframe = nestegg_packet_has_keyframe(holder->Packet()); + break; + default: + NS_WARNING("Cannot detect keyframes in unknown WebM video codec"); + return NS_ERROR_FAILURE; + } + if (isKeyframe) { + // For both VP8 and VP9, we only look for resolution changes + // on keyframes. Other resolution changes are invalid. + auto dimensions = nsIntSize(0, 0); + switch (mVideoCodec) { + case NESTEGG_CODEC_VP8: + dimensions = VPXDecoder::GetFrameSize(sample, VPXDecoder::Codec::VP8); + break; + case NESTEGG_CODEC_VP9: + dimensions = VPXDecoder::GetFrameSize(sample, VPXDecoder::Codec::VP9); + break; +#ifdef MOZ_AV1 + case NESTEGG_CODEC_AV1: + dimensions = Dav1dDecoder::GetFrameSize(sample); + break; +#endif + } + if (dimensions.width > 0 && dimensions.height > 0) { + if (mLastSeenFrameSize.isSome() + && (dimensions != mLastSeenFrameSize.value())) { + mInfo.mVideo.mDisplay = dimensions; + mSharedVideoTrackInfo = new SharedTrackInfo(mInfo.mVideo, ++sStreamSourceID); + } + mLastSeenFrameSize = Some(dimensions); + } + } + } + } + + WEBM_DEBUG("push sample tstamp: %ld next_tstamp: %ld length: %ld kf: %d", + tstamp, next_tstamp, length, isKeyframe); + RefPtr sample; + if (mInfo.mVideo.HasAlpha() && alphaData != 0) { + sample = new MediaRawData(data, length, alphaData, alphaLength); + if (length && !sample->Data() || (alphaLength && !sample->AlphaData())) { + // OOM. + return NS_ERROR_OUT_OF_MEMORY; + } + } else { + sample = new MediaRawData(data, length); + if (length && !sample->Data()) { + // OOM. + return NS_ERROR_OUT_OF_MEMORY; + } + } + sample->mTimecode = tstamp; + sample->mTime = tstamp; + sample->mDuration = next_tstamp - tstamp; + sample->mOffset = holder->Offset(); + sample->mKeyframe = isKeyframe; + if (discardPadding && i == count - 1) { + CheckedInt64 discardFrames; + if (discardPadding < 0) { + // This is an invalid value as discard padding should never be negative. + // Set to maximum value so that the decoder will reject it as it's + // greater than the number of frames available. + discardFrames = INT32_MAX; + WEBM_DEBUG("Invalid negative discard padding"); + } else { + discardFrames = TimeUnitToFrames( + media::TimeUnit::FromNanoseconds(discardPadding), mInfo.mAudio.mRate); + } + if (discardFrames.isValid()) { + sample->mDiscardPadding = discardFrames.value(); + } + } + + if (packetEncryption == NESTEGG_PACKET_HAS_SIGNAL_BYTE_UNENCRYPTED || + packetEncryption == NESTEGG_PACKET_HAS_SIGNAL_BYTE_ENCRYPTED) { + nsAutoPtr writer(sample->CreateWriter()); + unsigned char const* iv; + size_t ivLength; + nestegg_packet_iv(holder->Packet(), &iv, &ivLength); + writer->mCrypto.mValid = true; + writer->mCrypto.mIVSize = ivLength; + if (ivLength == 0) { + // Frame is not encrypted + writer->mCrypto.mPlainSizes.AppendElement(length); + writer->mCrypto.mEncryptedSizes.AppendElement(0); + } else { + // Frame is encrypted + writer->mCrypto.mIV.AppendElements(iv, 8); + // Iv from a sample is 64 bits, must be padded with 64 bits more 0s + // in compliance with spec + for (uint32_t i = 0; i < 8; i++) { + writer->mCrypto.mIV.AppendElement(0); + } + writer->mCrypto.mPlainSizes.AppendElement(0); + writer->mCrypto.mEncryptedSizes.AppendElement(length); + } + } + if (aType == TrackInfo::kVideoTrack) { + sample->mTrackInfo = mSharedVideoTrackInfo; + } + + if (mVideoCodec == NESTEGG_CODEC_AVC1) { + sample->mExtraData = mInfo.mVideo.mExtraData; + } + + aSamples->Push(sample); + } + return NS_OK; +} + +nsresult +WebMDemuxer::NextPacket(TrackInfo::TrackType aType, + RefPtr& aPacket) +{ + bool isVideo = aType == TrackInfo::kVideoTrack; + + // Flag to indicate that we do need to playback these types of + // packets. + bool hasType = isVideo ? mHasVideo : mHasAudio; + + if (!hasType) { + return NS_ERROR_DOM_MEDIA_DEMUXER_ERR; + } + + // The packet queue for the type that we are interested in. + WebMPacketQueue &packets = isVideo ? mVideoPackets : mAudioPackets; + + if (packets.GetSize() > 0) { + aPacket = packets.PopFront(); + return NS_OK; + } + + // Track we are interested in + uint32_t ourTrack = isVideo ? mVideoTrack : mAudioTrack; + + do { + RefPtr holder; + nsresult rv = DemuxPacket(aType, holder); + if (NS_FAILED(rv)) { + return rv; + } + if (!holder) { + return NS_ERROR_DOM_MEDIA_DEMUXER_ERR; + } + + if (ourTrack == holder->Track()) { + aPacket = holder; + return NS_OK; + } + } while (true); +} + +nsresult +WebMDemuxer::DemuxPacket(TrackInfo::TrackType aType, + RefPtr& aPacket) +{ + nestegg_packet* packet; + int r = nestegg_read_packet(Context(aType), &packet); + if (r == 0) { + nestegg_read_reset(Context(aType)); + return NS_ERROR_DOM_MEDIA_END_OF_STREAM; + } else if (r < 0) { + return NS_ERROR_DOM_MEDIA_DEMUXER_ERR; + } + + unsigned int track = 0; + r = nestegg_packet_track(packet, &track); + if (r == -1) { + return NS_ERROR_DOM_MEDIA_DEMUXER_ERR; + } + + int64_t offset = Resource(aType).Tell(); + RefPtr holder = new NesteggPacketHolder(); + if (!holder->Init(packet, Context(aType), offset, track, false)) { + return NS_ERROR_DOM_MEDIA_DEMUXER_ERR; + } + + aPacket = holder; + return NS_OK; +} + +void +WebMDemuxer::PushAudioPacket(NesteggPacketHolder* aItem) +{ + mAudioPackets.PushFront(aItem); +} + +void +WebMDemuxer::PushVideoPacket(NesteggPacketHolder* aItem) +{ + mVideoPackets.PushFront(aItem); +} + +nsresult +WebMDemuxer::SeekInternal(TrackInfo::TrackType aType, + const media::TimeUnit& aTarget) +{ + EnsureUpToDateIndex(); + uint32_t trackToSeek = mHasVideo ? mVideoTrack : mAudioTrack; + uint64_t target = aTarget.ToNanoseconds(); + + if (NS_FAILED(Reset(aType))) { + return NS_ERROR_FAILURE; + } + + if (mSeekPreroll) { + uint64_t startTime = 0; + if (!mBufferedState->GetStartTime(&startTime)) { + startTime = 0; + } + WEBM_DEBUG("Seek Target: %f", + media::TimeUnit::FromNanoseconds(target).ToSeconds()); + if (target < mSeekPreroll || target - mSeekPreroll < startTime) { + target = startTime; + } else { + target -= mSeekPreroll; + } + WEBM_DEBUG("SeekPreroll: %f StartTime: %f Adjusted Target: %f", + media::TimeUnit::FromNanoseconds(mSeekPreroll).ToSeconds(), + media::TimeUnit::FromNanoseconds(startTime).ToSeconds(), + media::TimeUnit::FromNanoseconds(target).ToSeconds()); + } + int r = nestegg_track_seek(Context(aType), trackToSeek, target); + if (r == -1) { + WEBM_DEBUG("track_seek for track %u to %f failed, r=%d", trackToSeek, + media::TimeUnit::FromNanoseconds(target).ToSeconds(), r); + // Try seeking directly based on cluster information in memory. + int64_t offset = 0; + bool rv = mBufferedState->GetOffsetForTime(target, &offset); + if (!rv) { + WEBM_DEBUG("mBufferedState->GetOffsetForTime failed too"); + return NS_ERROR_FAILURE; + } + + r = nestegg_offset_seek(Context(aType), offset); + if (r == -1) { + WEBM_DEBUG("and nestegg_offset_seek to %" PRIu64 " failed", offset); + return NS_ERROR_FAILURE; + } + WEBM_DEBUG("got offset from buffered state: %" PRIu64 "", offset); + } + + if (aType == TrackInfo::kAudioTrack) { + mLastAudioFrameTime.reset(); + } else { + mLastVideoFrameTime.reset(); + } + + return NS_OK; +} + +media::TimeIntervals +WebMDemuxer::GetBuffered() +{ + EnsureUpToDateIndex(); + AutoPinned resource( + Resource(TrackInfo::kVideoTrack).GetResource()); + + media::TimeIntervals buffered; + + MediaByteRangeSet ranges; + nsresult rv = resource->GetCachedRanges(ranges); + if (NS_FAILED(rv)) { + return media::TimeIntervals(); + } + uint64_t duration = 0; + uint64_t startOffset = 0; + if (!nestegg_duration(Context(TrackInfo::kVideoTrack), &duration)) { + if(mBufferedState->GetStartTime(&startOffset)) { + duration += startOffset; + } + WEBM_DEBUG("Duration: %f StartTime: %f", + media::TimeUnit::FromNanoseconds(duration).ToSeconds(), + media::TimeUnit::FromNanoseconds(startOffset).ToSeconds()); + } + for (uint32_t index = 0; index < ranges.Length(); index++) { + uint64_t start, end; + bool rv = mBufferedState->CalculateBufferedForRange(ranges[index].mStart, + ranges[index].mEnd, + &start, &end); + if (rv) { + NS_ASSERTION(startOffset <= start, + "startOffset negative or larger than start time"); + + if (duration && end > duration) { + WEBM_DEBUG("limit range to duration, end: %f duration: %f", + media::TimeUnit::FromNanoseconds(end).ToSeconds(), + media::TimeUnit::FromNanoseconds(duration).ToSeconds()); + end = duration; + } + media::TimeUnit startTime = media::TimeUnit::FromNanoseconds(start); + media::TimeUnit endTime = media::TimeUnit::FromNanoseconds(end); + WEBM_DEBUG("add range %f-%f", startTime.ToSeconds(), endTime.ToSeconds()); + buffered += media::TimeInterval(startTime, endTime); + } + } + return buffered; +} + +bool WebMDemuxer::GetOffsetForTime(uint64_t aTime, int64_t* aOffset) +{ + EnsureUpToDateIndex(); + return mBufferedState && mBufferedState->GetOffsetForTime(aTime, aOffset); +} + + +//WebMTrackDemuxer +WebMTrackDemuxer::WebMTrackDemuxer(WebMDemuxer* aParent, + TrackInfo::TrackType aType, + uint32_t aTrackNumber) + : mParent(aParent) + , mType(aType) + , mNeedKeyframe(true) +{ + mInfo = mParent->GetTrackInfo(aType, aTrackNumber); + MOZ_ASSERT(mInfo); +} + +WebMTrackDemuxer::~WebMTrackDemuxer() +{ + mSamples.Reset(); +} + +UniquePtr +WebMTrackDemuxer::GetInfo() const +{ + return mInfo->Clone(); +} + +RefPtr +WebMTrackDemuxer::Seek(media::TimeUnit aTime) +{ + // Seeks to aTime. Upon success, SeekPromise will be resolved with the + // actual time seeked to. Typically the random access point time + + media::TimeUnit seekTime = aTime; + mSamples.Reset(); + mParent->SeekInternal(mType, aTime); + nsresult rv = mParent->GetNextPacket(mType, &mSamples); + if (NS_FAILED(rv)) { + if (rv == NS_ERROR_DOM_MEDIA_END_OF_STREAM) { + // Ignore the error for now, the next GetSample will be rejected with EOS. + return SeekPromise::CreateAndResolve(media::TimeUnit(), __func__); + } + return SeekPromise::CreateAndReject(rv, __func__); + } + mNeedKeyframe = true; + + // Check what time we actually seeked to. + if (mSamples.GetSize() > 0) { + const RefPtr& sample = mSamples.First(); + seekTime = media::TimeUnit::FromMicroseconds(sample->mTime); + } + SetNextKeyFrameTime(); + + return SeekPromise::CreateAndResolve(seekTime, __func__); +} + +nsresult +WebMTrackDemuxer::NextSample(RefPtr& aData) +{ + nsresult rv; + while (mSamples.GetSize() < 1 && + NS_SUCCEEDED((rv = mParent->GetNextPacket(mType, &mSamples)))) { + } + if (mSamples.GetSize()) { + aData = mSamples.PopFront(); + return NS_OK; + } + return rv; +} + +RefPtr +WebMTrackDemuxer::GetSamples(int32_t aNumSamples) +{ + RefPtr samples = new SamplesHolder; + MOZ_ASSERT(aNumSamples); + + nsresult rv = NS_ERROR_DOM_MEDIA_END_OF_STREAM; + + while (aNumSamples) { + RefPtr sample; + rv = NextSample(sample); + if (NS_FAILED(rv)) { + break; + } + if (mNeedKeyframe && !sample->mKeyframe) { + continue; + } + mNeedKeyframe = false; + samples->mSamples.AppendElement(sample); + aNumSamples--; + } + + if (samples->mSamples.IsEmpty()) { + return SamplesPromise::CreateAndReject(rv, __func__); + } else { + UpdateSamples(samples->mSamples); + return SamplesPromise::CreateAndResolve(samples, __func__); + } +} + +void +WebMTrackDemuxer::SetNextKeyFrameTime() +{ + if (mType != TrackInfo::kVideoTrack || mParent->IsMediaSource()) { + return; + } + + int64_t frameTime = -1; + + mNextKeyframeTime.reset(); + + MediaRawDataQueue skipSamplesQueue; + bool foundKeyframe = false; + while (!foundKeyframe && mSamples.GetSize()) { + RefPtr sample = mSamples.PopFront(); + if (sample->mKeyframe) { + frameTime = sample->mTime; + foundKeyframe = true; + } + skipSamplesQueue.Push(sample.forget()); + } + Maybe startTime; + if (skipSamplesQueue.GetSize()) { + const RefPtr& sample = skipSamplesQueue.First(); + startTime.emplace(sample->mTimecode); + } + // Demux and buffer frames until we find a keyframe. + RefPtr sample; + nsresult rv = NS_OK; + while (!foundKeyframe && NS_SUCCEEDED((rv = NextSample(sample)))) { + if (sample->mKeyframe) { + frameTime = sample->mTime; + foundKeyframe = true; + } + int64_t sampleTimecode = sample->mTimecode; + skipSamplesQueue.Push(sample.forget()); + if (!startTime) { + startTime.emplace(sampleTimecode); + } else if (!foundKeyframe && + sampleTimecode > startTime.ref() + MAX_LOOK_AHEAD) { + WEBM_DEBUG("Couldn't find keyframe in a reasonable time, aborting"); + break; + } + } + // We may have demuxed more than intended, so ensure that all frames are kept + // in the right order. + mSamples.PushFront(Move(skipSamplesQueue)); + + if (frameTime != -1) { + mNextKeyframeTime.emplace(media::TimeUnit::FromMicroseconds(frameTime)); + WEBM_DEBUG("Next Keyframe %f (%u queued %.02fs)", + mNextKeyframeTime.value().ToSeconds(), + uint32_t(mSamples.GetSize()), + media::TimeUnit::FromMicroseconds(mSamples.Last()->mTimecode - mSamples.First()->mTimecode).ToSeconds()); + } else { + WEBM_DEBUG("Couldn't determine next keyframe time (%u queued)", + uint32_t(mSamples.GetSize())); + } +} + +void +WebMTrackDemuxer::Reset() +{ + mSamples.Reset(); + media::TimeIntervals buffered = GetBuffered(); + mNeedKeyframe = true; + if (buffered.Length()) { + WEBM_DEBUG("Seek to start point: %f", buffered.Start(0).ToSeconds()); + mParent->SeekInternal(mType, buffered.Start(0)); + SetNextKeyFrameTime(); + } else { + mNextKeyframeTime.reset(); + } +} + +void +WebMTrackDemuxer::UpdateSamples(nsTArray>& aSamples) +{ + for (const auto& sample : aSamples) { + if (sample->mCrypto.mValid) { + nsAutoPtr writer(sample->CreateWriter()); + writer->mCrypto.mMode = mInfo->mCrypto.mMode; + writer->mCrypto.mIVSize = mInfo->mCrypto.mIVSize; + writer->mCrypto.mKeyId.AppendElements(mInfo->mCrypto.mKeyId); + } + } + if (mNextKeyframeTime.isNothing() || + aSamples.LastElement()->mTime >= mNextKeyframeTime.value().ToMicroseconds()) { + SetNextKeyFrameTime(); + } +} + +nsresult +WebMTrackDemuxer::GetNextRandomAccessPoint(media::TimeUnit* aTime) +{ + if (mNextKeyframeTime.isNothing()) { + // There's no next key frame. + *aTime = + media::TimeUnit::FromMicroseconds(std::numeric_limits::max()); + } else { + *aTime = mNextKeyframeTime.ref(); + } + return NS_OK; +} + +RefPtr +WebMTrackDemuxer::SkipToNextRandomAccessPoint(media::TimeUnit aTimeThreshold) +{ + uint32_t parsed = 0; + bool found = false; + RefPtr sample; + nsresult rv = NS_OK; + int64_t sampleTime; + + WEBM_DEBUG("TimeThreshold: %f", aTimeThreshold.ToSeconds()); + while (!found && NS_SUCCEEDED((rv = NextSample(sample)))) { + parsed++; + sampleTime = sample->mTime; + if (sample->mKeyframe && sampleTime >= aTimeThreshold.ToMicroseconds()) { + found = true; + mSamples.Reset(); + mSamples.PushFront(sample.forget()); + } + } + if (NS_SUCCEEDED(rv)) { + SetNextKeyFrameTime(); + } + if (found) { + WEBM_DEBUG("next sample: %f (parsed: %d)", + media::TimeUnit::FromMicroseconds(sampleTime).ToSeconds(), + parsed); + return SkipAccessPointPromise::CreateAndResolve(parsed, __func__); + } else { + SkipFailureHolder failure(NS_ERROR_DOM_MEDIA_END_OF_STREAM, parsed); + return SkipAccessPointPromise::CreateAndReject(Move(failure), __func__); + } +} + +media::TimeIntervals +WebMTrackDemuxer::GetBuffered() +{ + return mParent->GetBuffered(); +} + +void +WebMTrackDemuxer::BreakCycles() +{ + mParent = nullptr; +} + +int64_t +WebMTrackDemuxer::GetEvictionOffset(const media::TimeUnit& aTime) +{ + int64_t offset; + if (!mParent->GetOffsetForTime(aTime.ToNanoseconds(), &offset)) { + return 0; + } + + return offset; +} + +#undef WEBM_DEBUG +} // namespace mozilla diff --git a/dom/media/webm/moz.build b/dom/media/webm/moz.build index e9387e8c98..b1926d9a04 100644 --- a/dom/media/webm/moz.build +++ b/dom/media/webm/moz.build @@ -24,6 +24,11 @@ if CONFIG['MOZ_WEBM_ENCODER']: 'WebMWriter.cpp', ] +if CONFIG['MOZ_AV1']: + LOCAL_INCLUDES += [ + '/dom/media/platforms/agnostic', + ] + CXXFLAGS += CONFIG['MOZ_LIBVPX_CFLAGS'] FINAL_LIBRARY = 'xul'