media/mojo/mojom/video_encode_accelerator_mojom_traits_unittest.cc

   1 // Copyright 2019 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 "media/base/video_bitrate_allocation.h"
   8 #include "media/mojo/mojom/video_encode_accelerator.mojom.h"
   9 #include "media/mojo/mojom/video_encoder_info_mojom_traits.h"
  10 #include "media/video/video_encode_accelerator.h"
  11 #include "media/video/video_encoder_info.h"
  12 #include "mojo/public/cpp/test_support/test_utils.h"
  13 #include "testing/gtest/include/gtest/gtest.h"
  14
  15 namespace media {
  16
  17 TEST(VideoEncodeAcceleratorSupportedProfile, RoundTrip) {
  18   ::media::VideoEncodeAccelerator::SupportedProfile input;
  19   input.profile = VP9PROFILE_PROFILE0;
  20   input.min_resolution = gfx::Size(64, 64);
  21   input.max_resolution = gfx::Size(4096, 4096);
  22   input.max_framerate_numerator = 30;
  23   input.max_framerate_denominator = 1;
  24   input.rate_control_modes = VideoEncodeAccelerator::kConstantMode |
  25                              VideoEncodeAccelerator::kVariableMode;
  26   input.scalability_modes.push_back(::media::SVCScalabilityMode::kL1T3);
  27   input.scalability_modes.push_back(::media::SVCScalabilityMode::kL3T3Key);
  28
  29   ::media::VideoEncodeAccelerator::SupportedProfile output;
  30   ASSERT_TRUE(mojo::test::SerializeAndDeserialize<
  31               mojom::VideoEncodeAcceleratorSupportedProfile>(input, output));
  32   EXPECT_EQ(input, output);
  33 }
  34
  35 TEST(VideoEncoderInfoStructTraitTest, RoundTrip) {
  36   ::media::VideoEncoderInfo input;
  37   input.implementation_name = "FakeVideoEncodeAccelerator";
  38   // Set `frame_delay` but leave `input_capacity` empty.
  39   input.frame_delay = 3;
  40   // FPS allocation.
  41   for (size_t i = 0; i < ::media::VideoEncoderInfo::kMaxSpatialLayers; ++i)
  42     input.fps_allocation[i] = {5, 5, 10};
  43   // Resolution bitrate limits.
  44   input.resolution_bitrate_limits.push_back(::media::ResolutionBitrateLimit(
  45       gfx::Size(123, 456), 123456, 123456, 789012));
  46   input.resolution_bitrate_limits.push_back(::media::ResolutionBitrateLimit(
  47       gfx::Size(789, 1234), 1234567, 1234567, 7890123));
  48   // Other bool values.
  49   input.supports_native_handle = true;
  50   input.has_trusted_rate_controller = true;
  51   input.is_hardware_accelerated = true;
  52   input.supports_simulcast = true;
  53
  54   ::media::VideoEncoderInfo output = input;
  55   ASSERT_TRUE(mojo::test::SerializeAndDeserialize<mojom::VideoEncoderInfo>(
  56       input, output));
  57   EXPECT_EQ(input, output);
  58 }
  59
  60 TEST(VideoBitrateAllocationStructTraitTest, ConstantBitrate_RoundTrip) {
  61   ::media::VideoBitrateAllocation input_allocation;
  62   ASSERT_TRUE(input_allocation.SetBitrate(0, 0, 1000u));
  63   ASSERT_TRUE(input_allocation.SetBitrate(1, 0, 3500u));
  64   ASSERT_TRUE(input_allocation.SetBitrate(0, 1, 2000u));
  65   ASSERT_TRUE(input_allocation.SetBitrate(1, 1, 5000u));
  66   ::media::VideoBitrateAllocation output_allocation;
  67
  68   ASSERT_TRUE(
  69       mojo::test::SerializeAndDeserialize<mojom::VideoBitrateAllocation>(
  70           input_allocation, output_allocation));
  71
  72   EXPECT_EQ(input_allocation, output_allocation);
  73 }
  74
  75 TEST(VideoBitrateAllocationStructTraitTest,
  76      VariableBitrate_PeakGreaterThanSum_RoundTrip) {
  77   ::media::VideoBitrateAllocation input_allocation(Bitrate::Mode::kVariable);
  78   input_allocation.SetBitrate(0, 0, 5000u);
  79   input_allocation.SetPeakBps(654321u);
  80   ::media::VideoBitrateAllocation output_allocation;
  81
  82   ASSERT_TRUE(
  83       mojo::test::SerializeAndDeserialize<mojom::VideoBitrateAllocation>(
  84           input_allocation, output_allocation));
  85
  86   EXPECT_EQ(input_allocation, output_allocation);
  87 }
  88
  89 TEST(VideoBitrateAllocationStructTraitTest,
  90      VariableBitrate_PeakEqualsSum_RoundTrip) {
  91   ::media::VideoBitrateAllocation input_allocation(Bitrate::Mode::kVariable);
  92   input_allocation.SetBitrate(0, 0, 5000u);
  93   input_allocation.SetPeakBps(5000u);
  94   ::media::VideoBitrateAllocation output_allocation;
  95
  96   ASSERT_TRUE(
  97       mojo::test::SerializeAndDeserialize<mojom::VideoBitrateAllocation>(
  98           input_allocation, output_allocation));
  99
 100   EXPECT_EQ(input_allocation, output_allocation);
 101 }
 102
 103 TEST(VideoBitrateAllocationStructTraitTest,
 104      VariableBitrate_InvalidTooLowPeak_Fails) {
 105   mojom::VideoBitrateAllocationPtr mojom_allocation =
 106       mojom::VideoBitrateAllocation::New();
 107   std::vector<uint32_t> bitrates = {1000u, 2500u, 3000u};
 108   mojom_allocation->bitrates = bitrates;
 109   mojom::VariableBitratePeakPtr mojom_peak = mojom::VariableBitratePeak::New();
 110   mojom_peak->bps = 6499u;  // invalid: must be >=6500u
 111   mojom_allocation->variable_bitrate_peak = std::move(mojom_peak);
 112   VideoBitrateAllocation output;
 113
 114   EXPECT_FALSE(
 115       mojo::test::SerializeAndDeserialize<mojom::VideoBitrateAllocation>(
 116           mojom_allocation, output));
 117 }
 118
 119 TEST(VideoBitrateAllocationStructTraitTest,
 120      VariableBitrate_InvalidZeroPeak_Fails) {
 121   mojom::VideoBitrateAllocationPtr mojom_allocation =
 122       mojom::VideoBitrateAllocation::New();
 123   std::vector<uint32_t> bitrates = {0u};
 124   mojom_allocation->bitrates = bitrates;
 125   mojom::VariableBitratePeakPtr mojom_peak = mojom::VariableBitratePeak::New();
 126   mojom_peak->bps = 0u;
 127   mojom_allocation->variable_bitrate_peak = std::move(mojom_peak);
 128   VideoBitrateAllocation output;
 129
 130   EXPECT_FALSE(
 131       mojo::test::SerializeAndDeserialize<mojom::VideoBitrateAllocation>(
 132           mojom_allocation, output));
 133 }
 134
 135 TEST(SpatialLayerStructTraitTest, RoundTrip) {
 136   ::media::VideoEncodeAccelerator::Config::SpatialLayer input_spatial_layer;
 137   input_spatial_layer.width = 320;
 138   input_spatial_layer.width = 180;
 139   input_spatial_layer.bitrate_bps = 12345678u;
 140   input_spatial_layer.framerate = 24u;
 141   input_spatial_layer.max_qp = 30u;
 142   input_spatial_layer.num_of_temporal_layers = 3u;
 143   ::media::VideoEncodeAccelerator::Config::SpatialLayer output_spatial_layer;
 144   ASSERT_TRUE(mojo::test::SerializeAndDeserialize<mojom::SpatialLayer>(
 145       input_spatial_layer, output_spatial_layer));
 146   EXPECT_EQ(input_spatial_layer, output_spatial_layer);
 147 }
 148
 149 TEST(VideoEncodeAcceleratorConfigStructTraitTest, RoundTrip) {
 150   std::vector<::media::VideoEncodeAccelerator::Config::SpatialLayer>
 151       input_spatial_layers(3);
 152   constexpr gfx::Size kBaseSize(320, 180);
 153   constexpr uint32_t kBaseBitrateBps = 123456u;
 154   constexpr uint32_t kBaseFramerate = 24u;
 155   for (size_t i = 0; i < input_spatial_layers.size(); ++i) {
 156     input_spatial_layers[i].width =
 157         static_cast<int32_t>(kBaseSize.width() * (i + 1));
 158     input_spatial_layers[i].height =
 159         static_cast<int32_t>(kBaseSize.height() * (i + 1));
 160     input_spatial_layers[i].bitrate_bps = kBaseBitrateBps * (i + 1) / 2;
 161     input_spatial_layers[i].framerate = kBaseFramerate * 2 / (i + 1);
 162     input_spatial_layers[i].max_qp = 30 * (i + 1) / 2;
 163     input_spatial_layers[i].num_of_temporal_layers = 3 - i;
 164   }
 165   constexpr ::media::Bitrate kBitrate =
 166       ::media::Bitrate::ConstantBitrate(kBaseBitrateBps);
 167
 168   ::media::VideoEncodeAccelerator::Config input_config(
 169       ::media::PIXEL_FORMAT_NV12, kBaseSize, ::media::VP9PROFILE_PROFILE0,
 170       kBitrate, kBaseFramerate, absl::nullopt, absl::nullopt, false,
 171       ::media::VideoEncodeAccelerator::Config::StorageType::kGpuMemoryBuffer,
 172       ::media::VideoEncodeAccelerator::Config::ContentType::kCamera,
 173       input_spatial_layers, ::media::SVCInterLayerPredMode::kOnKeyPic);
 174
 175   ::media::VideoEncodeAccelerator::Config output_config{};
 176   ASSERT_TRUE(
 177       mojo::test::SerializeAndDeserialize<mojom::VideoEncodeAcceleratorConfig>(
 178           input_config, output_config));
 179   EXPECT_EQ(input_config, output_config);
 180 }
 181
 182 TEST(VideoEncodeAcceleratorConfigStructTraitTest, RoundTripVariableBitrate) {
 183   constexpr gfx::Size kBaseSize(320, 180);
 184   constexpr uint32_t kBaseBitrateBps = 123456u;
 185   constexpr uint32_t kMaximumBitrate = 999999u;
 186   const ::media::Bitrate kBitrate =
 187       ::media::Bitrate::VariableBitrate(kBaseBitrateBps, kMaximumBitrate);
 188   ::media::VideoEncodeAccelerator::Config input_config(
 189       ::media::PIXEL_FORMAT_NV12, kBaseSize, ::media::VP9PROFILE_PROFILE0,
 190       kBitrate);
 191
 192   ::media::VideoEncodeAccelerator::Config output_config{};
 193   ASSERT_TRUE(
 194       mojo::test::SerializeAndDeserialize<mojom::VideoEncodeAcceleratorConfig>(
 195           input_config, output_config));
 196   EXPECT_EQ(input_config, output_config);
 197 }
 198
 199 TEST(VariableBitrateStructTraitTest, PeakZeroBps_Rejected) {
 200   mojom::VariableBitratePtr mojom_variable_bitrate =
 201       mojom::VariableBitrate::New();
 202   mojom_variable_bitrate->target_bps = 0u;
 203   mojom_variable_bitrate->peak_bps = 0u;
 204   Bitrate output;
 205
 206   bool result = mojo::test::SerializeAndDeserialize<mojom::VariableBitrate>(
 207       mojom_variable_bitrate, output);
 208   EXPECT_FALSE(result);
 209 }
 210
 211 TEST(VariableBitrateStructTraitTest, PeakLessThanTarget_Rejected) {
 212   mojom::VariableBitratePtr mojom_variable_bitrate =
 213       mojom::VariableBitrate::New();
 214   mojom_variable_bitrate->target_bps = 6000u;
 215   mojom_variable_bitrate->peak_bps = 5999u;
 216   Bitrate output;
 217
 218   bool result = mojo::test::SerializeAndDeserialize<mojom::VariableBitrate>(
 219       mojom_variable_bitrate, output);
 220   EXPECT_FALSE(result);
 221 }
 222
 223 TEST(BitstreamBufferMetadataTraitTest, RoundTrip) {
 224   ::media::BitstreamBufferMetadata input_metadata;
 225   input_metadata.payload_size_bytes = 1234;
 226   input_metadata.key_frame = true;
 227   input_metadata.timestamp = base::Milliseconds(123456);
 228   ::media::BitstreamBufferMetadata output_metadata;
 229   ASSERT_TRUE(
 230       mojo::test::SerializeAndDeserialize<mojom::BitstreamBufferMetadata>(
 231           input_metadata, output_metadata));
 232   EXPECT_EQ(input_metadata, output_metadata);
 233
 234   H264Metadata h264;
 235   h264.temporal_idx = 1;
 236   h264.layer_sync = true;
 237   input_metadata.h264 = h264;
 238   output_metadata = ::media::BitstreamBufferMetadata();
 239   ASSERT_TRUE(
 240       mojo::test::SerializeAndDeserialize<mojom::BitstreamBufferMetadata>(
 241           input_metadata, output_metadata));
 242   EXPECT_EQ(input_metadata, output_metadata);
 243   input_metadata.h264.reset();
 244
 245   Vp8Metadata vp8;
 246   vp8.non_reference = true;
 247   vp8.temporal_idx = 1;
 248   vp8.layer_sync = false;
 249   input_metadata.vp8 = vp8;
 250   output_metadata = ::media::BitstreamBufferMetadata();
 251   ASSERT_TRUE(
 252       mojo::test::SerializeAndDeserialize<mojom::BitstreamBufferMetadata>(
 253           input_metadata, output_metadata));
 254   EXPECT_EQ(input_metadata, output_metadata);
 255   input_metadata.vp8.reset();
 256
 257   Vp9Metadata vp9;
 258   vp9.inter_pic_predicted = true;
 259   vp9.temporal_up_switch = true;
 260   vp9.referenced_by_upper_spatial_layers = true;
 261   vp9.reference_lower_spatial_layers = true;
 262   vp9.end_of_picture = true;
 263   vp9.temporal_idx = 2;
 264   vp9.spatial_idx = 0;
 265   vp9.spatial_layer_resolutions = {gfx::Size(320, 180), gfx::Size(640, 360)};
 266   vp9.p_diffs = {0, 1};
 267   input_metadata.vp9 = vp9;
 268   output_metadata = ::media::BitstreamBufferMetadata();
 269   ASSERT_TRUE(
 270       mojo::test::SerializeAndDeserialize<mojom::BitstreamBufferMetadata>(
 271           input_metadata, output_metadata));
 272   EXPECT_EQ(input_metadata, output_metadata);
 273 }
 274 }  // namespace media