Source code
Revision control
Copy as Markdown
Other Tools
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim:set ts=2 sw=2 sts=2 et cindent: */
/* 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
#if !defined(VPXDecoder_h_)
# define VPXDecoder_h_
# include <stdint.h>
# include <vpx/vp8dx.h>
# include <vpx/vpx_codec.h>
# include <vpx/vpx_decoder.h>
# include "PlatformDecoderModule.h"
# include "mozilla/Span.h"
# include "mozilla/gfx/Types.h"
namespace mozilla {
DDLoggedTypeDeclNameAndBase(VPXDecoder, MediaDataDecoder);
class VPXDecoder final : public MediaDataDecoder,
public DecoderDoctorLifeLogger<VPXDecoder> {
public:
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(VPXDecoder, final);
explicit VPXDecoder(const CreateDecoderParams& aParams);
RefPtr<InitPromise> Init() override;
RefPtr<DecodePromise> Decode(MediaRawData* aSample) override;
RefPtr<DecodePromise> Drain() override;
RefPtr<FlushPromise> Flush() override;
RefPtr<ShutdownPromise> Shutdown() override;
nsCString GetDescriptionName() const override {
return "libvpx video decoder"_ns;
}
nsCString GetCodecName() const override;
enum Codec : uint8_t {
VP8 = 1 << 0,
VP9 = 1 << 1,
Unknown = 1 << 7,
};
// Return true if aMimeType is a one of the strings used by our demuxers to
// identify VPX of the specified type. Does not parse general content type
// strings, i.e. white space matters.
static bool IsVPX(const nsACString& aMimeType,
uint8_t aCodecMask = VP8 | VP9);
static bool IsVP8(const nsACString& aMimeType);
static bool IsVP9(const nsACString& aMimeType);
// Return true if a sample is a keyframe for the specified codec.
static bool IsKeyframe(Span<const uint8_t> aBuffer, Codec aCodec);
// Return the frame dimensions for a sample for the specified codec.
static gfx::IntSize GetFrameSize(Span<const uint8_t> aBuffer, Codec aCodec);
// Return the display dimensions for a sample for the specified codec.
static gfx::IntSize GetDisplaySize(Span<const uint8_t> aBuffer, Codec aCodec);
// Return negative value if error.
static int GetVP9Profile(Span<const uint8_t> aBuffer);
struct VPXStreamInfo {
gfx::IntSize mImage;
bool mDisplayAndImageDifferent = false;
gfx::IntSize mDisplay;
bool mKeyFrame = false;
uint8_t mProfile = 0;
uint8_t mBitDepth = 8;
/*
0 CS_UNKNOWN Unknown (in this case the color space must be signaled outside
the VP9 bitstream).
1 CS_BT_601 Rec. ITU-R BT.601-7
2 CS_BT_709 Rec. ITU-R BT.709-6
3 CS_SMPTE_170 SMPTE-170
4 CS_SMPTE_240 SMPTE-240
5 CS_BT_2020 Rec. ITU-R BT.2020-2
6 CS_RESERVED Reserved
7 CS_RGB sRGB (IEC 61966-2-1)
*/
int mColorSpace = 1; // CS_BT_601
gfx::YUVColorSpace ColorSpace() const {
switch (mColorSpace) {
case 1:
case 3:
case 4:
return gfx::YUVColorSpace::BT601;
case 2:
return gfx::YUVColorSpace::BT709;
case 5:
return gfx::YUVColorSpace::BT2020;
default:
return gfx::YUVColorSpace::Default;
}
}
uint8_t mColorPrimaries = gfx::CICP::ColourPrimaries::CP_UNSPECIFIED;
gfx::ColorSpace2 ColorPrimaries() const {
switch (mColorPrimaries) {
case gfx::CICP::ColourPrimaries::CP_BT709:
return gfx::ColorSpace2::BT709;
case gfx::CICP::ColourPrimaries::CP_UNSPECIFIED:
return gfx::ColorSpace2::BT709;
case gfx::CICP::ColourPrimaries::CP_BT2020:
return gfx::ColorSpace2::BT2020;
default:
return gfx::ColorSpace2::BT709;
}
}
uint8_t mTransferFunction =
gfx::CICP::TransferCharacteristics::TC_UNSPECIFIED;
gfx::TransferFunction TransferFunction() const {
switch (mTransferFunction) {
case gfx::CICP::TransferCharacteristics::TC_BT709:
return gfx::TransferFunction::BT709;
case gfx::CICP::TransferCharacteristics::TC_SRGB:
return gfx::TransferFunction::SRGB;
case gfx::CICP::TransferCharacteristics::TC_SMPTE2084:
return gfx::TransferFunction::PQ;
case gfx::CICP::TransferCharacteristics::TC_HLG:
return gfx::TransferFunction::HLG;
default:
return gfx::TransferFunction::BT709;
}
}
/*
mFullRange == false then:
For BitDepth equals 8:
Y is between 16 and 235 inclusive.
U and V are between 16 and 240 inclusive.
For BitDepth equals 10:
Y is between 64 and 940 inclusive.
U and V are between 64 and 960 inclusive.
For BitDepth equals 12:
Y is between 256 and 3760.
U and V are between 256 and 3840 inclusive.
mFullRange == true then:
No restriction on Y, U, V values.
*/
bool mFullRange = false;
gfx::ColorRange ColorRange() const {
return mFullRange ? gfx::ColorRange::FULL : gfx::ColorRange::LIMITED;
}
/*
Sub-sampling, used only for non sRGB colorspace.
subsampling_x subsampling_y Description
0 0 YUV 4:4:4
0 1 YUV 4:4:0
1 0 YUV 4:2:2
1 1 YUV 4:2:0
*/
bool mSubSampling_x = true;
bool mSubSampling_y = true;
bool IsCompatible(const VPXStreamInfo& aOther) const {
return mImage == aOther.mImage && mProfile == aOther.mProfile &&
mBitDepth == aOther.mBitDepth &&
mSubSampling_x == aOther.mSubSampling_x &&
mSubSampling_y == aOther.mSubSampling_y &&
mColorSpace == aOther.mColorSpace &&
mFullRange == aOther.mFullRange;
}
};
static bool GetStreamInfo(Span<const uint8_t> aBuffer, VPXStreamInfo& aInfo,
Codec aCodec);
static void GetVPCCBox(MediaByteBuffer* aDestBox, const VPXStreamInfo& aInfo);
// Set extradata for a VP8/VP9 track, returning false if the codec was
// invalid.
static bool SetVideoInfo(VideoInfo* aDestInfo, const nsAString& aCodec);
static void SetChroma(VPXStreamInfo& aDestInfo, uint8_t chroma);
static void ReadVPCCBox(VPXStreamInfo& aDestInfo, MediaByteBuffer* aBox);
private:
~VPXDecoder();
RefPtr<DecodePromise> ProcessDecode(MediaRawData* aSample);
MediaResult DecodeAlpha(vpx_image_t** aImgAlpha, const MediaRawData* aSample);
const RefPtr<layers::ImageContainer> mImageContainer;
RefPtr<layers::KnowsCompositor> mImageAllocator;
const RefPtr<TaskQueue> mTaskQueue;
// VPx decoder state
vpx_codec_ctx_t mVPX;
// VPx alpha decoder state
vpx_codec_ctx_t mVPXAlpha;
const VideoInfo mInfo;
const Codec mCodec;
const bool mLowLatency;
const Maybe<TrackingId> mTrackingId;
};
} // namespace mozilla
#endif