[go: nahoru, domu]
Google Git
Sign in
chromium / chromium / src / c4d7584a8aee9429af9ee8843f23785110f12713 / . / media / gpu / vp9_decoder.cc
blob: 1e5bb2b3b9817b77263416823ab718d60c215b7e [file] [log] [blame]
Avi Drissmand387f0922022-09-14 20:51:31[diff] [blame]1// Copyright 2015 The Chromium Authors
posciakd94b2b082015-09-18 04:03:40[diff] [blame]2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
markdittmer6e70beb82016-05-02 05:40:47[diff] [blame]5#include "media/gpu/vp9_decoder.h"
mostynb6682b1c42016-04-19 10:17:30[diff] [blame]6
7#include <memory>
8
Hirokazu Honda10df95d2019-07-19 19:31:43[diff] [blame]9#include "base/feature_list.h"
Avi Drissmand70f89a2023-01-11 23:52:55[diff] [blame]10#include "base/functional/bind.h"
mostynb6682b1c42016-04-19 10:17:30[diff] [blame]11#include "base/logging.h"
Qiu Jianlin2153ac02022-08-18 04:13:15[diff] [blame]12#include "base/metrics/histogram_functions.h"
Hirokazu Honda967b9192019-08-27 00:59:42[diff] [blame]13#include "build/build_config.h"
Yuta Hijikata29f67812020-10-24 01:15:44[diff] [blame]14#include "build/chromeos_buildflags.h"
posciakd94b2b082015-09-18 04:03:40[diff] [blame]15#include "media/base/limits.h"
Hirokazu Honda10df95d2019-07-19 19:31:43[diff] [blame]16#include "media/base/media_switches.h"
markdittmer6e70beb82016-05-02 05:40:47[diff] [blame]17#include "media/gpu/vp9_decoder.h"
posciakd94b2b082015-09-18 04:03:40[diff] [blame]18
markdittmer6e70beb82016-05-02 05:40:47[diff] [blame]19namespace media {
posciakd94b2b082015-09-18 04:03:40[diff] [blame]20
Hirokazu Honda10df95d2019-07-19 19:31:43[diff] [blame]21namespace {
Hirokazu Hondafb2681c2021-10-29 03:53:59[diff] [blame]22bool GetSpatialLayerFrameSize(const DecoderBuffer& decoder_buffer,
23 std::vector<uint32_t>& frame_sizes) {
24 frame_sizes.clear();
25
Hirokazu Honda10df95d2019-07-19 19:31:43[diff] [blame]26 const uint32_t* cue_data =
27 reinterpret_cast<const uint32_t*>(decoder_buffer.side_data());
Hirokazu Hondafb2681c2021-10-29 03:53:59[diff] [blame]28 if (!cue_data)
29 return true;
30
Hirokazu Hondabbf7f402022-04-04 08:13:49[diff] [blame]31 bool enable_vp9_ksvc =
Shuhai Pengfe10fd02021-11-11 03:20:59[diff] [blame]32// On windows, currently only d3d11 supports decoding VP9 kSVC stream, we
33// shouldn't combine the switch kD3D11Vp9kSVCHWDecoding to kVp9kSVCHWDecoding
34// due to we want keep returning false to MediaCapability.
Xiaohan Wangd4983e82022-01-15 06:19:37[diff] [blame]35#if BUILDFLAG(IS_WIN)
Hirokazu Hondabbf7f402022-04-04 08:13:49[diff] [blame]36 base::FeatureList::IsEnabled(media::kD3D11Vp9kSVCHWDecoding);
Xiaohan Wangc33487932022-04-22 23:37:21[diff] [blame]37#elif BUILDFLAG(IS_CHROMEOS) && defined(ARCH_CPU_ARM_FAMILY)
Hirokazu Hondabbf7f402022-04-04 08:13:49[diff] [blame]38 // V4L2 stateless API decoder is not capable of decoding VP9 k-SVC stream.
39 false;
Shuhai Pengfe10fd02021-11-11 03:20:59[diff] [blame]40#else
Hirokazu Hondabbf7f402022-04-04 08:13:49[diff] [blame]41 base::FeatureList::IsEnabled(media::kVp9kSVCHWDecoding);
42#endif
43
44 if (!enable_vp9_ksvc) {
Hirokazu Hondafb2681c2021-10-29 03:53:59[diff] [blame]45 DLOG(ERROR) << "Vp9 k-SVC hardware decoding is disabled";
46 return false;
Hirokazu Honda10df95d2019-07-19 19:31:43[diff] [blame]47 }
48
49 size_t num_of_layers = decoder_buffer.side_data_size() / sizeof(uint32_t);
50 if (num_of_layers > 3u) {
51 DLOG(WARNING) << "The maximum number of spatial layers in VP9 is three";
Hirokazu Hondafb2681c2021-10-29 03:53:59[diff] [blame]52 return false;
Hirokazu Honda10df95d2019-07-19 19:31:43[diff] [blame]53 }
Hirokazu Hondafb2681c2021-10-29 03:53:59[diff] [blame]54
55 frame_sizes = std::vector<uint32_t>(cue_data, cue_data + num_of_layers);
56 return true;
Hirokazu Honda10df95d2019-07-19 19:31:43[diff] [blame]57}
Hirokazu Honda7ec32652019-11-22 09:40:21[diff] [blame]58
59VideoCodecProfile VP9ProfileToVideoCodecProfile(uint8_t profile) {
60 switch (profile) {
61 case 0:
62 return VP9PROFILE_PROFILE0;
63 case 1:
64 return VP9PROFILE_PROFILE1;
65 case 2:
66 return VP9PROFILE_PROFILE2;
67 case 3:
68 return VP9PROFILE_PROFILE3;
69 default:
70 return VIDEO_CODEC_PROFILE_UNKNOWN;
71 }
72}
73
Hirokazu Honda963303782020-12-03 05:57:04[diff] [blame]74bool IsValidBitDepth(uint8_t bit_depth, VideoCodecProfile profile) {
75 // Spec 7.2.
76 switch (profile) {
77 case VP9PROFILE_PROFILE0:
78 case VP9PROFILE_PROFILE1:
79 return bit_depth == 8u;
80 case VP9PROFILE_PROFILE2:
81 case VP9PROFILE_PROFILE3:
82 return bit_depth == 10u || bit_depth == 12u;
83 default:
84 NOTREACHED();
85 return false;
86 }
87}
Hirokazu Honda790d98e2020-12-04 03:41:48[diff] [blame]88
Qiu Jianlin2153ac02022-08-18 04:13:15[diff] [blame]89VideoChromaSampling GetVP9ChromaSampling(const Vp9FrameHeader& frame_header) {
90 // Spec section 7.2.2
91 uint8_t subsampling_x = frame_header.subsampling_x;
92 uint8_t subsampling_y = frame_header.subsampling_y;
93 if (subsampling_x == 0 && subsampling_y == 0) {
94 return VideoChromaSampling::k444;
95 } else if (subsampling_x == 1u && subsampling_y == 0u) {
96 return VideoChromaSampling::k422;
97 } else if (subsampling_x == 1u && subsampling_y == 1u) {
98 return VideoChromaSampling::k420;
99 } else {
100 DLOG(WARNING) << "Unknown chroma sampling format.";
101 return VideoChromaSampling::kUnknown;
102 }
Hirokazu Honda790d98e2020-12-04 03:41:48[diff] [blame]103}
Hirokazu Honda10df95d2019-07-19 19:31:43[diff] [blame]104} // namespace
105
posciakd94b2b082015-09-18 04:03:40[diff] [blame]106VP9Decoder::VP9Accelerator::VP9Accelerator() {}
107
108VP9Decoder::VP9Accelerator::~VP9Accelerator() {}
109
Miguel Casas71b9dc42022-03-05 02:45:41[diff] [blame]110bool VP9Decoder::VP9Accelerator::SupportsContextProbabilityReadback() const {
111 return false;
112}
113
Fredrik Hubinette3cebc622018-10-27 01:01:12[diff] [blame]114VP9Decoder::VP9Decoder(std::unique_ptr<VP9Accelerator> accelerator,
Hirokazu Honda7ec32652019-11-22 09:40:21[diff] [blame]115 VideoCodecProfile profile,
Drew Davenporteb9cb952023-01-31 00:29:39[diff] [blame]116 const VideoColorSpace& container_color_space)
posciak77118c92016-08-28 13:18:39[diff] [blame]117 : state_(kNeedStreamMetadata),
Fredrik Hubinette3cebc622018-10-27 01:01:12[diff] [blame]118 container_color_space_(container_color_space),
Hirokazu Honda7ec32652019-11-22 09:40:21[diff] [blame]119 // TODO(hiroh): Set profile to UNKNOWN.
120 profile_(profile),
Miguel Casas2d5ecad82018-02-22 19:03:05[diff] [blame]121 accelerator_(std::move(accelerator)),
Miguel Casas4eab0212022-03-13 17:32:52[diff] [blame]122 parser_(accelerator_->NeedsCompressedHeaderParsed(),
Miguel Casas71b9dc42022-03-05 02:45:41[diff] [blame]123 accelerator_->SupportsContextProbabilityReadback()) {}
posciakd94b2b082015-09-18 04:03:40[diff] [blame]124
Miguel Casas2d5ecad82018-02-22 19:03:05[diff] [blame]125VP9Decoder::~VP9Decoder() = default;
posciakd94b2b082015-09-18 04:03:40[diff] [blame]126
Hirokazu Honda23132c32019-07-09 14:31:20[diff] [blame]127void VP9Decoder::SetStream(int32_t id, const DecoderBuffer& decoder_buffer) {
128 const uint8_t* ptr = decoder_buffer.data();
129 const size_t size = decoder_buffer.data_size();
130 const DecryptConfig* decrypt_config = decoder_buffer.decrypt_config();
131
posciakd94b2b082015-09-18 04:03:40[diff] [blame]132 DCHECK(ptr);
133 DCHECK(size);
Pawel Osciakec6e21b2018-03-19 09:13:06[diff] [blame]134 DVLOG(4) << "New input stream id: " << id << " at: " << (void*)ptr
135 << " size: " << size;
136 stream_id_ = id;
Hirokazu Hondafb2681c2021-10-29 03:53:59[diff] [blame]137 std::vector<uint32_t> frame_sizes;
138 if (!GetSpatialLayerFrameSize(decoder_buffer, frame_sizes)) {
139 SetError();
140 return;
Ted Meyer0b35c5fd2018-11-27 22:29:29[diff] [blame]141 }
Hirokazu Hondafb2681c2021-10-29 03:53:59[diff] [blame]142
143 parser_.SetStream(ptr, size, frame_sizes,
144 decrypt_config ? decrypt_config->Clone() : nullptr);
posciakd94b2b082015-09-18 04:03:40[diff] [blame]145}
146
147bool VP9Decoder::Flush() {
148 DVLOG(2) << "Decoder flush";
149 Reset();
150 return true;
151}
152
153void VP9Decoder::Reset() {
154 curr_frame_hdr_ = nullptr;
Jeffrey Kardatzke48ebdb692021-01-11 22:05:02[diff] [blame]155 decrypt_config_.reset();
Jeffrey Kardatzke5e36baf2020-11-20 22:17:13[diff] [blame]156 pending_pic_.reset();
Sreerenj Balachandran1beb5482019-04-03 03:40:05[diff] [blame]157
158 ref_frames_.Clear();
posciakd94b2b082015-09-18 04:03:40[diff] [blame]159
160 parser_.Reset();
161
Jose Lopes24d1cda82020-02-21 13:22:36[diff] [blame]162 if (state_ == kDecoding) {
posciakd94b2b082015-09-18 04:03:40[diff] [blame]163 state_ = kAfterReset;
Jose Lopes24d1cda82020-02-21 13:22:36[diff] [blame]164 }
posciakd94b2b082015-09-18 04:03:40[diff] [blame]165}
166
167VP9Decoder::DecodeResult VP9Decoder::Decode() {
Jeffrey Kardatzke5e36baf2020-11-20 22:17:13[diff] [blame]168 while (true) {
Hirokazu Hondafb2681c2021-10-29 03:53:59[diff] [blame]169 if (state_ == kError)
170 return kDecodeError;
171
Jeffrey Kardatzke5e36baf2020-11-20 22:17:13[diff] [blame]172 // If we have a pending picture to decode, try that first.
173 if (pending_pic_) {
Jeffrey Kardatzke4ed4e332020-12-05 00:32:15[diff] [blame]174 VP9Accelerator::Status status =
175 DecodeAndOutputPicture(std::move(pending_pic_));
Jeffrey Kardatzke5e36baf2020-11-20 22:17:13[diff] [blame]176 if (status == VP9Accelerator::Status::kFail) {
Jeffrey Kardatzke5e36baf2020-11-20 22:17:13[diff] [blame]177 SetError();
178 return kDecodeError;
179 }
180 if (status == VP9Accelerator::Status::kTryAgain)
181 return kTryAgain;
Jeffrey Kardatzke5e36baf2020-11-20 22:17:13[diff] [blame]182 }
183
posciakd94b2b082015-09-18 04:03:40[diff] [blame]184 // Read a new frame header if one is not awaiting decoding already.
185 if (!curr_frame_hdr_) {
Hirokazu Honda10df95d2019-07-19 19:31:43[diff] [blame]186 gfx::Size allocate_size;
xhwang60f96672016-06-14 21:47:53[diff] [blame]187 std::unique_ptr<Vp9FrameHeader> hdr(new Vp9FrameHeader());
Ted Meyer0b35c5fd2018-11-27 22:29:29[diff] [blame]188 Vp9Parser::Result res =
Jeffrey Kardatzke48ebdb692021-01-11 22:05:02[diff] [blame]189 parser_.ParseNextFrame(hdr.get(), &allocate_size, &decrypt_config_);
posciakd94b2b082015-09-18 04:03:40[diff] [blame]190 switch (res) {
xhwang60f96672016-06-14 21:47:53[diff] [blame]191 case Vp9Parser::kOk:
brusi_roy8e7155962016-09-14 18:22:58[diff] [blame]192 curr_frame_hdr_ = std::move(hdr);
Hirokazu Honda10df95d2019-07-19 19:31:43[diff] [blame]193 curr_frame_size_ = allocate_size;
posciakd94b2b082015-09-18 04:03:40[diff] [blame]194 break;
195
xhwang60f96672016-06-14 21:47:53[diff] [blame]196 case Vp9Parser::kEOStream:
posciakd94b2b082015-09-18 04:03:40[diff] [blame]197 return kRanOutOfStreamData;
198
xhwang60f96672016-06-14 21:47:53[diff] [blame]199 case Vp9Parser::kInvalidStream:
posciakd94b2b082015-09-18 04:03:40[diff] [blame]200 DVLOG(1) << "Error parsing stream";
201 SetError();
202 return kDecodeError;
kcwue5a9a6292016-08-17 03:40:02[diff] [blame]203
204 case Vp9Parser::kAwaitingRefresh:
posciak77118c92016-08-28 13:18:39[diff] [blame]205 DVLOG(4) << "Awaiting context update";
206 return kNeedContextUpdate;
posciakd94b2b082015-09-18 04:03:40[diff] [blame]207 }
208 }
209
210 if (state_ != kDecoding) {
211 // Not kDecoding, so we need a resume point (a keyframe), as we are after
212 // reset or at the beginning of the stream. Drop anything that is not
213 // a keyframe in such case, and continue looking for a keyframe.
Sreerenj Balachandran57163302018-11-28 02:45:57[diff] [blame]214 // Only exception is when the stream/sequence starts with an Intra only
215 // frame.
216 if (curr_frame_hdr_->IsKeyframe() ||
217 (curr_frame_hdr_->IsIntra() && pic_size_.IsEmpty())) {
posciakd94b2b082015-09-18 04:03:40[diff] [blame]218 state_ = kDecoding;
219 } else {
220 curr_frame_hdr_.reset();
Jeffrey Kardatzke48ebdb692021-01-11 22:05:02[diff] [blame]221 decrypt_config_.reset();
posciakd94b2b082015-09-18 04:03:40[diff] [blame]222 continue;
223 }
224 }
225
226 if (curr_frame_hdr_->show_existing_frame) {
227 // This frame header only instructs us to display one of the
228 // previously-decoded frames, but has no frame data otherwise. Display
229 // and continue decoding subsequent frames.
kcwue5a9a6292016-08-17 03:40:02[diff] [blame]230 size_t frame_to_show = curr_frame_hdr_->frame_to_show_map_idx;
Sreerenj Balachandran1beb5482019-04-03 03:40:05[diff] [blame]231 if (frame_to_show >= kVp9NumRefFrames ||
232 !ref_frames_.GetFrame(frame_to_show)) {
posciakd94b2b082015-09-18 04:03:40[diff] [blame]233 DVLOG(1) << "Request to show an invalid frame";
234 SetError();
235 return kDecodeError;
236 }
237
Chih-Yu Huangcd5181e2018-10-23 06:33:06[diff] [blame]238 // Duplicate the VP9Picture and set the current bitstream id to keep the
239 // correct timestamp.
Sreerenj Balachandran1beb5482019-04-03 03:40:05[diff] [blame]240 scoped_refptr<VP9Picture> pic =
241 ref_frames_.GetFrame(frame_to_show)->Duplicate();
Chih-Yu Huangcd5181e2018-10-23 06:33:06[diff] [blame]242 if (pic == nullptr) {
243 DVLOG(1) << "Failed to duplicate the VP9Picture.";
244 SetError();
245 return kDecodeError;
246 }
247 pic->set_bitstream_id(stream_id_);
248 if (!accelerator_->OutputPicture(std::move(pic))) {
posciakd94b2b082015-09-18 04:03:40[diff] [blame]249 SetError();
250 return kDecodeError;
251 }
252
253 curr_frame_hdr_.reset();
Jeffrey Kardatzke48ebdb692021-01-11 22:05:02[diff] [blame]254 decrypt_config_.reset();
posciakd94b2b082015-09-18 04:03:40[diff] [blame]255 continue;
256 }
257
Hirokazu Honda10df95d2019-07-19 19:31:43[diff] [blame]258 gfx::Size new_pic_size = curr_frame_size_;
Hirokazu Honda436cf27b2019-05-21 10:44:39[diff] [blame]259 gfx::Rect new_render_rect(curr_frame_hdr_->render_width,
260 curr_frame_hdr_->render_height);
Hirokazu Hondacffd0ef2020-02-28 03:32:31[diff] [blame]261 // For safety, check the validity of render size or leave it as pic size.
Hirokazu Honda436cf27b2019-05-21 10:44:39[diff] [blame]262 if (!gfx::Rect(new_pic_size).Contains(new_render_rect)) {
263 DVLOG(1) << "Render size exceeds picture size. render size: "
264 << new_render_rect.ToString()
265 << ", picture size: " << new_pic_size.ToString();
Hirokazu Hondacffd0ef2020-02-28 03:32:31[diff] [blame]266 new_render_rect = gfx::Rect(new_pic_size);
Hirokazu Honda436cf27b2019-05-21 10:44:39[diff] [blame]267 }
Hirokazu Honda7ec32652019-11-22 09:40:21[diff] [blame]268 VideoCodecProfile new_profile =
269 VP9ProfileToVideoCodecProfile(curr_frame_hdr_->profile);
270 if (new_profile == VIDEO_CODEC_PROFILE_UNKNOWN) {
271 VLOG(1) << "Invalid profile: " << curr_frame_hdr_->profile;
272 return kDecodeError;
273 }
Hirokazu Honda963303782020-12-03 05:57:04[diff] [blame]274 if (!IsValidBitDepth(curr_frame_hdr_->bit_depth, new_profile)) {
275 DVLOG(1) << "Invalid bit depth="
276 << base::strict_cast<int>(curr_frame_hdr_->bit_depth)
277 << ", profile=" << GetProfileName(new_profile);
278 return kDecodeError;
279 }
Qiu Jianlin2153ac02022-08-18 04:13:15[diff] [blame]280 VideoChromaSampling new_chroma_sampling =
281 GetVP9ChromaSampling(*curr_frame_hdr_);
282 if (new_chroma_sampling != chroma_sampling_) {
283 chroma_sampling_ = new_chroma_sampling;
284 base::UmaHistogramEnumeration(
285 "Media.PlatformVideoDecoding.ChromaSampling", chroma_sampling_);
286 }
287
288 if (chroma_sampling_ != VideoChromaSampling::k420) {
Hirokazu Honda790d98e2020-12-04 03:41:48[diff] [blame]289 DVLOG(1) << "Only YUV 4:2:0 is supported";
290 return kDecodeError;
291 }
posciakd94b2b082015-09-18 04:03:40[diff] [blame]292
Hirokazu Honda436cf27b2019-05-21 10:44:39[diff] [blame]293 DCHECK(!new_pic_size.IsEmpty());
Miguel Casasc4d75842023-04-25 04:37:00[diff] [blame^]294
295 const bool is_pic_size_different = new_pic_size != pic_size_;
296 const bool is_pic_size_larger = new_pic_size.width() > pic_size_.width() ||
297 new_pic_size.height() > pic_size_.height();
298 const bool is_new_configuration_different_enough =
299 (ignore_resolution_changes_to_smaller_for_testing_
300 ? is_pic_size_larger
301 : is_pic_size_different) ||
302 new_profile != profile_ || curr_frame_hdr_->bit_depth != bit_depth_;
303
304 if (is_new_configuration_different_enough) {
Hirokazu Honda7ec32652019-11-22 09:40:21[diff] [blame]305 DVLOG(1) << "New profile: " << GetProfileName(new_profile)
Miguel Casasc4d75842023-04-25 04:37:00[diff] [blame^]306 << ", new resolution: " << new_pic_size.ToString()
307 << ", new bit depth: "
Hirokazu Honda963303782020-12-03 05:57:04[diff] [blame]308 << base::strict_cast<int>(curr_frame_hdr_->bit_depth);
posciakd94b2b082015-09-18 04:03:40[diff] [blame]309
Sreerenj Balachandran57163302018-11-28 02:45:57[diff] [blame]310 if (!curr_frame_hdr_->IsKeyframe() &&
Hirokazu Honda7ec32652019-11-22 09:40:21[diff] [blame]311 !(curr_frame_hdr_->IsIntra() && pic_size_.IsEmpty())) {
posciakd94b2b082015-09-18 04:03:40[diff] [blame]312 // TODO(posciak): This is doable, but requires a few modifications to
313 // VDA implementations to allow multiple picture buffer sets in flight.
Dongseong Hwang4f20ebb2018-06-07 00:28:20[diff] [blame]314 // http://crbug.com/832264
Sreerenj Balachandran57163302018-11-28 02:45:57[diff] [blame]315 DVLOG(1) << "Resolution change currently supported for keyframes and "
316 "sequence begins with Intra only when there is no prior "
317 "frames in the context";
Dongseong Hwang4f20ebb2018-06-07 00:28:20[diff] [blame]318 if (++size_change_failure_counter_ > kVPxMaxNumOfSizeChangeFailures) {
319 SetError();
320 return kDecodeError;
321 }
322
323 curr_frame_hdr_.reset();
Jeffrey Kardatzke48ebdb692021-01-11 22:05:02[diff] [blame]324 decrypt_config_.reset();
Dongseong Hwang4f20ebb2018-06-07 00:28:20[diff] [blame]325 return kRanOutOfStreamData;
posciakd94b2b082015-09-18 04:03:40[diff] [blame]326 }
327
328 // TODO(posciak): This requires us to be on a keyframe (see above) and is
329 // required, because VDA clients expect all surfaces to be returned before
Hirokazu Honda7ec32652019-11-22 09:40:21[diff] [blame]330 // they can cycle surface sets after receiving kConfigChange.
posciakd94b2b082015-09-18 04:03:40[diff] [blame]331 // This is only an implementation detail of VDAs and can be improved.
Sreerenj Balachandran1beb5482019-04-03 03:40:05[diff] [blame]332 ref_frames_.Clear();
posciakd94b2b082015-09-18 04:03:40[diff] [blame]333
334 pic_size_ = new_pic_size;
Hirokazu Honda436cf27b2019-05-21 10:44:39[diff] [blame]335 visible_rect_ = new_render_rect;
Hirokazu Honda7ec32652019-11-22 09:40:21[diff] [blame]336 profile_ = new_profile;
Hirokazu Honda963303782020-12-03 05:57:04[diff] [blame]337 bit_depth_ = curr_frame_hdr_->bit_depth;
Dongseong Hwang4f20ebb2018-06-07 00:28:20[diff] [blame]338 size_change_failure_counter_ = 0;
Hirokazu Honda7ec32652019-11-22 09:40:21[diff] [blame]339 return kConfigChange;
posciakd94b2b082015-09-18 04:03:40[diff] [blame]340 }
341
Jeffrey Kardatzke4ed4e332020-12-05 00:32:15[diff] [blame]342 scoped_refptr<VP9Picture> pic = accelerator_->CreateVP9Picture();
343 if (!pic) {
posciakd94b2b082015-09-18 04:03:40[diff] [blame]344 return kRanOutOfSurfaces;
Jose Lopes24d1cda82020-02-21 13:22:36[diff] [blame]345 }
johnylin74410872017-06-19 13:05:30[diff] [blame]346 DVLOG(2) << "Render resolution: " << new_render_rect.ToString();
347
Jeffrey Kardatzke4ed4e332020-12-05 00:32:15[diff] [blame]348 pic->set_visible_rect(new_render_rect);
349 pic->set_bitstream_id(stream_id_);
Fredrik Hubinette3cebc622018-10-27 01:01:12[diff] [blame]350
Jeffrey Kardatzke48ebdb692021-01-11 22:05:02[diff] [blame]351 pic->set_decrypt_config(std::move(decrypt_config_));
Ted Meyer0b35c5fd2018-11-27 22:29:29[diff] [blame]352
Fredrik Hubinette3cebc622018-10-27 01:01:12[diff] [blame]353 // For VP9, container color spaces override video stream color spaces.
Jeffrey Kardatzke5e36baf2020-11-20 22:17:13[diff] [blame]354 if (container_color_space_.IsSpecified())
Jeffrey Kardatzke4ed4e332020-12-05 00:32:15[diff] [blame]355 pic->set_colorspace(container_color_space_);
Jeffrey Kardatzke5e36baf2020-11-20 22:17:13[diff] [blame]356 else if (curr_frame_hdr_)
Jeffrey Kardatzke4ed4e332020-12-05 00:32:15[diff] [blame]357 pic->set_colorspace(curr_frame_hdr_->GetColorSpace());
posciakd94b2b082015-09-18 04:03:40[diff] [blame]358
Jeffrey Kardatzke4ed4e332020-12-05 00:32:15[diff] [blame]359 pic->frame_hdr = std::move(curr_frame_hdr_);
Jeffrey Kardatzke5e36baf2020-11-20 22:17:13[diff] [blame]360
Jeffrey Kardatzke4ed4e332020-12-05 00:32:15[diff] [blame]361 VP9Accelerator::Status status = DecodeAndOutputPicture(std::move(pic));
Jeffrey Kardatzke5e36baf2020-11-20 22:17:13[diff] [blame]362 if (status == VP9Accelerator::Status::kFail) {
posciakd94b2b082015-09-18 04:03:40[diff] [blame]363 SetError();
364 return kDecodeError;
365 }
Jeffrey Kardatzke5e36baf2020-11-20 22:17:13[diff] [blame]366 if (status == VP9Accelerator::Status::kTryAgain)
367 return kTryAgain;
posciakd94b2b082015-09-18 04:03:40[diff] [blame]368 }
369}
370
posciak77118c92016-08-28 13:18:39[diff] [blame]371void VP9Decoder::UpdateFrameContext(
Ted Meyer4fac4f62019-05-08 22:57:15[diff] [blame]372 scoped_refptr<VP9Picture> pic,
Jose Lopes24d1cda82020-02-21 13:22:36[diff] [blame]373 Vp9Parser::ContextRefreshCallback context_refresh_cb) {
Dale Curtise25163812018-09-21 22:13:39[diff] [blame]374 DCHECK(context_refresh_cb);
posciak77118c92016-08-28 13:18:39[diff] [blame]375 Vp9FrameContext frame_ctx;
376 memset(&frame_ctx, 0, sizeof(frame_ctx));
377
Ted Meyer4fac4f62019-05-08 22:57:15[diff] [blame]378 if (!accelerator_->GetFrameContext(std::move(pic), &frame_ctx)) {
posciak77118c92016-08-28 13:18:39[diff] [blame]379 SetError();
380 return;
381 }
382
Jose Lopes24d1cda82020-02-21 13:22:36[diff] [blame]383 std::move(context_refresh_cb).Run(frame_ctx);
posciak77118c92016-08-28 13:18:39[diff] [blame]384}
385
Jeffrey Kardatzke5e36baf2020-11-20 22:17:13[diff] [blame]386VP9Decoder::VP9Accelerator::Status VP9Decoder::DecodeAndOutputPicture(
387 scoped_refptr<VP9Picture> pic) {
posciakd94b2b082015-09-18 04:03:40[diff] [blame]388 DCHECK(!pic_size_.IsEmpty());
389 DCHECK(pic->frame_hdr);
390
Chih-Yu Huangcc6b1b92019-12-19 08:57:16[diff] [blame]391 base::OnceClosure done_cb;
Jose Lopes24d1cda82020-02-21 13:22:36[diff] [blame]392 Vp9Parser::ContextRefreshCallback context_refresh_cb =
posciak77118c92016-08-28 13:18:39[diff] [blame]393 parser_.GetContextRefreshCb(pic->frame_hdr->frame_context_idx);
Jose Lopes24d1cda82020-02-21 13:22:36[diff] [blame]394 if (context_refresh_cb) {
395 done_cb =
396 base::BindOnce(&VP9Decoder::UpdateFrameContext, base::Unretained(this),
397 pic, std::move(context_refresh_cb));
398 }
posciak77118c92016-08-28 13:18:39[diff] [blame]399
400 const Vp9Parser::Context& context = parser_.context();
Jeffrey Kardatzke5e36baf2020-11-20 22:17:13[diff] [blame]401 VP9Accelerator::Status status = accelerator_->SubmitDecode(
402 pic, context.segmentation(), context.loop_filter(), ref_frames_,
403 std::move(done_cb));
Jeffrey Kardatzke4ed4e332020-12-05 00:32:15[diff] [blame]404 if (status != VP9Accelerator::Status::kOk) {
405 if (status == VP9Accelerator::Status::kTryAgain)
406 pending_pic_ = std::move(pic);
Jeffrey Kardatzke5e36baf2020-11-20 22:17:13[diff] [blame]407 return status;
Jeffrey Kardatzke4ed4e332020-12-05 00:32:15[diff] [blame]408 }
posciakd94b2b082015-09-18 04:03:40[diff] [blame]409
410 if (pic->frame_hdr->show_frame) {
Jeffrey Kardatzke5e36baf2020-11-20 22:17:13[diff] [blame]411 if (!accelerator_->OutputPicture(pic))
412 return VP9Accelerator::Status::kFail;
posciakd94b2b082015-09-18 04:03:40[diff] [blame]413 }
414
Ted Meyer4fac4f62019-05-08 22:57:15[diff] [blame]415 ref_frames_.Refresh(std::move(pic));
Jeffrey Kardatzke5e36baf2020-11-20 22:17:13[diff] [blame]416 return status;
posciakd94b2b082015-09-18 04:03:40[diff] [blame]417}
418
419void VP9Decoder::SetError() {
420 Reset();
421 state_ = kError;
422}
423
424gfx::Size VP9Decoder::GetPicSize() const {
425 return pic_size_;
426}
427
Hirokazu Honda436cf27b2019-05-21 10:44:39[diff] [blame]428gfx::Rect VP9Decoder::GetVisibleRect() const {
429 return visible_rect_;
430}
431
Hirokazu Honda7ec32652019-11-22 09:40:21[diff] [blame]432VideoCodecProfile VP9Decoder::GetProfile() const {
433 return profile_;
434}
435
Hirokazu Honda963303782020-12-03 05:57:04[diff] [blame]436uint8_t VP9Decoder::GetBitDepth() const {
437 return bit_depth_;
438}
439
Qiu Jianlina790b3d2022-07-29 03:09:44[diff] [blame]440VideoChromaSampling VP9Decoder::GetChromaSampling() const {
Qiu Jianlin2153ac02022-08-18 04:13:15[diff] [blame]441 return chroma_sampling_;
Qiu Jianlina790b3d2022-07-29 03:09:44[diff] [blame]442}
443
Sida Zhuc4276442022-12-03 03:54:24[diff] [blame]444absl::optional<gfx::HDRMetadata> VP9Decoder::GetHDRMetadata() const {
445 // VP9 only allow HDR metadata exists in the container.
446 return absl::nullopt;
447}
448
posciakd94b2b082015-09-18 04:03:40[diff] [blame]449size_t VP9Decoder::GetRequiredNumOfPictures() const {
Miguel Casas477a7062019-01-04 19:13:45[diff] [blame]450 constexpr size_t kPicsInPipeline = limits::kMaxVideoFrames + 1;
451 return kPicsInPipeline + GetNumReferenceFrames();
452}
453
454size_t VP9Decoder::GetNumReferenceFrames() const {
Miguel Casas3dd7e562019-02-14 17:38:46[diff] [blame]455 // Maximum number of reference frames
456 return kVp9NumRefFrames;
posciakd94b2b082015-09-18 04:03:40[diff] [blame]457}
458
markdittmer6e70beb82016-05-02 05:40:47[diff] [blame]459} // namespace media