1 // Copyright 2015 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.
5 // This file contains an implementation of a VP9 bitstream parser.
8 // 1 something wrong in bitstream
10 // 3 parsed values (selected)
12 #include "media/filters/vp9_parser.h"
16 #include "base/bind.h"
17 #include "base/callback_helpers.h"
18 #include "base/containers/circular_deque.h"
19 #include "base/cxx17_backports.h"
20 #include "base/logging.h"
21 #include "base/numerics/safe_conversions.h"
22 #include "base/sys_byteorder.h"
23 #include "media/filters/vp9_compressed_header_parser.h"
24 #include "media/filters/vp9_uncompressed_header_parser.h"
30 // Coefficients extracted verbatim from "VP9 Bitstream & Decoding Process
31 // Specification" Version 0.6, Sec 8.6.1 Dequantization functions, see:
32 // https://www.webmproject.org/vp9/#draft-vp9-bitstream-and-decoding-process-specification
33 constexpr size_t kQIndexRange = 256;
35 // libva is the only user of high bit depth VP9 formats and only supports
36 // 10 bits per component, see https://github.com/01org/libva/issues/137.
37 // TODO(mcasas): Add the 12 bit versions of these tables.
38 const int16_t kDcQLookup[][kQIndexRange] = {
40 4, 8, 8, 9, 10, 11, 12, 12, 13, 14, 15, 16,
41 17, 18, 19, 19, 20, 21, 22, 23, 24, 25, 26, 26,
42 27, 28, 29, 30, 31, 32, 32, 33, 34, 35, 36, 37,
43 38, 38, 39, 40, 41, 42, 43, 43, 44, 45, 46, 47,
44 48, 48, 49, 50, 51, 52, 53, 53, 54, 55, 56, 57,
45 57, 58, 59, 60, 61, 62, 62, 63, 64, 65, 66, 66,
46 67, 68, 69, 70, 70, 71, 72, 73, 74, 74, 75, 76,
47 77, 78, 78, 79, 80, 81, 81, 82, 83, 84, 85, 85,
48 87, 88, 90, 92, 93, 95, 96, 98, 99, 101, 102, 104,
49 105, 107, 108, 110, 111, 113, 114, 116, 117, 118, 120, 121,
50 123, 125, 127, 129, 131, 134, 136, 138, 140, 142, 144, 146,
51 148, 150, 152, 154, 156, 158, 161, 164, 166, 169, 172, 174,
52 177, 180, 182, 185, 187, 190, 192, 195, 199, 202, 205, 208,
53 211, 214, 217, 220, 223, 226, 230, 233, 237, 240, 243, 247,
54 250, 253, 257, 261, 265, 269, 272, 276, 280, 284, 288, 292,
55 296, 300, 304, 309, 313, 317, 322, 326, 330, 335, 340, 344,
56 349, 354, 359, 364, 369, 374, 379, 384, 389, 395, 400, 406,
57 411, 417, 423, 429, 435, 441, 447, 454, 461, 467, 475, 482,
58 489, 497, 505, 513, 522, 530, 539, 549, 559, 569, 579, 590,
59 602, 614, 626, 640, 654, 668, 684, 700, 717, 736, 755, 775,
60 796, 819, 843, 869, 896, 925, 955, 988, 1022, 1058, 1098, 1139,
61 1184, 1232, 1282, 1336,
64 4, 9, 10, 13, 15, 17, 20, 22, 25, 28, 31, 34,
65 37, 40, 43, 47, 50, 53, 57, 60, 64, 68, 71, 75,
66 78, 82, 86, 90, 93, 97, 101, 105, 109, 113, 116, 120,
67 124, 128, 132, 136, 140, 143, 147, 151, 155, 159, 163, 166,
68 170, 174, 178, 182, 185, 189, 193, 197, 200, 204, 208, 212,
69 215, 219, 223, 226, 230, 233, 237, 241, 244, 248, 251, 255,
70 259, 262, 266, 269, 273, 276, 280, 283, 287, 290, 293, 297,
71 300, 304, 307, 310, 314, 317, 321, 324, 327, 331, 334, 337,
72 343, 350, 356, 362, 369, 375, 381, 387, 394, 400, 406, 412,
73 418, 424, 430, 436, 442, 448, 454, 460, 466, 472, 478, 484,
74 490, 499, 507, 516, 525, 533, 542, 550, 559, 567, 576, 584,
75 592, 601, 609, 617, 625, 634, 644, 655, 666, 676, 687, 698,
76 708, 718, 729, 739, 749, 759, 770, 782, 795, 807, 819, 831,
77 844, 856, 868, 880, 891, 906, 920, 933, 947, 961, 975, 988,
78 1001, 1015, 1030, 1045, 1061, 1076, 1090, 1105, 1120, 1137, 1153, 1170,
79 1186, 1202, 1218, 1236, 1253, 1271, 1288, 1306, 1323, 1342, 1361, 1379,
80 1398, 1416, 1436, 1456, 1476, 1496, 1516, 1537, 1559, 1580, 1601, 1624,
81 1647, 1670, 1692, 1717, 1741, 1766, 1791, 1817, 1844, 1871, 1900, 1929,
82 1958, 1990, 2021, 2054, 2088, 2123, 2159, 2197, 2236, 2276, 2319, 2363,
83 2410, 2458, 2508, 2561, 2616, 2675, 2737, 2802, 2871, 2944, 3020, 3102,
84 3188, 3280, 3375, 3478, 3586, 3702, 3823, 3953, 4089, 4236, 4394, 4559,
85 4737, 4929, 5130, 5347
89 const int16_t kAcQLookup[][kQIndexRange] = {
91 4, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
92 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
93 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
94 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
95 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66,
96 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
97 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
98 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102,
99 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126,
100 128, 130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150,
101 152, 155, 158, 161, 164, 167, 170, 173, 176, 179, 182, 185,
102 188, 191, 194, 197, 200, 203, 207, 211, 215, 219, 223, 227,
103 231, 235, 239, 243, 247, 251, 255, 260, 265, 270, 275, 280,
104 285, 290, 295, 300, 305, 311, 317, 323, 329, 335, 341, 347,
105 353, 359, 366, 373, 380, 387, 394, 401, 408, 416, 424, 432,
106 440, 448, 456, 465, 474, 483, 492, 501, 510, 520, 530, 540,
107 550, 560, 571, 582, 593, 604, 615, 627, 639, 651, 663, 676,
108 689, 702, 715, 729, 743, 757, 771, 786, 801, 816, 832, 848,
109 864, 881, 898, 915, 933, 951, 969, 988, 1007, 1026, 1046, 1066,
110 1087, 1108, 1129, 1151, 1173, 1196, 1219, 1243, 1267, 1292, 1317, 1343,
111 1369, 1396, 1423, 1451, 1479, 1508, 1537, 1567, 1597, 1628, 1660, 1692,
112 1725, 1759, 1793, 1828,
115 4, 9, 11, 13, 16, 18, 21, 24, 27, 30, 33, 37,
116 40, 44, 48, 51, 55, 59, 63, 67, 71, 75, 79, 83,
117 88, 92, 96, 100, 105, 109, 114, 118, 122, 127, 131, 136,
118 140, 145, 149, 154, 158, 163, 168, 172, 177, 181, 186, 190,
119 195, 199, 204, 208, 213, 217, 222, 226, 231, 235, 240, 244,
120 249, 253, 258, 262, 267, 271, 275, 280, 284, 289, 293, 297,
121 302, 306, 311, 315, 319, 324, 328, 332, 337, 341, 345, 349,
122 354, 358, 362, 367, 371, 375, 379, 384, 388, 392, 396, 401,
123 409, 417, 425, 433, 441, 449, 458, 466, 474, 482, 490, 498,
124 506, 514, 523, 531, 539, 547, 555, 563, 571, 579, 588, 596,
125 604, 616, 628, 640, 652, 664, 676, 688, 700, 713, 725, 737,
126 749, 761, 773, 785, 797, 809, 825, 841, 857, 873, 889, 905,
127 922, 938, 954, 970, 986, 1002, 1018, 1038, 1058, 1078, 1098, 1118,
128 1138, 1158, 1178, 1198, 1218, 1242, 1266, 1290, 1314, 1338, 1362, 1386,
129 1411, 1435, 1463, 1491, 1519, 1547, 1575, 1603, 1631, 1663, 1695, 1727,
130 1759, 1791, 1823, 1859, 1895, 1931, 1967, 2003, 2039, 2079, 2119, 2159,
131 2199, 2239, 2283, 2327, 2371, 2415, 2459, 2507, 2555, 2603, 2651, 2703,
132 2755, 2807, 2859, 2915, 2971, 3027, 3083, 3143, 3203, 3263, 3327, 3391,
133 3455, 3523, 3591, 3659, 3731, 3803, 3876, 3952, 4028, 4104, 4184, 4264,
134 4348, 4432, 4516, 4604, 4692, 4784, 4876, 4972, 5068, 5168, 5268, 5372,
135 5476, 5584, 5692, 5804, 5916, 6032, 6148, 6268, 6388, 6512, 6640, 6768,
136 6900, 7036, 7172, 7312
141 static_assert(std::size(kDcQLookup[0]) == std::size(kAcQLookup[0]),
142 "quantizer lookup arrays of incorrect size");
144 size_t ClampQ(int64_t q) {
146 : base::checked_cast<size_t>(
147 std::min(q, static_cast<int64_t>(kQIndexRange - 1)));
150 int ClampLf(int lf) {
151 constexpr int kMaxLoopFilterLevel = 63;
152 return base::clamp(lf, 0, kMaxLoopFilterLevel);
155 std::string IncrementIV(const std::string& iv, uint32_t by) {
156 // What we call the 'IV' value is actually somewhat of a misnomer:
157 // "IV" = 0xFFFFFFFFFFFFFFFF0000000000000000
158 // └──actual IV───┘└─block counter┘
159 // When we want to 'increment' this structure, we treat them both
160 // as big-endian 64 bit unsigned integers, then increment _only_ the
161 // block counter, then combine them back into a big-endian bytestring.
162 // |by| is usually going to be the number of blocks (aka 16 byte chunks)
164 DCHECK_EQ(iv.size(), 16u);
165 uint64_t integral_data[2];
166 memcpy(integral_data, reinterpret_cast<const uint8_t*>(iv.data()), 16);
167 uint64_t block_counter = base::NetToHost64(integral_data[1]) + by;
168 integral_data[1] = base::HostToNet64(block_counter);
170 memcpy(new_iv, integral_data, 16);
171 return std::string(reinterpret_cast<char*>(new_iv), 16);
174 // |frame_size|: The size of the current frame; this controls how long we
175 // loop through the subsamples.
176 // |current_subsample_index|: An index into the |subsamples| vector, we need
177 // to have this saved between function calls.
178 // |extra_clear_bytes|: The previous call may have set this variable to show
179 // that a subsample mey have already started being parsed
180 // and that only X bytes of free data are left in it.
181 // |base_decrypt_config|: Not an output parameter, it is just a raw ptr from a
183 // |subsamples|: A vector of subsamples.
184 // |iv|: The initialization vector (128bit number stored as std::string). This
185 // gets incremented by (cipher_bytes % 16) for each frame, and must be
186 // preserved across function calls.
187 std::unique_ptr<DecryptConfig> SplitSubsamples(
189 size_t* current_subsample_index,
190 size_t* extra_clear_subsample_bytes,
191 DecryptConfig* base_decrypt_config,
192 const std::vector<SubsampleEntry>& subsamples,
194 // We copy iv so that we can use the starting value in our
195 // new config while still incrementing IV for the next frame.
196 std::string frame_dc_iv = *iv;
197 std::vector<SubsampleEntry> frame_dc_subsamples;
199 if (*current_subsample_index >= subsamples.size()) {
200 DVLOG(1) << "Not enough subsamples in the superframe decrypt config";
204 uint32_t subsample_clear = subsamples[*current_subsample_index].clear_bytes;
205 uint32_t subsample_cipher =
206 subsamples[*current_subsample_index].cypher_bytes;
208 // if clear+cipher bytes would be over the max of uint32_t, we need to
209 // quit immediatly, to prevent malicious overflowing.
210 if (0xFFFFFFFF - subsample_clear < subsample_cipher) {
211 DVLOG(1) << "Invalid subsample alignment";
215 // It's possible that the previous frame didn't use all the clear bytes
216 // in this subsample, in which case we have to start from midway through
217 // the clear section.
218 if (*extra_clear_subsample_bytes) {
219 subsample_clear = *extra_clear_subsample_bytes;
222 if (subsample_clear > frame_size) {
223 // Support scenario where clear section is larger than our frame:
224 // The entire length is clear. If |subsample_clear| is the same length,
225 // we handle it below.
226 frame_dc_subsamples.push_back(SubsampleEntry(frame_size, 0));
227 *extra_clear_subsample_bytes = subsample_clear - frame_size;
229 } else if (subsample_clear + subsample_cipher > frame_size) {
230 // Only a clear section can cross over a frame boundary, otherwise
231 // the frame header for the next frame would be encrypted, which is not
233 DVLOG(1) << "Invalid subsample alignment";
235 } else if (subsample_clear + subsample_cipher <= frame_size) {
236 // In this case a subsample is less than or equal to a whole frame
237 // This is the most likely case for almost all encrypted media.
238 // note that |subsample_cipher| can be 0.
239 frame_dc_subsamples.push_back(
240 SubsampleEntry(subsample_clear, subsample_cipher));
241 frame_size -= (subsample_clear + subsample_cipher);
242 *extra_clear_subsample_bytes = 0;
244 // IV gets incremented by 1 for every 16 bytes of cypher
245 *iv = IncrementIV(*iv, subsample_cipher >> 4); // uint32 logical shift.
248 // Don't go to the next subsample if there are more clear bytes.
249 if (!*extra_clear_subsample_bytes) {
250 (*current_subsample_index)++;
253 // It is possible for there to be more than one subsample associated
254 // with a single frame, so we need to try again if there are more bytes
255 // left unaccounted for in this frame.
256 } while (frame_size);
258 return base_decrypt_config->CopyNewSubsamplesIV(frame_dc_subsamples,
262 bool IsByteNEncrypted(off_t byte,
263 const std::vector<SubsampleEntry>& subsamples) {
264 off_t original_byte = byte;
265 for (const SubsampleEntry& subsample : subsamples) {
269 if (static_cast<uint32_t>(byte) < subsample.clear_bytes) {
272 byte -= subsample.clear_bytes;
273 if (static_cast<uint32_t>(byte) < subsample.cypher_bytes) {
276 byte -= subsample.cypher_bytes;
278 DVLOG(3) << "Subsamples do not extend to cover offset " << original_byte;
284 bool Vp9FrameHeader::IsKeyframe() const {
285 // When show_existing_frame is true, the frame header does not precede an
286 // actual frame to be decoded, so frame_type does not apply (and is not read
288 return !show_existing_frame && frame_type == KEYFRAME;
291 bool Vp9FrameHeader::IsIntra() const {
292 return !show_existing_frame && (frame_type == KEYFRAME || intra_only);
295 VideoColorSpace Vp9FrameHeader::GetColorSpace() const {
297 ret.range = color_range ? gfx::ColorSpace::RangeID::FULL
298 : gfx::ColorSpace::RangeID::LIMITED;
299 switch (color_space) {
300 case Vp9ColorSpace::RESERVED:
301 case Vp9ColorSpace::UNKNOWN:
303 case Vp9ColorSpace::BT_601:
304 case Vp9ColorSpace::SMPTE_170:
305 ret.primaries = VideoColorSpace::PrimaryID::SMPTE170M;
306 ret.transfer = VideoColorSpace::TransferID::SMPTE170M;
307 ret.matrix = VideoColorSpace::MatrixID::SMPTE170M;
309 case Vp9ColorSpace::BT_709:
310 ret.primaries = VideoColorSpace::PrimaryID::BT709;
311 ret.transfer = VideoColorSpace::TransferID::BT709;
312 ret.matrix = VideoColorSpace::MatrixID::BT709;
314 case Vp9ColorSpace::SMPTE_240:
315 ret.primaries = VideoColorSpace::PrimaryID::SMPTE240M;
316 ret.transfer = VideoColorSpace::TransferID::SMPTE240M;
317 ret.matrix = VideoColorSpace::MatrixID::SMPTE240M;
319 case Vp9ColorSpace::BT_2020:
320 ret.primaries = VideoColorSpace::PrimaryID::BT2020;
321 ret.transfer = VideoColorSpace::TransferID::BT2020_10;
322 ret.matrix = VideoColorSpace::MatrixID::BT2020_NCL;
324 case Vp9ColorSpace::SRGB:
325 ret.primaries = VideoColorSpace::PrimaryID::BT709;
326 ret.transfer = VideoColorSpace::TransferID::IEC61966_2_1;
327 ret.matrix = VideoColorSpace::MatrixID::BT709;
333 Vp9Parser::FrameInfo::FrameInfo() = default;
335 Vp9Parser::FrameInfo::~FrameInfo() = default;
337 Vp9Parser::FrameInfo::FrameInfo(const uint8_t* ptr, off_t size)
338 : ptr(ptr), size(size) {}
340 Vp9Parser::FrameInfo::FrameInfo(const FrameInfo& copy_from)
341 : ptr(copy_from.ptr),
342 size(copy_from.size),
343 allocate_size(copy_from.allocate_size),
344 decrypt_config(copy_from.decrypt_config
345 ? copy_from.decrypt_config->Clone()
348 Vp9Parser::FrameInfo& Vp9Parser::FrameInfo::operator=(
349 const FrameInfo& copy_from) {
350 this->ptr = copy_from.ptr;
351 this->size = copy_from.size;
352 this->allocate_size = copy_from.allocate_size;
353 this->decrypt_config =
354 copy_from.decrypt_config ? copy_from.decrypt_config->Clone() : nullptr;
358 bool Vp9FrameContext::IsValid() const {
359 // probs should be in [1, 255] range.
360 static_assert(sizeof(Vp9Prob) == 1,
361 "following checks assuming Vp9Prob is single byte");
362 if (memchr(tx_probs_8x8, 0, sizeof(tx_probs_8x8))) {
365 if (memchr(tx_probs_16x16, 0, sizeof(tx_probs_16x16))) {
368 if (memchr(tx_probs_32x32, 0, sizeof(tx_probs_32x32))) {
372 for (auto& a : coef_probs) {
374 for (auto& aj : ai) {
375 for (auto& ak : aj) {
376 int max_l = (+ak == +aj[0]) ? 3 : 6;
377 for (int l = 0; l < max_l; l++) {
378 for (auto& x : ak[l]) {
388 if (memchr(skip_prob, 0, sizeof(skip_prob))) {
391 if (memchr(inter_mode_probs, 0, sizeof(inter_mode_probs))) {
394 if (memchr(interp_filter_probs, 0, sizeof(interp_filter_probs))) {
397 if (memchr(is_inter_prob, 0, sizeof(is_inter_prob))) {
400 if (memchr(comp_mode_prob, 0, sizeof(comp_mode_prob))) {
403 if (memchr(single_ref_prob, 0, sizeof(single_ref_prob))) {
406 if (memchr(comp_ref_prob, 0, sizeof(comp_ref_prob))) {
409 if (memchr(y_mode_probs, 0, sizeof(y_mode_probs))) {
412 if (memchr(uv_mode_probs, 0, sizeof(uv_mode_probs))) {
415 if (memchr(partition_probs, 0, sizeof(partition_probs))) {
418 if (memchr(mv_joint_probs, 0, sizeof(mv_joint_probs))) {
421 if (memchr(mv_sign_prob, 0, sizeof(mv_sign_prob))) {
424 if (memchr(mv_class_probs, 0, sizeof(mv_class_probs))) {
427 if (memchr(mv_class0_bit_prob, 0, sizeof(mv_class0_bit_prob))) {
430 if (memchr(mv_bits_prob, 0, sizeof(mv_bits_prob))) {
433 if (memchr(mv_class0_fr_probs, 0, sizeof(mv_class0_fr_probs))) {
436 if (memchr(mv_fr_probs, 0, sizeof(mv_fr_probs))) {
439 if (memchr(mv_class0_hp_prob, 0, sizeof(mv_class0_hp_prob))) {
442 if (memchr(mv_hp_prob, 0, sizeof(mv_hp_prob))) {
449 Vp9Parser::Context::Vp9FrameContextManager::Vp9FrameContextManager() {}
451 Vp9Parser::Context::Vp9FrameContextManager::~Vp9FrameContextManager() = default;
453 const Vp9FrameContext&
454 Vp9Parser::Context::Vp9FrameContextManager::frame_context() const {
455 DCHECK(initialized_);
456 DCHECK(!needs_client_update_);
457 return frame_context_;
460 void Vp9Parser::Context::Vp9FrameContextManager::Reset() {
461 initialized_ = false;
462 needs_client_update_ = false;
463 weak_ptr_factory_.InvalidateWeakPtrs();
466 void Vp9Parser::Context::Vp9FrameContextManager::SetNeedsClientUpdate() {
467 DCHECK(!needs_client_update_);
469 needs_client_update_ = true;
472 Vp9Parser::ContextRefreshCallback
473 Vp9Parser::Context::Vp9FrameContextManager::GetUpdateCb() {
474 if (needs_client_update_) {
475 return base::BindOnce(&Vp9FrameContextManager::UpdateFromClient,
476 weak_ptr_factory_.GetWeakPtr());
482 void Vp9Parser::Context::Vp9FrameContextManager::Update(
483 const Vp9FrameContext& frame_context) {
484 // DCHECK because we can trust values from our parser.
485 DCHECK(frame_context.IsValid());
487 frame_context_ = frame_context;
489 // For frame context we are updating, it may be still awaiting previous
490 // ContextRefreshCallback. Because we overwrite the value of context here and
491 // previous ContextRefreshCallback no longer matters, invalidate the weak ptr
492 // to prevent previous ContextRefreshCallback run.
493 // With this optimization, we may be able to parse more frames while previous
494 // are still decoding.
495 weak_ptr_factory_.InvalidateWeakPtrs();
496 needs_client_update_ = false;
499 void Vp9Parser::Context::Vp9FrameContextManager::UpdateFromClient(
500 const Vp9FrameContext& frame_context) {
501 DVLOG(2) << "Got external frame_context update";
502 DCHECK(needs_client_update_);
503 if (!frame_context.IsValid()) {
504 DLOG(ERROR) << "Invalid prob value in frame_context";
507 needs_client_update_ = false;
509 frame_context_ = frame_context;
512 void Vp9Parser::Context::Reset() {
513 memset(&segmentation_, 0, sizeof(segmentation_));
514 memset(&loop_filter_, 0, sizeof(loop_filter_));
515 memset(&ref_slots_, 0, sizeof(ref_slots_));
516 for (auto& manager : frame_context_managers_)
520 void Vp9Parser::Context::MarkFrameContextForUpdate(size_t frame_context_idx) {
521 DCHECK_LT(frame_context_idx, std::size(frame_context_managers_));
522 frame_context_managers_[frame_context_idx].SetNeedsClientUpdate();
525 void Vp9Parser::Context::UpdateFrameContext(
526 size_t frame_context_idx,
527 const Vp9FrameContext& frame_context) {
528 DCHECK_LT(frame_context_idx, std::size(frame_context_managers_));
529 frame_context_managers_[frame_context_idx].Update(frame_context);
532 const Vp9Parser::ReferenceSlot& Vp9Parser::Context::GetRefSlot(
533 size_t ref_type) const {
534 DCHECK_LT(ref_type, std::size(ref_slots_));
535 return ref_slots_[ref_type];
538 void Vp9Parser::Context::UpdateRefSlot(
540 const Vp9Parser::ReferenceSlot& ref_slot) {
541 DCHECK_LT(ref_type, std::size(ref_slots_));
542 ref_slots_[ref_type] = ref_slot;
545 Vp9Parser::Vp9Parser(bool parsing_compressed_header)
546 : Vp9Parser(parsing_compressed_header,
547 /*needs_external_context_update=*/false) {}
549 Vp9Parser::Vp9Parser(bool parsing_compressed_header,
550 bool needs_external_context_update)
551 : parsing_compressed_header_(parsing_compressed_header),
552 needs_external_context_update_(needs_external_context_update) {
556 Vp9Parser::~Vp9Parser() = default;
558 void Vp9Parser::SetStream(const uint8_t* stream,
560 const std::vector<uint32_t>& spatial_layer_frame_size,
561 std::unique_ptr<DecryptConfig> stream_config) {
564 bytes_left_ = stream_size;
566 spatial_layer_frame_size_ = spatial_layer_frame_size;
567 stream_decrypt_config_ = std::move(stream_config);
570 void Vp9Parser::SetStream(const uint8_t* stream,
572 std::unique_ptr<DecryptConfig> stream_config) {
573 SetStream(stream, stream_size, {}, std::move(stream_config));
576 void Vp9Parser::Reset() {
580 spatial_layer_frame_size_.clear();
581 curr_frame_info_.Reset();
586 bool Vp9Parser::ParseUncompressedHeader(const FrameInfo& frame_info,
587 Vp9FrameHeader* fhdr,
589 Vp9Parser::Context* context) {
590 memset(&curr_frame_header_, 0, sizeof(curr_frame_header_));
591 *result = kInvalidStream;
593 Vp9UncompressedHeaderParser uncompressed_parser(context);
594 if (!uncompressed_parser.Parse(frame_info.ptr, frame_info.size,
595 &curr_frame_header_)) {
596 *result = kInvalidStream;
600 if (curr_frame_header_.header_size_in_bytes == 0) {
601 // Verify padding bits are zero.
602 for (off_t i = curr_frame_header_.uncompressed_header_size;
603 i < frame_info.size; i++) {
604 if (frame_info.ptr[i] != 0) {
605 DVLOG(1) << "Padding bits are not zeros.";
606 *result = kInvalidStream;
610 *fhdr = curr_frame_header_;
614 if (curr_frame_header_.uncompressed_header_size +
615 curr_frame_header_.header_size_in_bytes >
616 base::checked_cast<size_t>(frame_info.size)) {
617 DVLOG(1) << "header_size_in_bytes="
618 << curr_frame_header_.header_size_in_bytes
619 << " is larger than bytes left in buffer: "
620 << frame_info.size - curr_frame_header_.uncompressed_header_size;
621 *result = kInvalidStream;
628 bool Vp9Parser::ParseCompressedHeader(const FrameInfo& frame_info,
630 *result = kInvalidStream;
631 size_t frame_context_idx = curr_frame_header_.frame_context_idx;
632 const Context::Vp9FrameContextManager& context_to_load =
633 context_.frame_context_managers_[frame_context_idx];
634 if (!context_to_load.initialized()) {
635 // 8.2 Frame order constraints
636 // must load an initialized set of probabilities.
637 DVLOG(1) << "loading uninitialized frame context, index="
638 << frame_context_idx;
639 *result = kInvalidStream;
642 if (context_to_load.needs_client_update()) {
643 DVLOG(3) << "waiting frame_context_idx=" << frame_context_idx
645 curr_frame_info_ = frame_info;
646 *result = kAwaitingRefresh;
649 curr_frame_header_.initial_frame_context = curr_frame_header_.frame_context =
650 context_to_load.frame_context();
652 Vp9CompressedHeaderParser compressed_parser;
654 if (!needs_external_context_update_) {
655 parse_success = compressed_parser.ParseNoContext(
656 frame_info.ptr + curr_frame_header_.uncompressed_header_size,
657 curr_frame_header_.header_size_in_bytes, &curr_frame_header_);
659 parse_success = compressed_parser.Parse(
660 frame_info.ptr + curr_frame_header_.uncompressed_header_size,
661 curr_frame_header_.header_size_in_bytes, &curr_frame_header_);
663 if (!parse_success) {
664 *result = kInvalidStream;
668 if (curr_frame_header_.refresh_frame_context) {
669 // In frame parallel mode, we can refresh the context without decoding
671 if (curr_frame_header_.frame_parallel_decoding_mode) {
672 context_.UpdateFrameContext(frame_context_idx,
673 curr_frame_header_.frame_context);
675 if (needs_external_context_update_)
676 context_.MarkFrameContextForUpdate(frame_context_idx);
682 Vp9Parser::Result Vp9Parser::ParseNextFrame(
683 Vp9FrameHeader* fhdr,
684 gfx::Size* allocate_size,
685 std::unique_ptr<DecryptConfig>* frame_decrypt_config) {
687 DCHECK(allocate_size);
688 DVLOG(2) << "ParseNextFrame";
689 FrameInfo frame_info;
692 // If |curr_frame_info_| is valid, uncompressed header was parsed into
693 // |curr_frame_header_| and we are awaiting context update to proceed with
694 // compressed header parsing.
695 if (curr_frame_info_.IsValid()) {
696 DCHECK(parsing_compressed_header_);
697 frame_info = curr_frame_info_;
698 curr_frame_info_.Reset();
700 if (frames_.empty()) {
701 // No frames to be decoded, if there is no more stream, request more.
706 // New stream to be parsed, parse it and fill frames_.
707 if (!spatial_layer_frame_size_.empty()) {
708 // If it is SVC stream, we have to parse the stream with
709 // |spatial_layer_frame_size_|.
710 frames_ = ParseSVCFrame();
712 frames_ = ParseSuperframe();
715 if (frames_.empty()) {
716 DVLOG(1) << "Failed parsing superframes/SVC frame";
717 return kInvalidStream;
721 frame_info = frames_.front();
723 if (frame_decrypt_config) {
724 if (frame_info.decrypt_config) {
725 *frame_decrypt_config = frame_info.decrypt_config->Clone();
727 *frame_decrypt_config = nullptr;
731 if (ParseUncompressedHeader(frame_info, fhdr, &result, &context_)) {
736 if (parsing_compressed_header_) {
737 if (ParseCompressedHeader(frame_info, &result)) {
738 DCHECK(result != kAwaitingRefresh || curr_frame_info_.IsValid());
743 if (!SetupSegmentationDequant()) {
744 return kInvalidStream;
747 UpdateSlots(&context_);
749 *fhdr = curr_frame_header_;
750 // show_frame must be true for the last frame, otherwise false in SVC frame.
751 if (!spatial_layer_frame_size_.empty()) {
752 fhdr->show_frame = frames_.empty();
755 if (frame_info.allocate_size.IsEmpty()) {
756 allocate_size->SetSize(fhdr->frame_width, fhdr->frame_height);
758 *allocate_size = frame_info.allocate_size;
764 Vp9Parser::ContextRefreshCallback Vp9Parser::GetContextRefreshCb(
765 size_t frame_context_idx) {
766 DCHECK_LT(frame_context_idx, std::size(context_.frame_context_managers_));
767 auto& frame_context_manager =
768 context_.frame_context_managers_[frame_context_idx];
770 return frame_context_manager.GetUpdateCb();
773 std::unique_ptr<DecryptConfig> Vp9Parser::NextFrameDecryptContextForTesting() {
774 if (frames_.empty()) {
775 // No frames to be decoded, if there is no more stream, request more.
780 // New stream to be parsed, parse it and fill frames_.
781 frames_ = ParseSuperframe();
782 if (frames_.empty()) {
786 FrameInfo frame_info = std::move(frames_.front());
788 return std::move(frame_info.decrypt_config);
791 std::string Vp9Parser::IncrementIVForTesting(const std::string& iv,
793 return IncrementIV(iv, by);
796 // Annex B Superframes
797 base::circular_deque<Vp9Parser::FrameInfo> Vp9Parser::ParseSuperframe() {
798 const uint8_t* stream = stream_;
799 off_t bytes_left = bytes_left_;
801 // Make sure we don't parse stream_ more than once.
805 base::circular_deque<FrameInfo> frames;
807 if (bytes_left < 1) {
811 // The marker byte might be encrypted, in which case we should treat
812 // the stream as a single frame.
813 off_t marker_offset = bytes_left - 1;
814 if (stream_decrypt_config_) {
815 if (IsByteNEncrypted(marker_offset, stream_decrypt_config_->subsamples())) {
816 frames.push_back(FrameInfo(stream, bytes_left));
817 frames[0].decrypt_config = stream_decrypt_config_->Clone();
822 // If this is a superframe, the last byte in the stream will contain the
823 // superframe marker. If not, the whole buffer contains a single frame.
824 uint8_t marker = *(stream + marker_offset);
825 if ((marker & 0xe0) != 0xc0) {
826 frames.push_back(FrameInfo(stream, bytes_left));
827 if (stream_decrypt_config_) {
828 frames[0].decrypt_config = stream_decrypt_config_->Clone();
833 DVLOG(1) << "Parsing a superframe";
835 // The bytes immediately before the superframe marker constitute superframe
836 // index, which stores information about sizes of each frame in it.
837 // Calculate its size and set index_ptr to the beginning of it.
838 size_t num_frames = (marker & 0x7) + 1;
839 size_t mag = ((marker >> 3) & 0x3) + 1;
840 off_t index_size = 2 + mag * num_frames;
842 if (bytes_left < index_size) {
843 return base::circular_deque<FrameInfo>();
846 const uint8_t* index_ptr = stream + bytes_left - index_size;
847 if (marker != *index_ptr) {
848 return base::circular_deque<FrameInfo>();
852 bytes_left -= index_size;
854 // Parse frame information contained in the index and add a pointer to and
855 // size of each frame to frames.
857 // Use this to calculate the per-frame IV value.
859 std::vector<SubsampleEntry> subsamples;
860 size_t current_subsample = 0;
861 size_t extra_clear_subsample_bytes = 0;
862 if (stream_decrypt_config_) {
863 iv = stream_decrypt_config_->iv();
864 subsamples = stream_decrypt_config_->subsamples();
867 for (size_t i = 0; i < num_frames; ++i) {
869 for (size_t j = 0; j < mag; ++j) {
870 size |= *index_ptr << (j * 8);
874 if (!base::IsValueInRangeForNumericType<off_t>(size) ||
875 static_cast<off_t>(size) > bytes_left) {
876 DVLOG(1) << "Not enough data in the buffer for frame " << i;
881 FrameInfo frame = FrameInfo(stream, size);
882 if (subsamples.size()) {
883 std::unique_ptr<DecryptConfig> frame_dc = SplitSubsamples(
884 size, ¤t_subsample, &extra_clear_subsample_bytes,
885 stream_decrypt_config_.get(), subsamples, &iv);
887 DVLOG(1) << "Failed to calculate decrypt config for frame " << i;
892 frame.decrypt_config = std::move(frame_dc);
895 frames.push_back(std::move(frame));
899 DVLOG(1) << "Frame " << i << ", size: " << size;
905 base::circular_deque<Vp9Parser::FrameInfo> Vp9Parser::ParseSVCFrame() {
906 if (parsing_compressed_header_) {
907 LOG(ERROR) << "Vp9Parser doesn't support parsing SVC stream when "
908 << "a compressed header needs to be parsed";
911 if (stream_decrypt_config_) {
912 LOG(ERROR) << "Encrypted frame with SVC stream is not supported";
916 const uint8_t* stream = stream_;
917 off_t bytes_left = bytes_left_;
919 // Make sure we don't parse stream_ more than once.
923 base::circular_deque<FrameInfo> frames;
925 for (size_t i = 0; i < spatial_layer_frame_size_.size(); i++) {
926 const uint32_t size = spatial_layer_frame_size_[i];
927 if (!base::IsValueInRangeForNumericType<off_t>(size) ||
928 static_cast<off_t>(size) > bytes_left) {
929 DVLOG(1) << "Not enough data in the buffer for frame " << i;
933 frames.emplace_back(stream, size);
936 DVLOG(1) << "Frame " << i << ", size: " << size;
939 DCHECK(!frames.empty());
941 gfx::Size max_frame_size;
943 // Context is not copyable because it has base::WeakPtrFactory. The weak
944 // pointer is necessary to update context for compressed header. To parse
945 // uncompressed header, |segmentation_|, |loop_filter| and |ref_slots_| are
946 // sufficient. Copy the variables manually here.
948 tmp_context.segmentation_ = context_.segmentation_;
949 tmp_context.loop_filter_ = context_.loop_filter_;
950 memcpy(tmp_context.ref_slots_, context_.ref_slots_,
951 sizeof(context_.ref_slots_));
952 for (const auto& frame_info : frames) {
953 // |curr_frame_header_| is used safely because it is reset every
954 // ParseUncompressedHeader().
955 Vp9FrameHeader dummy_fhdr;
957 if (ParseUncompressedHeader(frame_info, &dummy_fhdr, &result,
962 UpdateSlots(&tmp_context);
963 max_frame_size.SetToMax(gfx::Size(curr_frame_header_.frame_width,
964 curr_frame_header_.frame_height));
967 for (auto& frame_info : frames)
968 frame_info.allocate_size = max_frame_size;
972 // 8.6.1 Dequantization functions
973 int64_t Vp9Parser::GetQIndex(const Vp9QuantizationParams& quant,
974 size_t segid) const {
975 const Vp9SegmentationParams& segmentation = context_.segmentation();
977 if (segmentation.FeatureEnabled(segid,
978 Vp9SegmentationParams::SEG_LVL_ALT_Q)) {
979 int16_t feature_data =
980 segmentation.FeatureData(segid, Vp9SegmentationParams::SEG_LVL_ALT_Q);
981 int64_t q_index = segmentation.abs_or_delta_update
983 : quant.base_q_idx + feature_data;
984 return ClampQ(q_index);
986 return quant.base_q_idx;
989 // 8.6.1 Dequantization functions
990 bool Vp9Parser::SetupSegmentationDequant() {
991 const Vp9QuantizationParams& quant = curr_frame_header_.quant_params;
992 Vp9SegmentationParams& segmentation = context_.segmentation_;
994 if (curr_frame_header_.bit_depth > 10) {
995 DLOG(ERROR) << "bit_depth > 10 is not supported yet, kDcQLookup and "
996 "kAcQLookup need to be extended";
999 const size_t bit_depth_index = (curr_frame_header_.bit_depth == 8) ? 0 : 1;
1001 if (segmentation.enabled) {
1002 for (size_t i = 0; i < Vp9SegmentationParams::kNumSegments; ++i) {
1003 const int64_t q_index = GetQIndex(quant, i);
1004 segmentation.y_dequant[i][0] =
1005 kDcQLookup[bit_depth_index][ClampQ(q_index + quant.delta_q_y_dc)];
1006 segmentation.y_dequant[i][1] =
1007 kAcQLookup[bit_depth_index][ClampQ(q_index)];
1008 segmentation.uv_dequant[i][0] =
1009 kDcQLookup[bit_depth_index][ClampQ(q_index + quant.delta_q_uv_dc)];
1010 segmentation.uv_dequant[i][1] =
1011 kAcQLookup[bit_depth_index][ClampQ(q_index + quant.delta_q_uv_ac)];
1014 const int64_t q_index = quant.base_q_idx;
1015 segmentation.y_dequant[0][0] =
1016 kDcQLookup[bit_depth_index][ClampQ(q_index + quant.delta_q_y_dc)];
1017 segmentation.y_dequant[0][1] = kAcQLookup[bit_depth_index][ClampQ(q_index)];
1018 segmentation.uv_dequant[0][0] =
1019 kDcQLookup[bit_depth_index][ClampQ(q_index + quant.delta_q_uv_dc)];
1020 segmentation.uv_dequant[0][1] =
1021 kAcQLookup[bit_depth_index][ClampQ(q_index + quant.delta_q_uv_ac)];
1026 // 8.8.1 Loop filter frame init process
1027 void Vp9Parser::SetupLoopFilter() {
1028 Vp9LoopFilterParams& loop_filter = context_.loop_filter_;
1029 if (!loop_filter.level) {
1033 int scale = loop_filter.level < 32 ? 1 : 2;
1035 for (size_t i = 0; i < Vp9SegmentationParams::kNumSegments; ++i) {
1036 int level = loop_filter.level;
1037 const Vp9SegmentationParams& segmentation = context_.segmentation();
1039 if (segmentation.FeatureEnabled(i, Vp9SegmentationParams::SEG_LVL_ALT_LF)) {
1041 segmentation.FeatureData(i, Vp9SegmentationParams::SEG_LVL_ALT_LF);
1042 level = ClampLf(segmentation.abs_or_delta_update ? feature_data
1043 : level + feature_data);
1046 if (!loop_filter.delta_enabled) {
1047 memset(loop_filter.lvl[i], level, sizeof(loop_filter.lvl[i]));
1049 loop_filter.lvl[i][Vp9RefType::VP9_FRAME_INTRA][0] = ClampLf(
1050 level + loop_filter.ref_deltas[Vp9RefType::VP9_FRAME_INTRA] * scale);
1051 loop_filter.lvl[i][Vp9RefType::VP9_FRAME_INTRA][1] = 0;
1053 for (size_t type = Vp9RefType::VP9_FRAME_LAST;
1054 type < Vp9RefType::VP9_FRAME_MAX; ++type) {
1055 for (size_t mode = 0; mode < Vp9LoopFilterParams::kNumModeDeltas;
1057 loop_filter.lvl[i][type][mode] =
1058 ClampLf(level + loop_filter.ref_deltas[type] * scale +
1059 loop_filter.mode_deltas[mode] * scale);
1066 void Vp9Parser::UpdateSlots(Vp9Parser::Context* context) {
1067 // 8.10 Reference frame update process
1068 for (size_t i = 0; i < kVp9NumRefFrames; i++) {
1069 if (curr_frame_header_.RefreshFlag(i)) {
1070 ReferenceSlot ref_slot;
1071 ref_slot.initialized = true;
1073 ref_slot.frame_width = curr_frame_header_.frame_width;
1074 ref_slot.frame_height = curr_frame_header_.frame_height;
1075 ref_slot.subsampling_x = curr_frame_header_.subsampling_x;
1076 ref_slot.subsampling_y = curr_frame_header_.subsampling_y;
1077 ref_slot.bit_depth = curr_frame_header_.bit_depth;
1079 ref_slot.profile = curr_frame_header_.profile;
1080 ref_slot.color_space = curr_frame_header_.color_space;
1081 context->UpdateRefSlot(i, ref_slot);
1086 } // namespace media