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