media/mojo/mojom/video_encode_accelerator_mojom_traits.cc

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