media/mojo/mojom/video_encode_accelerator_mojom_traits.h

   1 // Copyright 2017 The Chromium Authors
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef MEDIA_MOJO_MOJOM_VIDEO_ENCODE_ACCELERATOR_MOJOM_TRAITS_H_
   6 #define MEDIA_MOJO_MOJOM_VIDEO_ENCODE_ACCELERATOR_MOJOM_TRAITS_H_
   7
   8 #include "base/notreached.h"
   9 #include "media/base/bitrate.h"
  10 #include "media/base/ipc/media_param_traits.h"
  11 #include "media/base/video_bitrate_allocation.h"
  12 #include "media/base/video_encoder.h"
  13 #include "media/mojo/mojom/media_types.mojom-shared.h"
  14 #include "media/mojo/mojom/video_encode_accelerator.mojom-shared.h"
  15 #include "media/video/video_encode_accelerator.h"
  16 #include "mojo/public/cpp/bindings/union_traits.h"
  17 #include "ui/gfx/geometry/mojom/geometry_mojom_traits.h"
  18
  19 namespace mojo {
  20
  21 template <>
  22 struct EnumTraits<media::mojom::VideoEncodeAcceleratorSupportedRateControlMode,
  23                   media::VideoEncodeAccelerator::SupportedRateControlMode> {
  24   static media::mojom::VideoEncodeAcceleratorSupportedRateControlMode ToMojom(
  25       media::VideoEncodeAccelerator::SupportedRateControlMode mode);
  26
  27   static bool FromMojom(
  28       media::mojom::VideoEncodeAcceleratorSupportedRateControlMode input,
  29       media::VideoEncodeAccelerator::SupportedRateControlMode* out);
  30 };
  31
  32 template <>
  33 struct StructTraits<
  34     media::mojom::VideoEncodeAcceleratorSupportedProfileDataView,
  35     media::VideoEncodeAccelerator::SupportedProfile> {
  36   static media::VideoCodecProfile profile(
  37       const media::VideoEncodeAccelerator::SupportedProfile& profile) {
  38     return profile.profile;
  39   }
  40
  41   static const gfx::Size& min_resolution(
  42       const media::VideoEncodeAccelerator::SupportedProfile& profile) {
  43     return profile.min_resolution;
  44   }
  45
  46   static const gfx::Size& max_resolution(
  47       const media::VideoEncodeAccelerator::SupportedProfile& profile) {
  48     return profile.max_resolution;
  49   }
  50
  51   static uint32_t max_framerate_numerator(
  52       const media::VideoEncodeAccelerator::SupportedProfile& profile) {
  53     return profile.max_framerate_numerator;
  54   }
  55
  56   static uint32_t max_framerate_denominator(
  57       const media::VideoEncodeAccelerator::SupportedProfile& profile) {
  58     return profile.max_framerate_denominator;
  59   }
  60
  61   static std::vector<media::VideoEncodeAccelerator::SupportedRateControlMode>
  62   rate_control_modes(
  63       const media::VideoEncodeAccelerator::SupportedProfile& profile) {
  64     std::vector<media::VideoEncodeAccelerator::SupportedRateControlMode> modes;
  65     if (profile.rate_control_modes &
  66         media::VideoEncodeAccelerator::kConstantMode) {
  67       modes.push_back(media::VideoEncodeAccelerator::kConstantMode);
  68     }
  69     if (profile.rate_control_modes &
  70         media::VideoEncodeAccelerator::kVariableMode) {
  71       modes.push_back(media::VideoEncodeAccelerator::kVariableMode);
  72     }
  73     if (profile.rate_control_modes &
  74         media::VideoEncodeAccelerator::kExternalMode) {
  75       modes.push_back(media::VideoEncodeAccelerator::kExternalMode);
  76     }
  77     return modes;
  78   }
  79
  80   static const std::vector<media::SVCScalabilityMode>& scalability_modes(
  81       const media::VideoEncodeAccelerator::SupportedProfile& profile) {
  82     return profile.scalability_modes;
  83   }
  84
  85   static bool is_software_codec(
  86       const media::VideoEncodeAccelerator::SupportedProfile& profile) {
  87     return profile.is_software_codec;
  88   }
  89
  90   static bool Read(
  91       media::mojom::VideoEncodeAcceleratorSupportedProfileDataView data,
  92       media::VideoEncodeAccelerator::SupportedProfile* out);
  93 };
  94
  95 template <>
  96 class StructTraits<media::mojom::VariableBitratePeakDataView, uint32_t> {
  97  public:
  98   static constexpr uint32_t bps(const uint32_t peak_bps) { return peak_bps; }
  99
 100   static bool Read(media::mojom::VariableBitratePeakDataView data,
 101                    uint32_t* out_peak_bps);
 102 };
 103
 104 template <>
 105 class StructTraits<media::mojom::VideoBitrateAllocationDataView,
 106                    media::VideoBitrateAllocation> {
 107  public:
 108   static std::vector<uint32_t> bitrates(
 109       const media::VideoBitrateAllocation& bitrate_allocation);
 110
 111   static absl::optional<uint32_t> variable_bitrate_peak(
 112       const media::VideoBitrateAllocation& bitrate_allocation) {
 113     if (bitrate_allocation.GetMode() == media::Bitrate::Mode::kConstant) {
 114       return absl::nullopt;
 115     } else {
 116       return absl::optional<uint32_t>(
 117           bitrate_allocation.GetSumBitrate().peak_bps());
 118     }
 119   }
 120
 121   static bool Read(media::mojom::VideoBitrateAllocationDataView data,
 122                    media::VideoBitrateAllocation* out_bitrate_allocation);
 123 };
 124
 125 template <>
 126 class StructTraits<media::mojom::VideoEncodeOptionsDataView,
 127                    media::VideoEncoder::EncodeOptions> {
 128  public:
 129   static bool force_keyframe(
 130       const media::VideoEncoder::EncodeOptions& options) {
 131     return options.key_frame;
 132   }
 133
 134   static int32_t quantizer(const media::VideoEncoder::EncodeOptions& options) {
 135     return options.quantizer.value_or(-1);
 136   }
 137
 138   static bool Read(media::mojom::VideoEncodeOptionsDataView data,
 139                    media::VideoEncoder::EncodeOptions* out_options);
 140 };
 141
 142 template <>
 143 struct UnionTraits<media::mojom::CodecMetadataDataView,
 144                    media::BitstreamBufferMetadata> {
 145   static media::mojom::CodecMetadataDataView::Tag GetTag(
 146       const media::BitstreamBufferMetadata& metadata) {
 147     if (metadata.h264) {
 148       return media::mojom::CodecMetadataDataView::Tag::kH264;
 149     } else if (metadata.vp8) {
 150       return media::mojom::CodecMetadataDataView::Tag::kVp8;
 151     } else if (metadata.vp9) {
 152       return media::mojom::CodecMetadataDataView::Tag::kVp9;
 153     } else if (metadata.av1) {
 154       return media::mojom::CodecMetadataDataView::Tag::kAv1;
 155     } else if (metadata.h265) {
 156       return media::mojom::CodecMetadataDataView::Tag::kH265;
 157     }
 158     NOTREACHED_NORETURN();
 159   }
 160
 161   static bool IsNull(const media::BitstreamBufferMetadata& metadata) {
 162     return !metadata.h264 && !metadata.vp8 && !metadata.vp9 && !metadata.av1 &&
 163            !metadata.h265;
 164   }
 165
 166   static void SetToNull(media::BitstreamBufferMetadata* metadata) {
 167     metadata->h264.reset();
 168     metadata->vp8.reset();
 169     metadata->vp9.reset();
 170     metadata->av1.reset();
 171     metadata->h265.reset();
 172   }
 173
 174   static const media::H264Metadata& h264(
 175       const media::BitstreamBufferMetadata& metadata) {
 176     return *metadata.h264;
 177   }
 178
 179   static const media::Vp8Metadata& vp8(
 180       const media::BitstreamBufferMetadata& metadata) {
 181     return *metadata.vp8;
 182   }
 183
 184   static const media::Vp9Metadata& vp9(
 185       const media::BitstreamBufferMetadata& metadata) {
 186     return *metadata.vp9;
 187   }
 188
 189   static const media::Av1Metadata& av1(
 190       const media::BitstreamBufferMetadata& metadata) {
 191     return *metadata.av1;
 192   }
 193
 194   static const media::H265Metadata& h265(
 195       const media::BitstreamBufferMetadata& metadata) {
 196     return *metadata.h265;
 197   }
 198
 199   static bool Read(media::mojom::CodecMetadataDataView data,
 200                    media::BitstreamBufferMetadata* metadata);
 201 };
 202
 203 template <>
 204 class StructTraits<media::mojom::BitstreamBufferMetadataDataView,
 205                    media::BitstreamBufferMetadata> {
 206  public:
 207   static size_t payload_size_bytes(const media::BitstreamBufferMetadata& bbm) {
 208     return bbm.payload_size_bytes;
 209   }
 210   static bool key_frame(const media::BitstreamBufferMetadata& bbm) {
 211     return bbm.key_frame;
 212   }
 213   static base::TimeDelta timestamp(const media::BitstreamBufferMetadata& bbm) {
 214     return bbm.timestamp;
 215   }
 216   static int32_t qp(const media::BitstreamBufferMetadata& bbm) {
 217     return bbm.qp;
 218   }
 219   static const media::BitstreamBufferMetadata& codec_metadata(
 220       const media::BitstreamBufferMetadata& bbm) {
 221     return bbm;
 222   }
 223   static absl::optional<gfx::Size> encoded_size(
 224       const media::BitstreamBufferMetadata& bbm) {
 225     return bbm.encoded_size;
 226   }
 227   static absl::optional<gfx::ColorSpace> encoded_color_space(
 228       const media::BitstreamBufferMetadata& bbm) {
 229     return bbm.encoded_color_space;
 230   }
 231
 232   static bool Read(media::mojom::BitstreamBufferMetadataDataView data,
 233                    media::BitstreamBufferMetadata* out_metadata);
 234 };
 235
 236 template <>
 237 class StructTraits<media::mojom::H264MetadataDataView, media::H264Metadata> {
 238  public:
 239   static uint8_t temporal_idx(const media::H264Metadata& h264) {
 240     return h264.temporal_idx;
 241   }
 242
 243   static bool layer_sync(const media::H264Metadata& h264) {
 244     return h264.layer_sync;
 245   }
 246
 247   static bool Read(media::mojom::H264MetadataDataView data,
 248                    media::H264Metadata* out_metadata);
 249 };
 250
 251 template <>
 252 class StructTraits<media::mojom::H265MetadataDataView, media::H265Metadata> {
 253  public:
 254   static uint8_t temporal_idx(const media::H265Metadata& h265) {
 255     return h265.temporal_idx;
 256   }
 257
 258   static bool Read(media::mojom::H265MetadataDataView data,
 259                    media::H265Metadata* out_metadata);
 260 };
 261
 262 template <>
 263 class StructTraits<media::mojom::Vp8MetadataDataView, media::Vp8Metadata> {
 264  public:
 265   static bool non_reference(const media::Vp8Metadata& vp8) {
 266     return vp8.non_reference;
 267   }
 268
 269   static uint8_t temporal_idx(const media::Vp8Metadata& vp8) {
 270     return vp8.temporal_idx;
 271   }
 272
 273   static bool layer_sync(const media::Vp8Metadata& vp8) {
 274     return vp8.layer_sync;
 275   }
 276
 277   static bool Read(media::mojom::Vp8MetadataDataView data,
 278                    media::Vp8Metadata* out_metadata);
 279 };
 280
 281 template <>
 282 class StructTraits<media::mojom::Vp9MetadataDataView, media::Vp9Metadata> {
 283  public:
 284   static bool inter_pic_predicted(const media::Vp9Metadata& vp9) {
 285     return vp9.inter_pic_predicted;
 286   }
 287   static bool temporal_up_switch(const media::Vp9Metadata& vp9) {
 288     return vp9.temporal_up_switch;
 289   }
 290   static bool referenced_by_upper_spatial_layers(
 291       const media::Vp9Metadata& vp9) {
 292     return vp9.referenced_by_upper_spatial_layers;
 293   }
 294   static bool reference_lower_spatial_layers(const media::Vp9Metadata& vp9) {
 295     return vp9.reference_lower_spatial_layers;
 296   }
 297   static bool end_of_picture(const media::Vp9Metadata& vp9) {
 298     return vp9.end_of_picture;
 299   }
 300   static uint8_t temporal_idx(const media::Vp9Metadata& vp9) {
 301     return vp9.temporal_idx;
 302   }
 303   static uint8_t spatial_idx(const media::Vp9Metadata& vp9) {
 304     return vp9.spatial_idx;
 305   }
 306   static const std::vector<gfx::Size>& spatial_layer_resolutions(
 307       const media::Vp9Metadata& vp9) {
 308     return vp9.spatial_layer_resolutions;
 309   }
 310   static uint8_t begin_active_spatial_layer_index(
 311       const media::Vp9Metadata& vp9) {
 312     return vp9.begin_active_spatial_layer_index;
 313   }
 314   static uint8_t end_active_spatial_layer_index(const media::Vp9Metadata& vp9) {
 315     return vp9.end_active_spatial_layer_index;
 316   }
 317   static const std::vector<uint8_t>& p_diffs(const media::Vp9Metadata& vp9) {
 318     return vp9.p_diffs;
 319   }
 320
 321   static bool Read(media::mojom::Vp9MetadataDataView data,
 322                    media::Vp9Metadata* out_metadata);
 323 };
 324
 325 template <>
 326 class StructTraits<media::mojom::Av1MetadataDataView, media::Av1Metadata> {
 327  public:
 328   static uint8_t temporal_idx(const media::Av1Metadata& av1) {
 329     return av1.temporal_idx;
 330   }
 331
 332   static bool Read(media::mojom::Av1MetadataDataView data,
 333                    media::Av1Metadata* out_metadata);
 334 };
 335
 336 template <>
 337 struct EnumTraits<media::mojom::VideoEncodeAcceleratorConfig_StorageType,
 338                   media::VideoEncodeAccelerator::Config::StorageType> {
 339   static media::mojom::VideoEncodeAcceleratorConfig_StorageType ToMojom(
 340       media::VideoEncodeAccelerator::Config::StorageType input);
 341
 342   static bool FromMojom(
 343       media::mojom::VideoEncodeAcceleratorConfig_StorageType,
 344       media::VideoEncodeAccelerator::Config::StorageType* output);
 345 };
 346
 347 template <>
 348 struct EnumTraits<media::mojom::VideoEncodeAcceleratorConfig_EncoderType,
 349                   media::VideoEncodeAccelerator::Config::EncoderType> {
 350   static media::mojom::VideoEncodeAcceleratorConfig_EncoderType ToMojom(
 351       media::VideoEncodeAccelerator::Config::EncoderType input);
 352
 353   static bool FromMojom(
 354       media::mojom::VideoEncodeAcceleratorConfig_EncoderType,
 355       media::VideoEncodeAccelerator::Config::EncoderType* output);
 356 };
 357
 358 template <>
 359 struct EnumTraits<media::mojom::VideoEncodeAcceleratorConfig_ContentType,
 360                   media::VideoEncodeAccelerator::Config::ContentType> {
 361   static media::mojom::VideoEncodeAcceleratorConfig_ContentType ToMojom(
 362       media::VideoEncodeAccelerator::Config::ContentType input);
 363
 364   static bool FromMojom(
 365       media::mojom::VideoEncodeAcceleratorConfig_ContentType,
 366       media::VideoEncodeAccelerator::Config::ContentType* output);
 367 };
 368
 369 template <>
 370 struct StructTraits<media::mojom::SpatialLayerDataView,
 371                     media::VideoEncodeAccelerator::Config::SpatialLayer> {
 372   static int32_t width(
 373       const media::VideoEncodeAccelerator::Config::SpatialLayer& input) {
 374     return input.width;
 375   }
 376
 377   static int32_t height(
 378       const media::VideoEncodeAccelerator::Config::SpatialLayer& input) {
 379     return input.height;
 380   }
 381
 382   static uint32_t bitrate_bps(
 383       const media::VideoEncodeAccelerator::Config::SpatialLayer& input) {
 384     return input.bitrate_bps;
 385   }
 386
 387   static uint32_t framerate(
 388       const media::VideoEncodeAccelerator::Config::SpatialLayer& input) {
 389     return input.framerate;
 390   }
 391
 392   static uint8_t max_qp(
 393       const media::VideoEncodeAccelerator::Config::SpatialLayer& input) {
 394     return input.max_qp;
 395   }
 396
 397   static uint8_t num_of_temporal_layers(
 398       const media::VideoEncodeAccelerator::Config::SpatialLayer& input) {
 399     return input.num_of_temporal_layers;
 400   }
 401
 402   static bool Read(media::mojom::SpatialLayerDataView input,
 403                    media::VideoEncodeAccelerator::Config::SpatialLayer* output);
 404 };
 405
 406 template <>
 407 struct StructTraits<media::mojom::ConstantBitrateDataView, media::Bitrate> {
 408   static uint32_t target_bps(const media::Bitrate& input) {
 409     return input.target_bps();
 410   }
 411
 412   static bool Read(media::mojom::ConstantBitrateDataView input,
 413                    media::Bitrate* output);
 414 };
 415
 416 template <>
 417 struct StructTraits<media::mojom::VariableBitrateDataView, media::Bitrate> {
 418   static uint32_t target_bps(const media::Bitrate& input) {
 419     return input.target_bps();
 420   }
 421   static uint32_t peak_bps(const media::Bitrate& input) {
 422     return input.peak_bps();
 423   }
 424   static bool Read(media::mojom::VariableBitrateDataView input,
 425                    media::Bitrate* output);
 426 };
 427
 428 template <>
 429 struct StructTraits<media::mojom::ExternalBitrateDataView, media::Bitrate> {
 430   static bool Read(media::mojom::ExternalBitrateDataView input,
 431                    media::Bitrate* output);
 432 };
 433
 434 template <>
 435 struct UnionTraits<media::mojom::BitrateDataView, media::Bitrate> {
 436   static media::mojom::BitrateDataView::Tag GetTag(const media::Bitrate& input);
 437   static media::Bitrate constant(const media::Bitrate& input) { return input; }
 438   static media::Bitrate variable(const media::Bitrate& input) { return input; }
 439   static media::Bitrate external(const media::Bitrate& input) { return input; }
 440   static bool Read(media::mojom::BitrateDataView input, media::Bitrate* output);
 441 };
 442
 443 template <>
 444 struct StructTraits<media::mojom::VideoEncodeAcceleratorConfigDataView,
 445                     media::VideoEncodeAccelerator::Config> {
 446   static media::VideoPixelFormat input_format(
 447       const media::VideoEncodeAccelerator::Config& input) {
 448     return input.input_format;
 449   }
 450
 451   static const gfx::Size& input_visible_size(
 452       const media::VideoEncodeAccelerator::Config& input) {
 453     return input.input_visible_size;
 454   }
 455
 456   static media::VideoCodecProfile output_profile(
 457       const media::VideoEncodeAccelerator::Config& input) {
 458     return input.output_profile;
 459   }
 460
 461   static const media::Bitrate& bitrate(
 462       const media::VideoEncodeAccelerator::Config& input) {
 463     return input.bitrate;
 464   }
 465
 466   static uint32_t initial_framerate(
 467       const media::VideoEncodeAccelerator::Config& input) {
 468     return input.initial_framerate.value_or(0);
 469   }
 470
 471   static bool has_initial_framerate(
 472       const media::VideoEncodeAccelerator::Config& input) {
 473     return input.initial_framerate.has_value();
 474   }
 475
 476   static uint32_t gop_length(
 477       const media::VideoEncodeAccelerator::Config& input) {
 478     return input.gop_length.value_or(0);
 479   }
 480
 481   static bool has_gop_length(
 482       const media::VideoEncodeAccelerator::Config& input) {
 483     return input.gop_length.has_value();
 484   }
 485
 486   static uint8_t h264_output_level(
 487       const media::VideoEncodeAccelerator::Config& input) {
 488     return input.h264_output_level.value_or(0);
 489   }
 490
 491   static bool has_h264_output_level(
 492       const media::VideoEncodeAccelerator::Config& input) {
 493     return input.h264_output_level.has_value();
 494   }
 495
 496   static bool is_constrained_h264(
 497       const media::VideoEncodeAccelerator::Config& input) {
 498     return input.is_constrained_h264;
 499   }
 500
 501   static media::VideoEncodeAccelerator::Config::StorageType storage_type(
 502       const media::VideoEncodeAccelerator::Config& input) {
 503     return input.storage_type.value_or(
 504         media::VideoEncodeAccelerator::Config::StorageType::kShmem);
 505   }
 506
 507   static bool has_storage_type(
 508       const media::VideoEncodeAccelerator::Config& input) {
 509     return input.storage_type.has_value();
 510   }
 511
 512   static media::VideoEncodeAccelerator::Config::ContentType content_type(
 513       const media::VideoEncodeAccelerator::Config& input) {
 514     return input.content_type;
 515   }
 516
 517   static const std::vector<media::VideoEncodeAccelerator::Config::SpatialLayer>&
 518   spatial_layers(const media::VideoEncodeAccelerator::Config& input) {
 519     return input.spatial_layers;
 520   }
 521
 522   static media::SVCInterLayerPredMode inter_layer_pred(
 523       const media::VideoEncodeAccelerator::Config& input) {
 524     return input.inter_layer_pred;
 525   }
 526
 527   static bool require_low_delay(
 528       const media::VideoEncodeAccelerator::Config& input) {
 529     return input.require_low_delay;
 530   }
 531
 532   static media::VideoEncodeAccelerator::Config::EncoderType
 533   required_encoder_type(const media::VideoEncodeAccelerator::Config& input) {
 534     return input.required_encoder_type;
 535   }
 536
 537   static bool Read(media::mojom::VideoEncodeAcceleratorConfigDataView input,
 538                    media::VideoEncodeAccelerator::Config* output);
 539 };
 540
 541 }  // namespace mojo
 542
 543 #endif  // MEDIA_MOJO_MOJOM_VIDEO_ENCODE_ACCELERATOR_MOJOM_TRAITS_H_