Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-10-08 10:44:56 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Bug 1697670 - Remove gfx::YUVColorSpace::UNKNOWN. r=mstange

Browse Source 
Replace with Maybe<YUVColorSpace> where still needed.

Differential Revision: https://phabricator.services.mozilla.com/D107938
This commit is contained in:
Jeff Gilbert 2021-03-19 00:58:23 +00:00
parent 278b283c1a
commit d517313a40
47 changed files with 179 additions and 212 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
dom/media/MediaData.cpp
View File

@ -289,9 +289,6 @@ bool VideoData::SetVideoDataToImage(PlanarYCbCrImage* aVideoImage,
return false;
}
MOZ_ASSERT(aBuffer.mYUVColorSpace != gfx::YUVColorSpace::UNKNOWN,
"We must know the colorframe at this point");
PlanarYCbCrData data = ConstructPlanarYCbCrData(aInfo, aBuffer, aPicture);
aVideoImage->SetDelayedConversion(true);
@ -320,9 +317,6 @@ already_AddRefed<VideoData> VideoData::CreateAndCopyData(
return nullptr;
}
MOZ_ASSERT(aBuffer.mYUVColorSpace != gfx::YUVColorSpace::UNKNOWN,
"We must know the colorframe at this point");
RefPtr<VideoData> v(new VideoData(aOffset, aTime, aDuration, aKeyframe,
aTimecode, aInfo.mDisplay, 0));

2
dom/media/MediaData.h
View File

@ -442,7 +442,7 @@ class VideoData : public MediaData {
};
Plane mPlanes[3];
YUVColorSpace mYUVColorSpace = YUVColorSpace::UNKNOWN;
YUVColorSpace mYUVColorSpace = YUVColorSpace::Identity;
ColorDepth mColorDepth = ColorDepth::COLOR_8;
ColorRange mColorRange = ColorRange::LIMITED;
};

2
dom/media/MediaInfo.h
View File

@ -244,7 +244,7 @@ class VideoInfo : public TrackInfo {
// Should be 8, 10 or 12. Default value is 8.
gfx::ColorDepth mColorDepth = gfx::ColorDepth::COLOR_8;
gfx::YUVColorSpace mColorSpace = gfx::YUVColorSpace::UNKNOWN;
Maybe<gfx::YUVColorSpace> mColorSpace;
// True indicates no restriction on Y, U, V values (otherwise 16-235 for 8
// bits etc)

2
dom/media/moz.build
View File

@ -384,4 +384,6 @@ if CONFIG["CC_TYPE"] in ("clang", "gcc"):
"-Wno-error=shadow",
]
CXXFLAGS += ["-Werror=switch"]
FINAL_LIBRARY = "xul"

87
dom/media/platforms/agnostic/DAV1DDecoder.cpp
View File

@ -188,6 +188,46 @@ int DAV1DDecoder::GetPicture(DecodedData& aData, MediaResult& aResult) {
return 0;
}
Maybe<gfx::YUVColorSpace> GetColorSpace(const Dav1dPicture& aPicture,
LazyLogModule& aLogger) {
// On every other case use the default (BT601).
if (!aPicture.seq_hdr->color_description_present) {
return {};
}
switch (aPicture.seq_hdr->mtrx) {
case DAV1D_MC_BT2020_NCL:
case DAV1D_MC_BT2020_CL:
return Some(gfx::YUVColorSpace::BT2020);
case DAV1D_MC_BT601:
return Some(gfx::YUVColorSpace::BT601);
case DAV1D_MC_BT709:
return Some(gfx::YUVColorSpace::BT709);
case DAV1D_MC_IDENTITY:
return Some(gfx::YUVColorSpace::Identity);
case DAV1D_MC_CHROMAT_NCL:
case DAV1D_MC_CHROMAT_CL:
case DAV1D_MC_UNKNOWN: // MIAF specific
switch (aPicture.seq_hdr->pri) {
case DAV1D_COLOR_PRI_BT601:
return Some(gfx::YUVColorSpace::BT601);
case DAV1D_COLOR_PRI_BT709:
return Some(gfx::YUVColorSpace::BT709);
case DAV1D_COLOR_PRI_BT2020:
return Some(gfx::YUVColorSpace::BT2020);
default:
MOZ_LOG(aLogger, LogLevel::Debug,
("Couldn't infer color matrix from primaries: %u",
aPicture.seq_hdr->pri));
return {};
}
default:
MOZ_LOG(aLogger, LogLevel::Debug,
("Unsupported color matrix value: %u", aPicture.seq_hdr->mtrx));
return {};
}
}
already_AddRefed<VideoData> DAV1DDecoder::ConstructImage(
const Dav1dPicture& aPicture) {
VideoData::YCbCrBuffer b;
@ -195,50 +235,15 @@ already_AddRefed<VideoData> DAV1DDecoder::ConstructImage(
b.mColorDepth = gfx::ColorDepth::COLOR_10;
} else if (aPicture.p.bpc == 12) {
b.mColorDepth = gfx::ColorDepth::COLOR_12;
} else {
b.mColorDepth = gfx::ColorDepth::COLOR_8;
}
// On every other case use the default (BT601).
if (aPicture.seq_hdr->color_description_present) {
switch (aPicture.seq_hdr->mtrx) {
case DAV1D_MC_BT2020_NCL:
case DAV1D_MC_BT2020_CL:
b.mYUVColorSpace = gfx::YUVColorSpace::BT2020;
break;
case DAV1D_MC_BT601:
b.mYUVColorSpace = gfx::YUVColorSpace::BT601;
break;
case DAV1D_MC_BT709:
b.mYUVColorSpace = gfx::YUVColorSpace::BT709;
break;
case DAV1D_MC_IDENTITY:
b.mYUVColorSpace = gfx::YUVColorSpace::Identity;
break;
case DAV1D_MC_CHROMAT_NCL:
case DAV1D_MC_CHROMAT_CL:
case DAV1D_MC_UNKNOWN: // MIAF specific
switch (aPicture.seq_hdr->pri) {
case DAV1D_COLOR_PRI_BT601:
b.mYUVColorSpace = gfx::YUVColorSpace::BT601;
break;
case DAV1D_COLOR_PRI_BT709:
b.mYUVColorSpace = gfx::YUVColorSpace::BT709;
break;
case DAV1D_COLOR_PRI_BT2020:
b.mYUVColorSpace = gfx::YUVColorSpace::BT2020;
break;
default:
b.mYUVColorSpace = gfx::YUVColorSpace::UNKNOWN;
break;
}
break;
default:
LOG("Unsupported color matrix value: %u", aPicture.seq_hdr->mtrx);
b.mYUVColorSpace = gfx::YUVColorSpace::UNKNOWN;
}
}
if (b.mYUVColorSpace == gfx::YUVColorSpace::UNKNOWN) {
b.mYUVColorSpace = DefaultColorSpace({aPicture.p.w, aPicture.p.h});
auto colorSpace = GetColorSpace(aPicture, sPDMLog);
if (!colorSpace) {
colorSpace = Some(DefaultColorSpace({aPicture.p.w, aPicture.p.h}));
}
b.mYUVColorSpace = *colorSpace;
b.mColorRange = aPicture.seq_hdr->color_range ? gfx::ColorRange::FULL
: gfx::ColorRange::LIMITED;

2
dom/media/platforms/agnostic/VPXDecoder.h
View File

@ -90,7 +90,7 @@ class VPXDecoder : public MediaDataDecoder,
case 5:
return gfx::YUVColorSpace::BT2020;
default:
return gfx::YUVColorSpace::UNKNOWN;
return gfx::YUVColorSpace::Default;
}
}

4
dom/media/platforms/agnostic/bytestreams/H264.cpp
View File

@ -303,9 +303,7 @@ gfx::YUVColorSpace SPSData::ColorSpace() const {
case GUESS_BT2020:
return gfx::YUVColorSpace::BT2020;
default:
MOZ_ASSERT_UNREACHABLE(
"not possible to get here but makes compiler happy");
return gfx::YUVColorSpace::UNKNOWN;
MOZ_CRASH("not possible to get here but makes compiler happy");
}
}

6
dom/media/platforms/apple/AppleVTDecoder.cpp
View File

@ -41,9 +41,9 @@ AppleVTDecoder::AppleVTDecoder(const VideoInfo& aConfig,
mPictureHeight(aConfig.mImage.height),
mDisplayWidth(aConfig.mDisplay.width),
mDisplayHeight(aConfig.mDisplay.height),
mColorSpace(aConfig.mColorSpace == gfx::YUVColorSpace::UNKNOWN
? DefaultColorSpace({mPictureWidth, mPictureHeight})
: aConfig.mColorSpace),
mColorSpace(aConfig.mColorSpace
? *aConfig.mColorSpace
: DefaultColorSpace({mPictureWidth, mPictureHeight})),
mColorRange(aConfig.mColorRange),
mStreamType(MP4Decoder::IsH264(aConfig.mMimeType) ? StreamType::H264
: VPXDecoder::IsVP9(aConfig.mMimeType) ? StreamType::VP9

12
dom/media/platforms/omx/OmxDataDecoder.cpp
View File

@ -937,12 +937,14 @@ already_AddRefed<VideoData> MediaDataHelper::CreateYUV420VideoData(
b.mPlanes[2].mStride = (stride + 1) / 2;
b.mPlanes[2].mSkip = 0;
b.mYUVColorSpace =
mTrackInfo->GetAsVideoInfo()->mColorSpace == YUVColorSpace::UNKNOWN
? DefaultColorSpace({width, height})
: mTrackInfo->GetAsVideoInfo()->mColorSpace;
VideoInfo info(*mTrackInfo->GetAsVideoInfo());
auto maybeColorSpace = info.mColorSpace;
if (!maybeColorSpace) {
maybeColorSpace = Some(DefaultColorSpace({width, height}));
}
b.mYUVColorSpace = *maybeColorSpace;
RefPtr<VideoData> data = VideoData::CreateAndCopyData(
info, mImageContainer,
0, // Filled later by caller.

2
dom/media/platforms/wmf/DXVA2Manager.cpp
View File

@ -602,7 +602,7 @@ class D3D11DXVA2Manager : public DXVA2Manager {
UINT mDeviceManagerToken = 0;
RefPtr<IMFMediaType> mInputType;
GUID mInputSubType;
gfx::YUVColorSpace mYUVColorSpace = gfx::YUVColorSpace::UNKNOWN;
gfx::YUVColorSpace mYUVColorSpace;
gfx::ColorRange mColorRange = gfx::ColorRange::LIMITED;
};

13
dom/media/platforms/wmf/WMFUtils.cpp
View File

@ -65,21 +65,22 @@ GetDefaultStride(IMFMediaType* aType, uint32_t aWidth, uint32_t* aOutStride) {
return hr;
}
gfx::YUVColorSpace GetYUVColorSpace(IMFMediaType* aType) {
Maybe<gfx::YUVColorSpace> GetYUVColorSpace(IMFMediaType* aType) {
UINT32 yuvColorMatrix;
HRESULT hr = aType->GetUINT32(MF_MT_YUV_MATRIX, &yuvColorMatrix);
NS_ENSURE_TRUE(SUCCEEDED(hr), gfx::YUVColorSpace::UNKNOWN);
NS_ENSURE_TRUE(SUCCEEDED(hr), {});
switch (yuvColorMatrix) {
case MFVideoTransferMatrix_BT2020_10:
case MFVideoTransferMatrix_BT2020_12:
return gfx::YUVColorSpace::BT2020;
return Some(gfx::YUVColorSpace::BT2020);
case MFVideoTransferMatrix_BT709:
return gfx::YUVColorSpace::BT709;
return Some(gfx::YUVColorSpace::BT709);
case MFVideoTransferMatrix_BT601:
return gfx::YUVColorSpace::BT601;
return Some(gfx::YUVColorSpace::BT601);
default:
return gfx::YUVColorSpace::UNKNOWN;
MOZ_ASSERT_UNREACHABLE("Unhandled MFVideoTransferMatrix_?");
return {};
}
}

2
dom/media/platforms/wmf/WMFUtils.h
View File

@ -33,7 +33,7 @@ HRESULT HNsToFrames(int64_t aHNs, uint32_t aRate, int64_t* aOutFrames);
HRESULT
GetDefaultStride(IMFMediaType* aType, uint32_t aWidth, uint32_t* aOutStride);
gfx::YUVColorSpace GetYUVColorSpace(IMFMediaType* aType);
Maybe<gfx::YUVColorSpace> GetYUVColorSpace(IMFMediaType* aType);
int32_t MFOffsetToInt32(const MFOffset& aOffset);

6
dom/media/platforms/wmf/WMFVideoMFTManager.cpp
View File

@ -116,9 +116,7 @@ WMFVideoMFTManager::WMFVideoMFTManager(
mImageSize(aConfig.mImage),
mDecodedImageSize(aConfig.mImage),
mVideoStride(0),
mColorSpace(aConfig.mColorSpace != gfx::YUVColorSpace::UNKNOWN
? Some(aConfig.mColorSpace)
: Nothing()),
mColorSpace(aConfig.mColorSpace),
mColorRange(aConfig.mColorRange),
mImageContainer(aImageContainer),
mKnowsCompositor(aKnowsCompositor),
@ -476,7 +474,7 @@ WMFVideoMFTManager::Input(MediaRawData* aSample) {
// The colorspace definition is found in the H264 SPS NAL, available out of
// band, while for VP9 it's only available within the VP9 bytestream.
// The info would have been updated by the MediaChangeMonitor.
mColorSpace = Some(aSample->mTrackInfo->GetAsVideoInfo()->mColorSpace);
mColorSpace = aSample->mTrackInfo->GetAsVideoInfo()->mColorSpace;
mColorRange = aSample->mTrackInfo->GetAsVideoInfo()->mColorRange;
}
mLastDuration = aSample->mDuration;

4
dom/media/platforms/wrappers/MediaChangeMonitor.cpp
View File

@ -132,7 +132,7 @@ class H264ChangeMonitor : public MediaChangeMonitor::CodecChangeMonitor {
mCurrentConfig.mDisplay.width = spsdata.display_width;
mCurrentConfig.mDisplay.height = spsdata.display_height;
mCurrentConfig.mColorDepth = spsdata.ColorDepth();
mCurrentConfig.mColorSpace = spsdata.ColorSpace();
mCurrentConfig.mColorSpace = Some(spsdata.ColorSpace());
mCurrentConfig.mColorRange = spsdata.video_full_range_flag
? gfx::ColorRange::FULL
: gfx::ColorRange::LIMITED;
@ -211,7 +211,7 @@ class VPXChangeMonitor : public MediaChangeMonitor::CodecChangeMonitor {
mCurrentConfig.mImage = info.mImage;
mCurrentConfig.mDisplay = info.mDisplay;
mCurrentConfig.mColorDepth = gfx::ColorDepthForBitDepth(info.mBitDepth);
mCurrentConfig.mColorSpace = info.ColorSpace();
mCurrentConfig.mColorSpace = Some(info.ColorSpace());
mCurrentConfig.mColorRange = info.ColorRange();
if (mCodec == VPXDecoder::Codec::VP9) {
VPXDecoder::GetVPCCBox(mCurrentConfig.mExtraData, info);

10
gfx/2d/MacIOSurface.h
View File

@ -69,13 +69,13 @@ class MacIOSurface final
IOSurfaceID aSurfaceID, double aContentsScaleFactor = 1.0,
bool aHasAlpha = true,
mozilla::gfx::YUVColorSpace aColorSpace =
mozilla::gfx::YUVColorSpace::UNKNOWN);
mozilla::gfx::YUVColorSpace::Identity);
explicit MacIOSurface(CFTypeRefPtr<IOSurfaceRef> aIOSurfaceRef,
double aContentsScaleFactor = 1.0,
bool aHasAlpha = true,
mozilla::gfx::YUVColorSpace aColorSpace =
mozilla::gfx::YUVColorSpace::UNKNOWN);
mozilla::gfx::YUVColorSpace::Identity);
~MacIOSurface();
IOSurfaceID GetIOSurfaceID() const;
@ -142,10 +142,10 @@ class MacIOSurface final
private:
CFTypeRefPtr<IOSurfaceRef> mIOSurfaceRef;
double mContentsScaleFactor;
bool mHasAlpha;
const double mContentsScaleFactor;
const bool mHasAlpha;
YUVColorSpace mColorSpace = YUVColorSpace::Identity;
bool mIsLocked = false;
YUVColorSpace mColorSpace = YUVColorSpace::UNKNOWN;
};
#endif

26
gfx/2d/Types.h
View File

@ -200,10 +200,10 @@ enum class YUVColorSpace : uint8_t {
BT601,
BT709,
BT2020,
Identity, // aka RGB
// This represents the unknown format and is a valid value.
UNKNOWN,
_NUM_COLORSPACE
Identity, // Todo: s/YUVColorSpace/ColorSpace/, s/Identity/SRGB/
Default = BT709,
_First = BT601,
_Last = Identity,
};
enum class ColorDepth : uint8_t {
@ -211,10 +211,16 @@ enum class ColorDepth : uint8_t {
COLOR_10,
COLOR_12,
COLOR_16,
UNKNOWN
_First = COLOR_8,
_Last = COLOR_16,
};
enum class ColorRange : uint8_t { LIMITED, FULL, UNKNOWN };
enum class ColorRange : uint8_t {
LIMITED,
FULL,
_First = LIMITED,
_Last = FULL,
};
static inline SurfaceFormat SurfaceFormatForColorDepth(ColorDepth aColorDepth) {
SurfaceFormat format = SurfaceFormat::A8;
@ -226,8 +232,6 @@ static inline SurfaceFormat SurfaceFormatForColorDepth(ColorDepth aColorDepth) {
case ColorDepth::COLOR_16:
format = SurfaceFormat::A16;
break;
case ColorDepth::UNKNOWN:
MOZ_ASSERT_UNREACHABLE("invalid color depth value");
}
return format;
}
@ -246,8 +250,6 @@ static inline uint32_t BitDepthForColorDepth(ColorDepth aColorDepth) {
case ColorDepth::COLOR_16:
depth = 16;
break;
case ColorDepth::UNKNOWN:
MOZ_ASSERT_UNREACHABLE("invalid color depth value");
}
return depth;
}
@ -266,8 +268,6 @@ static inline ColorDepth ColorDepthForBitDepth(uint8_t aBitDepth) {
case 16:
depth = ColorDepth::COLOR_16;
break;
default:
MOZ_ASSERT_UNREACHABLE("invalid color depth value");
}
return depth;
}
@ -287,8 +287,6 @@ static inline uint32_t RescalingFactorForColorDepth(ColorDepth aColorDepth) {
break;
case ColorDepth::COLOR_16:
break;
case ColorDepth::UNKNOWN:
MOZ_ASSERT_UNREACHABLE("invalid color depth value");
}
return factor;
}

1
gfx/2d/moz.build
View File

@ -239,6 +239,7 @@ if CONFIG["MOZ_WIDGET_TOOLKIT"] in ("android", "gtk"):
DEFINES["MOZ_ENABLE_FREETYPE"] = True
CXXFLAGS += CONFIG["MOZ_CAIRO_CFLAGS"]
CXXFLAGS += ["-Werror=switch"]
if CONFIG["MOZ_WIDGET_TOOLKIT"] in ("android", "gtk"):
CXXFLAGS += CONFIG["CAIRO_FT_CFLAGS"]

2
gfx/gl/SharedSurfaceANGLE.cpp
View File

@ -143,7 +143,7 @@ SharedSurface_ANGLEShareHandle::ToSurfaceDescriptor() {
const auto format = gfx::SurfaceFormat::B8G8R8A8;
return Some(layers::SurfaceDescriptorD3D10(
(WindowsHandle)mShareHandle, format, mDesc.size,
gfx::YUVColorSpace::UNKNOWN, gfx::ColorRange::FULL));
gfx::YUVColorSpace::Identity, gfx::ColorRange::FULL));
}
class ScopedLockTexture final {

2
gfx/gl/SharedSurfaceD3D11Interop.cpp
View File

@ -439,7 +439,7 @@ SharedSurface_D3D11Interop::ToSurfaceDescriptor() {
const auto format = gfx::SurfaceFormat::B8G8R8A8;
return Some(layers::SurfaceDescriptorD3D10(
WindowsHandle(mData.dxgiHandle), format, mDesc.size,
gfx::YUVColorSpace::UNKNOWN, gfx::ColorRange::FULL));
gfx::YUVColorSpace::Identity, gfx::ColorRange::FULL));
}
//////////////////////////////////////////////////////////////////////////////////////////

2
gfx/gl/moz.build
View File

@ -156,6 +156,8 @@ CXXFLAGS += CONFIG["TK_CFLAGS"]
CFLAGS += CONFIG["MOZ_CAIRO_CFLAGS"]
CFLAGS += CONFIG["TK_CFLAGS"]
CXXFLAGS += ["-Werror=switch"]
if CONFIG["MOZ_WAYLAND"]:
CXXFLAGS += CONFIG["MOZ_WAYLAND_CFLAGS"]
CFLAGS += CONFIG["MOZ_WAYLAND_CFLAGS"]

18
gfx/ipc/GfxMessageUtils.h
View File

@ -722,21 +722,21 @@ struct ParamTraits<mozilla::gfx::SurfaceFormat>
template <>
struct ParamTraits<mozilla::gfx::ColorDepth>
: public ContiguousEnumSerializer<mozilla::gfx::ColorDepth,
mozilla::gfx::ColorDepth::COLOR_8,
mozilla::gfx::ColorDepth::UNKNOWN> {};
: public ContiguousEnumSerializerInclusive<
mozilla::gfx::ColorDepth, mozilla::gfx::ColorDepth::_First,
mozilla::gfx::ColorDepth::_Last> {};
template <>
struct ParamTraits<mozilla::gfx::ColorRange>
: public ContiguousEnumSerializer<mozilla::gfx::ColorRange,
mozilla::gfx::ColorRange::LIMITED,
mozilla::gfx::ColorRange::UNKNOWN> {};
: public ContiguousEnumSerializerInclusive<
mozilla::gfx::ColorRange, mozilla::gfx::ColorRange::_First,
mozilla::gfx::ColorRange::_Last> {};
template <>
struct ParamTraits<mozilla::gfx::YUVColorSpace>
: public ContiguousEnumSerializer<
mozilla::gfx::YUVColorSpace, mozilla::gfx::YUVColorSpace::BT601,
mozilla::gfx::YUVColorSpace::_NUM_COLORSPACE> {};
: public ContiguousEnumSerializerInclusive<
mozilla::gfx::YUVColorSpace, mozilla::gfx::YUVColorSpace::_First,
mozilla::gfx::YUVColorSpace::_Last> {};
template <>
struct ParamTraits<mozilla::StereoMode>

1
gfx/ipc/moz.build
View File

@ -86,5 +86,6 @@ FINAL_LIBRARY = "xul"
CXXFLAGS += CONFIG["MOZ_CAIRO_CFLAGS"]
CXXFLAGS += CONFIG["TK_CFLAGS"]
CXXFLAGS += ["-Werror=switch"]
LOCAL_INCLUDES += CONFIG["SKIA_INCLUDES"]

14
gfx/layers/D3D9SurfaceImage.cpp
View File

@ -81,13 +81,19 @@ already_AddRefed<IDirect3DSurface9> DXGID3D9TextureData::GetD3D9Surface()
}
bool DXGID3D9TextureData::Serialize(SurfaceDescriptor& aOutDescriptor) {
SurfaceDescriptorD3D10 desc((WindowsHandle)(mHandle), mFormat, GetSize(),
gfx::YUVColorSpace::Identity,
gfx::ColorRange::FULL);
// In reality, with D3D9 we will only ever deal with RGBA textures.
bool isYUV = mFormat == SurfaceFormat::NV12 ||
mFormat == SurfaceFormat::P010 || mFormat == SurfaceFormat::P016;
aOutDescriptor = SurfaceDescriptorD3D10(
(WindowsHandle)(mHandle), mFormat, GetSize(),
isYUV ? gfx::YUVColorSpace::BT601 : gfx::YUVColorSpace::UNKNOWN,
gfx::ColorRange::LIMITED);
if (isYUV) {
gfxCriticalError() << "Unexpected YUV format for DXGID3D9TextureData: "
<< mFormat;
desc.yUVColorSpace() = gfx::YUVColorSpace::BT601;
desc.colorRange() = gfx::ColorRange::LIMITED;
}
aOutDescriptor = desc;
return true;
}

1
gfx/layers/Effects.h
View File

@ -245,7 +245,6 @@ inline already_AddRefed<TexturedEffect> CreateTexturedEffect(
switch (aHost->GetReadFormat()) {
case gfx::SurfaceFormat::YUV:
MOZ_ASSERT(aHost->GetYUVColorSpace() != gfx::YUVColorSpace::UNKNOWN);
result = new EffectYCbCr(aSource, aHost->GetYUVColorSpace(),
aHost->GetColorRange(), aHost->GetColorDepth(),
aSamplingFilter);

2
gfx/layers/ImageContainer.h
View File

@ -661,7 +661,7 @@ struct PlanarYCbCrData {
gfx::IntSize mPicSize = gfx::IntSize(0, 0);
StereoMode mStereoMode = StereoMode::MONO;
gfx::ColorDepth mColorDepth = gfx::ColorDepth::COLOR_8;
gfx::YUVColorSpace mYUVColorSpace = gfx::YUVColorSpace::UNKNOWN;
gfx::YUVColorSpace mYUVColorSpace = gfx::YUVColorSpace::Default;
gfx::ColorRange mColorRange = gfx::ColorRange::LIMITED;
gfx::IntRect GetPictureRect() const {

2
gfx/layers/composite/GPUVideoTextureHost.cpp
View File

@ -147,7 +147,7 @@ void GPUVideoTextureHost::SetTextureSourceProvider(
gfx::YUVColorSpace GPUVideoTextureHost::GetYUVColorSpace() const {
MOZ_ASSERT(mWrappedTextureHost, "Image isn't valid yet");
if (!mWrappedTextureHost) {
return gfx::YUVColorSpace::UNKNOWN;
return TextureHost::GetYUVColorSpace();
}
return mWrappedTextureHost->GetYUVColorSpace();
}

2
gfx/layers/composite/TextureHost.cpp
View File

@ -1021,7 +1021,7 @@ gfx::YUVColorSpace BufferTextureHost::GetYUVColorSpace() const {
const YCbCrDescriptor& desc = mDescriptor.get_YCbCrDescriptor();
return desc.yUVColorSpace();
}
return gfx::YUVColorSpace::UNKNOWN;
return gfx::YUVColorSpace::Identity;
}
gfx::ColorDepth BufferTextureHost::GetColorDepth() const {

2
gfx/layers/composite/TextureHost.h
View File

@ -444,7 +444,7 @@ class TextureHost : public AtomicRefCountedWithFinalize<TextureHost> {
virtual gfx::SurfaceFormat GetReadFormat() const { return GetFormat(); }
virtual gfx::YUVColorSpace GetYUVColorSpace() const {
return gfx::YUVColorSpace::UNKNOWN;
return gfx::YUVColorSpace::Identity;
}
/**

3
gfx/layers/d3d11/TextureD3D11.cpp
View File

@ -239,6 +239,7 @@ static bool LockD3DTexture(T* aTexture) {
template <typename T>
static bool HasKeyedMutex(T* aTexture) {
MOZ_ASSERT(aTexture);
RefPtr<IDXGIKeyedMutex> mutex;
aTexture->QueryInterface((IDXGIKeyedMutex**)getter_AddRefs(mutex));
return !!mutex;
@ -265,11 +266,11 @@ D3D11TextureData::D3D11TextureData(ID3D11Texture2D* aTexture,
mFormat(aFormat),
mNeedsClear(aFlags & ALLOC_CLEAR_BUFFER),
mNeedsClearWhite(aFlags & ALLOC_CLEAR_BUFFER_WHITE),
mHasSynchronization(HasKeyedMutex(aTexture)),
mIsForOutOfBandContent(aFlags & ALLOC_FOR_OUT_OF_BAND_CONTENT),
mTexture(aTexture),
mAllocationFlags(aFlags) {
MOZ_ASSERT(aTexture);
mHasSynchronization = HasKeyedMutex(aTexture);
}
static void DestroyDrawTarget(RefPtr<DrawTarget>& aDT,

14
gfx/layers/d3d11/TextureD3D11.h
View File

@ -119,14 +119,14 @@ class D3D11TextureData final : public TextureData {
// Hold on to the DrawTarget because it is expensive to create one each
// ::Lock.
RefPtr<gfx::DrawTarget> mDrawTarget;
gfx::IntSize mSize;
gfx::SurfaceFormat mFormat;
gfx::YUVColorSpace mYUVColorSpace = gfx::YUVColorSpace::UNKNOWN;
const gfx::IntSize mSize;
const gfx::SurfaceFormat mFormat;
gfx::YUVColorSpace mYUVColorSpace = gfx::YUVColorSpace::Identity;
gfx::ColorRange mColorRange = gfx::ColorRange::LIMITED;
bool mNeedsClear;
bool mNeedsClearWhite;
bool mHasSynchronization;
bool mIsForOutOfBandContent;
bool mNeedsClear = false;
bool mNeedsClearWhite = false;
const bool mHasSynchronization;
const bool mIsForOutOfBandContent;
RefPtr<ID3D11Texture2D> mTexture;
const TextureAllocationFlags mAllocationFlags;

1
gfx/layers/moz.build
View File

@ -613,6 +613,7 @@ BROWSER_CHROME_MANIFESTS += ["apz/test/mochitest/browser.ini"]
CXXFLAGS += CONFIG["MOZ_CAIRO_CFLAGS"]
CXXFLAGS += CONFIG["TK_CFLAGS"]
CXXFLAGS += ["-Werror=switch"]
LOCAL_INCLUDES += CONFIG["SKIA_INCLUDES"]

2
gfx/layers/opengl/DMABUFTextureHostOGL.cpp
View File

@ -94,7 +94,7 @@ gfx::SurfaceFormat DMABUFTextureHostOGL::GetFormat() const {
gfx::YUVColorSpace DMABUFTextureHostOGL::GetYUVColorSpace() const {
if (!mSurface) {
return gfx::YUVColorSpace::UNKNOWN;
return gfx::YUVColorSpace::Identity;
}
return mSurface->GetYUVColorSpace();
}

2
gfx/layers/opengl/MacIOSurfaceTextureHostOGL.cpp
View File

@ -119,7 +119,7 @@ gl::GLContext* MacIOSurfaceTextureHostOGL::gl() const {
gfx::YUVColorSpace MacIOSurfaceTextureHostOGL::GetYUVColorSpace() const {
if (!mSurface) {
return gfx::YUVColorSpace::UNKNOWN;
return gfx::YUVColorSpace::Identity;
}
return mSurface->GetYUVColorSpace();
}

15
gfx/thebes/gfxUtils.cpp
View File

@ -1128,9 +1128,8 @@ const float kIdentityNarrowYCbCrToRGB_RowMajor[16] = {
return rec2020;
case gfx::YUVColorSpace::Identity:
return identity;
default: // YUVColorSpace::UNKNOWN
MOZ_ASSERT(false, "unknown aYUVColorSpace");
return rec601;
default:
MOZ_CRASH("Bad YUVColorSpace");
}
}
@ -1155,9 +1154,8 @@ const float kIdentityNarrowYCbCrToRGB_RowMajor[16] = {
return rec2020;
case YUVColorSpace::Identity:
return identity;
default: // YUVColorSpace::UNKNOWN
MOZ_ASSERT(false, "unknown aYUVColorSpace");
return rec601;
default:
MOZ_CRASH("Bad YUVColorSpace");
}
}
@ -1185,9 +1183,8 @@ const float kIdentityNarrowYCbCrToRGB_RowMajor[16] = {
return rec2020;
case YUVColorSpace::Identity:
return identity;
default: // YUVColorSpace::UNKNOWN
MOZ_ASSERT(false, "unknown aYUVColorSpace");
return rec601;
default:
MOZ_CRASH("Bad YUVColorSpace");
}
}

2
gfx/thebes/moz.build
View File

@ -293,3 +293,5 @@ DEFINES["GRAPHITE2_STATIC"] = True
if CONFIG["CC_TYPE"] == "clang":
# Suppress warnings from Skia header files.
SOURCES["gfxPlatform.cpp"].flags += ["-Wno-implicit-fallthrough"]
CXXFLAGS += ["-Werror=switch"]

2
gfx/webrender_bindings/RenderAndroidSurfaceTextureHost.h
View File

@ -47,7 +47,7 @@ class RenderAndroidSurfaceTextureHost final : public RenderTextureHostSWGL {
PlaneInfo& aPlaneInfo) override;
void UnmapPlanes() override;
gfx::YUVColorSpace GetYUVColorSpace() const override {
return gfx::YUVColorSpace::UNKNOWN;
return gfx::YUVColorSpace::Default;
}
RenderAndroidSurfaceTextureHost* AsRenderAndroidSurfaceTextureHost()

2
gfx/webrender_bindings/RenderBufferTextureHost.cpp
View File

@ -188,7 +188,7 @@ gfx::YUVColorSpace RenderBufferTextureHost::GetYUVColorSpace() const {
case layers::BufferDescriptor::TYCbCrDescriptor:
return mDescriptor.get_YCbCrDescriptor().yUVColorSpace();
default:
return gfx::YUVColorSpace::UNKNOWN;
return gfx::YUVColorSpace::Default;
}
}

2
gfx/webrender_bindings/RenderExternalTextureHost.cpp
View File

@ -218,7 +218,7 @@ gfx::YUVColorSpace RenderExternalTextureHost::GetYUVColorSpace() const {
case layers::BufferDescriptor::TYCbCrDescriptor:
return mDescriptor.get_YCbCrDescriptor().yUVColorSpace();
default:
return gfx::YUVColorSpace::UNKNOWN;
return gfx::YUVColorSpace::Default;
}
}

5
gfx/webrender_bindings/RenderTextureHostSWGL.cpp
View File

@ -52,9 +52,6 @@ bool RenderTextureHostSWGL::UpdatePlanes(RenderCompositor* aCompositor,
case gfx::ColorDepth::COLOR_16:
internalFormat = LOCAL_GL_R16;
break;
default:
MOZ_RELEASE_ASSERT(false, "Unhandled YUV color depth");
break;
}
break;
case gfx::SurfaceFormat::NV12:
@ -170,10 +167,8 @@ bool RenderTextureHostSWGL::LockSWGLCompositeSurface(
case gfx::SurfaceFormat::YUV422: {
aInfo->yuv_planes = mPlanes.size();
auto colorSpace = GetYUVColorSpace();
MOZ_ASSERT(colorSpace != gfx::YUVColorSpace::UNKNOWN);
aInfo->color_space = ToWrYuvColorSpace(colorSpace);
auto colorDepth = GetColorDepth();
MOZ_ASSERT(colorDepth != gfx::ColorDepth::UNKNOWN);
aInfo->color_depth = ToWrColorDepth(colorDepth);
break;
}

4
gfx/webrender_bindings/RenderTextureHostSWGL.h
View File

@ -30,11 +30,11 @@ class RenderTextureHostSWGL : public RenderTextureHost {
virtual gfx::SurfaceFormat GetFormat() const = 0;
virtual gfx::ColorDepth GetColorDepth() const {
return gfx::ColorDepth::UNKNOWN;
return gfx::ColorDepth::COLOR_8;
}
virtual gfx::YUVColorSpace GetYUVColorSpace() const {
return gfx::YUVColorSpace::UNKNOWN;
return gfx::YUVColorSpace::Default;
}
struct PlaneInfo {

4
gfx/webrender_bindings/RenderTextureHostWrapper.cpp
View File

@ -108,14 +108,14 @@ gfx::ColorDepth RenderTextureHostWrapper::GetColorDepth() const {
if (RenderTextureHostSWGL* swglHost = EnsureRenderTextureHostSWGL()) {
return swglHost->GetColorDepth();
}
return gfx::ColorDepth::UNKNOWN;
return gfx::ColorDepth::COLOR_8;
}
gfx::YUVColorSpace RenderTextureHostWrapper::GetYUVColorSpace() const {
if (RenderTextureHostSWGL* swglHost = EnsureRenderTextureHostSWGL()) {
return swglHost->GetYUVColorSpace();
}
return gfx::YUVColorSpace::UNKNOWN;
return gfx::YUVColorSpace::Default;
}
bool RenderTextureHostWrapper::MapPlane(RenderCompositor* aCompositor,

1
gfx/webrender_bindings/moz.build
View File

@ -121,3 +121,4 @@ FINAL_LIBRARY = "xul"
CXXFLAGS += CONFIG["TK_CFLAGS"]
CXXFLAGS += CONFIG["MOZ_CAIRO_CFLAGS"]
CXXFLAGS += ["-Werror=switch"]

2
image/decoders/moz.build
View File

@ -54,5 +54,7 @@ FINAL_LIBRARY = "xul"
if CONFIG["CC_TYPE"] in ("clang", "gcc"):
CXXFLAGS += ["-Wno-error=shadow"]
CXXFLAGS += ["-Werror=switch"]
# Add libFuzzer configuration directives
include("/tools/fuzzing/libfuzzer-config.mozbuild")

83
image/decoders/nsAVIFDecoder.cpp
View File

@ -22,6 +22,9 @@
using namespace mozilla::gfx;
namespace mozilla {
Maybe<gfx::YUVColorSpace> GetColorSpace(const Dav1dPicture&, LazyLogModule&);
namespace image {
using Telemetry::LABELS_AVIF_AOM_DECODE_ERROR;
@ -34,14 +37,11 @@ static LazyLogModule sAVIFLog("AVIFDecoder");
static const LABELS_AVIF_BIT_DEPTH gColorDepthLabel[] = {
LABELS_AVIF_BIT_DEPTH::color_8, LABELS_AVIF_BIT_DEPTH::color_10,
LABELS_AVIF_BIT_DEPTH::color_12, LABELS_AVIF_BIT_DEPTH::color_16,
LABELS_AVIF_BIT_DEPTH::unknown};
LABELS_AVIF_BIT_DEPTH::color_12, LABELS_AVIF_BIT_DEPTH::color_16};
static const LABELS_AVIF_YUV_COLOR_SPACE gColorSpaceLabel[static_cast<size_t>(
gfx::YUVColorSpace::_NUM_COLORSPACE)] = {
static const LABELS_AVIF_YUV_COLOR_SPACE gColorSpaceLabel[] = {
LABELS_AVIF_YUV_COLOR_SPACE::BT601, LABELS_AVIF_YUV_COLOR_SPACE::BT709,
LABELS_AVIF_YUV_COLOR_SPACE::BT2020, LABELS_AVIF_YUV_COLOR_SPACE::identity,
LABELS_AVIF_YUV_COLOR_SPACE::unknown};
LABELS_AVIF_YUV_COLOR_SPACE::BT2020, LABELS_AVIF_YUV_COLOR_SPACE::identity};
class AVIFParser {
public:
@ -629,49 +629,12 @@ layers::PlanarYCbCrAData Dav1dDecoder::Dav1dPictureToYCbCrAData(
data.mStereoMode = StereoMode::MONO;
data.mColorDepth = ColorDepthForBitDepth(aPicture->p.bpc);
switch (aPicture->seq_hdr->mtrx) {
case DAV1D_MC_BT601:
data.mYUVColorSpace = gfx::YUVColorSpace::BT601;
break;
case DAV1D_MC_BT709:
data.mYUVColorSpace = gfx::YUVColorSpace::BT709;
break;
case DAV1D_MC_BT2020_NCL:
data.mYUVColorSpace = gfx::YUVColorSpace::BT2020;
break;
case DAV1D_MC_BT2020_CL:
data.mYUVColorSpace = gfx::YUVColorSpace::BT2020;
break;
case DAV1D_MC_IDENTITY:
data.mYUVColorSpace = gfx::YUVColorSpace::Identity;
break;
case DAV1D_MC_CHROMAT_NCL:
case DAV1D_MC_CHROMAT_CL:
case DAV1D_MC_UNKNOWN: // MIAF specific
switch (aPicture->seq_hdr->pri) {
case DAV1D_COLOR_PRI_BT601:
data.mYUVColorSpace = gfx::YUVColorSpace::BT601;
break;
case DAV1D_COLOR_PRI_BT709:
data.mYUVColorSpace = gfx::YUVColorSpace::BT709;
break;
case DAV1D_COLOR_PRI_BT2020:
data.mYUVColorSpace = gfx::YUVColorSpace::BT2020;
break;
default:
data.mYUVColorSpace = gfx::YUVColorSpace::UNKNOWN;
break;
}
break;
default:
MOZ_LOG(sAVIFLog, LogLevel::Debug,
("unsupported color matrix value: %u", aPicture->seq_hdr->mtrx));
data.mYUVColorSpace = gfx::YUVColorSpace::UNKNOWN;
}
if (data.mYUVColorSpace == gfx::YUVColorSpace::UNKNOWN) {
auto colorSpace = GetColorSpace(*aPicture, sAVIFLog);
if (!colorSpace) {
// MIAF specific: UNKNOWN color space should be treated as BT601
data.mYUVColorSpace = gfx::YUVColorSpace::BT601;
colorSpace = Some(gfx::YUVColorSpace::BT601);
}
data.mYUVColorSpace = *colorSpace;
data.mColorRange = aPicture->seq_hdr->color_range ? gfx::ColorRange::FULL
: gfx::ColorRange::LIMITED;
@ -726,50 +689,50 @@ layers::PlanarYCbCrAData AOMDecoder::AOMImageToYCbCrAData(
data.mStereoMode = StereoMode::MONO;
data.mColorDepth = ColorDepthForBitDepth(aImage->bit_depth);
Maybe<gfx::YUVColorSpace> colorSpace;
switch (aImage->mc) {
case AOM_CICP_MC_BT_601:
data.mYUVColorSpace = gfx::YUVColorSpace::BT601;
colorSpace = Some(gfx::YUVColorSpace::BT601);
break;
case AOM_CICP_MC_BT_709:
data.mYUVColorSpace = gfx::YUVColorSpace::BT709;
colorSpace = Some(gfx::YUVColorSpace::BT709);
break;
case AOM_CICP_MC_BT_2020_NCL:
data.mYUVColorSpace = gfx::YUVColorSpace::BT2020;
colorSpace = Some(gfx::YUVColorSpace::BT2020);
break;
case AOM_CICP_MC_BT_2020_CL:
data.mYUVColorSpace = gfx::YUVColorSpace::BT2020;
colorSpace = Some(gfx::YUVColorSpace::BT2020);
break;
case AOM_CICP_MC_IDENTITY:
data.mYUVColorSpace = gfx::YUVColorSpace::Identity;
colorSpace = Some(gfx::YUVColorSpace::Identity);
break;
case AOM_CICP_MC_CHROMAT_NCL:
case AOM_CICP_MC_CHROMAT_CL:
case AOM_CICP_MC_UNSPECIFIED: // MIAF specific
switch (aImage->cp) {
case AOM_CICP_CP_BT_601:
data.mYUVColorSpace = gfx::YUVColorSpace::BT601;
colorSpace = Some(gfx::YUVColorSpace::BT601);
break;
case AOM_CICP_CP_BT_709:
data.mYUVColorSpace = gfx::YUVColorSpace::BT709;
colorSpace = Some(gfx::YUVColorSpace::BT709);
break;
case AOM_CICP_CP_BT_2020:
data.mYUVColorSpace = gfx::YUVColorSpace::BT2020;
colorSpace = Some(gfx::YUVColorSpace::BT2020);
break;
default:
data.mYUVColorSpace = gfx::YUVColorSpace::UNKNOWN;
break;
}
break;
default:
MOZ_LOG(sAVIFLog, LogLevel::Debug,
("unsupported aom_matrix_coefficients value: %u", aImage->mc));
data.mYUVColorSpace = gfx::YUVColorSpace::UNKNOWN;
break;
}
if (data.mYUVColorSpace == gfx::YUVColorSpace::UNKNOWN) {
if (!colorSpace) {
// MIAF specific: UNKNOWN color space should be treated as BT601
data.mYUVColorSpace = gfx::YUVColorSpace::BT601;
colorSpace = Some(gfx::YUVColorSpace::BT601);
}
data.mYUVColorSpace = *colorSpace;
switch (aImage->range) {
case AOM_CR_STUDIO_RANGE:

6
widget/gtk/DMABufSurface.cpp
View File

@ -794,11 +794,7 @@ already_AddRefed<DMABufSurfaceYUV> DMABufSurfaceYUV::CreateYUVSurface(
}
DMABufSurfaceYUV::DMABufSurfaceYUV()
: DMABufSurface(SURFACE_NV12),
mWidth(),
mHeight(),
mTexture(),
mColorSpace(mozilla::gfx::YUVColorSpace::UNKNOWN) {
: DMABufSurface(SURFACE_NV12), mWidth(), mHeight(), mTexture() {
for (int i = 0; i < DMABUF_BUFFER_PLANES; i++) {
mEGLImage[i] = LOCAL_EGL_NO_IMAGE;
}

5
widget/gtk/DMABufSurface.h
View File

@ -84,7 +84,7 @@ class DMABufSurface {
virtual DMABufSurfaceYUV* GetAsDMABufSurfaceYUV() { return nullptr; }
virtual mozilla::gfx::YUVColorSpace GetYUVColorSpace() {
return mozilla::gfx::YUVColorSpace::UNKNOWN;
return mozilla::gfx::YUVColorSpace::Default;
};
virtual bool IsFullRange() { return false; };
@ -301,7 +301,8 @@ class DMABufSurfaceYUV : public DMABufSurface {
int mHeight[DMABUF_BUFFER_PLANES];
EGLImageKHR mEGLImage[DMABUF_BUFFER_PLANES];
GLuint mTexture[DMABUF_BUFFER_PLANES];
mozilla::gfx::YUVColorSpace mColorSpace;
mozilla::gfx::YUVColorSpace mColorSpace =
mozilla::gfx::YUVColorSpace::Default;
};
#endif

1
widget/gtk/moz.build
View File

@ -176,3 +176,4 @@ if CONFIG["MOZ_ENABLE_DBUS"]:
CXXFLAGS += CONFIG["MOZ_DBUS_GLIB_CFLAGS"]
CXXFLAGS += ["-Wno-error=shadow"]
CXXFLAGS += ["-Werror=switch"]