1 // Copyright 2013 The Chromium Authors. All rights reserved.
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/video/video_encode_accelerator.h"
6
7 #include <inttypes.h>
8
9 #include "base/callback.h"
10 #include "base/strings/stringprintf.h"
11
12 namespace media {
13
Vp8Metadata()14 Vp8Metadata::Vp8Metadata()
15 : non_reference(false), temporal_idx(0), layer_sync(false) {}
16
17 Vp9Metadata::Vp9Metadata() = default;
18 Vp9Metadata::~Vp9Metadata() = default;
19 Vp9Metadata::Vp9Metadata(const Vp9Metadata&) = default;
20
BitstreamBufferMetadata()21 BitstreamBufferMetadata::BitstreamBufferMetadata()
22 : payload_size_bytes(0), key_frame(false) {}
23 BitstreamBufferMetadata::BitstreamBufferMetadata(
24 const BitstreamBufferMetadata& other) = default;
25 BitstreamBufferMetadata& BitstreamBufferMetadata::operator=(
26 const BitstreamBufferMetadata& other) = default;
27 BitstreamBufferMetadata::BitstreamBufferMetadata(
28 BitstreamBufferMetadata&& other) = default;
BitstreamBufferMetadata(size_t payload_size_bytes,bool key_frame,base::TimeDelta timestamp)29 BitstreamBufferMetadata::BitstreamBufferMetadata(size_t payload_size_bytes,
30 bool key_frame,
31 base::TimeDelta timestamp)
32 : payload_size_bytes(payload_size_bytes),
33 key_frame(key_frame),
34 timestamp(timestamp) {}
35 BitstreamBufferMetadata::~BitstreamBufferMetadata() = default;
36
Config()37 VideoEncodeAccelerator::Config::Config()
38 : input_format(PIXEL_FORMAT_UNKNOWN),
39 output_profile(VIDEO_CODEC_PROFILE_UNKNOWN),
40 initial_bitrate(0),
41 content_type(ContentType::kCamera) {}
42
43 VideoEncodeAccelerator::Config::Config(const Config& config) = default;
44
Config(VideoPixelFormat input_format,const gfx::Size & input_visible_size,VideoCodecProfile output_profile,uint32_t initial_bitrate,base::Optional<uint32_t> initial_framerate,base::Optional<uint32_t> gop_length,base::Optional<uint8_t> h264_output_level,bool is_constrained_h264,base::Optional<StorageType> storage_type,ContentType content_type,const std::vector<SpatialLayer> & spatial_layers)45 VideoEncodeAccelerator::Config::Config(
46 VideoPixelFormat input_format,
47 const gfx::Size& input_visible_size,
48 VideoCodecProfile output_profile,
49 uint32_t initial_bitrate,
50 base::Optional<uint32_t> initial_framerate,
51 base::Optional<uint32_t> gop_length,
52 base::Optional<uint8_t> h264_output_level,
53 bool is_constrained_h264,
54 base::Optional<StorageType> storage_type,
55 ContentType content_type,
56 const std::vector<SpatialLayer>& spatial_layers)
57 : input_format(input_format),
58 input_visible_size(input_visible_size),
59 output_profile(output_profile),
60 initial_bitrate(initial_bitrate),
61 initial_framerate(initial_framerate.value_or(
62 VideoEncodeAccelerator::kDefaultFramerate)),
63 gop_length(gop_length),
64 h264_output_level(h264_output_level),
65 is_constrained_h264(is_constrained_h264),
66 storage_type(storage_type),
67 content_type(content_type),
68 spatial_layers(spatial_layers) {}
69
70 VideoEncodeAccelerator::Config::~Config() = default;
71
AsHumanReadableString() const72 std::string VideoEncodeAccelerator::Config::AsHumanReadableString() const {
73 std::string str = base::StringPrintf(
74 "input_format: %s, input_visible_size: %s, output_profile: %s, "
75 "initial_bitrate: %u",
76 VideoPixelFormatToString(input_format).c_str(),
77 input_visible_size.ToString().c_str(),
78 GetProfileName(output_profile).c_str(), initial_bitrate);
79 if (initial_framerate) {
80 str += base::StringPrintf(", initial_framerate: %u",
81 initial_framerate.value());
82 }
83 if (gop_length)
84 str += base::StringPrintf(", gop_length: %u", gop_length.value());
85
86 if (VideoCodecProfileToVideoCodec(output_profile) == kCodecH264) {
87 if (h264_output_level) {
88 str += base::StringPrintf(", h264_output_level: %u",
89 h264_output_level.value());
90 }
91
92 str += base::StringPrintf(", is_constrained_h264: %u", is_constrained_h264);
93 }
94
95 if (spatial_layers.empty())
96 return str;
97
98 for (size_t i = 0; i < spatial_layers.size(); ++i) {
99 const auto& sl = spatial_layers[i];
100 str += base::StringPrintf(
101 ", {SatialLayer#%zu: width=%" PRId32 ", height=%" PRId32
102 ", bitrate_bps=%" PRIu32 ", framerate=%" PRId32
103 ", max_qp=%u, num_of_temporal_layers=%u}",
104 i, sl.width, sl.height, sl.bitrate_bps, sl.framerate, sl.max_qp,
105 sl.num_of_temporal_layers);
106 }
107 return str;
108 }
109
HasTemporalLayer() const110 bool VideoEncodeAccelerator::Config::HasTemporalLayer() const {
111 return std::any_of(
112 spatial_layers.begin(), spatial_layers.end(),
113 [](const SpatialLayer& sl) { return sl.num_of_temporal_layers > 1u; });
114 }
115
HasSpatialLayer() const116 bool VideoEncodeAccelerator::Config::HasSpatialLayer() const {
117 return spatial_layers.size() > 1u;
118 }
119
NotifyEncoderInfoChange(const VideoEncoderInfo & info)120 void VideoEncodeAccelerator::Client::NotifyEncoderInfoChange(
121 const VideoEncoderInfo& info) {
122 // Do nothing if a client doesn't use the info.
123 }
124
125 VideoEncodeAccelerator::~VideoEncodeAccelerator() = default;
126
SupportedProfile()127 VideoEncodeAccelerator::SupportedProfile::SupportedProfile()
128 : profile(media::VIDEO_CODEC_PROFILE_UNKNOWN),
129 max_framerate_numerator(0),
130 max_framerate_denominator(0) {
131 }
132
SupportedProfile(VideoCodecProfile profile,const gfx::Size & max_resolution,uint32_t max_framerate_numerator,uint32_t max_framerate_denominator)133 VideoEncodeAccelerator::SupportedProfile::SupportedProfile(
134 VideoCodecProfile profile,
135 const gfx::Size& max_resolution,
136 uint32_t max_framerate_numerator,
137 uint32_t max_framerate_denominator)
138 : profile(profile),
139 max_resolution(max_resolution),
140 max_framerate_numerator(max_framerate_numerator),
141 max_framerate_denominator(max_framerate_denominator) {}
142
143 VideoEncodeAccelerator::SupportedProfile::~SupportedProfile() = default;
144
Flush(FlushCallback flush_callback)145 void VideoEncodeAccelerator::Flush(FlushCallback flush_callback) {
146 // TODO(owenlin): implements this https://crbug.com/755889.
147 NOTIMPLEMENTED();
148 std::move(flush_callback).Run(false);
149 }
150
IsFlushSupported()151 bool VideoEncodeAccelerator::IsFlushSupported() {
152 return false;
153 }
154
RequestEncodingParametersChange(const VideoBitrateAllocation & bitrate_allocation,uint32_t framerate)155 void VideoEncodeAccelerator::RequestEncodingParametersChange(
156 const VideoBitrateAllocation& bitrate_allocation,
157 uint32_t framerate) {
158 RequestEncodingParametersChange(bitrate_allocation.GetSumBps(), framerate);
159 }
160
operator ==(const Vp8Metadata & l,const Vp8Metadata & r)161 bool operator==(const Vp8Metadata& l, const Vp8Metadata& r) {
162 return l.non_reference == r.non_reference &&
163 l.temporal_idx == r.temporal_idx && l.layer_sync == r.layer_sync;
164 }
165
operator ==(const Vp9Metadata & l,const Vp9Metadata & r)166 bool operator==(const Vp9Metadata& l, const Vp9Metadata& r) {
167 return l.has_reference == r.has_reference &&
168 l.temporal_up_switch == r.temporal_up_switch &&
169 l.temporal_idx == r.temporal_idx && l.p_diffs == r.p_diffs;
170 }
171
operator ==(const BitstreamBufferMetadata & l,const BitstreamBufferMetadata & r)172 bool operator==(const BitstreamBufferMetadata& l,
173 const BitstreamBufferMetadata& r) {
174 return l.payload_size_bytes == r.payload_size_bytes &&
175 l.key_frame == r.key_frame && l.timestamp == r.timestamp &&
176 l.vp8 == r.vp8 && l.vp9 == r.vp9;
177 }
178
operator ==(const VideoEncodeAccelerator::Config::SpatialLayer & l,const VideoEncodeAccelerator::Config::SpatialLayer & r)179 bool operator==(const VideoEncodeAccelerator::Config::SpatialLayer& l,
180 const VideoEncodeAccelerator::Config::SpatialLayer& r) {
181 return l.width == r.width && l.height == r.height &&
182 l.bitrate_bps == r.bitrate_bps && l.framerate == r.framerate &&
183 l.max_qp == r.max_qp &&
184 l.num_of_temporal_layers == r.num_of_temporal_layers;
185 }
186
operator ==(const VideoEncodeAccelerator::Config & l,const VideoEncodeAccelerator::Config & r)187 bool operator==(const VideoEncodeAccelerator::Config& l,
188 const VideoEncodeAccelerator::Config& r) {
189 return l.input_format == r.input_format &&
190 l.input_visible_size == r.input_visible_size &&
191 l.output_profile == r.output_profile &&
192 l.initial_bitrate == r.initial_bitrate &&
193 l.initial_framerate == r.initial_framerate &&
194 l.gop_length == r.gop_length &&
195 l.h264_output_level == r.h264_output_level &&
196 l.storage_type == r.storage_type && l.content_type == r.content_type &&
197 l.spatial_layers == r.spatial_layers;
198 }
199 } // namespace media
200
201 namespace std {
202
operator ()(media::VideoEncodeAccelerator * vea) const203 void default_delete<media::VideoEncodeAccelerator>::operator()(
204 media::VideoEncodeAccelerator* vea) const {
205 vea->Destroy();
206 }
207
208 } // namespace std
209