| // Copyright 2021 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| module media.stable.mojom; |
| |
| import "media/mojo/mojom/media_types.mojom"; |
| import "mojo/public/mojom/base/time.mojom"; |
| import "mojo/public/mojom/base/values.mojom"; |
| import "ui/gfx/geometry/mojom/geometry.mojom"; |
| import "ui/gfx/mojom/buffer_types.mojom"; |
| import "ui/gfx/mojom/native_handle_types.mojom"; |
| |
| // Maps to |media.mojom.VideoCodec|. |
| [Stable, Extensible] |
| enum VideoCodec { |
| [Default] kUnknown = 0, |
| kH264, |
| kVC1, |
| kMPEG2, |
| kMPEG4, |
| kTheora, |
| kVP8, |
| kVP9, |
| kHEVC, |
| kDolbyVision, |
| kAV1, |
| // DO NOT ADD RANDOM VIDEO CODECS! |
| // |
| // The only acceptable time to add a new codec is if there is production code |
| // that uses said codec in the same CL. |
| }; |
| |
| // Maps to |media.mojom.VideoCodecProfile|. |
| [Stable, Extensible] |
| enum VideoCodecProfile { |
| // Keep the values in this enum unique, as they imply format (h.264 vs. VP8, |
| // for example), and keep the values for a particular format grouped |
| // together for clarity. |
| [Default] kVideoCodecProfileUnknown = -1, |
| kH264ProfileMin = 0, |
| kH264ProfileBaseline = kH264ProfileMin, |
| kH264ProfileMain = 1, |
| kH264ProfileExtended = 2, |
| kH264ProfileHigh = 3, |
| kH264ProfileHigh10 = 4, |
| kH264ProfileHigh422 = 5, |
| kH264ProfileHigh444Predictive = 6, |
| kH264ProfileScalableBaseline = 7, |
| kH264ProfileScalableHigh = 8, |
| kH264ProfileStereoHigh = 9, |
| kH264ProfileMultiviewHigh = 10, |
| kH264ProfileMax = kH264ProfileMultiviewHigh, |
| kVP8ProfileMin = 11, |
| kVP8ProfileAny = kVP8ProfileMin, |
| kVP8ProfileMax = kVP8ProfileAny, |
| kVP9ProfileMin = 12, |
| kVP9Profile0 = kVP9ProfileMin, |
| kVP9Profile1 = 13, |
| kVP9Profile2 = 14, |
| kVP9Profile3 = 15, |
| kVP9ProfileMax = kVP9Profile3, |
| kHEVCProfileMin = 16, |
| kHEVCProfileMain = kHEVCProfileMin, |
| kHEVCProfileMain10 = 17, |
| kHEVCProfileMainStillPicture = 18, |
| kHEVCProfileMax = kHEVCProfileMainStillPicture, |
| kDolbyVisionProfile0 = 19, |
| kDolbyVisionProfile4 = 20, |
| kDolbyVisionProfile5 = 21, |
| kDolbyVisionProfile7 = 22, |
| kTheoraProfileMin = 23, |
| kTheoraProfileAny = kTheoraProfileMin, |
| kTheoraProfileMax = kTheoraProfileAny, |
| kAV1ProfileMin = 24, |
| kAV1ProfileMain = kAV1ProfileMin, |
| kAV1ProfileHigh = 25, |
| kAV1ProfilePro = 26, |
| kAV1ProfileMax = kAV1ProfilePro, |
| kDolbyVisionProfile8 = 27, |
| kDolbyVisionProfile9 = 28, |
| }; |
| |
| // Based on |media.mojom.SubsampleEntry|. |
| // Next min field ID: 2 |
| [Stable] |
| struct SubsampleEntry { |
| uint32 clear_bytes@0; |
| uint32 cypher_bytes@1; |
| }; |
| |
| // Maps to |media.mojom.EncryptionScheme|. |
| [Stable, Extensible] |
| enum EncryptionScheme { |
| [Default] kUnencrypted = 0, |
| kCenc, // 'cenc' subsample encryption using AES-CTR mode. |
| kCbcs, // 'cbcs' pattern encryption using AES-CBC mode. |
| }; |
| |
| // Based on |media.mojom.DecryptConfig| but does not depend on |
| // |media.mojom.EncryptionScheme| and |media.mojom.SubsampleEntry|. |
| // Next min field ID: 5 |
| [Stable] |
| struct DecryptConfig { |
| EncryptionScheme encryption_scheme@0; |
| string key_id@1; |
| string iv@2; |
| array<SubsampleEntry> subsamples@3; |
| media.mojom.EncryptionPattern? encryption_pattern@4; |
| }; |
| |
| // Based on |gfx.mojom.ColorVolumeMetadata|. |
| // Next min field ID: 6 |
| [Stable] |
| struct ColorVolumeMetadata { |
| gfx.mojom.PointF primary_r@0; |
| gfx.mojom.PointF primary_g@1; |
| gfx.mojom.PointF primary_b@2; |
| gfx.mojom.PointF white_point@3; |
| float luminance_max@4; |
| float luminance_min@5; |
| }; |
| |
| // Based on |gfx.mojom.HDRMetadata| but does not depend on |
| // |gfx.mojom.ColorVolumeMetadata|. |
| // Next min field ID: 3 |
| [Stable] |
| struct HDRMetadata { |
| ColorVolumeMetadata color_volume_metadata@0; |
| uint32 max_content_light_level@1; |
| uint32 max_frame_average_light_level@2; |
| }; |
| |
| // Based on |media.mojom.VideoDecoderConfig| but does not depend on |
| // |media.mojom.VideoCodec|, |media.mojom.VideoCodecProfile|, |
| // |media.mojom.VideoTransformation|, |media.mojom.EncryptionScheme|, |
| // |media.mojom.VideoColorSpace| and |gfx.mojom.HDRMetadata|. |
| // Next min field ID: 11 |
| [Stable] |
| struct VideoDecoderConfig { |
| VideoCodec codec@0; |
| VideoCodecProfile profile@1; |
| uint32 level@2; |
| bool has_alpha@3; |
| gfx.mojom.Size coded_size@4; |
| gfx.mojom.Rect visible_rect@5; |
| gfx.mojom.Size natural_size@6; |
| array<uint8> extra_data@7; |
| EncryptionScheme encryption_scheme@8; |
| ColorSpace color_space_info@9; |
| HDRMetadata? hdr_metadata@10; |
| }; |
| |
| // Based on |media.mojom.SupportedVideoDecoderConfig| but does not |
| // depend on |media.mojom.VideoCodecProfile| |
| // Next min field ID: 6 |
| [Stable] |
| struct SupportedVideoDecoderConfig { |
| // Range of VideoCodecProfiles to match, inclusive. |
| VideoCodecProfile profile_min@0; |
| VideoCodecProfile profile_max@1; |
| |
| // Range of coded sizes to match, inclusive in each dimension. |
| gfx.mojom.Size coded_size_min@2; |
| gfx.mojom.Size coded_size_max@3; |
| |
| // Match configs that have encryption configured. |
| bool allow_encrypted@4; |
| |
| // Do not match configs that do not have encryption configured. |
| bool require_encrypted@5; |
| }; |
| |
| [Stable, Extensible] |
| enum StatusCode { |
| kOk, |
| kAborted, |
| [Default] kError, |
| }; |
| |
| // Based on |media.mojom.StatusData|. |
| // Next min field ID: 6 |
| [Stable] |
| struct StatusData { |
| string group@0; |
| StatusCode code@1; |
| string message@2; |
| array<mojo_base.mojom.Value> frames@3; |
| array<StatusData> causes@4; |
| mojo_base.mojom.Value data@5; |
| }; |
| |
| // Based on |media.mojom.Status|. |
| // Next min field ID: 1 |
| [Stable] |
| struct Status { |
| StatusData? internal@0; |
| }; |
| |
| // Based on |media.mojom.DecoderBuffer| but does not depend on |
| // |media.mojom.DecryptConfig|. |
| // Next min field ID: 9 |
| [Stable] |
| struct DecoderBuffer { |
| mojo_base.mojom.TimeDelta timestamp@0; |
| mojo_base.mojom.TimeDelta duration@1; |
| |
| bool is_end_of_stream@2; |
| |
| uint32 data_size@3; |
| |
| bool is_key_frame@4; |
| |
| array<uint8> side_data@5; |
| |
| DecryptConfig? decrypt_config@6; |
| |
| mojo_base.mojom.TimeDelta front_discard@7; |
| mojo_base.mojom.TimeDelta back_discard@8; |
| }; |
| |
| // Maps to |media.mojom.VideoDecoderType|. |
| [Stable, Extensible] |
| enum VideoDecoderType { |
| [Default] kUnknown, |
| kVaapi, |
| kVda, |
| kV4L2, |
| kTesting, |
| }; |
| |
| // Maps to |gfx.mojom.ColorSpacePrimaryID|. |
| [Stable, Extensible] |
| enum ColorSpacePrimaryID { |
| [Default] kInvalid, |
| kBT709, |
| kBT470M, |
| kBT470BG, |
| kSMPTE170M, |
| kSMPTE240M, |
| kFilm, |
| kBT2020, |
| kSMPTEST428_1, |
| kSMPTEST431_2, |
| kSMPTEST432_1, |
| kXYZ_D50, |
| kAdobeRGB, |
| kAppleGenericRGB, |
| kWideGamutColorSpin, |
| kCustom, |
| }; |
| |
| // Maps to |gfx.mojom.ColorSpaceTransferID|. |
| [Stable, Extensible] |
| enum ColorSpaceTransferID { |
| [Default] kInvalid, |
| kBT709, |
| kBT709Apple, |
| kGamma18, |
| kGamma22, |
| kGamma24, |
| kGamma28, |
| kSMPTE170M, |
| kSMPTE240M, |
| kLinear, |
| kLog, |
| kLogSqrt, |
| kIEC61966_2_4, |
| kBT1361_ECG, |
| kIEC61966_2_1, |
| kBT2020_10, |
| kBT2020_12, |
| kSMPTEST2084, |
| kSMPTEST428_1, |
| kARIB_STD_B67, |
| kIEC61966_2_1_HDR, |
| kLinearHDR, |
| kCustom, |
| kCustomHDR, |
| kPiecewiseHDR, |
| }; |
| |
| // Maps to |gfx.mojom.ColorSpaceMatrixID|. |
| [Stable, Extensible] |
| enum ColorSpaceMatrixID { |
| [Default] kInvalid, |
| kRGB, |
| kBT709, |
| kFCC, |
| kBT470BG, |
| kSMPTE170M, |
| kSMPTE240M, |
| kYCOCG, |
| kBT2020_NCL, |
| kBT2020_CL, |
| kYDZDX, |
| kGBR, |
| }; |
| |
| // Maps to |gfx.mojom.ColorSpaceRangeID|. |
| [Stable, Extensible] |
| enum ColorSpaceRangeID { |
| [Default] kInvalid, |
| kLimited, |
| kFull, |
| kDerived, |
| }; |
| |
| // Based on |gfx.mojom.ColorSpace| but does not depend on |
| // |gfx.mojom.ColorSpacePrimaryID|, |gfx.mojom.ColorSpaceTransferID|, |
| // |gfx.mojom.ColorSpaceMatrixID| and |gfx.mojom.ColorSpaceRangeID|. |
| // Next min field ID: 6 |
| [Stable] |
| struct ColorSpace { |
| ColorSpacePrimaryID primaries@0; |
| ColorSpaceTransferID transfer@1; |
| ColorSpaceMatrixID matrix@2; |
| ColorSpaceRangeID range@3; |
| array<float, 9> custom_primary_matrix@4; |
| array<float, 7> transfer_params@5; |
| }; |
| |
| // Maps to |media.mojom.VideoPixelFormat|. |
| [Stable, Extensible] |
| enum VideoPixelFormat { |
| [Default] kPixelFormatUnknown = 0, // Unknown or unspecified format value. |
| kPixelFormatI420 = |
| 1, // 12bpp YUV planar 1x1 Y, 2x2 UV samples, a.k.a. YU12. |
| |
| // Note: Chrome does not actually support YVU compositing, so you probably |
| // don't actually want to use this. See http://crbug.com/784627. |
| kPixelFormatYV12 = 2, // 12bpp YVU planar 1x1 Y, 2x2 VU samples. |
| |
| kPixelFormatI422 = 3, // 16bpp YUV planar 1x1 Y, 2x1 UV samples. |
| kPixelFormatI420A = 4, // 20bpp YUVA planar 1x1 Y, 2x2 UV, 1x1 A samples. |
| kPixelFormatI444 = 5, // 24bpp YUV planar, no subsampling. |
| kPixelFormatNV12 = |
| 6, // 12bpp with Y plane followed by a 2x2 interleaved UV plane. |
| kPixelFormatNV21 = |
| 7, // 12bpp with Y plane followed by a 2x2 interleaved VU plane. |
| kPixelFormatUYVY = |
| 8, // 16bpp interleaved 2x1 U, 1x1 Y, 2x1 V, 1x1 Y samples. |
| kPixelFormatYUY2 = |
| 9, // 16bpp interleaved 1x1 Y, 2x1 U, 1x1 Y, 2x1 V samples. |
| kPixelFormatARGB = 10, // 32bpp BGRA (byte-order), 1 plane. |
| kPixelFormatXRGB = 11, // 24bpp BGRX (byte-order), 1 plane. |
| kPixelFormatRGB24 = 12, // 24bpp BGR (byte-order), 1 plane. |
| |
| kPixelFormatMJPEG = 14, // MJPEG compressed. |
| |
| // The P* in the formats below designates the number of bits per pixel |
| // component. I.e. P9 is 9-bits per pixel component, P10 is 10-bits per pixel |
| // component, etc. |
| kPixelFormatYUV420P9 = 16, |
| kPixelFormatYUV420P10 = 17, |
| kPixelFormatYUV422P9 = 18, |
| kPixelFormatYUV422P10 = 19, |
| kPixelFormatYUV444P9 = 20, |
| kPixelFormatYUV444P10 = 21, |
| kPixelFormatYUV420P12 = 22, |
| kPixelFormatYUV422P12 = 23, |
| kPixelFormatYUV444P12 = 24, |
| |
| kPixelFormatY16 = 26, // single 16bpp plane. |
| |
| kPixelFormatABGR = 27, // 32bpp RGBA (byte-order), 1 plane. |
| kPixelFormatXBGR = 28, // 24bpp RGBX (byte-order), 1 plane. |
| |
| kPixelFormatP016LE = 29, // 24bpp NV12, 16 bits per channel |
| |
| kPixelFormatXR30 = |
| 30, // 32bpp BGRX, 10 bits per channel, 2 bits ignored, 1 plane |
| kPixelFormatXB30 = |
| 31, // 32bpp RGBX, 10 bits per channel, 2 bits ignored, 1 plane |
| |
| kPixelFormatBGRA = 32, // 32bpp ARGB (byte-order), 1 plane. |
| |
| kPixelFormatRGBAF16 = 33, // Half float RGBA, 1 plane. |
| }; |
| |
| // Based on |media.mojom.EosVideoFrameData|. |
| [Stable] |
| struct EosVideoFrameData { |
| }; |
| |
| // Based on |gfx.mojom.NativePixmapHandle|. |
| // Next min field ID: 2 |
| [EnableIf=supports_native_pixmap, Stable] |
| struct NativePixmapHandle { |
| array<gfx.mojom.NativePixmapPlane> planes@0; |
| uint64 modifier@1; |
| }; |
| |
| // Based on |gfx.mojom.GpuMemoryBufferHandle| but does not depend on |
| // |gfx.mojom.GpuMemoryBufferPlatformHandle|. |
| // Next min field ID: 2 |
| [Stable] |
| struct NativeGpuMemoryBufferHandle { |
| gfx.mojom.GpuMemoryBufferId id@0; |
| |
| [EnableIf=supports_native_pixmap] |
| NativePixmapHandle? platform_handle@1; |
| }; |
| |
| // Based on |media.mojom.GpuMemoryBufferVideoFrameData| but does not depend |
| // on |gfx.mojom.GpuMemoryBufferHandle| or |gpu.mojom.MailboxHolder|. |
| // Next min field ID: 1 |
| [Stable] |
| struct GpuMemoryBufferVideoFrameData { |
| NativeGpuMemoryBufferHandle gpu_memory_buffer_handle@0; |
| }; |
| |
| // Based on |media.mojom.VideoFrameMetadata| but does not depend on |
| // |media.mojom.VideoTransformation| or |media.mojom.CopyMode|. |
| // Next min field ID: 6 |
| [Stable] |
| struct VideoFrameMetadata { |
| bool allow_overlay@0; |
| |
| bool end_of_stream@1; |
| |
| bool read_lock_fences_enabled@2; |
| |
| bool protected_video@3; |
| |
| bool hw_protected@4; |
| |
| bool power_efficient@5; |
| }; |
| |
| // Based on |media.mojom.VideoFrameData| but does not depend on |
| // |media.mojom.EosVideoFrameData|, |media.mojom.SharedBufferVideoFrameData|, |
| // |media.mojom.GpuMemoryBufferVideoFrameData| or |
| // |media.mojom.MailboxVideoFrameData|. |
| [Stable] |
| union VideoFrameData { |
| EosVideoFrameData eos_data; |
| GpuMemoryBufferVideoFrameData gpu_memory_buffer_data; |
| }; |
| |
| // Based on |media.mojom.VideoFrame| but does not depend on |
| // |media.mojom.VideoPixelFormat|, |media.mojom.VideoFrameData|, |
| // |media.mojom.VideoFrameMetadata|, |gfx.mojom.ColorSpace| or |
| // or |gfx.mojom.HDRMetadata|. |
| // Next min field ID: 9 |
| [Stable] |
| struct VideoFrame { |
| // Format of the frame. |
| VideoPixelFormat format@0; |
| |
| // Width and height of the video frame, in pixels. |
| gfx.mojom.Size coded_size@1; |
| |
| // Visible size of the frame. |
| gfx.mojom.Rect visible_rect@2; |
| |
| // Natural size of the frame. |
| gfx.mojom.Size natural_size@3; |
| |
| // Timestamp in microseconds of the associated frame. |
| mojo_base.mojom.TimeDelta timestamp@4; |
| |
| // Contents of the video frame (or EOS marker). |
| VideoFrameData data@5; |
| |
| // Extra properties associated with the VideoFrame. |
| VideoFrameMetadata metadata@6; |
| |
| ColorSpace color_space@7; |
| HDRMetadata? hdr_metadata@8; |
| }; |
| |
| // Maps to |media.mojom.WaitingReason|. |
| [Stable, Extensible] |
| enum WaitingReason { |
| // The playback cannot start because "Media Data May Contain Encrypted Blocks" |
| // and no CDM is available. The playback will start after a CDM is set. See |
| // https://www.w3.org/TR/encrypted-media/#media-may-contain-encrypted-blocks |
| [Default] kNoCdm, |
| |
| // The playback cannot proceed because some decryption key is not available. |
| // This could happen when the license exchange is delayed or failed. The |
| // playback will resume after the decryption key becomes available. |
| // See https://www.w3.org/TR/encrypted-media/#encrypted-block-encountered |
| kNoDecryptionKey, |
| |
| // The playback cannot proceed because the decoder has lost its state, e.g. |
| // information about reference frames. Usually this only happens to hardware |
| // decoders. To recover from this state, reset the decoder and start decoding |
| // from a key frame, which can typically be accomplished by a pipeline seek. |
| kDecoderStateLost, |
| }; |
| |
| // Based on |media.mojom.MediaLogRecord|. |
| // Next min field ID: 4 |
| [Stable] |
| struct MediaLogRecord { |
| [Stable, Extensible] |
| enum Type { |
| // See media/base/media_log_message_levels.h for info. |
| [Default] kMessage, |
| |
| // See media/base/media_log_properties.h for info. |
| kMediaPropertyChange, |
| |
| // See media/base/media_log_events.h for info. |
| kMediaEventTriggered, |
| |
| kMediaStatus, |
| }; |
| |
| int32 id@0; |
| Type type@1; |
| mojo_base.mojom.DictionaryValue params@2; |
| mojo_base.mojom.TimeTicks time@3; |
| }; |