Debian Codegraph @

media_driver/agnostic/common/codec/hal/codechal_decode_vc1.cpp

raw
1 /*
2 * Copyright (c) 2011-2020, Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included
12 * in all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
21 */
22
23 //!
24 //! \file codechal_decode_vc1.cpp
25 //! \brief Implements the decode interface extension for VC1.
26 //! \details Implements all functions required by CodecHal for VC1 decoding.
27 //!
28
29 #include "codechal_decoder.h"
30 #include "codechal_decode_vc1.h"
31 #include "codechal_secure_decode_interface.h"
32 #include "codechal_mmc_decode_vc1.h"
33 #include "hal_oca_interface.h"
34 #if USE_CODECHAL_DEBUG_TOOL
35 #include <sstream>
36 #include <fstream>
37 #include "codechal_debug.h"
38 #endif
39 #define CODECHAL_DECODE_VC1_EOS ((uint32_t)(-1))
40
41 // picture layer bits
42 #define CODECHAL_DECODE_VC1_BITS_INTERPFRM 1
43 #define CODECHAL_DECODE_VC1_BITS_FRMCNT 2
44 #define CODECHAL_DECODE_VC1_BITS_RANGEREDFRM 1
45 #define CODECHAL_DECODE_VC1_BITS_FPTYPE 3
46 #define CODECHAL_DECODE_VC1_BITS_BF 7
47 #define CODECHAL_DECODE_VC1_BITS_PQINDEX 5
48 #define CODECHAL_DECODE_VC1_BITS_HALFQP 1
49 #define CODECHAL_DECODE_VC1_BITS_PQUANTIZER 1
50 #define CODECHAL_DECODE_VC1_BITS_RESPIC 2
51 #define CODECHAL_DECODE_VC1_BITS_INTERLCF 1
52
53 #define CODECHAL_DECODE_VC1_BITS_TRANSACFRM_1 1
54 #define CODECHAL_DECODE_VC1_BITS_TRANSACFRM_2 1
55 #define CODECHAL_DECODE_VC1_BITS_TRANSACFRM2_1 1
56 #define CODECHAL_DECODE_VC1_BITS_TRANSACFRM2_2 1
57 #define CODECHAL_DECODE_VC1_BITS_TRANSDCTAB 1
58
59 #define CODECHAL_DECODE_VC1_BITS_FRSKIP 1
60 #define CODECHAL_DECODE_VC1_BITS_TFCNTR 8
61 #define CODECHAL_DECODE_VC1_BITS_FCM_1 1
62 #define CODECHAL_DECODE_VC1_BITS_FCM_2 1
63 #define CODECHAL_DECODE_VC1_BITS_TFF 1
64 #define CODECHAL_DECODE_VC1_BITS_RFF 1
65 #define CODECHAL_DECODE_VC1_BITS_REPSEQHDR 1
66 #define CODECHAL_DECODE_VC1_BITS_UVSAMP 1
67 #define CODECHAL_DECODE_VC1_BITS_POSTPROC 2
68 #define CODECHAL_DECODE_VC1_BITS_DQUANTFRM 1
69 #define CODECHAL_DECODE_VC1_BITS_DQPROFILE 2
70 #define CODECHAL_DECODE_VC1_BITS_DQSBEDGE 2
71 #define CODECHAL_DECODE_VC1_BITS_DQDBEDGE 2
72 #define CODECHAL_DECODE_VC1_BITS_DQBILEVEL 1
73 #define CODECHAL_DECODE_VC1_BITS_PQDIFF 3
74 #define CODECHAL_DECODE_VC1_BITS_ABSPQ 5
75
76 #define CODECHAL_DECODE_VC1_BITS_MVMODEBIT 1
77 #define CODECHAL_DECODE_VC1_BITS_LUMSCALE 6
78 #define CODECHAL_DECODE_VC1_BITS_LUMSHIFT 6
79 #define CODECHAL_DECODE_VC1_BITS_MVTAB 2
80 #define CODECHAL_DECODE_VC1_BITS_CBPTAB 2
81 #define CODECHAL_DECODE_VC1_BITS_TTMBF 1
82 #define CODECHAL_DECODE_VC1_BITS_TTFRM 2
83 #define CODECHAL_DECODE_VC1_BITS_ABSMQ 5
84
85 #define CODECHAL_DECODE_VC1_BITS_RPTFRM 2
86 #define CODECHAL_DECODE_VC1_BITS_RNDCTRL 1
87
88 #define CODECHAL_DECODE_VC1_BITS_PS_PRESENT 1
89 #define CODECHAL_DECODE_VC1_BITS_PS_HOFFSET 18
90 #define CODECHAL_DECODE_VC1_BITS_PS_VOFFSET 18
91 #define CODECHAL_DECODE_VC1_BITS_PS_WIDTH 14
92 #define CODECHAL_DECODE_VC1_BITS_PS_HEIGHT 14
93
94 #define CODECHAL_DECODE_VC1_BITS_REFDIST 2
95 #define CODECHAL_DECODE_VC1_BITS_REFFIELD 1
96
97 #define CODECHAL_DECODE_VC1_BITS_NUMREF 1
98 #define CODECHAL_DECODE_VC1_BITS_MBMODETAB 3
99 #define CODECHAL_DECODE_VC1_BITS_CBPTAB_INTERLACE 3
100 #define CODECHAL_DECODE_VC1_BITS_4MVBPTAB 2
101 #define CODECHAL_DECODE_VC1_BITS_2MVBPTAB 2
102
103 #define CODECHAL_DECODE_VC1_BITS_4MVSWITCH 1
104 #define CODECHAL_DECODE_VC1_BITS_INTCOMP 1
105
106 // bitplane
107 #define CODECHAL_DECODE_VC1_BITS_BITPLANE_INVERT 1
108 #define CODECHAL_DECODE_VC1_BITS_BITPLANE_ROWSKIP 1
109 #define CODECHAL_DECODE_VC1_BITS_BITPLANE_COLSKIP 1
110
111 // slice layer bits
112 #define CODECHAL_DECODE_VC1_BITS_SC_SUFFIX 8
113 #define CODECHAL_DECODE_VC1_BITS_SLICE_ADDR 9
114 #define CODECHAL_DECODE_VC1_BITS_PIC_HEADER_FLAG 1
115 #define CODECHAL_DECODE_VC1_BITS_SLICE_HEADER ((CODECHAL_DECODE_VC1_BITS_SC_SUFFIX) + (CODECHAL_DECODE_VC1_BITS_SLICE_ADDR) + (CODECHAL_DECODE_VC1_BITS_PIC_HEADER_FLAG))
116
117 #define CODECHAL_DECODE_VC1_MV_OFFEST_SIZE 3
118
119 MOS_STATUS CodechalDecodeVc1::GetBits(uint32_t bitsRead, uint32_t &value)
120 {
121 value = GetBits(bitsRead);
122
123 if (CODECHAL_DECODE_VC1_EOS == value)
124 {
125 return MOS_STATUS_UNKNOWN;
126 }
127
128 return MOS_STATUS_SUCCESS;
129 }
130
131 MOS_STATUS CodechalDecodeVc1::GetVLC(const uint32_t* table, uint32_t &value)
132 {
133 value = GetVLC(table);
134 if (CODECHAL_DECODE_VC1_EOS == value)
135 {
136 return MOS_STATUS_UNKNOWN;
137 }
138 return MOS_STATUS_SUCCESS;
139 }
140
141 MOS_STATUS CodechalDecodeVc1::SkipWords(uint32_t dwordNumber, uint32_t &value)
142 {
143 for (uint32_t i = 0; i < dwordNumber; i++)
144 {
145 value = SkipBits(16);
146 if (CODECHAL_DECODE_VC1_EOS == value)
147 {
148 return MOS_STATUS_UNKNOWN;
149 }
150 }
151
152 return MOS_STATUS_SUCCESS;
153 }
154
155 MOS_STATUS CodechalDecodeVc1::SkipBits(uint32_t bits, uint32_t &value)
156 {
157 if ((bits) > 0)
158 {
159 value = SkipBits(bits);
160 if (CODECHAL_DECODE_VC1_EOS == value)
161 {
162 return MOS_STATUS_UNKNOWN;
163 }
164 }
165 return MOS_STATUS_SUCCESS;
166 }
167
168 typedef union _CODECHAL_DECODE_VC1_BITSTREAM_BUFFER_VALUE
169 {
170 uint32_t u32Value;
171 uint8_t u8Value[sizeof(uint32_t)];
172 } CODECHAL_DECODE_VC1_BITSTREAM_VALUE, *PCODECHAL_DECODE_VC1_BITSTREAM_VALUE;
173
174 typedef enum _CODECHAL_DECODE_VC1_MVMODE
175 {
176 CODECHAL_VC1_MVMODE_1MV_HALFPEL_BILINEAR,
177 CODECHAL_VC1_MVMODE_1MV_HALFPEL,
178 CODECHAL_VC1_MVMODE_1MV,
179 CODECHAL_VC1_MVMODE_MIXEDMV,
180 CODECHAL_VC1_MVMODE_IC // Intensity Compensation
181 } CODECHAL_DECODE_VC1_MVMODE;
182
183 typedef enum _CODECHAL_DECODE_VC1_BITPLANE_CODING_MODE
184 {
185 CODECHAL_VC1_BITPLANE_RAW,
186 CODECHAL_VC1_BITPLANE_NORMAL2,
187 CODECHAL_VC1_BITPLANE_DIFF2,
188 CODECHAL_VC1_BITPLANE_NORMAL6,
189 CODECHAL_VC1_BITPLANE_DIFF6,
190 CODECHAL_VC1_BITPLANE_ROWSKIP,
191 CODECHAL_VC1_BITPLANE_COLSKIP
192 } CODECHAL_DECODE_VC1_BITPLANE_CODING_MODE;
193
194 static const uint32_t CODECHAL_DECODE_VC1_VldBitplaneModeTable[] =
195 {
196 4, /* max bits */
197 0, /* 1-bit codes */
198 2, /* 2-bit codes */
199 2, CODECHAL_VC1_BITPLANE_NORMAL2,
200 3, CODECHAL_VC1_BITPLANE_NORMAL6,
201 3, /* 3-bit codes */
202 1, CODECHAL_VC1_BITPLANE_DIFF2,
203 2, CODECHAL_VC1_BITPLANE_ROWSKIP,
204 3, CODECHAL_VC1_BITPLANE_COLSKIP,
205 2, /* 4-bit codes */
206 0, CODECHAL_VC1_BITPLANE_RAW,
207 1, CODECHAL_VC1_BITPLANE_DIFF6,
208 (uint32_t)-1
209 };
210
211 static const uint32_t CODECHAL_DECODE_VC1_VldCode3x2Or2x3TilesTable[] =
212 {
213 13, /* max bits */
214 1, /* 1-bit codes */
215 1, 0,
216 0, /* 2-bit codes */
217 0, /* 3-bit codes */
218 6, /* 4-bit codes */
219 2, 1,
220 3, 2,
221 4, 4,
222 5, 8,
223
224 6, 16,
225 7, 32,
226 0, /* 5-bit codes */
227 1, /* 6-bit codes */
228 (3 << 1) | 1, 63,
229 0, /* 7-bit codes */
230 15, /* 8-bit codes */
231 0, 3,
232 1, 5,
233 2, 6,
234 3, 9,
235
236 4, 10,
237 5, 12,
238 6, 17,
239 7, 18,
240
241 8, 20,
242 9, 24,
243 10, 33,
244 11, 34,
245
246 12, 36,
247 13, 40,
248 14, 48,
249 6, /* 9-bit codes */
250 (3 << 4) | 7, 31,
251 (3 << 4) | 6, 47,
252 (3 << 4) | 5, 55,
253 (3 << 4) | 4, 59,
254
255 (3 << 4) | 3, 61,
256 (3 << 4) | 2, 62,
257 20, /* 10-bit codes */
258 (1 << 6) | 11, 11,
259 (1 << 6) | 7, 7,
260 (1 << 6) | 13, 13,
261 (1 << 6) | 14, 14,
262
263 (1 << 6) | 19, 19,
264 (1 << 6) | 21, 21,
265 (1 << 6) | 22, 22,
266 (1 << 6) | 25, 25,
267
268 (1 << 6) | 26, 26,
269 (1 << 6) | 28, 28,
270 (1 << 6) | 3, 35,
271 (1 << 6) | 5, 37,
272
273 (1 << 6) | 6, 38,
274 (1 << 6) | 9, 41,
275 (1 << 6) | 10, 42,
276 (1 << 6) | 12, 44,
277
278 (1 << 6) | 17, 49,
279 (1 << 6) | 18, 50,
280 (1 << 6) | 20, 52,
281 (1 << 6) | 24, 56,
282 0, /* 11-bit codes */
283 0, /* 12-bit codes */
284 15, /* 13-bit codes */
285 (3 << 8) | 14, 15,
286 (3 << 8) | 13, 23,
287 (3 << 8) | 12, 27,
288 (3 << 8) | 11, 29,
289
290 (3 << 8) | 10, 30,
291 (3 << 8) | 9, 39,
292 (3 << 8) | 8, 43,
293 (3 << 8) | 7, 45,
294
295 (3 << 8) | 6, 46,
296 (3 << 8) | 5, 51,
297 (3 << 8) | 4, 53,
298 (3 << 8) | 3, 54,
299
300 (3 << 8) | 2, 57,
301 (3 << 8) | 1, 58,
302 (3 << 8) | 0, 60,
303 (uint32_t)-1
304 };
305
306 static const uint32_t CODECHAL_DECODE_VC1_VldPictureTypeTable[] =
307 {
308 4, /* max bits */
309 1, /* 1-bit codes */
310 0, vc1PFrame,
311 1, /* 2-bit codes */
312 2, vc1BFrame,
313 1, /* 3-bit codes */
314 6, vc1IFrame,
315 2, /* 4-bit codes */
316 14, vc1BIFrame,
317 15, vc1SkippedFrame,
318 (uint32_t)-1
319 };
320
321 static const uint32_t CODECHAL_DECODE_VC1_VldBFractionTable[] =
322 {
323 7, /* max bits */
324 0, /* 1-bit codes */
325 0, /* 2-bit codes */
326 7, /* 3-bit codes */
327 0x00, 0,
328 0x01, 1,
329 0x02, 2,
330 0x03, 3,
331
332 0x04, 4,
333 0x05, 5,
334 0x06, 6,
335 0, /* 4-bit codes */
336 0, /* 5-bit codes */
337 0, /* 6-bit codes */
338 14, /* 7-bit codes */
339 0x70, 7,
340 0x71, 8,
341 0x72, 9,
342 0x73, 10,
343
344 0x74, 11,
345 0x75, 12,
346 0x76, 13,
347 0x77, 14,
348
349 0x78, 15,
350 0x79, 16,
351 0x7A, 17,
352 0x7B, 18,
353
354 0x7C, 19,
355 0x7D, 20,
356 (uint32_t)-1
357 };
358
359 static const uint32_t CODECHAL_DECODE_VC1_VldRefDistTable[] =
360 {
361 14, /* max bits */
362 1, /* 1-bit codes */
363 0, 3,
364 1, /* 2-bit codes */
365 2, 4,
366 1, /* 3-bit codes */
367 6, 5,
368 1, /* 4-bit codes */
369 14, 6,
370 1, /* 5-bit codes */
371 30, 7,
372 1, /* 6-bit codes */
373 62, 8,
374 1, /* 7-bit codes */
375 126, 9,
376 1, /* 8-bit codes */
377 254, 10,
378 1, /* 9-bit codes */
379 510, 11,
380 1, /* 10-bit codes */
381 1022, 12,
382 1, /* 11-bit codes */
383 2046, 13,
384 1, /* 12-bit codes */
385 4094, 14,
386 1, /* 13-bit codes */
387 8190, 15,
388 1, /* 14-bit codes */
389 16382, 16,
390 (uint32_t)-1
391 };
392
393 // lookup tables for MVMODE
394 static const uint32_t CODECHAL_DECODE_VC1_LowRateMvModeTable[] =
395 {
396 CODECHAL_VC1_MVMODE_1MV_HALFPEL_BILINEAR,
397 CODECHAL_VC1_MVMODE_1MV,
398 CODECHAL_VC1_MVMODE_1MV_HALFPEL,
399 CODECHAL_VC1_MVMODE_MIXEDMV,
400 CODECHAL_VC1_MVMODE_IC
401 };
402
403 static const uint32_t CODECHAL_DECODE_VC1_HighRateMvModeTable[] =
404 {
405 CODECHAL_VC1_MVMODE_1MV,
406 CODECHAL_VC1_MVMODE_MIXEDMV,
407 CODECHAL_VC1_MVMODE_1MV_HALFPEL,
408 CODECHAL_VC1_MVMODE_1MV_HALFPEL_BILINEAR,
409 CODECHAL_VC1_MVMODE_IC
410 };
411
412 // lock up table for luma polarity (Interlaced picture)
413 static const CODECHAL_DECODE_VC1_I_LUMA_BLOCKS CODECHAL_DECODE_VC1_LumaBlocks_I[16] =
414 {
415 { 4,{ 0 }, 0, 0, 0 },{ 3,{ 0 }, 2, 4, 6 },{ 3,{ 0 }, 0, 4, 6 },{ 2,{ 4 }, 6, 0, 2 },{ 3,{ 0 }, 0, 2, 6 },{ 2,{ 2 }, 6, 0, 4 },{ 2,{ 0 }, 6, 2, 4 },{ 3,{ 1 }, 0, 2, 4 },
416 { 3,{ 0 }, 0, 2, 4 },{ 2,{ 2 }, 4, 0, 6 },{ 2,{ 0 }, 4, 2, 6 },{ 3,{ 1 }, 0, 2, 6 },{ 2,{ 0 }, 2, 4, 6 },{ 3,{ 1 }, 0, 4, 6 },{ 3,{ 1 }, 2, 4, 6 },{ 4,{ 1 }, 0, 0, 0 }
417 };
418
419 // lock up table for luma inter-coded blocks (Progressive picture)
420 static const CODECHAL_DECODE_VC1_P_LUMA_BLOCKS CODECHAL_DECODE_VC1_LumaBlocks_P[16] =
421 {
422 { 4, 0, 0, 0 },{ 3, 0, 2, 4 },{ 3, 0, 2, 6 },{ 2, 0, 2, 0 },{ 3, 0, 4, 6 },{ 2, 0, 4, 0 },{ 2, 0, 6, 0 },{ 0, 0, 0, 0 },
423 { 3, 2, 4, 6 },{ 2, 2, 4, 0 },{ 2, 2, 6, 0 },{ 0, 0, 0, 0 },{ 2, 4, 6, 0 },{ 0, 0, 0, 0 },{ 0, 0, 0, 0 },{ 0, 0, 0, 0 }
424 };
425
426 static const int16_t CODECHAL_DECODE_VC1_MV_OFFEST[CODECHAL_DECODE_VC1_MV_OFFEST_SIZE][2] = { { 0, 2 },{ -2, 0 },{ 0, 0 } };
427 static const uint8_t CODECHAL_DECODE_VC1_RndTb[4] = { 0, 0, 0, 1 };
428
429 const CODECHAL_DECODE_VC1_OLP_STATIC_DATA g_cInit_CODECHAL_DECODE_VC1_OLP_STATIC_DATA =
430 {
431 // uint32_t 0
432 {
433 { 0 } // Reserved
434 },
435
436 // uint32_t 1
437 {
438 {
439 16, // BlockWidth in Byte
440 16 // BlockHeight in Byte
441 }
442 },
443
444 // uint32_t 2
445 {
446 {
447 0, // Profile
448 0, // RangeExpansionFlag
449 0, // UpsamplingFlag
450 0, // InterlaceFieldFlag
451 0, // RangeMapUV
452 0, // RangeMapUVFlag
453 0, // RangeMapY
454 0, // RangeMapYFlag
455 0 // ComponentFlag
456 }
457 },
458
459 // uint32_t 3
460 {
461 { 0 } // ComponentFlag
462 },
463
464 // uint32_t 4
465 {
466 { 0 } // SourceDataBindingIndex (default: CODECHAL_DECODE_VC1_OLP_SRC_Y)
467 },
468
469 // uint32_t 5
470 {
471 { 3 } // DestDataBindingIndex (default: CODECHAL_DECODE_VC1_OLP_DST_Y)
472 },
473
474 // uint32_t 6
475 {
476 { 0 } // Reserved
477 },
478
479 // uint32_t 7
480 {
481 { 0 } // Reserved
482 }
483 };
484
485 //==<Functions>=======================================================
486
487 int16_t CodechalDecodeVc1::PackMotionVectorsMedian3(int16_t mv1, int16_t mv2, int16_t mv3)
488 {
489 if (mv1 > mv2)
490 {
491 if (mv2 > mv3)
492 return mv2;
493 if (mv1 > mv3)
494 return mv3;
495 return mv1;
496 }
497 if (mv1 > mv3)
498 return mv1;
499 if (mv2 > mv3)
500 return mv3;
501 return mv2;
502 }
503
504 int16_t CodechalDecodeVc1::PackMotionVectorsMedian4(int16_t mv1, int16_t mv2, int16_t mv3, int16_t mv4)
505 {
506 int16_t max = mv1, min = mv1;
507
508 if (mv2 > max)
509 {
510 max = mv2;
511 }
512 else if (mv2 < min)
513 {
514 min = mv2;
515 }
516
517 if (mv3 > max)
518 {
519 max = mv3;
520 }
521 else if (mv3 < min)
522 {
523 min = mv3;
524 }
525
526 if (mv4 > max)
527 {
528 max = mv4;
529 }
530 else if (mv4 < min)
531 {
532 min = mv4;
533 }
534
535 return (mv1 + mv2 + mv3 + mv4 - max - min) / 2;
536 }
537
538 void CodechalDecodeVc1::PackMotionVectorsChroma4MvP(uint16_t intraFlags, int16_t *lmv, int16_t *cmv)
539 {
540 int16_t mvX = 0, mvY = 0;
541
542 if (CODECHAL_DECODE_VC1_LumaBlocks_P[intraFlags].u8NumIntercodedBlocks == 4)
543 {
544 mvX = PackMotionVectorsMedian4(lmv[0], lmv[2], lmv[4], lmv[6]);
545 mvY = PackMotionVectorsMedian4(lmv[1], lmv[3], lmv[5], lmv[7]);
546 }
547 else if (CODECHAL_DECODE_VC1_LumaBlocks_P[intraFlags].u8NumIntercodedBlocks == 3)
548 {
549 mvX = PackMotionVectorsMedian3(lmv[CODECHAL_DECODE_VC1_LumaBlocks_P[intraFlags].u8MvIndex1],
550 lmv[CODECHAL_DECODE_VC1_LumaBlocks_P[intraFlags].u8MvIndex2],
551 lmv[CODECHAL_DECODE_VC1_LumaBlocks_P[intraFlags].u8MvIndex3]);
552 mvY = PackMotionVectorsMedian3(lmv[CODECHAL_DECODE_VC1_LumaBlocks_P[intraFlags].u8MvIndex1 + 1],
553 lmv[CODECHAL_DECODE_VC1_LumaBlocks_P[intraFlags].u8MvIndex2 + 1],
554 lmv[CODECHAL_DECODE_VC1_LumaBlocks_P[intraFlags].u8MvIndex3 + 1]);
555 }
556 else if (CODECHAL_DECODE_VC1_LumaBlocks_P[intraFlags].u8NumIntercodedBlocks == 2)
557 {
558 mvX = (lmv[CODECHAL_DECODE_VC1_LumaBlocks_P[intraFlags].u8MvIndex1] + lmv[CODECHAL_DECODE_VC1_LumaBlocks_P[intraFlags].u8MvIndex2]) / 2;
559 mvY = (lmv[CODECHAL_DECODE_VC1_LumaBlocks_P[intraFlags].u8MvIndex1 + 1] + lmv[CODECHAL_DECODE_VC1_LumaBlocks_P[intraFlags].u8MvIndex2 + 1]) / 2;
560 }
561
562 cmv[0] = CODECHAL_DECODE_VC1_CHROMA_MV(mvX);
563 cmv[1] = CODECHAL_DECODE_VC1_CHROMA_MV(mvY);
564 }
565
566 uint8_t CodechalDecodeVc1::PackMotionVectorsChroma4MvI(
567 uint16_t fieldSelect,
568 uint16_t currentField,
569 bool fastUVMotionCompensation,
570 int16_t *lmv,
571 int16_t *cmv)
572 {
573 int16_t mvX = 0, mvY = 0;
574 uint8_t polarity;
575 uint16_t offset, offsetIndex;
576 uint8_t index1, index2, index3, index4;
577
578 if ((currentField == PICTURE_FRAME) || (currentField == PICTURE_INTERLACED_FRAME))
579 {
580 offsetIndex = 2;
581 }
582 else
583 {
584 offsetIndex = currentField - 1;
585 }
586
587 if (offsetIndex >= CODECHAL_DECODE_VC1_MV_OFFEST_SIZE)
588 {
589 CODECHAL_DECODE_ASSERTMESSAGE("ERROR: offsetIndex out of bounds (%d, max %d)", offsetIndex, CODECHAL_DECODE_VC1_MV_OFFEST_SIZE);
590 return 0;
591 }
592
593 if (CODECHAL_DECODE_VC1_LumaBlocks_I[fieldSelect].u8NumSamePolarity == 4)
594 {
595 polarity = CODECHAL_DECODE_VC1_LumaBlocks_I[fieldSelect].u8Polarity ? 1 : 0;
596 offset = CODECHAL_DECODE_VC1_MV_OFFEST[offsetIndex][polarity];
597
598 // Unadjust Luma
599 lmv[1] += offset;
600 lmv[3] += offset;
601 lmv[5] += offset;
602 lmv[7] += offset;
603
604 mvX = PackMotionVectorsMedian4(lmv[0], lmv[2], lmv[4], lmv[6]);
605 mvY = PackMotionVectorsMedian4(lmv[1], lmv[3], lmv[5], lmv[7]);
606 }
607 else if (CODECHAL_DECODE_VC1_LumaBlocks_I[fieldSelect].u8NumSamePolarity == 3)
608 {
609 polarity = CODECHAL_DECODE_VC1_LumaBlocks_I[fieldSelect].u8Polarity ? 1 : 0;
610 index2 = CODECHAL_DECODE_VC1_LumaBlocks_I[fieldSelect].u8MvIndex1;
611 index3 = CODECHAL_DECODE_VC1_LumaBlocks_I[fieldSelect].u8MvIndex2;
612 index4 = CODECHAL_DECODE_VC1_LumaBlocks_I[fieldSelect].u8MvIndex3;
613 index1 = 12 - (index2 + index3 + index4); // Sum of indices is 12
614
615 // Unadjust Luma of current polarity
616 offset = CODECHAL_DECODE_VC1_MV_OFFEST[offsetIndex][polarity];
617 lmv[index2 + 1] += offset;
618 lmv[index3 + 1] += offset;
619 lmv[index4 + 1] += offset;
620
621 if (PICTURE_TOP_FIELD != currentField && PICTURE_BOTTOM_FIELD != currentField)
622 {
623 CODECHAL_DECODE_ASSERTMESSAGE("Invalid Parameters.");
624 }
625 else
626 {
627 // Unadjust Luma of opposite polarity
628 offset = CODECHAL_DECODE_VC1_MV_OFFEST[currentField - 1][1 - polarity];
629 }
630
631 lmv[index1 + 1] += offset;
632
633 mvX = PackMotionVectorsMedian3(lmv[index2],
634 lmv[index3],
635 lmv[index4]);
636 mvY = PackMotionVectorsMedian3(lmv[index2 + 1],
637 lmv[index3 + 1],
638 lmv[index4 + 1]);
639 }
640 else
641 {
642 if (currentField == PICTURE_TOP_FIELD)
643 {
644 index1 = CODECHAL_DECODE_VC1_LumaBlocks_I[fieldSelect].u8MvIndex0;
645 index2 = CODECHAL_DECODE_VC1_LumaBlocks_I[fieldSelect].u8MvIndex1;
646 index3 = CODECHAL_DECODE_VC1_LumaBlocks_I[fieldSelect].u8MvIndex2;
647 index4 = CODECHAL_DECODE_VC1_LumaBlocks_I[fieldSelect].u8MvIndex3;
648 polarity = 0;
649 }
650 else
651 {
652 index1 = CODECHAL_DECODE_VC1_LumaBlocks_I[fieldSelect].u8MvIndex2;
653 index2 = CODECHAL_DECODE_VC1_LumaBlocks_I[fieldSelect].u8MvIndex3;
654 index3 = CODECHAL_DECODE_VC1_LumaBlocks_I[fieldSelect].u8MvIndex0;
655 index4 = CODECHAL_DECODE_VC1_LumaBlocks_I[fieldSelect].u8MvIndex1;
656 polarity = 1;
657 }
658
659 // Unadjust Luma of current polarity
660 offset = CODECHAL_DECODE_VC1_MV_OFFEST[offsetIndex][polarity];
661 lmv[index1 + 1] += offset;
662 lmv[index2 + 1] += offset;
663
664 // Unadjust Luma of opposite polarity
665 offset = CODECHAL_DECODE_VC1_MV_OFFEST[offsetIndex][1 - polarity];
666 lmv[index3 + 1] += offset;
667 lmv[index4 + 1] += offset;
668
669 mvX = (lmv[index1] + lmv[index2]) / 2;
670 mvY = (lmv[index1 + 1] + lmv[index2 + 1]) / 2;
671 offset = 0;
672 }
673
674 cmv[0] = CODECHAL_DECODE_VC1_CHROMA_MV(mvX);
675 cmv[1] = CODECHAL_DECODE_VC1_CHROMA_MV(mvY);
676
677 if (fastUVMotionCompensation)
678 {
679 cmv[0] = CODECHAL_DECODE_VC1_FAST_CHROMA_MV(cmv[0]);
680 cmv[1] = CODECHAL_DECODE_VC1_FAST_CHROMA_MV(cmv[1]);
681 }
682
683 return polarity;
684 }
685
686 void CodechalDecodeVc1::PackMotionVectors(
687 PMHW_VDBOX_VC1_MB_STATE vc1MbState,
688 int16_t *mv,
689 int16_t *packedLumaMvs,
690 int16_t *packedChromaMv)
691 {
692 uint16_t selectFlags;
693
694 PCODEC_VC1_MB_PARAMS mb = vc1MbState->pMb;
695 uint8_t b4Mv = mb->mb_type.motion_4mv;
696 uint8_t mfwd = mb->mb_type.motion_forward;
697 uint8_t mbwd = mb->mb_type.motion_backward;
698 uint8_t mtype = mb->mb_type.motion_type;
699 vc1MbState->bMotionSwitch = 0;
700 PCODEC_VC1_PIC_PARAMS vc1PicParams = vc1MbState->pVc1PicParams;
701
702 bool isPPicture = m_mfxInterface->IsVc1PPicture(
703 vc1PicParams->CurrPic,
704 vc1PicParams->picture_fields.is_first_field,
705 vc1PicParams->picture_fields.picture_type) ? true : false;
706
707 if (packedLumaMvs == nullptr)
708 {
709 CODECHAL_DECODE_ASSERTMESSAGE("ERROR: packedLumaMvs is nullptr");
710 return;
711 }
712
713 if (packedChromaMv == nullptr)
714 {
715 CODECHAL_DECODE_ASSERTMESSAGE("ERROR: packedChromaMv is nullptr");
716 return;
717 }
718
719 packedLumaMvs[0] = packedLumaMvs[2] = packedLumaMvs[4] = packedLumaMvs[6] = 0;
720 packedLumaMvs[1] = packedLumaMvs[3] = packedLumaMvs[5] = packedLumaMvs[7] = 0;
721
722 packedChromaMv[0] = CODECHAL_DECODE_VC1_CHROMA_MV(packedLumaMvs[0]);
723 packedChromaMv[1] = CODECHAL_DECODE_VC1_CHROMA_MV(packedLumaMvs[1]);
724
725 if (b4Mv)
726 {
727 packedLumaMvs[0] = (int16_t)mv[CodechalDecodeRstFirstForwHorz];
728 packedLumaMvs[1] = (int16_t)mv[CodechalDecodeRstFirstForwVert];
729 packedLumaMvs[2] = (int16_t)mv[CodechalDecodeRstFirstBackHorz];
730 packedLumaMvs[3] = (int16_t)mv[CodechalDecodeRstFirstBackVert];
731 packedLumaMvs[4] = (int16_t)mv[CodechalDecodeRstSecndForwHorz];
732 packedLumaMvs[5] = (int16_t)mv[CodechalDecodeRstSecndForwVert];
733 packedLumaMvs[6] = (int16_t)mv[CodechalDecodeRstSecndBackHorz];
734 packedLumaMvs[7] = (int16_t)mv[CodechalDecodeRstSecndBackVert];
735 if (vc1MbState->PicFlags == PICTURE_FRAME)
736 {
737 selectFlags = mb->pattern_code.block_luma_intra;
738 PackMotionVectorsChroma4MvP(selectFlags, packedLumaMvs, packedChromaMv);
739 }
740 else if (vc1MbState->PicFlags != PICTURE_INTERLACED_FRAME)
741 {
742 selectFlags = (mb->mb_type.value & 0xF000) >> 12;
743 vc1MbState->bFieldPolarity = PackMotionVectorsChroma4MvI(
744 selectFlags,
745 vc1MbState->PicFlags,
746 vc1PicParams->fast_uvmc_flag ? true : false,
747 packedLumaMvs,
748 packedChromaMv);
749 }
750 }
751 else
752 {
753 // default settings for frame pictures, relevant Motion Vectors will be reset if needed
754 packedLumaMvs[0] = packedLumaMvs[2] = packedLumaMvs[4] = packedLumaMvs[6] = (int16_t)mv[CodechalDecodeRstFirstForwHorz];
755 packedLumaMvs[1] = packedLumaMvs[3] = packedLumaMvs[5] = packedLumaMvs[7] = (int16_t)mv[CodechalDecodeRstFirstForwVert];
756
757 packedChromaMv[0] = CODECHAL_DECODE_VC1_CHROMA_MV(packedLumaMvs[0]);
758 packedChromaMv[1] = CODECHAL_DECODE_VC1_CHROMA_MV(packedLumaMvs[1]);
759
760 if (vc1MbState->PicFlags == PICTURE_FRAME)
761 {
762 if (mbwd && mfwd)
763 {
764 // Progressive, direct
765 packedLumaMvs[2] = packedLumaMvs[6] = (int16_t)mv[CodechalDecodeRstSecndForwHorz];
766 packedLumaMvs[3] = packedLumaMvs[7] = (int16_t)mv[CodechalDecodeRstSecndForwVert];
767 }
768 }
769 else
770 {
771 if (vc1MbState->PicFlags == PICTURE_INTERLACED_FRAME)
772 {
773 packedLumaMvs[2] = packedLumaMvs[6] = (int16_t)mv[CodechalDecodeRstFirstBackHorz];
774 packedLumaMvs[3] = packedLumaMvs[7] = (int16_t)mv[CodechalDecodeRstFirstBackVert];
775
776 if (mtype == CodechalDecodeMcFrame)
777 {
778 if (isPPicture)
779 {
780 packedLumaMvs[2] = packedLumaMvs[6] = packedLumaMvs[0];
781 packedLumaMvs[3] = packedLumaMvs[7] = packedLumaMvs[1];
782 }
783 }
784 else if (mtype == CodechalDecodeMcField)
785 {
786 packedLumaMvs[4] = (int16_t)mv[CodechalDecodeRstSecndForwHorz];
787 packedLumaMvs[5] = (int16_t)mv[CodechalDecodeRstSecndForwVert];
788 packedLumaMvs[6] = (int16_t)mv[CodechalDecodeRstSecndBackHorz];
789 packedLumaMvs[7] = (int16_t)mv[CodechalDecodeRstSecndBackVert];
790 }
791 }
792 else // Interlaced field
793 {
794 uint8_t fieldPolarity2, offsetIndex;
795 uint32_t i;
796 int16_t offset;
797
798 i = 0;
799 fieldPolarity2 = 0;
800 offsetIndex = vc1MbState->PicFlags - 1;
801
802 if (offsetIndex >= CODECHAL_DECODE_VC1_MV_OFFEST_SIZE)
803 {
804 CODECHAL_DECODE_ASSERTMESSAGE("ERROR: offsetIndex out of bounds (%d, max %d)", offsetIndex, CODECHAL_DECODE_VC1_MV_OFFEST_SIZE);
805 return;
806 }
807
808 if (mfwd)
809 {
810 vc1MbState->bFieldPolarity = mb->mb_type.mvert_field_sel_0;
811 fieldPolarity2 = mb->mb_type.mvert_field_sel_1;
812 i = 1;
813 }
814
815 if (mbwd)
816 {
817 vc1MbState->bFieldPolarity = mb->mb_type.mvert_field_sel_1;
818 fieldPolarity2 = mb->mb_type.mvert_field_sel_0;
819 i = 3;
820
821 packedLumaMvs[2] = packedLumaMvs[6] = (int16_t)mv[CodechalDecodeRstFirstBackHorz];
822 packedLumaMvs[3] = packedLumaMvs[7] = (int16_t)mv[CodechalDecodeRstFirstBackVert];
823 }
824
825 // Unadjust luma
826 offset = CODECHAL_DECODE_VC1_MV_OFFEST[offsetIndex][vc1MbState->bFieldPolarity];
827 packedLumaMvs[i] += offset;
828
829 // Unadjust Luma of opposite polarity
830 offset = CODECHAL_DECODE_VC1_MV_OFFEST[offsetIndex][fieldPolarity2];
831 packedLumaMvs[4 - i] += offset;
832
833 if (isPPicture)
834 {
835 packedLumaMvs[3] = packedLumaMvs[5] = packedLumaMvs[7] = packedLumaMvs[1];
836
837 if (mb->mb_type.mvert_field_sel_0)
838 {
839 mb->mb_type.mvert_field_sel_0 = 1;
840 mb->mb_type.mvert_field_sel_1 = 1;
841 mb->mb_type.mvert_field_sel_2 = 1;
842 mb->mb_type.mvert_field_sel_3 = 1;
843 }
844 }
845 else
846 {
847 packedLumaMvs[5] = packedLumaMvs[1];
848 packedLumaMvs[7] = packedLumaMvs[3];
849 }
850
851 // Derive unadjusted chroma
852 packedChromaMv[0] = CODECHAL_DECODE_VC1_CHROMA_MV(packedLumaMvs[i - 1]);
853 packedChromaMv[1] = CODECHAL_DECODE_VC1_CHROMA_MV(packedLumaMvs[i]);
854 }
855 }
856 }
857
858 if ((vc1MbState->PicFlags == PICTURE_INTERLACED_FRAME) && (mtype == CodechalDecodeMcField))
859 {
860 uint16_t mvFieldSel = (mb->mb_type.value & 0xF000) >> 12;
861 uint16_t concealForSel2 = 0;
862 uint16_t concealForSel3 = 0;
863
864 if (!mb->mb_type.mvert_field_sel_2)
865 {
866 if (!(packedLumaMvs[4] || packedLumaMvs[5]))
867 {
868 concealForSel2 = 1;
869 }
870 packedLumaMvs[5] += 4;
871 }
872 if (!mb->mb_type.mvert_field_sel_3)
873 {
874 if (!(packedLumaMvs[6] || packedLumaMvs[7]))
875 {
876 concealForSel3 = 1;
877 }
878 packedLumaMvs[7] += 4;
879 }
880
881 if (!(mfwd && mbwd) && !b4Mv)
882 {
883 uint16_t topPredBit, botPredBit;
884 uint16_t topPred, botPred;
885
886 if (mfwd && !mbwd)
887 {
888 vc1MbState->bMotionSwitch = mb->mb_type.mvert_field_sel_1;
889
890 topPredBit = 0;
891 botPredBit = (vc1MbState->bMotionSwitch) ? 3 : 2;
892 }
893 else
894 {
895 vc1MbState->bMotionSwitch = mb->mb_type.mvert_field_sel_0;
896
897 topPredBit = 1;
898 botPredBit = (vc1MbState->bMotionSwitch) ? 2 : 3;
899 }
900
901 topPred = mvFieldSel & (1 << topPredBit);
902 botPred = mvFieldSel & (1 << botPredBit);
903
904 if (isPPicture)
905 {
906 packedLumaMvs[0] = packedLumaMvs[2] = packedLumaMvs[topPredBit * 2];
907 packedLumaMvs[1] = packedLumaMvs[3] = packedLumaMvs[(topPredBit * 2) + 1];
908
909 packedLumaMvs[4] = packedLumaMvs[6] = packedLumaMvs[botPredBit * 2];
910 packedLumaMvs[5] = packedLumaMvs[7] = packedLumaMvs[(botPredBit * 2) + 1];
911
912 mb->mb_type.value &= 0x0FFF;
913
914 if (topPred)
915 {
916 mb->mb_type.mvert_field_sel_0 = 1;
917 mb->mb_type.mvert_field_sel_1 = 1;
918 }
919
920 if (botPred)
921 {
922 mb->mb_type.mvert_field_sel_2 = 1;
923 mb->mb_type.mvert_field_sel_3 = 1;
924 }
925 }
926 else if (vc1MbState->bMotionSwitch) // && !P_TYPE
927 {
928 if (concealForSel2)
929 {
930 packedLumaMvs[4] = packedLumaMvs[6];
931 packedLumaMvs[5] = packedLumaMvs[7];
932 }
933 if (concealForSel3)
934 {
935 packedLumaMvs[6] = packedLumaMvs[4];
936 packedLumaMvs[7] = packedLumaMvs[5];
937 }
938
939 mb->mb_type.value &= 0x0FFF;
940
941 if (topPred)
942 {
943 if (topPredBit == 1)
944 {
945 mb->mb_type.mvert_field_sel_1 = 1;
946 }
947 else // topPredBit == 0
948 {
949 mb->mb_type.mvert_field_sel_0 = 1;
950 }
951 }
952
953 if (botPred)
954 {
955 if (botPredBit == 3)
956 {
957 mb->mb_type.mvert_field_sel_2 = 1;
958 }
959 else // botPredBit == 2
960 {
961 mb->mb_type.mvert_field_sel_3 = 1;
962 }
963 }
964 }
965 }
966 }
967
968 if (vc1PicParams->fast_uvmc_flag)
969 {
970 packedChromaMv[0] = CODECHAL_DECODE_VC1_FAST_CHROMA_MV(packedChromaMv[0]);
971 packedChromaMv[1] = CODECHAL_DECODE_VC1_FAST_CHROMA_MV(packedChromaMv[1]);
972 }
973 }
974
975 MOS_STATUS CodechalDecodeVc1::InitializeUnequalFieldSurface(
976 uint8_t refListIdx,
977 bool nullHwInUse)
978 {
979 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
980
981 CODECHAL_DECODE_FUNCTION_ENTER;
982
983 CODEC_PICTURE picture = m_vc1RefList[refListIdx]->RefPic;
984
985 bool isBPicture = m_mfxInterface->IsVc1BPicture(
986 m_vc1PicParams->CurrPic,
987 m_vc1PicParams->picture_fields.is_first_field,
988 m_vc1PicParams->picture_fields.picture_type)
989 ? true
990 : false;
991
992 if (m_vc1RefList[refListIdx]->bUnequalFieldSurfaceValid)
993 {
994 // Reset the Surface Valid flag for second field of B picture
995 if (m_vc1PicParams->CurrPic.FrameIdx == refListIdx && isBPicture)
996 {
997 m_vc1RefList[refListIdx]->bUnequalFieldSurfaceValid = false;
998 }
999
1000 // Unequal field surface may be re-used
1001 return eStatus;
1002 }
1003
1004 uint32_t currUnequalFieldIdx, prevRefListIdx;
1005 if (m_vc1PicParams->CurrPic.FrameIdx == refListIdx && isBPicture)
1006 {
1007 currUnequalFieldIdx = m_unequalFieldSurfaceForBType;
1008 }
1009 else
1010 {
1011 currUnequalFieldIdx = m_currUnequalFieldSurface;
1012
1013 m_currUnequalFieldSurface =
1014 (m_currUnequalFieldSurface + 1) % (CODECHAL_DECODE_VC1_UNEQUAL_FIELD_WA_SURFACES - 1);
1015
1016 prevRefListIdx = m_unequalFieldRefListIdx[currUnequalFieldIdx];
1017
1018 if (prevRefListIdx < CODECHAL_NUM_UNCOMPRESSED_SURFACE_VC1 &&
1019 m_vc1PicParams->CurrPic.FrameIdx != prevRefListIdx)
1020 {
1021 // Invalidate unequal field index for the old reference
1022 m_vc1RefList[prevRefListIdx]->bUnequalFieldSurfaceValid = false;
1023 }
1024 }
1025 // Set up new unequal field values
1026 m_vc1RefList[refListIdx]->bUnequalFieldSurfaceValid = true;
1027 m_vc1RefList[refListIdx]->dwUnequalFieldSurfaceIdx = currUnequalFieldIdx;
1028 m_unequalFieldRefListIdx[currUnequalFieldIdx] = refListIdx;
1029
1030 if (m_vc1PicParams->CurrPic.FrameIdx != refListIdx)
1031 {
1032 MOS_SURFACE srcSurface;
1033 MOS_ZeroMemory(&srcSurface, sizeof(MOS_SURFACE));
1034 srcSurface.Format = Format_NV12;
1035 srcSurface.OsResource = m_vc1RefList[refListIdx]->resRefPic;
1036 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalGetResourceInfo(m_osInterface, &srcSurface));
1037
1038 // Format the unequal field reference
1039 CODECHAL_DECODE_CHK_STATUS_RETURN(FormatUnequalFieldPicture(
1040 srcSurface,
1041 m_unequalFieldSurface[currUnequalFieldIdx],
1042 false,
1043 nullHwInUse));
1044 }
1045
1046 return eStatus;
1047 }
1048
1049 /*----------------------------------------------------------------------------
1050 | Name : CodechalDecodeVc1::FormatUnequalFieldPicture
1051 | Purpose : Formats the destination surface, in the pack case the UV surface
1052 | is moved to be adjacent to the UV surface such that NV12
1053 | formatting is maintained when the surface is returned to SW,
1054 | in the unpack case the UV surface is moved to be 32-pixel rows
1055 | away from the Y surface so that during decoding HW will not
1056 | overwrite the UV surface
1057 | Arguments : dwSrcSurfaceHandle - surface handle for the source surface
1058 | dwDstSurfaceHandle - surface handle for the destination surface
1059 | bPack - boolean value determining whether or not the source
1060 | surface should be packed or unpacked
1061 | Returns : MOS_STATUS - for success or failure
1062 \---------------------------------------------------------------------------*/
1063 MOS_STATUS CodechalDecodeVc1::FormatUnequalFieldPicture(
1064 MOS_SURFACE srcSurface,
1065 MOS_SURFACE dstSurface,
1066 bool pack,
1067 bool nullHwInUse)
1068 {
1069 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1070
1071 CODECHAL_DECODE_FUNCTION_ENTER;
1072
1073 uint32_t uvblockWidth = 16;
1074 uint32_t uvblockHeight = 16;
1075 uint32_t uvblockSize = uvblockWidth * uvblockHeight;
1076 uint32_t frameHeight = MOS_ALIGN_CEIL(m_height, 16);
1077 uint32_t ysize = srcSurface.dwPitch * MOS_ALIGN_CEIL(frameHeight, MOS_YTILE_H_ALIGNMENT);
1078
1079 MOS_COMMAND_BUFFER cmdBuffer;
1080 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &cmdBuffer, 0));
1081
1082 // Send command buffer header at the beginning (OS dependent)
1083 CODECHAL_DECODE_CHK_STATUS_RETURN(SendPrologWithFrameTracking(&cmdBuffer, false));
1084
1085 uint32_t frameSize = MOS_ALIGN_CEIL((srcSurface.dwPitch * (frameHeight + frameHeight / 2)), MOS_YTILE_H_ALIGNMENT);
1086
1087 // Copy Y data first
1088 if (m_hwInterface->m_noHuC)
1089 {
1090 CodechalDataCopyParams dataCopyParams;
1091 MOS_ZeroMemory(&dataCopyParams, sizeof(CodechalDataCopyParams));
1092 dataCopyParams.srcResource = &srcSurface.OsResource;
1093 dataCopyParams.srcSize = ysize;
1094 dataCopyParams.srcOffset = 0;
1095 dataCopyParams.dstResource = &dstSurface.OsResource;
1096 dataCopyParams.dstSize = frameSize;
1097 dataCopyParams.dstOffset = 0;
1098
1099 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->CopyDataSourceWithDrv(&dataCopyParams));
1100 }
1101 else
1102 {
1103 // Stream object params
1104 CODECHAL_DECODE_CHK_STATUS_RETURN(HucCopy(
1105 &cmdBuffer, // pCmdBuffer
1106 &srcSurface.OsResource, // presSrc
1107 &dstSurface.OsResource, // presDst
1108 ysize, // u32CopyLength
1109 0, // u32CopyInputOffset
1110 0)); // u32CopyOutputOffset
1111 }
1112
1113 // Copy 1 MB row of UV
1114 uint32_t srcOffset, dstOffset;
1115 for (uint32_t x = 0; x < srcSurface.dwPitch; x += uvblockWidth)
1116 {
1117 if (pack)
1118 {
1119 srcOffset = LinearToYTiledAddress(
1120 x,
1121 frameHeight + MOS_YTILE_H_ALIGNMENT,
1122 srcSurface.dwPitch);
1123 dstOffset = LinearToYTiledAddress(
1124 x,
1125 frameHeight,
1126 dstSurface.dwPitch);
1127 }
1128 else
1129 {
1130 srcOffset = LinearToYTiledAddress(
1131 x,
1132 frameHeight,
1133 srcSurface.dwPitch);
1134 dstOffset = LinearToYTiledAddress(
1135 x,
1136 frameHeight + MOS_YTILE_H_ALIGNMENT,
1137 dstSurface.dwPitch);
1138 }
1139
1140 if (m_hwInterface->m_noHuC)
1141 {
1142 CodechalDataCopyParams dataCopyParams;
1143 MOS_ZeroMemory(&dataCopyParams, sizeof(CodechalDataCopyParams));
1144 dataCopyParams.srcResource = &srcSurface.OsResource;
1145 dataCopyParams.srcSize = uvblockSize;
1146 dataCopyParams.srcOffset = srcOffset;
1147 dataCopyParams.dstResource = &dstSurface.OsResource;
1148 dataCopyParams.dstSize = frameSize;
1149 dataCopyParams.dstOffset = dstOffset;
1150
1151 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->CopyDataSourceWithDrv(&dataCopyParams));
1152 }
1153 else
1154 {
1155 // Stream object params
1156 CODECHAL_DECODE_CHK_STATUS_RETURN(HucCopy(
1157 &cmdBuffer, // pCmdBuffer
1158 &srcSurface.OsResource, // presSrc
1159 &dstSurface.OsResource, // presDst
1160 uvblockSize, // u32CopyLength
1161 srcOffset, // u32CopyInputOffset
1162 dstOffset)); // u32CopyOutputOffset
1163 }
1164 }
1165
1166 uint32_t uvsize = srcSurface.dwPitch * MOS_ALIGN_CEIL(((frameHeight / 2) - uvblockHeight), MOS_YTILE_H_ALIGNMENT);
1167
1168 if (pack)
1169 {
1170 srcOffset = srcSurface.dwPitch *
1171 (frameHeight + MOS_YTILE_H_ALIGNMENT + uvblockHeight);
1172 dstOffset = dstSurface.dwPitch * (frameHeight + uvblockHeight);
1173 }
1174 else
1175 {
1176 srcOffset = srcSurface.dwPitch * (frameHeight + uvblockHeight);
1177 dstOffset = dstSurface.dwPitch *
1178 (frameHeight + MOS_YTILE_H_ALIGNMENT + uvblockHeight);
1179 }
1180
1181 if (m_hwInterface->m_noHuC)
1182 {
1183 CodechalDataCopyParams dataCopyParams;
1184 MOS_ZeroMemory(&dataCopyParams, sizeof(CodechalDataCopyParams));
1185 dataCopyParams.srcResource = &srcSurface.OsResource;
1186 dataCopyParams.srcSize = uvsize;
1187 dataCopyParams.srcOffset = srcOffset;
1188 dataCopyParams.dstResource = &dstSurface.OsResource;
1189 dataCopyParams.dstSize = frameSize;
1190 dataCopyParams.dstOffset = dstOffset;
1191
1192 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->CopyDataSourceWithDrv(&dataCopyParams));
1193 }
1194 else
1195 {
1196 // Stream object params
1197 CODECHAL_DECODE_CHK_STATUS_RETURN(HucCopy(
1198 &cmdBuffer, // pCmdBuffer
1199 &srcSurface.OsResource, // presSrc
1200 &dstSurface.OsResource, // presDst
1201 uvsize, // u32CopyLength
1202 srcOffset, // u32CopyInputOffset
1203 dstOffset)); // u32CopyOutputOffset
1204 }
1205
1206 if (pack)
1207 {
1208 MOS_SYNC_PARAMS syncParams;
1209
1210 syncParams = g_cInitSyncParams;
1211 syncParams.GpuContext = m_videoContext;
1212 syncParams.presSyncResource = &m_destSurface.OsResource;
1213 syncParams.bReadOnly = false;
1214 syncParams.bDisableDecodeSyncLock = m_disableDecodeSyncLock;
1215 syncParams.bDisableLockForTranscode = m_disableLockForTranscode;
1216
1217 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnPerformOverlaySync(m_osInterface, &syncParams));
1218 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceWait(m_osInterface, &syncParams));
1219
1220 // Update the resource tag (s/w tag) for On-Demand Sync
1221 m_osInterface->pfnSetResourceSyncTag(m_osInterface, &syncParams);
1222
1223 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
1224 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
1225
1226 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(&cmdBuffer, &flushDwParams));
1227
1228 // Update the tag in GPU Sync status buffer (H/W Tag) to match the current S/W tag
1229 if (m_osInterface->bTagResourceSync)
1230 {
1231 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->WriteSyncTagToResource(&cmdBuffer, &syncParams));
1232 }
1233
1234 }
1235 else
1236 {
1237 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
1238 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
1239 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(&cmdBuffer, &flushDwParams));
1240 }
1241
1242 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(
1243 &cmdBuffer,
1244 nullptr));
1245
1246 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
1247
1248 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(m_osInterface, &cmdBuffer, nullHwInUse));
1249
1250 return eStatus;
1251 }
1252
1253 MOS_STATUS CodechalDecodeVc1::ConstructBistreamBuffer()
1254 {
1255 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1256
1257 CODECHAL_DECODE_FUNCTION_ENTER;
1258
1259 if (m_hwInterface->m_noHuC)
1260 {
1261 CodechalDataCopyParams dataCopyParams;
1262 MOS_ZeroMemory(&dataCopyParams, sizeof(CodechalDataCopyParams));
1263 dataCopyParams.srcResource = &m_resDataBuffer;
1264 dataCopyParams.srcSize = m_dataSize;
1265 dataCopyParams.srcOffset = 0;
1266 dataCopyParams.dstResource = &m_resPrivateBistreamBuffer;
1267 dataCopyParams.dstSize = m_privateBistreamBufferSize;
1268 dataCopyParams.dstOffset = CODECHAL_DECODE_VC1_STUFFING_BYTES;
1269
1270 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->CopyDataSourceWithDrv(&dataCopyParams));
1271
1272 return MOS_STATUS_SUCCESS;
1273 }
1274
1275 m_huCCopyInUse = true;
1276
1277 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSetGpuContext(m_osInterface, m_videoContextForWa));
1278 m_osInterface->pfnResetOsStates(m_osInterface);
1279 m_osInterface->pfnSetPerfTag(m_osInterface, (uint16_t)(((m_mode << 4) & 0xF0) | COPY_TYPE));
1280
1281 MOS_COMMAND_BUFFER cmdBuffer;
1282 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &cmdBuffer, 0));
1283
1284 // Send command buffer header at the beginning (OS dependent)
1285 CODECHAL_DECODE_CHK_STATUS_RETURN(SendPrologWithFrameTracking(&cmdBuffer, false));
1286
1287 CODECHAL_DECODE_CHK_STATUS_RETURN(HucCopy(
1288 &cmdBuffer, // pCmdBuffer
1289 &m_resDataBuffer, // presSrc
1290 &m_resPrivateBistreamBuffer, // presDst
1291 MOS_ALIGN_CEIL(m_dataSize, 16), // u32CopyLength
1292 0, // u32CopyInputOffset
1293 CODECHAL_DECODE_VC1_STUFFING_BYTES)); // u32CopyOutputOffset
1294
1295 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
1296 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
1297 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(
1298 &cmdBuffer,
1299 &flushDwParams));
1300
1301 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(
1302 &cmdBuffer,
1303 nullptr));
1304
1305 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
1306
1307 MOS_SYNC_PARAMS syncParams;
1308
1309 syncParams = g_cInitSyncParams;
1310 syncParams.GpuContext = m_videoContext;
1311 syncParams.presSyncResource = &m_resSyncObjectVideoContextInUse;
1312
1313 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineSignal(m_osInterface, &syncParams));
1314
1315 syncParams = g_cInitSyncParams;
1316 syncParams.GpuContext = m_videoContextForWa;
1317 syncParams.presSyncResource = &m_resSyncObjectVideoContextInUse;
1318
1319 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineWait(m_osInterface, &syncParams));
1320
1321 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(m_osInterface, &cmdBuffer, m_videoContextUsesNullHw));
1322
1323 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSetGpuContext(m_osInterface, m_videoContext));
1324
1325 return (MOS_STATUS)eStatus;
1326 }
1327
1328 MOS_STATUS CodechalDecodeVc1::HandleSkipFrame()
1329 {
1330 MOS_COMMAND_BUFFER cmdBuffer;
1331 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
1332 MHW_GENERIC_PROLOG_PARAMS genericPrologParams;
1333 MOS_SURFACE srcSurface;
1334 uint8_t fwdRefIdx;
1335 uint32_t surfaceSize;
1336 MOS_SYNC_PARAMS syncParams;
1337 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1338
1339 CODECHAL_DECODE_FUNCTION_ENTER;
1340
1341 fwdRefIdx = (uint8_t)m_vc1PicParams->ForwardRefIdx;
1342
1343 MOS_ZeroMemory(&srcSurface, sizeof(MOS_SURFACE));
1344 srcSurface.Format = Format_NV12;
1345 srcSurface.OsResource = m_vc1RefList[fwdRefIdx]->resRefPic;
1346 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalGetResourceInfo(m_osInterface, &srcSurface));
1347
1348 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mmc->SetSurfaceMmcMode(&m_destSurface, &srcSurface));
1349
1350 surfaceSize = ((srcSurface.OsResource.pGmmResInfo->GetArraySize()) > 1) ?
1351 ((uint32_t)(srcSurface.OsResource.pGmmResInfo->GetQPitchPlanar(GMM_PLANE_Y) *
1352 srcSurface.OsResource.pGmmResInfo->GetRenderPitch())) :
1353 (uint32_t)(srcSurface.OsResource.pGmmResInfo->GetSizeMainSurface());
1354
1355 // HuC is present
1356 if (m_hwInterface->m_noHuC)
1357 {
1358 CodechalDataCopyParams dataCopyParams;
1359 MOS_ZeroMemory(&dataCopyParams, sizeof(CodechalDataCopyParams));
1360 dataCopyParams.srcResource = &srcSurface.OsResource;
1361 dataCopyParams.srcSize = surfaceSize;
1362 dataCopyParams.srcOffset = srcSurface.dwOffset;
1363 dataCopyParams.dstResource = &m_destSurface.OsResource;
1364 dataCopyParams.dstSize = surfaceSize;
1365 dataCopyParams.dstOffset = m_destSurface.dwOffset;
1366
1367 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->CopyDataSourceWithDrv(&dataCopyParams));
1368 }
1369 else
1370 {
1371 m_huCCopyInUse = true;
1372
1373 syncParams = g_cInitSyncParams;
1374 syncParams.GpuContext = m_videoContext;
1375 syncParams.presSyncResource = &m_resSyncObjectVideoContextInUse;
1376
1377 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineSignal(m_osInterface, &syncParams));
1378
1379 syncParams = g_cInitSyncParams;
1380 syncParams.GpuContext = m_videoContextForWa;
1381 syncParams.presSyncResource = &m_resSyncObjectVideoContextInUse;
1382
1383 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineWait(m_osInterface, &syncParams));
1384
1385 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSetGpuContext(m_osInterface, m_videoContextForWa));
1386 m_osInterface->pfnResetOsStates(m_osInterface);
1387
1388 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &cmdBuffer, 0));
1389
1390 // Send command buffer header at the beginning (OS dependent)
1391 CODECHAL_DECODE_CHK_STATUS_RETURN(SendPrologWithFrameTracking(&cmdBuffer, false));
1392
1393 CODECHAL_DECODE_CHK_STATUS_RETURN(HucCopy(
1394 &cmdBuffer, // pCmdBuffer
1395 &srcSurface.OsResource, // presSrc
1396 &m_destSurface.OsResource, // presDst
1397 surfaceSize, // u32CopyLength
1398 srcSurface.dwOffset, // u32CopyInputOffset
1399 m_destSurface.dwOffset)); // u32CopyOutputOffset
1400
1401 syncParams = g_cInitSyncParams;
1402 syncParams.GpuContext = m_videoContextForWa;
1403 syncParams.presSyncResource = &m_destSurface.OsResource;
1404 syncParams.bReadOnly = false;
1405 syncParams.bDisableDecodeSyncLock = m_disableDecodeSyncLock;
1406 syncParams.bDisableLockForTranscode = m_disableLockForTranscode;
1407
1408 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnPerformOverlaySync(m_osInterface, &syncParams));
1409 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceWait(m_osInterface, &syncParams));
1410
1411 // Update the resource tag (s/w tag) for On-Demand Sync
1412 m_osInterface->pfnSetResourceSyncTag(m_osInterface, &syncParams);
1413
1414 // Update the tag in GPU Sync eStatus buffer (H/W Tag) to match the current S/W tag
1415 if (m_osInterface->bTagResourceSync)
1416 {
1417 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->WriteSyncTagToResource(
1418 &cmdBuffer,
1419 &syncParams));
1420 }
1421
1422 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
1423 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(
1424 &cmdBuffer,
1425 &flushDwParams));
1426
1427 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(
1428 &cmdBuffer,
1429 nullptr));
1430
1431 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
1432
1433 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(m_osInterface, &cmdBuffer, m_videoContextUsesNullHw));
1434
1435 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSetGpuContext(m_osInterface, m_videoContext));
1436 }
1437
1438 return (MOS_STATUS)eStatus;
1439 }
1440
1441 uint32_t CodechalDecodeVc1::PeekBits(uint32_t bitsRead)
1442 {
1443 uint32_t value = 0;
1444
1445 CODECHAL_DECODE_ASSERT((bitsRead) > 0 && (bitsRead) <= 32);
1446
1447 uint32_t *cache = m_bitstream.pu32Cache;
1448 int32_t shiftOffset = m_bitstream.iBitOffset - (bitsRead);
1449
1450 if (shiftOffset >= 0)
1451 {
1452 value = (*cache) >> (shiftOffset);
1453 }
1454 else
1455 {
1456 shiftOffset += 32;
1457 value = (cache[0] << (32 - shiftOffset)) + (cache[1] >> shiftOffset);
1458 }
1459
1460 return (value & ((1 << bitsRead) - 1));
1461 }
1462
1463 uint32_t CodechalDecodeVc1::UpdateBitstreamBuffer()
1464 {
1465 uint32_t *cache = (uint32_t *)m_bitstream.CacheBuffer;
1466 uint32_t *cacheEnd = m_bitstream.pu32CacheEnd;
1467 uint32_t *cacheDataEnd = m_bitstream.pu32CacheDataEnd;
1468 uint32_t zeroNum = m_bitstream.u32ZeroNum;
1469 uint8_t * originalBitBuffer = m_bitstream.pOriginalBitBuffer;
1470 uint8_t * originalBufferEnd = m_bitstream.pOriginalBufferEnd;
1471
1472 if (cacheDataEnd == cacheEnd)
1473 {
1474 *cache++ = *cacheEnd;
1475 }
1476
1477 while (cache <= cacheEnd)
1478 {
1479 uint32_t leftByte;
1480 CODECHAL_DECODE_VC1_BITSTREAM_VALUE value;
1481 if (m_bitstream.bIsEBDU)
1482 {
1483 // for EBDU, set dwLeftByte to 4 to remove emulation prevention bytes in the later while loop
1484 leftByte = 4;
1485 value.u32Value = 0;
1486 }
1487 else
1488 {
1489 leftByte = 0;
1490 value.u8Value[3] = *originalBitBuffer++;
1491 value.u8Value[2] = *originalBitBuffer++;
1492 value.u8Value[1] = *originalBitBuffer++;
1493 value.u8Value[0] = *originalBitBuffer++;
1494 }
1495
1496 while (leftByte)
1497 {
1498 if (originalBitBuffer >= originalBufferEnd) // End of the bitstream;
1499 {
1500 *cache = value.u32Value;
1501 m_bitstream.pu32Cache = (uint32_t *)m_bitstream.CacheBuffer;
1502 m_bitstream.u32ZeroNum = zeroNum;
1503 m_bitstream.pOriginalBitBuffer = originalBitBuffer;
1504 m_bitstream.pu32CacheDataEnd = cache;
1505 m_bitstream.iBitOffsetEnd = leftByte * 8;
1506 return 0;
1507 }
1508
1509 uint8_t data = *originalBitBuffer++;
1510
1511 if (zeroNum < 2)
1512 {
1513 zeroNum = data ? 0 : zeroNum + 1;
1514 }
1515 else if (zeroNum == 2)
1516 {
1517 if (data == 0x03)
1518 {
1519 if (originalBitBuffer < originalBufferEnd)
1520 {
1521 data = *originalBitBuffer++;
1522 zeroNum = (data == 0);
1523 }
1524 else
1525 {
1526 CODECHAL_DECODE_ASSERTMESSAGE("VC1 Bitstream Parsing Error: Incomplete bitstream.");
1527 return(CODECHAL_DECODE_VC1_EOS);
1528 }
1529
1530 if (data > 0x03)
1531 {
1532 CODECHAL_DECODE_ASSERTMESSAGE("VC1 Bitstream Parsing Error: Not a valid code 0x000003 %x.", data);
1533 return(CODECHAL_DECODE_VC1_EOS);
1534 }
1535 }
1536 else if (data == 0x02)
1537 {
1538 CODECHAL_DECODE_ASSERTMESSAGE("VC1 Bitstream Parsing Error: Not a valid code 0x000002.");
1539 return(CODECHAL_DECODE_VC1_EOS);
1540 }
1541 else
1542 {
1543 zeroNum = data ? 0 : (zeroNum + 1);
1544 }
1545 }
1546 else // zeroNum > 3
1547 {
1548 if (data == 0x00)
1549 {
1550 zeroNum++;
1551 }
1552 else if (data == 0x01)
1553 {
1554 zeroNum = 0;
1555 }
1556 else
1557 {
1558 CODECHAL_DECODE_ASSERTMESSAGE("VC1 Bitstream Parsing Error: Not a start code 0x000001.");
1559 return(CODECHAL_DECODE_VC1_EOS);
1560 }
1561 }
1562
1563 leftByte--;
1564 value.u8Value[leftByte] = data;
1565 }
1566
1567 *cache = value.u32Value;
1568 cache++;
1569 }
1570
1571 m_bitstream.pu32Cache = (uint32_t *)m_bitstream.CacheBuffer;
1572 m_bitstream.u32ZeroNum = zeroNum;
1573 m_bitstream.pOriginalBitBuffer = originalBitBuffer;
1574 m_bitstream.iBitOffsetEnd = 0;
1575 m_bitstream.pu32CacheDataEnd = m_bitstream.pu32CacheEnd;
1576
1577 return 0;
1578 }
1579
1580 uint32_t CodechalDecodeVc1::GetBits(uint32_t bitsRead)
1581 {
1582 uint32_t value = 0;
1583
1584 CODECHAL_DECODE_ASSERT((bitsRead > 0) && (bitsRead <= 32));
1585
1586 uint32_t *cache = m_bitstream.pu32Cache;
1587 int32_t shiftOffset = m_bitstream.iBitOffset - (bitsRead);
1588
1589 if (shiftOffset >= 0)
1590 {
1591 value = (*cache) >> (shiftOffset);
1592 }
1593 else
1594 {
1595 shiftOffset += 32;
1596 value = (cache[0] << (32 - shiftOffset)) + (cache[1] >> shiftOffset);
1597 m_bitstream.pu32Cache++;
1598 }
1599
1600 value &= ((0x1 << bitsRead) - 1);
1601 m_bitstream.iBitOffset = shiftOffset;
1602 m_bitstream.u32ProcessedBitNum += bitsRead;
1603
1604 if ((cache == m_bitstream.pu32CacheDataEnd) &&
1605 (m_bitstream.iBitOffset < m_bitstream.iBitOffsetEnd))
1606 {
1607 return CODECHAL_DECODE_VC1_EOS;
1608 }
1609
1610 if (cache == m_bitstream.pu32CacheEnd)
1611 {
1612 if (UpdateBitstreamBuffer() == CODECHAL_DECODE_VC1_EOS)
1613 {
1614 return CODECHAL_DECODE_VC1_EOS;
1615 }
1616 }
1617
1618 return value;
1619 }
1620
1621 uint32_t CodechalDecodeVc1::SkipBits(uint32_t bitsRead)
1622 {
1623 CODECHAL_DECODE_ASSERT((bitsRead > 0) && (bitsRead <= 32));
1624
1625 uint32_t *cache = m_bitstream.pu32Cache;
1626 int32_t shiftOffset = m_bitstream.iBitOffset - (bitsRead);
1627
1628 if (shiftOffset < 0)
1629 {
1630 shiftOffset += 32;
1631 m_bitstream.pu32Cache++;
1632 }
1633
1634 m_bitstream.iBitOffset = shiftOffset;
1635 m_bitstream.u32ProcessedBitNum += bitsRead;
1636
1637 if ((cache == m_bitstream.pu32CacheDataEnd) &&
1638 (m_bitstream.iBitOffset < m_bitstream.iBitOffsetEnd))
1639 {
1640 return CODECHAL_DECODE_VC1_EOS;
1641 }
1642
1643 if (cache == m_bitstream.pu32CacheEnd)
1644 {
1645 if (UpdateBitstreamBuffer() == CODECHAL_DECODE_VC1_EOS)
1646 {
1647 return CODECHAL_DECODE_VC1_EOS;
1648 }
1649 }
1650
1651 return 0;
1652 }
1653
1654 uint32_t CodechalDecodeVc1::GetVLC(const uint32_t *table)
1655 {
1656 if (table == nullptr)
1657 return CODECHAL_DECODE_VC1_EOS;
1658
1659 CODECHAL_DECODE_ASSERT(table[0] > 0); // max bits
1660
1661 uint32_t maxCodeLength = table[0];
1662 uint32_t tableSize = table[0];
1663 uint32_t index = 1;
1664 uint32_t codeLength = 1;
1665
1666 uint32_t value = PeekBits(maxCodeLength);
1667 if (CODECHAL_DECODE_VC1_EOS == value)
1668 {
1669 CODECHAL_DECODE_ASSERTMESSAGE("Bitstream exhausted.");
1670 return(value);
1671 }
1672
1673 for (uint32_t entryIndex = 0; entryIndex < tableSize; entryIndex++)
1674 {
1675 uint32_t subtableSize = table[index++];
1676
1677 if (subtableSize > 0)
1678 {
1679 while (subtableSize--)
1680 {
1681 if (table[index++] == (value >> (maxCodeLength - codeLength)))
1682 {
1683 value = GetBits((uint8_t)codeLength);
1684
1685 return(table[index]);
1686 }
1687
1688 index++;
1689 }
1690 }
1691
1692 codeLength++;
1693 }
1694
1695 CODECHAL_DECODE_ASSERTMESSAGE("Code is not in VLC table.");
1696
1697 return(CODECHAL_DECODE_VC1_EOS);
1698 }
1699
1700 MOS_STATUS CodechalDecodeVc1::InitialiseBitstream(
1701 uint8_t* buffer,
1702 uint32_t length,
1703 bool isEBDU)
1704 {
1705 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1706
1707 MOS_ZeroMemory(&m_bitstream, sizeof(m_bitstream));
1708 CODECHAL_DECODE_CHK_NULL_RETURN(&m_bitstream);
1709 CODECHAL_DECODE_CHK_NULL_RETURN(buffer);
1710
1711 m_bitstream.pOriginalBitBuffer = buffer;
1712 m_bitstream.pOriginalBufferEnd = buffer + length;
1713 m_bitstream.u32ZeroNum = 0;
1714 m_bitstream.u32ProcessedBitNum = 0;
1715 m_bitstream.pu32Cache = (uint32_t *)m_bitstream.CacheBuffer;
1716 m_bitstream.pu32CacheEnd = (uint32_t *)(m_bitstream.CacheBuffer + CODECHAL_DECODE_VC1_BITSTRM_BUF_LEN);
1717 m_bitstream.pu32CacheDataEnd = (uint32_t *)m_bitstream.CacheBuffer;
1718 m_bitstream.iBitOffset = 32;
1719 m_bitstream.iBitOffsetEnd = 32;
1720 m_bitstream.bIsEBDU = isEBDU;
1721
1722 if (UpdateBitstreamBuffer() == CODECHAL_DECODE_VC1_EOS)
1723 {
1724 return MOS_STATUS_UNKNOWN;
1725 }
1726
1727 return eStatus;
1728 }
1729
1730 MOS_STATUS CodechalDecodeVc1::BitplaneNorm2Mode()
1731 {
1732 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1733
1734 uint16_t frameFieldHeightInMb;
1735 CodecHal_GetFrameFieldHeightInMb(
1736 m_vc1PicParams->CurrPic,
1737 m_picHeightInMb,
1738 frameFieldHeightInMb);
1739 uint16_t frameFieldWidthInMb = m_picWidthInMb;
1740
1741 uint32_t count = frameFieldWidthInMb * frameFieldHeightInMb;
1742
1743 uint32_t value = 0;
1744 if ((frameFieldWidthInMb * frameFieldHeightInMb) & 1)
1745 {
1746 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(1, value));
1747
1748 count--;
1749 }
1750
1751 for (uint32_t i = 0; i < count / 2; i++)
1752 {
1753 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(1, value));
1754 if (value)
1755 {
1756 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(1, value));
1757 if (value == 0)
1758 {
1759 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(1, value));
1760 }
1761 }
1762 }
1763
1764 return eStatus;
1765 }
1766
1767 MOS_STATUS CodechalDecodeVc1::BitplaneNorm6Mode()
1768 {
1769 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1770
1771 uint16_t frameFieldHeightInMb;
1772 CodecHal_GetFrameFieldHeightInMb(
1773 m_vc1PicParams->CurrPic,
1774 m_picHeightInMb,
1775 frameFieldHeightInMb);
1776 uint16_t frameFieldWidthInMb = m_picWidthInMb;
1777
1778 bool is2x3Tiled = (0 != frameFieldWidthInMb % 3) && (0 == frameFieldHeightInMb % 3);
1779
1780 uint32_t heightInTiles = 0, widthInTiles = 0;
1781 uint32_t residualX = 0, residualY = 0;
1782 uint32_t value = 0;
1783 if (is2x3Tiled)
1784 {
1785 widthInTiles = frameFieldWidthInMb / 2;
1786 heightInTiles = frameFieldHeightInMb / 3;
1787
1788 for (uint32_t j = 0; j < heightInTiles; j++)
1789 {
1790 for (uint32_t i = 0; i < widthInTiles; i++)
1791 {
1792 CODECHAL_DECODE_CHK_STATUS_RETURN(GetVLC(CODECHAL_DECODE_VC1_VldCode3x2Or2x3TilesTable, value));
1793 }
1794 }
1795
1796 residualX = frameFieldWidthInMb & 1;
1797 residualY = 0;
1798 }
1799 else // 3x2 tiles
1800 {
1801 widthInTiles = frameFieldWidthInMb / 3;
1802 heightInTiles = frameFieldHeightInMb / 2;
1803
1804 for (uint32_t j = 0; j < heightInTiles; j++)
1805 {
1806 for (uint32_t i = 0; i < widthInTiles; i++)
1807 {
1808 CODECHAL_DECODE_CHK_STATUS_RETURN(GetVLC(CODECHAL_DECODE_VC1_VldCode3x2Or2x3TilesTable, value));
1809 }
1810 }
1811
1812 residualX = frameFieldWidthInMb % 3;
1813 residualY = frameFieldHeightInMb & 1;
1814 }
1815
1816 // ResidualY 0 or 1 or 2
1817 for (uint32_t i = 0; i < residualX; i++)
1818 {
1819 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_BITPLANE_COLSKIP, value));
1820
1821 if (value)
1822 {
1823 CODECHAL_DECODE_CHK_STATUS_RETURN(SkipWords(frameFieldHeightInMb >> 4, value));
1824 CODECHAL_DECODE_CHK_STATUS_RETURN(SkipBits(frameFieldHeightInMb & 0xF, value));
1825 }
1826 }
1827
1828 // ResidualY 0 or 1
1829 for (uint32_t j = 0; j < residualY; j++)
1830 {
1831 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_BITPLANE_ROWSKIP, value));
1832
1833 if (value)
1834 {
1835 uint32_t skipBits = frameFieldWidthInMb - residualX;
1836 CODECHAL_DECODE_CHK_STATUS_RETURN(SkipWords(skipBits >> 4, value));
1837 CODECHAL_DECODE_CHK_STATUS_RETURN(SkipBits(skipBits & 0xF, value));
1838 }
1839 }
1840
1841 return eStatus;
1842 }
1843
1844 MOS_STATUS CodechalDecodeVc1::BitplaneRowskipMode()
1845 {
1846 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1847
1848 uint16_t frameFieldHeightInMb;
1849 CodecHal_GetFrameFieldHeightInMb(
1850 m_vc1PicParams->CurrPic,
1851 m_picHeightInMb,
1852 frameFieldHeightInMb);
1853 uint16_t frameFieldWidthInMb = m_picWidthInMb;
1854
1855 uint32_t value = 0;
1856 for (uint32_t j = 0; j < frameFieldHeightInMb; j++)
1857 {
1858 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_BITPLANE_ROWSKIP, value));
1859
1860 if (value)
1861 {
1862 CODECHAL_DECODE_CHK_STATUS_RETURN(SkipWords(frameFieldWidthInMb >> 4, value));
1863 CODECHAL_DECODE_CHK_STATUS_RETURN(SkipBits(frameFieldWidthInMb & 0xF, value));
1864 }
1865 }
1866
1867 return eStatus;
1868 }
1869
1870 MOS_STATUS CodechalDecodeVc1::BitplaneColskipMode()
1871 {
1872 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1873
1874 uint16_t meFieldHeightInMb;
1875 CodecHal_GetFrameFieldHeightInMb(
1876 m_vc1PicParams->CurrPic,
1877 m_picHeightInMb,
1878 meFieldHeightInMb);
1879 uint16_t frameFieldWidthInMb = m_picWidthInMb;
1880
1881 uint32_t value = 0;
1882 uint32_t colSkip = 0;
1883 for (uint32_t i = 0; i < frameFieldWidthInMb; i++)
1884 {
1885 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_BITPLANE_COLSKIP, value));
1886 colSkip = value;
1887
1888 if (value)
1889 {
1890 CODECHAL_DECODE_CHK_STATUS_RETURN(SkipWords(meFieldHeightInMb >> 4, value));
1891 CODECHAL_DECODE_CHK_STATUS_RETURN(SkipBits(meFieldHeightInMb & 0xF, value));
1892 }
1893 }
1894
1895 return eStatus;
1896 }
1897
1898 MOS_STATUS CodechalDecodeVc1::ParseVopDquant()
1899 {
1900 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1901
1902 uint32_t value = 0;
1903 uint32_t dquantFRM = 0, dqprofile = 0, dqbilevel = 0;
1904 if ((1 == m_vc1PicParams->pic_quantizer_fields.dquant) ||
1905 (3 == m_vc1PicParams->pic_quantizer_fields.dquant))
1906 {
1907 // The DQUANTFRM field is a 1 bit value that is present only
1908 // when DQUANT = 1. If DQUANTFRM = 0 then the current picture
1909 // is only quantized with PQUANT.
1910 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_DQUANTFRM, value));
1911 dquantFRM = value;
1912
1913 if (dquantFRM)
1914 {
1915 // The DQPROFILE field is a 2 bits value that is present
1916 // only when DQUANT = 1 and DQUANTFRM = 1. It indicates
1917 // where we are allowed to change quantization step sizes
1918 // within the current picture.
1919 // Table 15: Macroblock Quantization Profile (DQPROFILE) Code Table
1920 // FLC Location
1921 // 00 All four Edges
1922 // 01 Double Edges
1923 // 10 Single Edges
1924 // 11 All Macroblocks
1925 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_DQPROFILE, value));
1926 dqprofile = value;
1927
1928 switch (dqprofile)
1929 {
1930 case 0: // all 4 edges
1931 {
1932 break;
1933 }
1934 case 1: // double edges
1935 {
1936 // The DQSBEDGE field is a 2 bits value that is present
1937 // when DQPROFILE = Single Edge. It indicates which edge
1938 // will be quantized with ALTPQUANT.
1939 // Table 16: Single Boundary Edge Selection (DQSBEDGE) Code Table
1940 // FLC Boundary Edge
1941 // 00 Left
1942 // 01 Top
1943 // 10 Right
1944 // 11 Bottom
1945 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_DQDBEDGE, value));
1946 break;
1947 }
1948 case 2: // single edge
1949 {
1950 // The DQSBEDGE field is a 2 bits value that is present
1951 // when DQPROFILE = Single Edge. It indicates which edge
1952 // will be quantized with ALTPQUANT.
1953 // Table 16: Single Boundary Edge Selection (DQSBEDGE) Code Table
1954 // FLC Boundary Edge
1955 // 00 Left
1956 // 01 Top
1957 // 10 Right
1958 // 11 Bottom
1959 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_DQDBEDGE, value));
1960 break;
1961 }
1962 case 3: // all MBs
1963 {
1964 // The DQBILEVEL field is a 1 bit value that is present
1965 // when DQPROFILE = All Macroblock. If DQBILEVEL = 1,
1966 // then each macroblock in the picture can take one of
1967 // two possible values (PQUANT or ALTPQUANT). If
1968 // DQBILEVEL = 0, then each macroblock in the picture
1969 // can take on any quantization step size.
1970 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_DQBILEVEL, value));
1971 dqbilevel = value;
1972 break;
1973 }
1974 }
1975 }
1976 }
1977 else if (2 == m_vc1PicParams->pic_quantizer_fields.dquant)
1978 {
1979 dquantFRM = 1;
1980 }
1981
1982 // PQDIFF is a 3 bit field that encodes either the PQUANT
1983 // differential or encodes an escape code.
1984 // If PQDIFF does not equal 7 then PQDIFF encodes the
1985 // differential and the ABSPQ field does not follow in
1986 // the bitstream. In this case:
1987 // ALTPQUANT = PQUANT + PQDIFF + 1
1988 // If PQDIFF equals 7 then the ABSPQ field follows in
1989 // the bitstream and ALTPQUANT is decoded as:
1990 // ALTPQUANT = ABSPQ
1991 if (dquantFRM)
1992 {
1993 if ((m_vc1PicParams->pic_quantizer_fields.dquant == 2) ||
1994 !(dqprofile == 3 && dqbilevel == 0))
1995 {
1996 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_PQDIFF, value));
1997
1998 if (7 == value)
1999 {
2000 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_ABSPQ, value));
2001 }
2002 }
2003 }
2004
2005 return eStatus;
2006 }
2007
2008 MOS_STATUS CodechalDecodeVc1::ParseMvRange()
2009 {
2010 uint32_t value;
2011 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2012
2013 // MVRANGE
2014 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(1, value));
2015
2016 if (value)
2017 {
2018 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(1, value));
2019
2020 if (value)
2021 {
2022 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(1, value));
2023 }
2024 }
2025
2026 return eStatus;
2027 }
2028
2029 MOS_STATUS CodechalDecodeVc1::ParseProgressiveMvMode(
2030 const uint32_t mvModeTable[],
2031 uint32_t* mvMode)
2032 {
2033 uint32_t value;
2034 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2035
2036 uint32_t bitCount = 1;
2037 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(1, value));
2038 while ((value == 0) && (bitCount < 4))
2039 {
2040 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(1, value));
2041 bitCount++;
2042 }
2043
2044 uint32_t index = (bitCount < 4) ? bitCount - 1 : bitCount + value - 1;
2045 uint32_t mvModeType = mvModeTable[index];
2046
2047 if (CODECHAL_VC1_MVMODE_IC == mvModeType)
2048 {
2049 bitCount = 1;
2050 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(1, value));
2051 while ((value == 0) && (bitCount < 3))
2052 {
2053 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(1, value));
2054 bitCount++;
2055 }
2056
2057 index = (bitCount < 3) ? bitCount - 1 : bitCount + !value - 1;
2058 mvModeType = mvModeTable[index];
2059
2060 CODECHAL_DECODE_CHK_STATUS_RETURN(SkipBits(CODECHAL_DECODE_VC1_BITS_LUMSCALE + CODECHAL_DECODE_VC1_BITS_LUMSHIFT, value));
2061 }
2062
2063 *mvMode = mvModeType;
2064
2065 return eStatus;
2066 }
2067
2068 MOS_STATUS CodechalDecodeVc1::ParseInterlaceMVMode(
2069 bool isPPicture,
2070 uint32_t* mvmode)
2071 {
2072 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2073
2074 CODECHAL_DECODE_CHK_NULL_RETURN(mvmode);
2075
2076 const uint32_t *mvModeTable;
2077 if (12 < m_vc1PicParams->pic_quantizer_fields.pic_quantizer_scale)
2078 {
2079 mvModeTable = CODECHAL_DECODE_VC1_LowRateMvModeTable;
2080 }
2081 else
2082 {
2083 mvModeTable = CODECHAL_DECODE_VC1_HighRateMvModeTable;
2084 }
2085
2086 uint32_t bitCount = 1;
2087 uint32_t value = 0;
2088 uint32_t index = 0, mvMode = 0;
2089 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(1, value));
2090
2091 if (isPPicture)
2092 {
2093 while ((value == 0) && (bitCount < 4))
2094 {
2095 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(1, value));
2096 bitCount++;
2097 }
2098
2099 index = (bitCount < 4) ? bitCount - 1 : bitCount + value - 1;
2100 mvMode = mvModeTable[index];
2101 }
2102 else // B picture
2103 {
2104 while ((value == 0) && (bitCount < 3))
2105 {
2106 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(1, value));
2107 bitCount++;
2108 }
2109
2110 index = (bitCount < 3) ? bitCount - 1 : bitCount + !value - 1;
2111 }
2112
2113 mvMode = mvModeTable[index];
2114
2115 if (CODECHAL_VC1_MVMODE_IC == value)
2116 {
2117 bitCount = 1;
2118 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(1, value));
2119 while ((value == 0) && (bitCount < 3))
2120 {
2121 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(1, value));
2122 bitCount++;
2123 }
2124
2125 index = (bitCount < 3) ? bitCount - 1 : bitCount + !value - 1;
2126 mvMode = mvModeTable[index];
2127
2128 // Intensity compensation flags
2129 uint32_t skipBits = 0;
2130 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(1, value));
2131 if (value == 0)
2132 {
2133 skipBits += 1 + CODECHAL_DECODE_VC1_BITS_LUMSCALE + CODECHAL_DECODE_VC1_BITS_LUMSHIFT;
2134 }
2135
2136 skipBits += CODECHAL_DECODE_VC1_BITS_LUMSCALE + CODECHAL_DECODE_VC1_BITS_LUMSHIFT;
2137
2138 CODECHAL_DECODE_CHK_STATUS_RETURN(SkipBits(skipBits, value));
2139 }
2140
2141 *mvmode = mvMode;
2142
2143 return eStatus;
2144 }
2145
2146 MOS_STATUS CodechalDecodeVc1::ParseBitplane()
2147 {
2148 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2149
2150 uint32_t value = 0;
2151 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_BITPLANE_INVERT, value));
2152
2153 CODECHAL_DECODE_CHK_STATUS_RETURN(GetVLC(CODECHAL_DECODE_VC1_VldBitplaneModeTable, value));
2154
2155 switch (value) // Bitplane mode
2156 {
2157 case CODECHAL_VC1_BITPLANE_NORMAL2:
2158 eStatus = BitplaneNorm2Mode();
2159 break;
2160 case CODECHAL_VC1_BITPLANE_NORMAL6:
2161 eStatus = BitplaneNorm6Mode();
2162 break;
2163 case CODECHAL_VC1_BITPLANE_DIFF2:
2164 eStatus = BitplaneNorm2Mode(); // Diff2 is the same as Norm2 mode
2165 break;
2166 case CODECHAL_VC1_BITPLANE_DIFF6:
2167 eStatus = BitplaneNorm6Mode(); // Diff6 is the same as Norm6 mode
2168 break;
2169 case CODECHAL_VC1_BITPLANE_ROWSKIP:
2170 eStatus = BitplaneRowskipMode();
2171 break;
2172 case CODECHAL_VC1_BITPLANE_COLSKIP:
2173 eStatus = BitplaneColskipMode();
2174 break;
2175 case CODECHAL_VC1_BITPLANE_RAW:
2176 // nothing to do
2177 break;
2178 default:
2179 CODECHAL_DECODE_ASSERTMESSAGE("Invalid bitplane mode %d.", value);
2180 }
2181
2182 return eStatus;
2183 }
2184
2185 MOS_STATUS CodechalDecodeVc1::ParsePictureLayerIAdvanced()
2186 {
2187 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2188
2189 uint32_t value = 0;
2190 if (CodecHal_PictureIsInterlacedFrame(m_vc1PicParams->CurrPic))
2191 {
2192 CODECHAL_DECODE_CHK_STATUS_RETURN(ParseBitplane());
2193 }
2194
2195 CODECHAL_DECODE_CHK_STATUS_RETURN(ParseBitplane());
2196
2197 if (m_vc1PicParams->sequence_fields.overlap &&
2198 (m_vc1PicParams->pic_quantizer_fields.pic_quantizer_scale <= 8))
2199 {
2200 //conditional overlap flag
2201 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(1, value));
2202
2203 if (1 == value)
2204 {
2205 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(1, value));
2206 if (1 == value)
2207 {
2208 // CONDOVER == 2
2209 CODECHAL_DECODE_CHK_STATUS_RETURN(ParseBitplane());
2210 }
2211 }
2212 }
2213
2214 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_TRANSACFRM_1, value));
2215 if (0 != value)
2216 {
2217 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_TRANSACFRM_2, value));
2218 }
2219
2220 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_TRANSACFRM2_1, value));
2221 if (0 != value)
2222 {
2223 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_TRANSACFRM2_2, value));
2224 }
2225
2226 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_TRANSDCTAB, value));
2227
2228 CODECHAL_DECODE_CHK_STATUS_RETURN(ParseVopDquant());
2229
2230 return eStatus;
2231 }
2232
2233 MOS_STATUS CodechalDecodeVc1::ParsePictureLayerPAdvanced()
2234 {
2235 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2236
2237 if (m_vc1PicParams->mv_fields.extended_mv_flag)
2238 {
2239 CODECHAL_DECODE_CHK_STATUS_RETURN(ParseMvRange());
2240 }
2241
2242 const uint32_t *mvModeTable = nullptr;
2243 mvModeTable = (12 < m_vc1PicParams->pic_quantizer_fields.pic_quantizer_scale) ? CODECHAL_DECODE_VC1_LowRateMvModeTable : CODECHAL_DECODE_VC1_HighRateMvModeTable;
2244
2245 uint32_t mvMode;
2246 CODECHAL_DECODE_CHK_STATUS_RETURN(ParseProgressiveMvMode(mvModeTable, &mvMode));
2247
2248 if (CODECHAL_VC1_MVMODE_MIXEDMV == mvMode)
2249 {
2250 CODECHAL_DECODE_CHK_STATUS_RETURN(ParseBitplane());
2251 }
2252
2253 CODECHAL_DECODE_CHK_STATUS_RETURN(ParseBitplane());
2254
2255 uint32_t value = 0;
2256 CODECHAL_DECODE_CHK_STATUS_RETURN(SkipBits(CODECHAL_DECODE_VC1_BITS_MVTAB + CODECHAL_DECODE_VC1_BITS_CBPTAB, value));
2257
2258 CODECHAL_DECODE_CHK_STATUS_RETURN(ParseVopDquant());
2259
2260 if (m_vc1PicParams->transform_fields.variable_sized_transform_flag)
2261 {
2262 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_TTMBF, value));
2263
2264 if (1 == value)
2265 {
2266 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_TTFRM, value));
2267 }
2268 }
2269
2270 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_TRANSACFRM_1, value));
2271
2272 if (0 != value)
2273 {
2274 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_TRANSACFRM_2, value));
2275 }
2276
2277 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_TRANSDCTAB, value));
2278
2279 return eStatus;
2280 }
2281
2282 MOS_STATUS CodechalDecodeVc1::ParsePictureLayerBAdvanced()
2283 {
2284 uint32_t value;
2285 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2286
2287 if (m_vc1PicParams->mv_fields.extended_mv_flag)
2288 {
2289 CODECHAL_DECODE_CHK_STATUS_RETURN(ParseMvRange());
2290 }
2291
2292 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(1, value));
2293
2294 // B frame direct mode macroblock bit syntax element
2295 CODECHAL_DECODE_CHK_STATUS_RETURN(ParseBitplane());
2296
2297 // skipped macroblock bit syntax element
2298 CODECHAL_DECODE_CHK_STATUS_RETURN(ParseBitplane());
2299
2300 CODECHAL_DECODE_CHK_STATUS_RETURN(SkipBits(CODECHAL_DECODE_VC1_BITS_MVTAB + CODECHAL_DECODE_VC1_BITS_CBPTAB, value));
2301
2302 CODECHAL_DECODE_CHK_STATUS_RETURN(ParseVopDquant());
2303
2304 if (m_vc1PicParams->transform_fields.variable_sized_transform_flag)
2305 {
2306 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_TTMBF, value));
2307
2308 if (1 == value)
2309 {
2310 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_TTFRM, value));
2311 }
2312 }
2313
2314 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_TRANSACFRM_1, value));
2315
2316 if (0 != value)
2317 {
2318 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_TRANSACFRM_2, value));
2319 }
2320
2321 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_TRANSDCTAB, value));
2322
2323 return eStatus;
2324 }
2325
2326 MOS_STATUS CodechalDecodeVc1::ParseFieldPictureLayerPAdvanced()
2327 {
2328 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2329
2330 uint32_t value = 0;
2331 uint32_t numRef = 0;
2332 if (CodecHal_PictureIsField(m_vc1PicParams->CurrPic))
2333 {
2334 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_NUMREF, value));
2335 numRef = value;
2336
2337 if (0 == value)
2338 {
2339 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_REFFIELD, value));
2340 }
2341 }
2342 else
2343 {
2344 numRef = 0;
2345 }
2346
2347 if (m_vc1PicParams->mv_fields.extended_mv_flag)
2348 {
2349 CODECHAL_DECODE_CHK_STATUS_RETURN(ParseMvRange());
2350 }
2351
2352 if (m_vc1PicParams->mv_fields.extended_dmv_flag)
2353 {
2354 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(1, value));
2355 if (value)
2356 {
2357 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(1, value));
2358 if (value)
2359 {
2360 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(1, value));
2361 }
2362 }
2363 }
2364
2365 uint32_t mvMode;
2366 if (CodecHal_PictureIsField(m_vc1PicParams->CurrPic))
2367 {
2368 CODECHAL_DECODE_CHK_STATUS_RETURN(ParseInterlaceMVMode(true, &mvMode));
2369 }
2370 else
2371 {
2372 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_4MVSWITCH, value));
2373 if (value)
2374 {
2375 mvMode = CODECHAL_VC1_MVMODE_MIXEDMV;
2376 }
2377 else
2378 {
2379 mvMode = CODECHAL_VC1_MVMODE_1MV;
2380 }
2381
2382 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_INTCOMP, value));
2383
2384 if (value)
2385 {
2386 CODECHAL_DECODE_CHK_STATUS_RETURN(SkipBits(CODECHAL_DECODE_VC1_BITS_LUMSCALE + CODECHAL_DECODE_VC1_BITS_LUMSHIFT, value));
2387 }
2388
2389 // skipped macroblock bitplane
2390 CODECHAL_DECODE_CHK_STATUS_RETURN(ParseBitplane());
2391 }
2392
2393 uint32_t skipBits = 0;
2394
2395 if (CodecHal_PictureIsInterlacedFrame(m_vc1PicParams->CurrPic))
2396 {
2397 skipBits += 2; // 2-bit MBMODETAB
2398 }
2399 else
2400 {
2401 skipBits += 3; // 3 bit MBMODETAB
2402 }
2403
2404 if (0 == numRef)
2405 {
2406 skipBits += 2; // 2-bit MVTAB
2407 }
2408 else
2409 {
2410 skipBits += 3; // 3-bit MVTAB
2411 }
2412
2413 skipBits += CODECHAL_DECODE_VC1_BITS_CBPTAB_INTERLACE;
2414
2415 if (CodecHal_PictureIsInterlacedFrame(m_vc1PicParams->CurrPic))
2416 {
2417 skipBits += CODECHAL_DECODE_VC1_BITS_2MVBPTAB;
2418 }
2419
2420 if (CODECHAL_VC1_MVMODE_MIXEDMV == mvMode)
2421 {
2422 skipBits += CODECHAL_DECODE_VC1_BITS_4MVBPTAB;
2423 }
2424
2425 CODECHAL_DECODE_CHK_STATUS_RETURN(SkipBits(skipBits, value));
2426
2427 CODECHAL_DECODE_CHK_STATUS_RETURN(ParseVopDquant());
2428
2429 if (m_vc1PicParams->transform_fields.variable_sized_transform_flag)
2430 {
2431 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_TTMBF, value));
2432
2433 if (1 == value)
2434 {
2435 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_TTFRM, value));
2436 }
2437 }
2438
2439 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_TRANSACFRM_1, value));
2440
2441 if (0 != value)
2442 {
2443 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_TRANSACFRM_2, value));
2444 }
2445
2446 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_TRANSDCTAB, value));
2447
2448 return eStatus;
2449 }
2450
2451 MOS_STATUS CodechalDecodeVc1::ParseFieldPictureLayerBAdvanced()
2452 {
2453 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2454
2455 uint32_t value = 0;
2456 if (CodecHal_PictureIsInterlacedFrame(m_vc1PicParams->CurrPic))
2457 {
2458 CODECHAL_DECODE_CHK_STATUS_RETURN(GetVLC(CODECHAL_DECODE_VC1_VldBFractionTable, value));
2459 m_vc1PicParams->b_picture_fraction = (uint8_t)value;
2460 }
2461
2462 if (m_vc1PicParams->mv_fields.extended_mv_flag)
2463 {
2464 CODECHAL_DECODE_CHK_STATUS_RETURN(ParseMvRange());
2465 }
2466
2467 if (m_vc1PicParams->mv_fields.extended_dmv_flag)
2468 {
2469 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(1, value));
2470 if (value)
2471 {
2472 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(1, value));
2473 if (value)
2474 {
2475 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(1, value));
2476 }
2477 }
2478 }
2479
2480 uint32_t mvMode;
2481 if (CodecHal_PictureIsField(m_vc1PicParams->CurrPic))
2482 {
2483 CODECHAL_DECODE_CHK_STATUS_RETURN(ParseInterlaceMVMode(false, &mvMode));
2484 }
2485 else
2486 {
2487 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_INTCOMP, value));
2488
2489 if (value)
2490 {
2491 CODECHAL_DECODE_VERBOSEMESSAGE("INTCOMP is not false.");
2492 }
2493 mvMode = CODECHAL_VC1_MVMODE_1MV;
2494
2495 // direct macroblock bitplane
2496 CODECHAL_DECODE_CHK_STATUS_RETURN(ParseBitplane());
2497
2498 // skipped macroblock bitplane
2499 CODECHAL_DECODE_CHK_STATUS_RETURN(ParseBitplane());
2500 }
2501
2502 if (CodecHal_PictureIsField(m_vc1PicParams->CurrPic))
2503 {
2504 // forward macroblock
2505 CODECHAL_DECODE_CHK_STATUS_RETURN(ParseBitplane());
2506 }
2507
2508 uint32_t skipBits = 0;
2509
2510 if (CodecHal_PictureIsInterlacedFrame(m_vc1PicParams->CurrPic))
2511 {
2512 skipBits += 2; // 2-bit MBMODETAB
2513 }
2514 else
2515 {
2516 skipBits += 3; // 3 bit MBMODETAB
2517 }
2518
2519 if (!CodecHal_PictureIsField(m_vc1PicParams->CurrPic))
2520 {
2521 skipBits += 2; // 2-bit MVTAB
2522 }
2523 else
2524 {
2525 skipBits += 3; // 3-bit MVTAB
2526 }
2527
2528 skipBits += CODECHAL_DECODE_VC1_BITS_CBPTAB_INTERLACE;
2529
2530 if (CodecHal_PictureIsInterlacedFrame(m_vc1PicParams->CurrPic))
2531 {
2532 skipBits += CODECHAL_DECODE_VC1_BITS_2MVBPTAB;
2533 }
2534
2535 if ((CODECHAL_VC1_MVMODE_MIXEDMV == mvMode) ||
2536 CodecHal_PictureIsInterlacedFrame(m_vc1PicParams->CurrPic))
2537 {
2538 skipBits += CODECHAL_DECODE_VC1_BITS_4MVBPTAB;
2539 }
2540
2541 CODECHAL_DECODE_CHK_STATUS_RETURN(SkipBits(skipBits, value));
2542
2543 CODECHAL_DECODE_CHK_STATUS_RETURN(ParseVopDquant());
2544
2545 if (m_vc1PicParams->transform_fields.variable_sized_transform_flag)
2546 {
2547 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_TTMBF, value));
2548
2549 if (1 == value)
2550 {
2551 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_TTFRM, value));
2552 }
2553 }
2554
2555 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_TRANSACFRM_1, value));
2556
2557 if (0 != value)
2558 {
2559 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_TRANSACFRM_2, value));
2560 }
2561
2562 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_TRANSDCTAB, value));
2563
2564 return eStatus;
2565 }
2566
2567 MOS_STATUS CodechalDecodeVc1::ParsePictureHeaderAdvanced()
2568 {
2569 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2570
2571 bool isIPicture = m_mfxInterface->IsVc1IPicture(
2572 m_vc1PicParams->CurrPic,
2573 m_vc1PicParams->picture_fields.is_first_field,
2574 m_vc1PicParams->picture_fields.picture_type)
2575 ? true
2576 : false;
2577 bool isPPicture = m_mfxInterface->IsVc1PPicture(
2578 m_vc1PicParams->CurrPic,
2579 m_vc1PicParams->picture_fields.is_first_field,
2580 m_vc1PicParams->picture_fields.picture_type)
2581 ? true
2582 : false;
2583 bool isBPicture = m_mfxInterface->IsVc1BPicture(
2584 m_vc1PicParams->CurrPic,
2585 m_vc1PicParams->picture_fields.is_first_field,
2586 m_vc1PicParams->picture_fields.picture_type)
2587 ? true
2588 : false;
2589 bool isBIPicture = m_mfxInterface->IsVc1BIPicture(
2590 m_vc1PicParams->CurrPic,
2591 m_vc1PicParams->picture_fields.is_first_field,
2592 m_vc1PicParams->picture_fields.picture_type)
2593 ? true
2594 : false;
2595
2596 uint32_t value = 0;
2597 if (m_vc1PicParams->sequence_fields.interlace)
2598 {
2599 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_FCM_1, value));
2600 if (0 != value)
2601 {
2602 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_FCM_2, value));
2603 }
2604 }
2605
2606 if (CodecHal_PictureIsField(m_vc1PicParams->CurrPic))
2607 {
2608 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_FPTYPE, value));
2609 }
2610 else
2611 {
2612 CODECHAL_DECODE_CHK_STATUS_RETURN(GetVLC(CODECHAL_DECODE_VC1_VldPictureTypeTable, value));
2613 }
2614
2615 if (m_vc1PicParams->sequence_fields.tfcntrflag)
2616 {
2617 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_TFCNTR, value));
2618 }
2619
2620 uint32_t repeatFrameCount = 0, numPanScanWindows, skipBits;
2621 uint32_t repeatFirstField = 0;
2622 if (m_vc1PicParams->sequence_fields.pulldown)
2623 {
2624 if (!m_vc1PicParams->sequence_fields.interlace)
2625 {
2626 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_RPTFRM, value));
2627
2628 repeatFrameCount = value;
2629 }
2630 else
2631 {
2632 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_TFF, value));
2633 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_RFF, value));
2634
2635 repeatFirstField = value;
2636 }
2637 }
2638
2639 if (m_vc1PicParams->entrypoint_fields.panscan_flag)
2640 {
2641 // parse PANSCAN
2642 if (!CodecHal_PictureIsField(m_vc1PicParams->CurrPic))
2643 {
2644 if (!m_vc1PicParams->sequence_fields.pulldown)
2645 {
2646 numPanScanWindows = 1;
2647 }
2648 else
2649 {
2650 numPanScanWindows = 1 + repeatFrameCount;
2651 }
2652 }
2653 else
2654 {
2655 if (!m_vc1PicParams->sequence_fields.pulldown)
2656 {
2657 numPanScanWindows = 2;
2658 }
2659 else
2660 {
2661 numPanScanWindows = 2 + repeatFirstField;
2662 }
2663 }
2664
2665 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_PS_PRESENT, value));
2666
2667 if (value)
2668 {
2669 skipBits = CODECHAL_DECODE_VC1_BITS_PS_HOFFSET + CODECHAL_DECODE_VC1_BITS_PS_VOFFSET;
2670 skipBits += CODECHAL_DECODE_VC1_BITS_PS_WIDTH + CODECHAL_DECODE_VC1_BITS_PS_HEIGHT;
2671 skipBits = skipBits * numPanScanWindows;
2672
2673 CODECHAL_DECODE_CHK_STATUS_RETURN(SkipWords(skipBits >> 4, value));
2674 CODECHAL_DECODE_CHK_STATUS_RETURN(SkipBits(skipBits & 0xF, value));
2675 }
2676 }
2677
2678 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_RNDCTRL, value));
2679
2680 if (isIPicture || isBIPicture)
2681 {
2682 if (value != 0)
2683 {
2684 CODECHAL_DECODE_ASSERTMESSAGE("RNDCTRL is not 0 for I, BI pictures.");
2685 return MOS_STATUS_UNKNOWN;
2686 }
2687 }
2688
2689 if (m_vc1PicParams->sequence_fields.interlace)
2690 {
2691 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_UVSAMP, value));
2692 }
2693
2694 if (m_vc1PicParams->sequence_fields.finterpflag && CodecHal_PictureIsFrame(m_vc1PicParams->CurrPic))
2695 {
2696 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_INTERPFRM, value));
2697 }
2698
2699 if (!CodecHal_PictureIsInterlacedFrame(m_vc1PicParams->CurrPic))
2700 {
2701 if (isBPicture ||
2702 (CodecHal_PictureIsField(m_vc1PicParams->CurrPic) && isBIPicture))
2703 {
2704 CODECHAL_DECODE_CHK_STATUS_RETURN(GetVLC(CODECHAL_DECODE_VC1_VldBFractionTable, value));
2705 m_vc1PicParams->b_picture_fraction = (uint8_t)value;
2706 }
2707 }
2708
2709 // REFDIST
2710 if (CodecHal_PictureIsField(m_vc1PicParams->CurrPic) &&
2711 m_vc1PicParams->reference_fields.reference_distance_flag &&
2712 m_vc1PicParams->reference_fields.reference_picture_flag)
2713 {
2714 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(2, value));
2715
2716 if (value == 3)
2717 {
2718 CODECHAL_DECODE_CHK_STATUS_RETURN(GetVLC(CODECHAL_DECODE_VC1_VldRefDistTable, value));
2719 }
2720
2721 m_vc1PicParams->reference_fields.reference_distance = value;
2722 }
2723
2724 // Quantization Params
2725 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_PQINDEX, value));
2726
2727 if (8 >= value)
2728 {
2729 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_HALFQP, value));
2730 }
2731
2732 if (1 == m_vc1PicParams->pic_quantizer_fields.quantizer)
2733 {
2734 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_PQUANTIZER, value));
2735 }
2736
2737 // POSTPROC
2738 if (m_vc1PicParams->post_processing)
2739 {
2740 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_POSTPROC, value));
2741 }
2742
2743 if (!CodecHal_PictureIsFrame(m_vc1PicParams->CurrPic))
2744 {
2745 if (isIPicture || isBIPicture)
2746 {
2747 eStatus = ParsePictureLayerIAdvanced();
2748 }
2749 else if (isPPicture)
2750 {
2751 eStatus = ParseFieldPictureLayerPAdvanced();
2752 }
2753 else if (isBPicture)
2754 {
2755 eStatus = ParseFieldPictureLayerBAdvanced();
2756 }
2757 }
2758 else
2759 {
2760 if (isIPicture || isBIPicture)
2761 {
2762 eStatus = ParsePictureLayerIAdvanced();
2763 }
2764 else if (isPPicture)
2765 {
2766 eStatus = ParsePictureLayerPAdvanced();
2767 }
2768 else if (isBPicture)
2769 {
2770 eStatus = ParsePictureLayerBAdvanced();
2771 }
2772 }
2773
2774 return eStatus;
2775 }
2776
2777 MOS_STATUS CodechalDecodeVc1::ParsePictureHeaderMainSimple()
2778 {
2779 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2780
2781 uint32_t value = 0;
2782 if (m_vc1PicParams->sequence_fields.finterpflag)
2783 {
2784 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_INTERPFRM, value));
2785 }
2786
2787 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_FRMCNT, value));
2788
2789 if (m_vc1PicParams->sequence_fields.rangered)
2790 {
2791 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_RANGEREDFRM, value));
2792 }
2793
2794 // picture type
2795 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(1, value));
2796 if ((0 == value) && (m_vc1PicParams->sequence_fields.max_b_frames > 0))
2797 {
2798 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(1, value));
2799 if (0 == value)
2800 {
2801 // it's B or BI picture, get B fraction
2802 CODECHAL_DECODE_CHK_STATUS_RETURN(GetVLC(CODECHAL_DECODE_VC1_VldBFractionTable, value));
2803 m_vc1PicParams->b_picture_fraction = (uint8_t)value;
2804 }
2805 }
2806
2807 // we don't need to parse more since we only want B fraction value
2808
2809 return eStatus;
2810 }
2811
2812 MOS_STATUS CodechalDecodeVc1::GetSliceMbDataOffset()
2813 {
2814 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2815
2816 CODECHAL_DECODE_FUNCTION_ENTER;
2817
2818 if (m_numSlices == 1)
2819 {
2820 return eStatus;
2821 }
2822
2823 CodechalResLock ResourceLock(m_osInterface, &m_resDataBuffer);
2824 auto bitstream = (uint8_t*)ResourceLock.Lock(CodechalResLock::readOnly);
2825 CODECHAL_DECODE_CHK_NULL_RETURN(bitstream);
2826
2827 // start from the second slice since HW only need MB data offset for subsequent slices
2828 uint32_t macroblockOffset = 0;
2829 for (uint32_t slcCount = 1; slcCount < m_numSlices; slcCount++)
2830 {
2831 uint8_t *slice = bitstream + m_vc1SliceParams[slcCount].slice_data_offset;
2832
2833 // skip start code prefix
2834 slice += m_vldSliceRecord[slcCount].dwOffset;
2835 uint32_t length = m_vldSliceRecord[slcCount].dwLength;
2836
2837 CODECHAL_DECODE_CHK_STATUS_RETURN(InitialiseBitstream(slice, length, true));
2838
2839 // parse slice header to get PIC_HEADER_FLAG
2840 uint32_t value = 0;
2841 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_SC_SUFFIX, value));
2842
2843 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_SLICE_ADDR, value));
2844
2845 CODECHAL_DECODE_CHK_STATUS_RETURN(GetBits(CODECHAL_DECODE_VC1_BITS_PIC_HEADER_FLAG, value));
2846
2847 // parse picture header to get MB data offset if PIC_HEADER_FLAG == true
2848 if (value)
2849 {
2850 if (macroblockOffset == 0)
2851 {
2852 CODECHAL_DECODE_CHK_STATUS_RETURN(ParsePictureHeaderAdvanced());
2853
2854 macroblockOffset = m_bitstream.u32ProcessedBitNum +
2855 (CODECHAL_DECODE_VC1_SC_PREFIX_LENGTH << 3);
2856 }
2857
2858 m_vc1SliceParams[slcCount].macroblock_offset = macroblockOffset;
2859 }
2860 }
2861
2862 return eStatus;
2863 }
2864
2865 MOS_STATUS CodechalDecodeVc1::ParsePictureHeader()
2866 {
2867 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2868
2869 CODECHAL_DECODE_FUNCTION_ENTER;
2870
2871 bool isEBDU = m_vc1PicParams->sequence_fields.AdvancedProfileFlag;
2872
2873 CodechalResLock ResourceLock(m_osInterface, &m_resDataBuffer);
2874 auto bitstream = (uint8_t*)ResourceLock.Lock(CodechalResLock::readOnly);
2875 CODECHAL_DECODE_CHK_NULL_RETURN(bitstream);
2876
2877 uint32_t skippedBytes = 0;
2878 if (m_vc1PicParams->sequence_fields.AdvancedProfileFlag)
2879 {
2880 // skip start code (4-byte)
2881 skippedBytes = CODECHAL_DECODE_VC1_SC_PREFIX_LENGTH + (CODECHAL_DECODE_VC1_BITS_SC_SUFFIX >> 3);
2882 }
2883
2884 bitstream += skippedBytes;
2885 uint32_t length = m_dataSize - skippedBytes;
2886 CODECHAL_DECODE_CHK_STATUS_RETURN(InitialiseBitstream(bitstream, length, isEBDU));
2887
2888 if (m_vc1PicParams->sequence_fields.AdvancedProfileFlag)
2889 {
2890 CODECHAL_DECODE_CHK_STATUS_RETURN(ParsePictureHeaderAdvanced());
2891 }
2892 else
2893 {
2894 CODECHAL_DECODE_CHK_STATUS_RETURN(ParsePictureHeaderMainSimple());
2895 }
2896
2897 return eStatus;
2898 }
2899
2900 MOS_STATUS CodechalDecodeVc1::AllocateResources()
2901 {
2902 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2903
2904 CODECHAL_DECODE_FUNCTION_ENTER;
2905
2906 MOS_LOCK_PARAMS lockFlagsWriteOnly;
2907 MOS_ZeroMemory(&lockFlagsWriteOnly, sizeof(MOS_LOCK_PARAMS));
2908 lockFlagsWriteOnly.WriteOnly = 1;
2909
2910 m_numMacroblocks = m_picWidthInMb * m_picHeightInMb;
2911 m_numMacroblocksUv = m_picWidthInMb * (MOS_ALIGN_CEIL(m_picHeightInMb, 2) / 2);
2912
2913 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnCreateSyncResource(m_osInterface, &m_resSyncObject));
2914
2915 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalAllocateDataList(
2916 m_vc1RefList,
2917 CODECHAL_NUM_UNCOMPRESSED_SURFACE_VC1));
2918
2919 // Second level batch buffer for IT mode
2920 if (m_mode == CODECHAL_DECODE_MODE_VC1IT)
2921 {
2922 MOS_ZeroMemory(&m_itObjectBatchBuffer, sizeof(m_itObjectBatchBuffer));
2923
2924 // Must reserve at least 8 cachelines after MI_BATCH_BUFFER_END_CMD since HW prefetch max 8 cachelines from BB everytime
2925 uint32_t size = m_standardDecodeSizeNeeded * m_numMacroblocks + m_hwInterface->m_sizeOfCmdBatchBufferEnd + 8 * CODECHAL_CACHELINE_SIZE;
2926
2927 CODECHAL_DECODE_CHK_STATUS_RETURN(Mhw_AllocateBb(
2928 m_osInterface,
2929 &m_itObjectBatchBuffer,
2930 nullptr,
2931 size));
2932 m_itObjectBatchBuffer.bSecondLevel = true;
2933 }
2934
2935 // Deblocking Filter Row Store Scratch buffer
2936 //(Num MacroBlock Width) * (Num Cachlines) * (Cachline size)
2937 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(AllocateBuffer(
2938 &m_resMfdDeblockingFilterRowStoreScratchBuffer,
2939 m_picWidthInMb * 7 * CODECHAL_CACHELINE_SIZE,
2940 "DeblockingScratchBuffer"),
2941 "Failed to allocate Deblocking Filter Row Store Scratch Buffer.");
2942
2943 // BSD/MPC Row Store Scratch buffer
2944 // (FrameWidth in MB) * (2) * (CacheLine size per MB)
2945 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(AllocateBuffer(
2946 &m_resBsdMpcRowStoreScratchBuffer,
2947 m_picWidthInMb * CODECHAL_CACHELINE_SIZE * 2,
2948 "MpcScratchBuffer"),
2949 "Failed to allocate BSD/MPC Row Store Scratch Buffer.");
2950
2951 // VC1 MV buffer, 1 cacheline for every MB
2952 for (uint32_t i = 0; i < CODECHAL_DECODE_VC1_DMV_MAX; i++)
2953 {
2954 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(AllocateBuffer(
2955 &m_resVc1BsdMvData[i],
2956 CODECHAL_CACHELINE_SIZE * m_numMacroblocks,
2957 "MvBuffer"),
2958 "Failed to allocate VC1 BSD MV Buffer.");
2959 }
2960
2961 // Bitplane buffer
2962 // (Bitplane buffer pitch) * (Height in Macroblock)
2963 uint32_t size;
2964 if (m_shortFormatInUse)
2965 {
2966 if (m_width <= 2048)
2967 {
2968 size = MHW_VDBOX_VC1_BITPLANE_BUFFER_PITCH_SMALL * m_picHeightInMb;
2969 }
2970 else
2971 {
2972 size = MHW_VDBOX_VC1_BITPLANE_BUFFER_PITCH_LARGE * m_picHeightInMb;
2973 }
2974
2975 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(AllocateBuffer(
2976 &m_resBitplaneBuffer,
2977 size,
2978 "BitplaneBuffer"),
2979 "Failed to allocate Bitplane Buffer.");
2980 }
2981
2982 // For SP/MP short format
2983 // Private bitstream buffer
2984 // FrameWidth * FrameHeight * 1.5 + CODECHAL_DECODE_VC1_STUFFING_BYTES
2985 if (m_shortFormatInUse)
2986 {
2987 size = m_width * m_height * 3 / 2 + CODECHAL_DECODE_VC1_STUFFING_BYTES;
2988 m_privateBistreamBufferSize = size;
2989 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(AllocateBuffer(
2990 &m_resPrivateBistreamBuffer,
2991 size,
2992 "PrivateBistreamBuffer"),
2993 "Failed to allocate BSD/MPC Row Store Scratch Buffer.");
2994 }
2995
2996 m_unequalFieldWaInUse = (MEDIA_IS_WA(m_waTable, WaVC1UnequalFieldHeights) && (m_picHeightInMb % 2));
2997
2998 if (m_unequalFieldWaInUse)
2999 {
3000 // Decoded frame surface
3001 for (uint32_t i = 0; i < CODECHAL_DECODE_VC1_UNEQUAL_FIELD_WA_SURFACES; i++)
3002 {
3003 // Error Frame is 1MB x 2MB
3004 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(AllocateSurface(
3005 &m_unequalFieldSurface[i],
3006 m_width,
3007 m_height + MOS_YTILE_H_ALIGNMENT,
3008 "Vc1UnequalFieldSurface"),
3009 "Failed to allocate VC1 Unequal Fields WA decoding ouput surface data buffer.");
3010
3011 // ensure that no entries are valid
3012 m_unequalFieldRefListIdx[i] = CODECHAL_NUM_UNCOMPRESSED_SURFACE_VC1;
3013 }
3014
3015 m_unequalFieldSurfaceForBType = CODECHAL_DECODE_VC1_UNEQUAL_FIELD_WA_SURFACES - 1;
3016 m_currUnequalFieldSurface = 0;
3017 }
3018
3019 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnCreateSyncResource(
3020 m_osInterface,
3021 &m_resSyncObjectWaContextInUse));
3022
3023 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnCreateSyncResource(
3024 m_osInterface,
3025 &m_resSyncObjectVideoContextInUse));
3026
3027 return (MOS_STATUS)eStatus;
3028 }
3029
3030 CodechalDecodeVc1::~CodechalDecodeVc1()
3031 {
3032 CODECHAL_DECODE_FUNCTION_ENTER;
3033
3034 m_osInterface->pfnDestroySyncResource(m_osInterface, &m_resSyncObject);
3035
3036 CodecHalFreeDataList(m_vc1RefList, CODECHAL_NUM_UNCOMPRESSED_SURFACE_VC1);
3037
3038 MOS_FreeMemory(m_vldSliceRecord);
3039 m_vldSliceRecord = nullptr;
3040
3041 Mhw_FreeBb(m_osInterface, &m_itObjectBatchBuffer, nullptr);
3042
3043 m_osInterface->pfnFreeResource(
3044 m_osInterface,
3045 &m_resMfdDeblockingFilterRowStoreScratchBuffer);
3046
3047 m_osInterface->pfnFreeResource(
3048 m_osInterface,
3049 &m_resBsdMpcRowStoreScratchBuffer);
3050
3051 for (uint32_t i = 0; i < CODECHAL_DECODE_VC1_DMV_MAX; i++)
3052 {
3053 m_osInterface->pfnFreeResource(
3054 m_osInterface,
3055 &m_resVc1BsdMvData[i]);
3056 }
3057
3058 if (m_shortFormatInUse)
3059 {
3060 m_osInterface->pfnFreeResource(
3061 m_osInterface,
3062 &m_resBitplaneBuffer);
3063 }
3064
3065 m_osInterface->pfnFreeResource(
3066 m_osInterface,
3067 &m_resPrivateBistreamBuffer);
3068
3069 if (m_unequalFieldWaInUse)
3070 {
3071 for (uint32_t i = 0; i < CODECHAL_DECODE_VC1_UNEQUAL_FIELD_WA_SURFACES; i++)
3072 {
3073 // Error Frame is 1MB x 2MB
3074 m_osInterface->pfnFreeResource(
3075 m_osInterface,
3076 &m_unequalFieldSurface[i].OsResource);
3077 ;
3078 }
3079 }
3080
3081 m_osInterface->pfnDestroySyncResource(
3082 m_osInterface,
3083 &m_resSyncObjectWaContextInUse);
3084
3085 m_osInterface->pfnDestroySyncResource(
3086 m_osInterface,
3087 &m_resSyncObjectVideoContextInUse);
3088 }
3089
3090 MOS_STATUS CodechalDecodeVc1::SetFrameStates()
3091 {
3092 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
3093
3094 CODECHAL_DECODE_FUNCTION_ENTER;
3095
3096 CODECHAL_DECODE_CHK_NULL_RETURN(m_decodeParams.m_destSurface);
3097 CODECHAL_DECODE_CHK_NULL_RETURN(m_decodeParams.m_dataBuffer);
3098
3099 m_dataSize = m_decodeParams.m_dataSize;
3100 m_dataOffset = m_decodeParams.m_dataOffset;
3101 m_numSlices = m_decodeParams.m_numSlices;
3102 m_numMacroblocks = m_decodeParams.m_numMacroblocks;
3103 m_vc1PicParams = (PCODEC_VC1_PIC_PARAMS)(m_decodeParams.m_picParams);
3104 m_vc1SliceParams = (PCODEC_VC1_SLICE_PARAMS)(m_decodeParams.m_sliceParams);
3105 m_vc1MbParams = (PCODEC_VC1_MB_PARAMS)(m_decodeParams.m_macroblockParams);
3106 m_destSurface = *(m_decodeParams.m_destSurface);
3107 m_resDataBuffer = *(m_decodeParams.m_dataBuffer);
3108 m_deblockDataBuffer = m_decodeParams.m_deblockData;
3109
3110 CODECHAL_DECODE_CHK_NULL_RETURN(m_vc1PicParams);
3111
3112 if (m_vc1PicParams->coded_width > m_destSurface.dwPitch ||
3113 m_vc1PicParams->coded_height > m_destSurface.dwHeight)
3114 {
3115 return MOS_STATUS_INVALID_PARAMETER;
3116 }
3117
3118 if (CodecHalIsDecodeModeVLD(m_mode))
3119 {
3120 CODECHAL_DECODE_CHK_NULL_RETURN(m_vc1SliceParams);
3121 uint32_t numSliceRecord = 0;
3122 bool invalidSliceNum = false;
3123
3124 numSliceRecord = m_numMacroblocks;
3125 if (m_numSlices > m_numMacroblocks)
3126 {
3127 numSliceRecord = m_numSlices;
3128 invalidSliceNum = true;
3129 }
3130
3131 if (numSliceRecord > m_numVldSliceRecord || m_vldSliceRecord == nullptr)
3132 {
3133 MOS_SafeFreeMemory(m_vldSliceRecord);
3134 m_vldSliceRecord =
3135 (PCODECHAL_VC1_VLD_SLICE_RECORD)MOS_AllocAndZeroMemory(numSliceRecord * sizeof(CODECHAL_VC1_VLD_SLICE_RECORD));
3136 CODECHAL_DECODE_CHK_NULL_RETURN(m_vldSliceRecord);
3137 m_numVldSliceRecord = numSliceRecord;
3138 }
3139 else
3140 {
3141 MOS_ZeroMemory(m_vldSliceRecord, m_numVldSliceRecord * sizeof(CODECHAL_VC1_VLD_SLICE_RECORD));
3142 }
3143 }
3144 else if (CodecHalIsDecodeModeIT(m_mode))
3145 {
3146 CODECHAL_DECODE_CHK_NULL_RETURN(m_vc1MbParams);
3147
3148 // Catch the case the codec does not send a deblocking surface, but requests ILDB
3149 if (m_deblockDataBuffer == nullptr)
3150 {
3151 m_vc1PicParams->entrypoint_fields.loopfilter = 0;
3152 }
3153 }
3154
3155 // For short format, check if it is skipped frame.
3156 if (m_shortFormatInUse)
3157 {
3158 m_numMacroblocks = m_picWidthInMb * m_picHeightInMb;
3159
3160 if (m_vc1PicParams->sequence_fields.AdvancedProfileFlag)
3161 {
3162 if ((m_vc1SliceParams->macroblock_offset == 0xFFFF) &&
3163 (m_vc1SliceParams->number_macroblocks == m_numMacroblocks))
3164 {
3165 m_vc1PicParams->picture_fields.picture_type = vc1SkippedFrame;
3166 }
3167 }
3168 else // Simple or Main Profiles
3169 {
3170 if (((m_vc1SliceParams->slice_data_size == 0) ||
3171 (m_vc1SliceParams->slice_data_size == 8)) &&
3172 (m_vc1SliceParams->number_macroblocks == m_numMacroblocks))
3173 {
3174 m_vc1PicParams->picture_fields.picture_type = vc1SkippedFrame;
3175 }
3176 }
3177 }
3178
3179 PCODEC_REF_LIST destEntry = m_vc1RefList[m_vc1PicParams->CurrPic.FrameIdx];
3180 uint16_t picType = (uint16_t)m_vc1PicParams->picture_fields.picture_type;
3181 CODEC_PICTURE currPic = m_vc1PicParams->CurrPic;
3182
3183 if (!CodecHal_PictureIsField(currPic) ||
3184 (CodecHal_PictureIsField(currPic) && m_vc1PicParams->picture_fields.is_first_field))
3185 {
3186 MOS_ZeroMemory(destEntry, sizeof(CODEC_REF_LIST));
3187 destEntry->RefPic = currPic;
3188 destEntry->resRefPic = m_destSurface.OsResource;
3189 }
3190 if (!m_vc1PicParams->sequence_fields.AdvancedProfileFlag)
3191 {
3192 if (m_vc1PicParams->range_mapping_fields.range_mapping_enabled)
3193 {
3194 MOS_BIT_ON(destEntry->dwRefSurfaceFlags, CODECHAL_WMV9_RANGE_ADJUSTMENT);
3195 }
3196 else
3197 {
3198 MOS_BIT_OFF(destEntry->dwRefSurfaceFlags, CODECHAL_WMV9_RANGE_ADJUSTMENT);
3199 }
3200 }
3201
3202 if (CodecHal_PictureIsFrame(currPic))
3203 {
3204 MOS_BIT_ON(destEntry->dwRefSurfaceFlags, CODECHAL_VC1_PROGRESSIVE);
3205 }
3206
3207 m_statusReportFeedbackNumber = m_vc1PicParams->StatusReportFeedbackNumber;
3208
3209 m_deblockingEnabled = m_vc1PicParams->entrypoint_fields.loopfilter;
3210 m_width = m_vc1PicParams->coded_width;
3211 m_height = m_vc1PicParams->coded_height;
3212 m_picWidthInMb =
3213 ((uint16_t)m_width + CODECHAL_MACROBLOCK_WIDTH - 1) / CODECHAL_MACROBLOCK_WIDTH;
3214 m_picHeightInMb =
3215 ((uint16_t)m_height + CODECHAL_MACROBLOCK_HEIGHT - 1) / CODECHAL_MACROBLOCK_HEIGHT;
3216
3217 if (CodecHal_PictureIsField(currPic) && (m_picHeightInMb % 2))
3218 {
3219 m_vc1OddFrameHeight = true;
3220 }
3221 else
3222 {
3223 m_vc1OddFrameHeight = false;
3224 }
3225
3226 // Overwrite the actual surface height with the coded height and width of the frame
3227 // for VC1 since it's possible for a VC1 frame to change size during playback
3228 m_destSurface.dwWidth = m_width;
3229 m_destSurface.dwHeight = m_height;
3230
3231 bool bOLPParamsAvailable =
3232 m_vc1PicParams->range_mapping_fields.range_mapping_enabled || m_vc1PicParams->UpsamplingFlag;
3233
3234 if (m_decodeParams.m_deblockSurface &&
3235 ((m_vc1PicParams->DeblockedPicIdx != m_vc1PicParams->CurrPic.FrameIdx) || bOLPParamsAvailable) &&
3236 !(CodecHal_PictureIsField(currPic) && m_vc1PicParams->picture_fields.is_first_field))
3237 {
3238 m_olpNeeded = true;
3239 m_deblockSurface = *(m_decodeParams.m_deblockSurface);
3240 }
3241
3242 if (m_decodeParams.m_vc1BitplaneSize == 0)
3243 {
3244 m_vc1PicParams->raw_coding.bitplane_present = 0;
3245 }
3246
3247 if (m_vc1PicParams->raw_coding.bitplane_present)
3248 {
3249 m_resBitplaneBuffer = *(m_decodeParams.m_bitplaneBuffer);
3250 }
3251
3252 bool pictureIsI = m_mfxInterface->IsVc1IPicture(currPic, m_vc1PicParams->picture_fields.is_first_field, picType);
3253 bool pictureIsP = m_mfxInterface->IsVc1PPicture(currPic, m_vc1PicParams->picture_fields.is_first_field, picType);
3254 bool pictureIsB =
3255 (m_mfxInterface->IsVc1BPicture(currPic, m_vc1PicParams->picture_fields.is_first_field, picType) ||
3256 m_mfxInterface->IsVc1BIPicture(currPic, m_vc1PicParams->picture_fields.is_first_field, picType));
3257
3258 // Save anchor picture type and field structure (TFF/BFF)
3259 if (!pictureIsB)
3260 {
3261 m_prevAnchorPictureTff = (uint16_t)m_vc1PicParams->picture_fields.top_field_first;
3262 if (CodecHal_PictureIsBottomField(currPic))
3263 {
3264 m_prevOddAnchorPictureIsP = pictureIsP;
3265 }
3266 else
3267 {
3268 m_prevEvenAnchorPictureIsP = pictureIsP;
3269 }
3270 }
3271
3272 if (m_unequalFieldWaInUse && CodecHal_PictureIsField(currPic))
3273 {
3274 CODECHAL_DECODE_CHK_STATUS_RETURN(InitializeUnequalFieldSurface(
3275 (uint8_t)m_vc1PicParams->CurrPic.FrameIdx,
3276 m_renderContextUsesNullHw));
3277 CODECHAL_DECODE_CHK_STATUS_RETURN(InitializeUnequalFieldSurface(
3278 (uint8_t)m_vc1PicParams->ForwardRefIdx,
3279 m_renderContextUsesNullHw));
3280 CODECHAL_DECODE_CHK_STATUS_RETURN(InitializeUnequalFieldSurface(
3281 (uint8_t)m_vc1PicParams->BackwardRefIdx,
3282 m_renderContextUsesNullHw));
3283 }
3284
3285 m_perfType = pictureIsI ? I_TYPE : (pictureIsP ? P_TYPE : B_TYPE);
3286
3287 m_crrPic = currPic;
3288 m_secondField = (m_vc1PicParams->picture_fields.is_first_field == 1) ? false : true;
3289
3290 CODECHAL_DEBUG_TOOL(
3291 CODECHAL_DECODE_CHK_NULL_RETURN(m_debugInterface);
3292 m_debugInterface->m_currPic = m_crrPic;
3293 m_debugInterface->m_secondField = m_secondField;
3294 m_debugInterface->m_frameType = m_perfType;
3295
3296 if (m_vc1PicParams) {
3297 CODECHAL_DECODE_CHK_STATUS_RETURN(DumpPicParams(
3298 m_vc1PicParams));
3299 }
3300
3301 if (m_vc1SliceParams) {
3302 CODECHAL_DECODE_CHK_STATUS_RETURN(DumpSliceParams(
3303 m_vc1SliceParams));
3304 }
3305
3306 if (m_vc1MbParams) {
3307 CODECHAL_DECODE_CHK_STATUS_RETURN(DumpMbParams(
3308 m_vc1MbParams));
3309 }
3310
3311 if (m_deblockDataBuffer) {
3312 //Dump decode deblocking
3313 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpData(
3314 m_deblockDataBuffer,
3315 m_decodeParams.m_deblockDataSize,
3316 CodechalDbgAttr::attrDeblocking,
3317 "_DEC"));
3318 }
3319
3320 if (m_decodeParams.m_vc1BitplaneSize != 0) {
3321 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
3322 &m_resBitplaneBuffer,
3323 CodechalDbgAttr::attrVc1Bitplane,
3324 "_DEC",
3325 m_decodeParams.m_vc1BitplaneSize));
3326
3327 })
3328
3329 return eStatus;
3330 }
3331
3332 MOS_STATUS CodechalDecodeVc1::DecodeStateLevel()
3333 {
3334 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
3335
3336 CODECHAL_DECODE_FUNCTION_ENTER;
3337
3338 PCODEC_REF_LIST *vc1RefList;
3339 vc1RefList = &(m_vc1RefList[0]);
3340
3341 uint8_t destIdx = m_vc1PicParams->CurrPic.FrameIdx;
3342 uint8_t fwdRefIdx = (uint8_t)m_vc1PicParams->ForwardRefIdx;
3343 uint8_t bwdRefIdx = (uint8_t)m_vc1PicParams->BackwardRefIdx;
3344
3345 bool isIPicture = m_mfxInterface->IsVc1IPicture(
3346 m_vc1PicParams->CurrPic,
3347 m_vc1PicParams->picture_fields.is_first_field,
3348 m_vc1PicParams->picture_fields.picture_type)
3349 ? true
3350 : false;
3351 bool isPPicture = m_mfxInterface->IsVc1PPicture(
3352 m_vc1PicParams->CurrPic,
3353 m_vc1PicParams->picture_fields.is_first_field,
3354 m_vc1PicParams->picture_fields.picture_type)
3355 ? true
3356 : false;
3357 bool isBPicture = m_mfxInterface->IsVc1BPicture(
3358 m_vc1PicParams->CurrPic,
3359 m_vc1PicParams->picture_fields.is_first_field,
3360 m_vc1PicParams->picture_fields.picture_type)
3361 ? true
3362 : false;
3363
3364 PMOS_SURFACE destSurface;
3365 PMOS_RESOURCE fwdRefSurface, bwdRefSurface;
3366 if (m_unequalFieldWaInUse && CodecHal_PictureIsField(m_vc1PicParams->CurrPic))
3367 {
3368 destSurface =
3369 &(m_unequalFieldSurface[vc1RefList[destIdx]->dwUnequalFieldSurfaceIdx]);
3370 fwdRefSurface =
3371 &(m_unequalFieldSurface[vc1RefList[fwdRefIdx]->dwUnequalFieldSurfaceIdx].OsResource);
3372 bwdRefSurface =
3373 &(m_unequalFieldSurface[vc1RefList[bwdRefIdx]->dwUnequalFieldSurfaceIdx].OsResource);
3374
3375 // Overwrite the actual surface height with the coded height and width of the frame
3376 // for VC1 since it's possible for a VC1 frame to change size during playback
3377 destSurface->dwWidth = m_width;
3378 destSurface->dwHeight = m_height;
3379 }
3380 else
3381 {
3382 destSurface = &m_destSurface;
3383 fwdRefSurface = &(vc1RefList[fwdRefIdx]->resRefPic);
3384 bwdRefSurface = &(vc1RefList[bwdRefIdx]->resRefPic);
3385 }
3386
3387 // For SP/MP short format
3388 if (m_shortFormatInUse &&
3389 !m_vc1PicParams->sequence_fields.AdvancedProfileFlag)
3390 {
3391 CODECHAL_DECODE_CHK_STATUS_RETURN(ConstructBistreamBuffer());
3392 }
3393
3394 MOS_COMMAND_BUFFER cmdBuffer;
3395 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &cmdBuffer, 0));
3396
3397 auto mmioRegisters = m_hwInterface->GetMfxInterface()->GetMmioRegisters(m_vdboxIndex);
3398 HalOcaInterface::On1stLevelBBStart(cmdBuffer, *m_osInterface->pOsContext, m_osInterface->CurrentGpuContextHandle, *m_miInterface, *mmioRegisters);
3399
3400 MHW_VDBOX_PIPE_MODE_SELECT_PARAMS pipeModeSelectParams;
3401 pipeModeSelectParams.Mode = m_mode;
3402 pipeModeSelectParams.bStreamOutEnabled = m_streamOutEnabled;
3403 pipeModeSelectParams.bPostDeblockOutEnable = m_deblockingEnabled;
3404 pipeModeSelectParams.bPreDeblockOutEnable = !m_deblockingEnabled;
3405 pipeModeSelectParams.bShortFormatInUse = m_shortFormatInUse;
3406 pipeModeSelectParams.bVC1OddFrameHeight = m_vc1OddFrameHeight;
3407
3408 MHW_VDBOX_SURFACE_PARAMS surfaceParams;
3409 MOS_ZeroMemory(&surfaceParams, sizeof(surfaceParams));
3410 surfaceParams.Mode = m_mode;
3411 surfaceParams.psSurface = destSurface;
3412
3413 MHW_VDBOX_PIPE_BUF_ADDR_PARAMS pipeBufAddrParams;
3414 pipeBufAddrParams.Mode = m_mode;
3415 if (m_deblockingEnabled)
3416 {
3417 pipeBufAddrParams.psPostDeblockSurface = destSurface;
3418 }
3419 else
3420 {
3421 pipeBufAddrParams.psPreDeblockSurface = destSurface;
3422 }
3423
3424 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mmc->SetPipeBufAddr(&pipeBufAddrParams));
3425
3426 // when there is not a forward or backward reference,
3427 // the index is set to the destination frame index
3428 m_presReferences[CodechalDecodeFwdRefTop] =
3429 m_presReferences[CodechalDecodeFwdRefBottom] =
3430 fwdRefSurface;
3431 m_presReferences[CodechalDecodeBwdRefTop] =
3432 m_presReferences[CodechalDecodeBwdRefBottom] =
3433 bwdRefSurface;
3434 // special case for second fields
3435 if (!m_vc1PicParams->picture_fields.is_first_field &&
3436 !m_mfxInterface->IsVc1IPicture(
3437 m_vc1PicParams->CurrPic,
3438 m_vc1PicParams->picture_fields.is_first_field,
3439 m_vc1PicParams->picture_fields.picture_type))
3440 {
3441 if (m_vc1PicParams->picture_fields.top_field_first)
3442 {
3443 m_presReferences[CodechalDecodeFwdRefTop] =
3444 &destSurface->OsResource;
3445 }
3446 else
3447 {
3448 m_presReferences[CodechalDecodeFwdRefBottom] =
3449 &destSurface->OsResource;
3450 }
3451 }
3452
3453 // set all ref pic addresses to valid addresses for error concealment purpose
3454 for (uint32_t i = 0; i < CODEC_MAX_NUM_REF_FRAME_NON_AVC; i++)
3455 {
3456 if (m_presReferences[i] == nullptr &&
3457 MEDIA_IS_WA(m_waTable, WaDummyReference) &&
3458 !Mos_ResourceIsNull(&m_dummyReference.OsResource))
3459 {
3460 m_presReferences[i] = &m_dummyReference.OsResource;
3461 }
3462 }
3463
3464 CODECHAL_DECODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(pipeBufAddrParams.presReferences, sizeof(PMOS_RESOURCE) * CODEC_MAX_NUM_REF_FRAME_NON_AVC, m_presReferences, sizeof(PMOS_RESOURCE) * CODEC_MAX_NUM_REF_FRAME_NON_AVC));
3465
3466 pipeBufAddrParams.presMfdDeblockingFilterRowStoreScratchBuffer =
3467 &m_resMfdDeblockingFilterRowStoreScratchBuffer;
3468
3469 if (m_streamOutEnabled)
3470 {
3471 pipeBufAddrParams.presStreamOutBuffer =
3472 &(m_streamOutBuffer[m_streamOutCurrBufIdx]);
3473 }
3474
3475 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mmc->CheckReferenceList(&pipeBufAddrParams));
3476
3477 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mmc->SetRefrenceSync(m_disableDecodeSyncLock, m_disableLockForTranscode));
3478
3479 CODECHAL_DEBUG_TOOL(
3480 for (int i = 0; i < CODEC_MAX_NUM_REF_FRAME_NON_AVC; i++)
3481 {
3482 if (pipeBufAddrParams.presReferences[i])
3483 {
3484 MOS_SURFACE dstSurface;
3485
3486 MOS_ZeroMemory(&dstSurface, sizeof(MOS_SURFACE));
3487 dstSurface.Format = Format_NV12;
3488 dstSurface.OsResource = *(pipeBufAddrParams.presReferences[i]);
3489 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalGetResourceInfo(
3490 m_osInterface,
3491 &dstSurface));
3492
3493 m_debugInterface->m_refIndex = (uint16_t)i;
3494 std::string refSurfName = "RefSurf[" + std::to_string(static_cast<uint32_t>(m_debugInterface->m_refIndex)) + "]";
3495 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpYUVSurface(
3496 &dstSurface,
3497 CodechalDbgAttr::attrDecodeReferenceSurfaces,
3498 refSurfName.data()));
3499 }
3500 }
3501 )
3502
3503 MHW_VDBOX_IND_OBJ_BASE_ADDR_PARAMS indObjBaseAddrParams;
3504 MOS_ZeroMemory(&indObjBaseAddrParams, sizeof(indObjBaseAddrParams));
3505 indObjBaseAddrParams.Mode = m_mode;
3506 if (m_shortFormatInUse &&
3507 !m_vc1PicParams->sequence_fields.AdvancedProfileFlag)
3508 {
3509 indObjBaseAddrParams.dwDataSize = m_dataSize + CODECHAL_DECODE_VC1_STUFFING_BYTES;
3510 indObjBaseAddrParams.presDataBuffer = &m_resPrivateBistreamBuffer;
3511 }
3512 else
3513 {
3514 indObjBaseAddrParams.dwDataSize = m_dataSize;
3515 indObjBaseAddrParams.presDataBuffer = &m_resDataBuffer;
3516 }
3517
3518 MHW_VDBOX_BSP_BUF_BASE_ADDR_PARAMS bspBufBaseAddrParams;
3519 MOS_ZeroMemory(&bspBufBaseAddrParams, sizeof(bspBufBaseAddrParams));
3520 bspBufBaseAddrParams.presBsdMpcRowStoreScratchBuffer = &m_resBsdMpcRowStoreScratchBuffer;
3521
3522 if (m_vc1PicParams->raw_coding.bitplane_present || m_shortFormatInUse)
3523 {
3524 bspBufBaseAddrParams.presBitplaneBuffer = &m_resBitplaneBuffer;
3525 }
3526
3527 MHW_VDBOX_VC1_PRED_PIPE_PARAMS vc1PredPipeParams;
3528 vc1PredPipeParams.pVc1PicParams = m_vc1PicParams;
3529 vc1PredPipeParams.ppVc1RefList = vc1RefList;
3530
3531 MHW_VDBOX_VC1_PIC_STATE vc1PicState;
3532 vc1PicState.pVc1PicParams = m_vc1PicParams;
3533 vc1PicState.Mode = m_mode;
3534 vc1PicState.ppVc1RefList = vc1RefList;
3535 vc1PicState.wPrevAnchorPictureTFF = m_prevAnchorPictureTff;
3536 vc1PicState.bPrevEvenAnchorPictureIsP = m_prevEvenAnchorPictureIsP;
3537 vc1PicState.bPrevOddAnchorPictureIsP = m_prevOddAnchorPictureIsP;
3538
3539 if (m_shortFormatInUse)
3540 {
3541 // APP does not provide REFDIST for I/P pictures correctly
3542 if (m_vc1PicParams->sequence_fields.AdvancedProfileFlag &&
3543 CodecHal_PictureIsField(m_vc1PicParams->CurrPic) &&
3544 (isIPicture || isPPicture) &&
3545 m_vc1PicParams->reference_fields.reference_distance_flag)
3546 {
3547 if (m_vc1PicParams->picture_fields.is_first_field)
3548 {
3549 CODECHAL_DECODE_CHK_STATUS_RETURN(ParsePictureHeader());
3550 m_referenceDistance = m_vc1PicParams->reference_fields.reference_distance;
3551 }
3552 else
3553 {
3554 m_vc1PicParams->reference_fields.reference_distance = m_referenceDistance;
3555 }
3556 }
3557
3558 // APP does not provide BFRACTION correctly. So parse picture header to get BFRACTION
3559 if (isBPicture)
3560 {
3561 if (m_vc1PicParams->picture_fields.is_first_field)
3562 {
3563 CODECHAL_DECODE_CHK_STATUS_RETURN(ParsePictureHeader());
3564 }
3565 }
3566 }
3567
3568 MHW_VDBOX_VC1_DIRECTMODE_PARAMS vc1DirectmodeParams;
3569 if (m_mode == CODECHAL_DECODE_MODE_VC1VLD)
3570 {
3571 uint8_t dmvBufferIdx = (m_vc1PicParams->CurrPic.PicFlags == PICTURE_BOTTOM_FIELD) ? CODECHAL_DECODE_VC1_DMV_ODD : CODECHAL_DECODE_VC1_DMV_EVEN;
3572 vc1DirectmodeParams.presDmvReadBuffer = &m_resVc1BsdMvData[dmvBufferIdx];
3573 vc1DirectmodeParams.presDmvWriteBuffer = &m_resVc1BsdMvData[dmvBufferIdx];
3574 }
3575
3576 CODECHAL_DECODE_CHK_STATUS_RETURN(SendPrologWithFrameTracking(&cmdBuffer, !m_olpNeeded));
3577
3578 if (m_statusQueryReportingEnabled)
3579 {
3580 CODECHAL_DECODE_CHK_STATUS_RETURN(StartStatusReport(&cmdBuffer));
3581 }
3582
3583 if (!CodecHal_PictureIsField(m_vc1PicParams->CurrPic) &&
3584 m_vc1PicParams->picture_fields.picture_type == vc1SkippedFrame)
3585 {
3586 // no further picture level commands needed for skipped frames
3587 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
3588
3589 return eStatus;
3590 }
3591
3592 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxPipeModeSelectCmd(&cmdBuffer, &pipeModeSelectParams));
3593
3594 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxSurfaceCmd(&cmdBuffer, &surfaceParams));
3595
3596 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxPipeBufAddrCmd(&cmdBuffer, &pipeBufAddrParams));
3597
3598 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxIndObjBaseAddrCmd(&cmdBuffer, &indObjBaseAddrParams));
3599
3600 if (m_mode == CODECHAL_DECODE_MODE_VC1VLD)
3601 {
3602 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxBspBufBaseAddrCmd(&cmdBuffer, &bspBufBaseAddrParams));
3603 }
3604
3605 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxVc1PredPipeCmd(&cmdBuffer, &vc1PredPipeParams));
3606
3607 if (m_intelEntrypointInUse || m_mode == CODECHAL_DECODE_MODE_VC1IT)
3608 {
3609 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxVc1LongPicCmd(&cmdBuffer, &vc1PicState));
3610 }
3611 else if (m_shortFormatInUse)
3612 {
3613 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfdVc1ShortPicCmd(&cmdBuffer, &vc1PicState));
3614 }
3615 else
3616 {
3617 CODECHAL_DECODE_ASSERTMESSAGE("Unsupported decode mode.");
3618 eStatus = MOS_STATUS_UNKNOWN;
3619 return eStatus;
3620 }
3621
3622 if (m_mode == CODECHAL_DECODE_MODE_VC1VLD)
3623 {
3624 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxVc1DirectmodeCmd(&cmdBuffer, &vc1DirectmodeParams));
3625 }
3626
3627 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
3628
3629 return eStatus;
3630 }
3631
3632 MOS_STATUS CodechalDecodeVc1::DecodePrimitiveLevel()
3633 {
3634 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
3635
3636 CODECHAL_DECODE_FUNCTION_ENTER;
3637
3638 if (m_mode == CODECHAL_DECODE_MODE_VC1IT)
3639 {
3640 CODECHAL_DECODE_CHK_STATUS_RETURN(DecodePrimitiveLevelIT());
3641 }
3642 else if (m_mode == CODECHAL_DECODE_MODE_VC1VLD)
3643 {
3644 CODECHAL_DECODE_CHK_STATUS_RETURN(DecodePrimitiveLevelVLD())
3645 }
3646 else
3647 {
3648 return MOS_STATUS_UNKNOWN;
3649 }
3650
3651 return eStatus;
3652 }
3653
3654 MOS_STATUS CodechalDecodeVc1::DecodePrimitiveLevelVLD()
3655 {
3656 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
3657
3658 CODECHAL_DECODE_FUNCTION_ENTER;
3659
3660 MOS_SYNC_PARAMS syncParams;
3661
3662 // static VC1 slice parameters
3663 MHW_VDBOX_VC1_SLICE_STATE vc1SliceState;
3664 vc1SliceState.presDataBuffer = &m_resDataBuffer;
3665
3666 uint16_t frameFieldHeightInMb;
3667 CodecHal_GetFrameFieldHeightInMb(
3668 m_vc1PicParams->CurrPic,
3669 m_picHeightInMb,
3670 frameFieldHeightInMb);
3671
3672 MOS_COMMAND_BUFFER cmdBuffer;
3673 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &cmdBuffer, 0));
3674
3675 if (!CodecHal_PictureIsField(m_vc1PicParams->CurrPic) &&
3676 m_vc1PicParams->picture_fields.picture_type == vc1SkippedFrame)
3677 {
3678 CODECHAL_DECODE_CHK_STATUS_RETURN(HandleSkipFrame());
3679 goto submit;
3680 }
3681 else
3682 {
3683 PCODEC_VC1_SLICE_PARAMS slc = m_vc1SliceParams;
3684 bool firstValidSlice = true;
3685 int prevValidSlc = 0;
3686 for (uint32_t slcCount = 0; slcCount < m_numSlices; slcCount++)
3687 {
3688 m_vldSliceRecord[slcCount].dwSliceYOffset = slc->slice_vertical_position;
3689 m_vldSliceRecord[slcCount].dwNextSliceYOffset = frameFieldHeightInMb; // init to last slice
3690
3691 int32_t length = slc->slice_data_size >> 3;
3692 int32_t offset = slc->macroblock_offset >> 3;
3693
3694 CodechalResLock ResourceLock(m_osInterface, &m_resDataBuffer);
3695 auto buf = (uint8_t*)ResourceLock.Lock(CodechalResLock::readOnly);
3696 if (offset > 3 && buf != nullptr &&
3697 m_vc1PicParams->sequence_fields.AdvancedProfileFlag)
3698 {
3699 int i = 0;
3700 int j = 0;
3701 buf += slc->slice_data_offset;
3702
3703 for (i = 0, j = 0; i < offset - 1; i++, j++)
3704 {
3705 if (!buf[j] && !buf[j + 1] && buf[j + 2] == 3 && buf[j + 3] < 4)
3706 {
3707 i++, j += 2;
3708 }
3709 }
3710 if (i == offset - 1)
3711 {
3712 if (!buf[j] && !buf[j + 1] && buf[j + 2] == 3 && buf[j + 3] < 4)
3713 {
3714 buf[j + 2] = 0;
3715 j++;
3716 }
3717 j++;
3718 }
3719 offset = (8 * j + slc->macroblock_offset % 8)>>3;
3720 }
3721
3722 // Check that the slice data does not overrun the bitstream buffer size
3723 if (((uintptr_t)(slc->slice_data_offset) + length) > m_dataSize)
3724 {
3725 length = m_dataSize - (uintptr_t)(slc->slice_data_offset);
3726
3727 if (length < 0)
3728 {
3729 length = 0;
3730 }
3731 }
3732
3733 // Error handling for garbage data
3734 if (((uintptr_t)(slc->slice_data_offset)) > m_dataSize)
3735 {
3736 slc++;
3737 m_vldSliceRecord[slcCount].dwSkip = true;
3738 continue;
3739 }
3740
3741 // Check offset not larger than slice length, can have slice length of 0
3742 if (offset > length)
3743 {
3744 slc++;
3745 m_vldSliceRecord[slcCount].dwSkip = true;
3746 continue;
3747 }
3748
3749 // Check that the slices do not overlap, else do not send the lower slice
3750 if (!firstValidSlice &&
3751 (m_vldSliceRecord[slcCount].dwSliceYOffset <= m_vldSliceRecord[prevValidSlc].dwSliceYOffset))
3752 {
3753 slc++;
3754 m_vldSliceRecord[slcCount].dwSkip = true;
3755 continue;
3756 }
3757
3758 if (firstValidSlice)
3759 {
3760 // Ensure that the first slice starts from 0
3761 m_vldSliceRecord[slcCount].dwSliceYOffset = 0;
3762 slc->slice_vertical_position = 0;
3763 }
3764 else
3765 {
3766 // Set next slice start Y offset of previous slice
3767 m_vldSliceRecord[prevValidSlc].dwNextSliceYOffset =
3768 m_vldSliceRecord[slcCount].dwSliceYOffset;
3769 }
3770
3771 if (m_shortFormatInUse)
3772 {
3773 if (m_vc1PicParams->sequence_fields.AdvancedProfileFlag)
3774 {
3775 if ((slc->macroblock_offset >> 3) < CODECHAL_DECODE_VC1_SC_PREFIX_LENGTH)
3776 {
3777 slc++;
3778 m_vldSliceRecord[slcCount].dwSkip = true;
3779 continue;
3780 }
3781
3782 // set macroblock_offset of the first slice to 0 match HW expectations.
3783 if (slcCount == 0)
3784 {
3785 slc->macroblock_offset = CODECHAL_DECODE_VC1_SC_PREFIX_LENGTH << 3;
3786 }
3787
3788 offset = CODECHAL_DECODE_VC1_SC_PREFIX_LENGTH;
3789 }
3790 else // Simple Profile or Main Profile
3791 {
3792 {
3793 offset = CODECHAL_DECODE_VC1_STUFFING_BYTES - 1;
3794 length += CODECHAL_DECODE_VC1_STUFFING_BYTES;
3795 slc->macroblock_offset += CODECHAL_DECODE_VC1_STUFFING_BYTES << 3;
3796 slc->macroblock_offset &= (~0x7); // Clear bit offset of first MB for short format
3797 }
3798 }
3799 }
3800
3801 m_vldSliceRecord[slcCount].dwOffset = offset;
3802 m_vldSliceRecord[slcCount].dwLength = length - offset;
3803 firstValidSlice = false;
3804 prevValidSlc = slcCount;
3805 slc++;
3806 }
3807
3808 if (m_shortFormatInUse &&
3809 m_vc1PicParams->sequence_fields.AdvancedProfileFlag)
3810 {
3811 CODECHAL_DECODE_CHK_STATUS_RETURN(GetSliceMbDataOffset());
3812 }
3813
3814 // Reset slc pointer
3815 slc -= m_numSlices;
3816
3817 //------------------------------------
3818 // Fill BSD Object Commands
3819 //------------------------------------
3820 for (uint32_t slcCount = 0; slcCount < m_numSlices; slcCount++)
3821 {
3822 if (m_vldSliceRecord[slcCount].dwSkip)
3823 {
3824 slc++;
3825 continue;
3826 }
3827
3828 vc1SliceState.pSlc = slc;
3829 vc1SliceState.dwOffset = m_vldSliceRecord[slcCount].dwOffset;
3830 vc1SliceState.dwLength = m_vldSliceRecord[slcCount].dwLength;
3831 vc1SliceState.dwNextVerticalPosition = m_vldSliceRecord[slcCount].dwNextSliceYOffset;
3832
3833 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfdVc1BsdObjectCmd(&cmdBuffer, &vc1SliceState));
3834
3835 slc++;
3836 }
3837
3838 // Free VLD slice record
3839 MOS_ZeroMemory(m_vldSliceRecord, (m_numSlices * sizeof(CODECHAL_VC1_VLD_SLICE_RECORD)));
3840 }
3841
3842 // Check if destination surface needs to be synchronized
3843 if (m_unequalFieldWaInUse &&
3844 CodecHal_PictureIsField(m_vc1PicParams->CurrPic) &&
3845 !m_vc1PicParams->picture_fields.is_first_field)
3846 {
3847 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
3848 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
3849
3850 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(&cmdBuffer, &flushDwParams));
3851 }
3852 else
3853 {
3854 // Check if destination surface needs to be synchronized
3855 syncParams = g_cInitSyncParams;
3856 syncParams.GpuContext = m_videoContext;
3857 syncParams.presSyncResource = &m_destSurface.OsResource;
3858 syncParams.bReadOnly = false;
3859 syncParams.bDisableDecodeSyncLock = m_disableDecodeSyncLock;
3860 syncParams.bDisableLockForTranscode = m_disableLockForTranscode;
3861
3862 if (!CodecHal_PictureIsField(m_vc1PicParams->CurrPic) ||
3863 m_vc1PicParams->picture_fields.is_first_field)
3864 {
3865 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnPerformOverlaySync(m_osInterface, &syncParams));
3866 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceWait(m_osInterface, &syncParams));
3867
3868 // Update the resource tag (s/w tag) for On-Demand Sync
3869 m_osInterface->pfnSetResourceSyncTag(m_osInterface, &syncParams);
3870 }
3871
3872 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
3873 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
3874
3875 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(&cmdBuffer, &flushDwParams));
3876
3877 // Update the tag in GPU Sync eStatus buffer (H/W Tag) to match the current S/W tag
3878 if (m_osInterface->bTagResourceSync &&
3879 !(CodecHal_PictureIsField(m_vc1PicParams->CurrPic) && m_vc1PicParams->picture_fields.is_first_field))
3880 {
3881 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->WriteSyncTagToResource(&cmdBuffer, &syncParams));
3882 }
3883 }
3884
3885 submit:
3886 if (m_statusQueryReportingEnabled)
3887 {
3888 CodechalDecodeStatusReport decodeStatusReport;
3889
3890 decodeStatusReport.m_statusReportNumber = m_statusReportFeedbackNumber;
3891 decodeStatusReport.m_currDecodedPic = m_vc1PicParams->CurrPic;
3892 if (m_olpNeeded)
3893 {
3894 CODECHAL_DEBUG_TOOL(
3895 decodeStatusReport.m_currDeblockedPic.FrameIdx = (uint8_t)m_vc1PicParams->DeblockedPicIdx;
3896 decodeStatusReport.m_currDeblockedPic.PicFlags = PICTURE_FRAME;)
3897 decodeStatusReport.m_deblockedPicResOlp = m_deblockSurface.OsResource;
3898 }
3899 else
3900 {
3901 decodeStatusReport.m_currDeblockedPic = m_vc1PicParams->CurrPic;
3902 }
3903 decodeStatusReport.m_codecStatus = CODECHAL_STATUS_UNAVAILABLE;
3904 decodeStatusReport.m_currDecodedPicRes = m_vc1RefList[m_vc1PicParams->CurrPic.FrameIdx]->resRefPic;
3905
3906 CODECHAL_DEBUG_TOOL(
3907 decodeStatusReport.m_secondField =
3908 (m_vc1PicParams->picture_fields.is_first_field == 1) ? false : true;
3909 decodeStatusReport.m_olpNeeded = m_olpNeeded;
3910 decodeStatusReport.m_frameType = m_perfType;)
3911
3912 CODECHAL_DECODE_CHK_STATUS_RETURN(EndStatusReport(decodeStatusReport, &cmdBuffer));
3913 }
3914
3915 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(&cmdBuffer, nullptr));
3916
3917 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
3918
3919 CODECHAL_DEBUG_TOOL(
3920 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpCmdBuffer(
3921 &cmdBuffer,
3922 CODECHAL_NUM_MEDIA_STATES,
3923 "_DEC"));
3924
3925 //CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHal_DbgReplaceAllCommands(
3926 // m_debugInterface,
3927 // &cmdBuffer));
3928 )
3929
3930 if (m_huCCopyInUse)
3931 {
3932 syncParams = g_cInitSyncParams;
3933 syncParams.GpuContext = m_videoContextForWa;
3934 syncParams.presSyncResource = &m_resSyncObjectWaContextInUse;
3935
3936 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineSignal(m_osInterface, &syncParams));
3937
3938 syncParams = g_cInitSyncParams;
3939 syncParams.GpuContext = m_videoContext;
3940 syncParams.presSyncResource = &m_resSyncObjectWaContextInUse;
3941
3942 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineWait(m_osInterface, &syncParams));
3943
3944 m_huCCopyInUse = false;
3945 }
3946
3947 HalOcaInterface::On1stLevelBBEnd(cmdBuffer, *m_osInterface);
3948
3949 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(m_osInterface, &cmdBuffer, m_videoContextUsesNullHw));
3950
3951 CODECHAL_DEBUG_TOOL(
3952 m_mmc->UpdateUserFeatureKey(&m_destSurface);)
3953
3954 if (m_unequalFieldWaInUse &&
3955 CodecHal_PictureIsField(m_vc1PicParams->CurrPic) &&
3956 !m_vc1PicParams->picture_fields.is_first_field)
3957 {
3958 CODECHAL_DECODE_CHK_NULL_RETURN(m_vc1RefList);
3959
3960 uint32_t destFrameIdx = m_vc1PicParams->CurrPic.FrameIdx;
3961
3962 CODECHAL_DECODE_CHK_STATUS_RETURN(FormatUnequalFieldPicture(
3963 m_unequalFieldSurface[m_vc1RefList[destFrameIdx]->dwUnequalFieldSurfaceIdx],
3964 m_destSurface,
3965 true,
3966 m_videoContextUsesNullHw));
3967 }
3968
3969 if (m_olpNeeded)
3970 {
3971 CODECHAL_DECODE_CHK_STATUS_RETURN(PerformVc1Olp());
3972 }
3973 else
3974 {
3975 if (m_statusQueryReportingEnabled)
3976 {
3977 CODECHAL_DECODE_CHK_STATUS_RETURN(ResetStatusReport(m_videoContextUsesNullHw));
3978 }
3979 }
3980
3981 // Needs to be re-set for Linux buffer re-use scenarios
3982 m_vc1RefList[m_vc1PicParams->CurrPic.FrameIdx]->resRefPic = m_destSurface.OsResource;
3983
3984 // Send the signal to indicate decode completion, in case On-Demand Sync is not present
3985 if (!(CodecHal_PictureIsField(m_vc1PicParams->CurrPic) &&
3986 m_vc1PicParams->picture_fields.is_first_field))
3987 {
3988 MOS_SYNC_PARAMS syncParams;
3989 syncParams = g_cInitSyncParams;
3990 syncParams.GpuContext = m_videoContext;
3991 syncParams.presSyncResource = &m_destSurface.OsResource;
3992
3993 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceSignal(m_osInterface, &syncParams));
3994
3995 if (m_olpNeeded)
3996 {
3997 syncParams = g_cInitSyncParams;
3998 syncParams.GpuContext = m_renderContext;
3999 syncParams.presSyncResource = &m_deblockSurface.OsResource;
4000
4001 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceSignal(m_osInterface, &syncParams));
4002 }
4003 }
4004
4005 m_olpNeeded = false;
4006
4007 return eStatus;
4008 }
4009
4010 MOS_STATUS CodechalDecodeVc1::DecodePrimitiveLevelIT()
4011 {
4012 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
4013
4014 CODECHAL_DECODE_FUNCTION_ENTER;
4015
4016 MOS_SYNC_PARAMS syncParams;
4017
4018 PCODEC_VC1_MB_PARAMS mb = m_vc1MbParams;
4019
4020 MHW_VDBOX_VC1_MB_STATE vc1MbState;
4021 MOS_ZeroMemory(&vc1MbState, sizeof(vc1MbState));
4022
4023 // static VC1 MB parameters
4024 vc1MbState.presDataBuffer = &m_resDataBuffer;
4025 vc1MbState.pVc1PicParams = m_vc1PicParams;
4026 vc1MbState.pWaTable = m_waTable;
4027 vc1MbState.pDeblockDataBuffer = m_deblockDataBuffer;
4028 vc1MbState.dwDataSize = m_dataSize;
4029 vc1MbState.wPicWidthInMb = m_picWidthInMb;
4030 vc1MbState.wPicHeightInMb = m_picHeightInMb;
4031 vc1MbState.PicFlags = m_vc1PicParams->CurrPic.PicFlags;
4032 vc1MbState.bFieldPolarity = m_fieldPolarity;
4033
4034 uint16_t frameFieldHeightInMb;
4035 CodecHal_GetFrameFieldHeightInMb(
4036 m_vc1PicParams->CurrPic,
4037 m_picHeightInMb,
4038 frameFieldHeightInMb);
4039
4040 MOS_COMMAND_BUFFER cmdBuffer;
4041 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &cmdBuffer, 0));
4042
4043 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferStartCmd(&cmdBuffer, &m_itObjectBatchBuffer));
4044
4045 CODECHAL_DECODE_CHK_STATUS_RETURN(Mhw_LockBb(m_osInterface, &m_itObjectBatchBuffer));
4046
4047 PMHW_BATCH_BUFFER batchBuffer = &m_itObjectBatchBuffer;
4048
4049 uint32_t mbAddress = 0;
4050 uint32_t mbCount;
4051 for (mbCount = 0; mbCount < m_numMacroblocks; mbCount++)
4052 {
4053 vc1MbState.pMb = mb + mbCount;
4054
4055 // Skipped MBs before current MB
4056 uint16_t skippedMBs = (mbCount) ?
4057 (mb[mbCount].mb_address - mb[mbCount - 1].mb_address - 1) :
4058 (mb[mbCount].mb_address);
4059
4060 while (skippedMBs--)
4061 {
4062 vc1MbState.bMbHorizOrigin = (uint8_t)(mbAddress % m_picWidthInMb);
4063 vc1MbState.bMbVertOrigin = (uint8_t)(mbAddress / m_picWidthInMb);
4064 vc1MbState.bSkipped = true;
4065
4066 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfdVc1ItObjectCmd(batchBuffer, &vc1MbState));
4067
4068 mbAddress++;
4069 }
4070
4071 // Current MB
4072 if (mbCount + 1 == m_numMacroblocks)
4073 {
4074 vc1MbState.dwLength = m_dataSize - mb[mbCount].data_offset;
4075 }
4076 else
4077 {
4078 vc1MbState.dwLength = mb[mbCount + 1].data_offset - mb[mbCount].data_offset;
4079 }
4080
4081 vc1MbState.bMbHorizOrigin = mb[mbCount].mb_address % m_picWidthInMb;
4082 vc1MbState.bMbVertOrigin = mb[mbCount].mb_address / m_picWidthInMb;
4083 vc1MbState.dwOffset = (vc1MbState.dwLength) ? mb[mbCount].data_offset : 0;
4084 vc1MbState.bSkipped = false;
4085
4086 if (m_vc1PicParams->entrypoint_fields.loopfilter)
4087 {
4088 eStatus = MOS_SecureMemcpy(vc1MbState.DeblockData,
4089 CODEC_NUM_BLOCK_PER_MB,
4090 m_deblockDataBuffer + CODEC_NUM_BLOCK_PER_MB * mb[mbCount].mb_address,
4091 CODEC_NUM_BLOCK_PER_MB);
4092 if (eStatus != MOS_STATUS_SUCCESS)
4093 {
4094 CODECHAL_DECODE_ASSERTMESSAGE("Failed to copy memory.");
4095 m_olpNeeded = false;
4096 return eStatus;
4097 }
4098 }
4099
4100 if (!mb[mbCount].mb_type.intra_mb)
4101 {
4102 if (mb[mbCount].mb_type.motion_forward || mb[mbCount].mb_type.motion_backward)
4103 {
4104 PackMotionVectors(
4105 &vc1MbState,
4106 (int16_t *)mb[mbCount].motion_vector,
4107 (int16_t *)vc1MbState.PackedLumaMvs,
4108 (int16_t *)&vc1MbState.PackedChromaMv);
4109 }
4110 else
4111 {
4112 mb[mbCount].mb_type.motion_forward = 1;
4113 MOS_ZeroMemory(vc1MbState.PackedLumaMvs, sizeof(vc1MbState.PackedLumaMvs)); // MV's of zero
4114 vc1MbState.bMotionSwitch = 0;
4115 }
4116 }
4117
4118 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfdVc1ItObjectCmd(batchBuffer, &vc1MbState));
4119
4120 mbAddress = mb[mbCount].mb_address;
4121 }
4122
4123 m_fieldPolarity = vc1MbState.bFieldPolarity;
4124
4125 // skipped MBs at the end
4126 uint16_t skippedMBs = m_picWidthInMb * frameFieldHeightInMb - mb[mbCount - 1].mb_address - 1;
4127
4128 while (skippedMBs--)
4129 {
4130 vc1MbState.bSkipped = true;
4131 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfdVc1ItObjectCmd(batchBuffer, &vc1MbState));
4132 }
4133
4134 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(nullptr, &m_itObjectBatchBuffer));
4135
4136 CODECHAL_DEBUG_TOOL(
4137 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->Dump2ndLvlBatch(
4138 batchBuffer,
4139 CODECHAL_NUM_MEDIA_STATES,
4140 "_DEC"));
4141 )
4142
4143 CODECHAL_DECODE_CHK_STATUS_RETURN(Mhw_UnlockBb(m_osInterface, &m_itObjectBatchBuffer, true));
4144
4145 // Check if destination surface needs to be synchronized
4146 if (m_unequalFieldWaInUse &&
4147 CodecHal_PictureIsField(m_vc1PicParams->CurrPic))
4148 {
4149 if (!m_vc1PicParams->picture_fields.is_first_field)
4150 {
4151 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
4152 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
4153
4154 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(&cmdBuffer, &flushDwParams));
4155 }
4156 }
4157 else
4158 {
4159 syncParams = g_cInitSyncParams;
4160 syncParams.GpuContext = m_videoContext;
4161 syncParams.presSyncResource = &m_destSurface.OsResource;
4162 syncParams.bReadOnly = false;
4163 syncParams.bDisableDecodeSyncLock = m_disableDecodeSyncLock;
4164 syncParams.bDisableLockForTranscode = m_disableLockForTranscode;
4165
4166 if (!CodecHal_PictureIsField(m_vc1PicParams->CurrPic) ||
4167 m_vc1PicParams->picture_fields.is_first_field)
4168 {
4169 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnPerformOverlaySync(m_osInterface, &syncParams));
4170 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceWait(m_osInterface, &syncParams));
4171
4172 // Update the resource tag (s/w tag) for On-Demand Sync
4173 m_osInterface->pfnSetResourceSyncTag(m_osInterface, &syncParams);
4174 }
4175
4176 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
4177 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
4178
4179 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(&cmdBuffer, &flushDwParams));
4180
4181 // Update the tag in GPU Sync eStatus buffer (H/W Tag) to match the current S/W tag
4182 if (m_osInterface->bTagResourceSync &&
4183 !(CodecHal_PictureIsField(m_vc1PicParams->CurrPic) && m_vc1PicParams->picture_fields.is_first_field))
4184 {
4185 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->WriteSyncTagToResource(&cmdBuffer, &syncParams));
4186 }
4187 }
4188
4189 if (m_statusQueryReportingEnabled)
4190 {
4191 CodechalDecodeStatusReport decodeStatusReport;
4192
4193 decodeStatusReport.m_statusReportNumber = m_statusReportFeedbackNumber;
4194 decodeStatusReport.m_currDecodedPic = m_vc1PicParams->CurrPic;
4195 if (m_olpNeeded)
4196 {
4197 CODECHAL_DEBUG_TOOL(
4198 decodeStatusReport.m_currDeblockedPic.FrameIdx = (uint8_t)m_vc1PicParams->DeblockedPicIdx;
4199 decodeStatusReport.m_currDeblockedPic.PicFlags = PICTURE_FRAME;)
4200 decodeStatusReport.m_deblockedPicResOlp = m_deblockSurface.OsResource;
4201 }
4202 else
4203 {
4204 decodeStatusReport.m_currDeblockedPic = m_vc1PicParams->CurrPic;
4205 }
4206 decodeStatusReport.m_codecStatus = CODECHAL_STATUS_UNAVAILABLE;
4207 decodeStatusReport.m_currDecodedPicRes = m_vc1RefList[m_vc1PicParams->CurrPic.FrameIdx]->resRefPic;
4208
4209 CODECHAL_DEBUG_TOOL(
4210 decodeStatusReport.m_secondField =
4211 (m_vc1PicParams->picture_fields.is_first_field == 1) ? false : true;
4212 decodeStatusReport.m_olpNeeded = m_olpNeeded;
4213 decodeStatusReport.m_frameType = m_perfType;)
4214
4215 CODECHAL_DECODE_CHK_STATUS_RETURN(EndStatusReport(decodeStatusReport, &cmdBuffer));
4216 }
4217
4218 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(&cmdBuffer, nullptr));
4219
4220 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
4221
4222 CODECHAL_DEBUG_TOOL(
4223 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpCmdBuffer(
4224 &cmdBuffer,
4225 CODECHAL_NUM_MEDIA_STATES,
4226 "_DEC"));
4227
4228 //CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHal_DbgReplaceAllCommands(
4229 // m_debugInterface,
4230 // &cmdBuffer));
4231 )
4232
4233 if (m_huCCopyInUse)
4234 {
4235 syncParams = g_cInitSyncParams;
4236 syncParams.GpuContext = m_videoContextForWa;
4237 syncParams.presSyncResource = &m_resSyncObjectWaContextInUse;
4238
4239 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineSignal(m_osInterface, &syncParams));
4240
4241 syncParams = g_cInitSyncParams;
4242 syncParams.GpuContext = m_videoContext;
4243 syncParams.presSyncResource = &m_resSyncObjectWaContextInUse;
4244
4245 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineWait(m_osInterface, &syncParams));
4246
4247 m_huCCopyInUse = false;
4248 }
4249
4250 HalOcaInterface::On1stLevelBBEnd(cmdBuffer, *m_osInterface);
4251
4252 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(m_osInterface, &cmdBuffer, m_videoContextUsesNullHw));
4253
4254 CODECHAL_DEBUG_TOOL(
4255 m_mmc->UpdateUserFeatureKey(&m_destSurface);)
4256
4257 if (m_unequalFieldWaInUse &&
4258 CodecHal_PictureIsField(m_vc1PicParams->CurrPic) &&
4259 !m_vc1PicParams->picture_fields.is_first_field)
4260 {
4261 CODECHAL_DECODE_CHK_NULL_RETURN(m_vc1RefList);
4262
4263 uint32_t destFrameIdx = m_vc1PicParams->CurrPic.FrameIdx;
4264
4265 CODECHAL_DECODE_CHK_STATUS_RETURN(FormatUnequalFieldPicture(
4266 m_unequalFieldSurface[m_vc1RefList[destFrameIdx]->dwUnequalFieldSurfaceIdx],
4267 m_destSurface,
4268 true,
4269 m_videoContextUsesNullHw));
4270 }
4271
4272 if (m_olpNeeded)
4273 {
4274 CODECHAL_DECODE_CHK_STATUS_RETURN(PerformVc1Olp());
4275 }
4276 else
4277 {
4278 if (m_statusQueryReportingEnabled)
4279 {
4280 CODECHAL_DECODE_CHK_STATUS_RETURN(ResetStatusReport(m_videoContextUsesNullHw));
4281 }
4282 }
4283
4284 // Needs to be re-set for Linux buffer re-use scenarios
4285 m_vc1RefList[m_vc1PicParams->CurrPic.FrameIdx]->resRefPic = m_destSurface.OsResource;
4286
4287 // Send the signal to indicate decode completion, in case On-Demand Sync is not present
4288 if (!(CodecHal_PictureIsField(m_vc1PicParams->CurrPic) &&
4289 m_vc1PicParams->picture_fields.is_first_field))
4290 {
4291 MOS_SYNC_PARAMS syncParams;
4292 syncParams = g_cInitSyncParams;
4293 syncParams.GpuContext = m_videoContext;
4294 syncParams.presSyncResource = &m_destSurface.OsResource;
4295
4296 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceSignal(m_osInterface, &syncParams));
4297
4298 if (m_olpNeeded)
4299 {
4300 syncParams = g_cInitSyncParams;
4301 syncParams.GpuContext = m_renderContext;
4302 syncParams.presSyncResource = &m_deblockSurface.OsResource;
4303
4304 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceSignal(m_osInterface, &syncParams));
4305 }
4306 }
4307
4308 m_olpNeeded = false;
4309
4310 return eStatus;
4311 }
4312
4313 MOS_STATUS CodechalDecodeVc1::AddVc1OlpCmd(
4314 PCODECHAL_DECODE_VC1_OLP_PARAMS vc1OlpParams)
4315 {
4316 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
4317
4318 CODECHAL_DECODE_FUNCTION_ENTER;
4319
4320 MhwRenderInterface *renderEngineInterface = m_hwInterface->GetRenderInterface();
4321 PMHW_KERNEL_STATE kernelState = &m_olpKernelState;
4322
4323 // Launch media walker to handle Y component
4324 CODECHAL_WALKER_CODEC_PARAMS walkerCodecParams;
4325 MOS_ZeroMemory(&walkerCodecParams, sizeof(walkerCodecParams));
4326 walkerCodecParams.WalkerMode = MHW_WALKER_MODE_SINGLE;
4327 walkerCodecParams.dwResolutionX = m_picWidthInMb;
4328 walkerCodecParams.dwResolutionY = m_picHeightInMb;
4329 walkerCodecParams.bNoDependency = true; // force raster scan mode
4330
4331 MHW_WALKER_PARAMS walkerParams;
4332 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalInitMediaObjectWalkerParams(
4333 m_hwInterface,
4334 &walkerParams,
4335 &walkerCodecParams));
4336
4337 CODECHAL_DECODE_CHK_STATUS_RETURN(renderEngineInterface->AddMediaObjectWalkerCmd(
4338 vc1OlpParams->pCmdBuffer,
4339 &walkerParams));
4340
4341 vc1OlpParams->pPipeControlParams->dwFlushMode = MHW_FLUSH_READ_CACHE;
4342 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddPipeControl(
4343 vc1OlpParams->pCmdBuffer,
4344 nullptr,
4345 vc1OlpParams->pPipeControlParams));
4346 vc1OlpParams->pPipeControlParams->dwFlushMode = MHW_FLUSH_WRITE_CACHE;
4347 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddPipeControl(
4348 vc1OlpParams->pCmdBuffer,
4349 nullptr,
4350 vc1OlpParams->pPipeControlParams));
4351
4352 CODECHAL_DECODE_CHK_STATUS_RETURN(renderEngineInterface->AddStateBaseAddrCmd(
4353 vc1OlpParams->pCmdBuffer,
4354 vc1OlpParams->pStateBaseAddrParams));
4355
4356 CODECHAL_DECODE_CHK_STATUS_RETURN(renderEngineInterface->AddMediaVfeCmd(
4357 vc1OlpParams->pCmdBuffer,
4358 vc1OlpParams->pVfeParams));
4359
4360 kernelState->dwCurbeOffset += kernelState->KernelParams.iCurbeLength;
4361 CODECHAL_DECODE_CHK_STATUS_RETURN(renderEngineInterface->AddMediaCurbeLoadCmd(
4362 vc1OlpParams->pCmdBuffer,
4363 vc1OlpParams->pCurbeLoadParams));
4364 kernelState->dwCurbeOffset -= kernelState->KernelParams.iCurbeLength;
4365
4366 CODECHAL_DECODE_CHK_STATUS_RETURN(renderEngineInterface->AddMediaIDLoadCmd(
4367 vc1OlpParams->pCmdBuffer,
4368 vc1OlpParams->pIdLoadParams));
4369
4370 // For UV component, block size changed in CURBE static data and keep FrameWidth/HeightInMb unchanged here
4371 CODECHAL_DECODE_CHK_STATUS_RETURN(renderEngineInterface->AddMediaObjectWalkerCmd(
4372 vc1OlpParams->pCmdBuffer,
4373 &walkerParams));
4374
4375 return eStatus;
4376 }
4377
4378 MOS_STATUS CodechalDecodeVc1::PerformVc1Olp()
4379 {
4380 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
4381
4382 CODECHAL_DECODE_FUNCTION_ENTER;
4383
4384 MhwRenderInterface *renderEngineInterface = m_hwInterface->GetRenderInterface();
4385 PMHW_KERNEL_STATE kernelState = &m_olpKernelState;
4386 PMHW_STATE_HEAP_INTERFACE stateHeapInterface = renderEngineInterface->m_stateHeapInterface;
4387
4388 CODECHAL_DECODE_CHK_NULL_RETURN(stateHeapInterface);
4389
4390 MOS_SYNC_PARAMS syncParams;
4391 syncParams = g_cInitSyncParams;
4392 syncParams.GpuContext = m_videoContext;
4393 syncParams.presSyncResource = &m_resSyncObject;
4394
4395 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineSignal(m_osInterface, &syncParams));
4396
4397 syncParams = g_cInitSyncParams;
4398 syncParams.GpuContext = m_renderContext;
4399 syncParams.presSyncResource = &m_resSyncObject;
4400
4401 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineWait(m_osInterface, &syncParams));
4402
4403 // Initialize DSH kernel region
4404 m_osInterface->pfnSetGpuContext(m_osInterface, m_renderContext);
4405 m_osInterface->pfnResetOsStates(m_osInterface);
4406
4407 m_osInterface->pfnSetPerfTag(
4408 m_osInterface,
4409 (uint16_t)(((m_mode << 4) & 0xF0) | OLP_TYPE));
4410 m_osInterface->pfnResetPerfBufferID(m_osInterface);
4411
4412 CodecHalGetResourceInfo(m_osInterface, &m_deblockSurface); // DstSurface
4413
4414 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mmc->DisableSurfaceMmcState(&m_deblockSurface));
4415
4416 CODECHAL_DECODE_CHK_STATUS_RETURN(stateHeapInterface->pfnRequestSshSpaceForCmdBuf(
4417 stateHeapInterface,
4418 kernelState->KernelParams.iBTCount));
4419
4420 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->AssignDshAndSshSpace(
4421 stateHeapInterface,
4422 kernelState,
4423 false,
4424 m_olpDshSize,
4425 false,
4426 m_decodeStatusBuf.m_swStoreData));
4427
4428 MHW_INTERFACE_DESCRIPTOR_PARAMS idParams;
4429 MOS_ZeroMemory(&idParams, sizeof(idParams));
4430 idParams.pKernelState = kernelState;
4431 CODECHAL_DECODE_CHK_STATUS_RETURN(stateHeapInterface->pfnSetInterfaceDescriptor(
4432 stateHeapInterface,
4433 1,
4434 &idParams));
4435 CODECHAL_DECODE_CHK_STATUS_RETURN(SetCurbeOlp());
4436
4437 // Send HW commands (including SSH)
4438 MOS_COMMAND_BUFFER cmdBuffer;
4439 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &cmdBuffer, 0));
4440
4441 MHW_PIPE_CONTROL_PARAMS pipeControlParams;
4442 MOS_ZeroMemory(&pipeControlParams, sizeof(pipeControlParams));
4443
4444 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->GetDefaultSSEuSetting(CODECHAL_MEDIA_STATE_OLP, false, false, false));
4445
4446 CODECHAL_DECODE_CHK_STATUS_RETURN(SendPrologWithFrameTracking(
4447 &cmdBuffer, true));
4448
4449 if (renderEngineInterface->GetL3CacheConfig()->bL3CachingEnabled)
4450 {
4451 CODECHAL_DECODE_CHK_STATUS_RETURN(renderEngineInterface->SetL3Cache(&cmdBuffer));
4452 }
4453
4454 CODECHAL_DECODE_CHK_STATUS_RETURN(renderEngineInterface->EnablePreemption(&cmdBuffer));
4455
4456 CODECHAL_DECODE_CHK_STATUS_RETURN(renderEngineInterface->AddPipelineSelectCmd(&cmdBuffer, false));
4457
4458 CODECHAL_DECODE_CHK_STATUS_RETURN(stateHeapInterface->pfnSetBindingTable(
4459 stateHeapInterface,
4460 kernelState));
4461
4462 // common function for codec needed when we make change for AVC
4463 MHW_RCS_SURFACE_PARAMS surfaceParamsSrc;
4464 MOS_ZeroMemory(&surfaceParamsSrc, sizeof(surfaceParamsSrc));
4465 surfaceParamsSrc.dwNumPlanes = 2; // Y, UV
4466 surfaceParamsSrc.psSurface = &m_destSurface;
4467 surfaceParamsSrc.psSurface->dwDepth = 1; // depth needs to be 0 for codec 2D surface
4468 // Y Plane
4469 surfaceParamsSrc.dwBindingTableOffset[MHW_Y_PLANE] = CODECHAL_DECODE_VC1_OLP_SRC_Y;
4470 surfaceParamsSrc.ForceSurfaceFormat[MHW_Y_PLANE] = MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM;
4471 // UV Plane
4472 surfaceParamsSrc.dwBindingTableOffset[MHW_U_PLANE] = CODECHAL_DECODE_VC1_OLP_SRC_UV;
4473 surfaceParamsSrc.ForceSurfaceFormat[MHW_U_PLANE] = MHW_GFX3DSTATE_SURFACEFORMAT_R16_UINT;
4474 surfaceParamsSrc.dwBaseAddrOffset[MHW_U_PLANE] =
4475 m_destSurface.dwPitch *
4476 MOS_ALIGN_FLOOR(m_destSurface.UPlaneOffset.iYOffset, MOS_YTILE_H_ALIGNMENT);
4477 surfaceParamsSrc.dwHeightToUse[MHW_U_PLANE] = surfaceParamsSrc.psSurface->dwHeight / 2;
4478 surfaceParamsSrc.dwYOffset[MHW_U_PLANE] =
4479 (m_destSurface.UPlaneOffset.iYOffset % MOS_YTILE_H_ALIGNMENT);
4480
4481 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mmc->GetSurfaceMmcState(surfaceParamsSrc.psSurface));
4482
4483 MHW_RCS_SURFACE_PARAMS surfaceParamsDst;
4484 MOS_ZeroMemory(&surfaceParamsDst, sizeof(surfaceParamsDst));
4485 surfaceParamsDst = surfaceParamsSrc;
4486 surfaceParamsDst.bIsWritable = true;
4487 surfaceParamsDst.psSurface = &m_deblockSurface;
4488 surfaceParamsDst.psSurface->dwDepth = 1; // depth needs to be 0 for codec 2D surface
4489 surfaceParamsDst.dwBindingTableOffset[MHW_Y_PLANE] = CODECHAL_DECODE_VC1_OLP_DST_Y;
4490 surfaceParamsDst.dwBindingTableOffset[MHW_U_PLANE] = CODECHAL_DECODE_VC1_OLP_DST_UV;
4491
4492 CODECHAL_DECODE_CHK_STATUS_RETURN(stateHeapInterface->pfnSetSurfaceState(
4493 stateHeapInterface,
4494 kernelState,
4495 &cmdBuffer,
4496 1,
4497 &surfaceParamsSrc));
4498 CODECHAL_DECODE_CHK_STATUS_RETURN(stateHeapInterface->pfnSetSurfaceState(
4499 stateHeapInterface,
4500 kernelState,
4501 &cmdBuffer,
4502 1,
4503 &surfaceParamsDst));
4504
4505 MHW_STATE_BASE_ADDR_PARAMS stateBaseAddrParams;
4506 MOS_ZeroMemory(&stateBaseAddrParams, sizeof(stateBaseAddrParams));
4507 MOS_RESOURCE *dsh = nullptr, *ish = nullptr;
4508 CODECHAL_DECODE_CHK_NULL_RETURN(dsh = kernelState->m_dshRegion.GetResource());
4509 CODECHAL_DECODE_CHK_NULL_RETURN(ish = kernelState->m_ishRegion.GetResource());
4510 stateBaseAddrParams.presDynamicState = dsh;
4511 stateBaseAddrParams.dwDynamicStateSize = kernelState->m_dshRegion.GetHeapSize();
4512 stateBaseAddrParams.presInstructionBuffer = ish;
4513 stateBaseAddrParams.dwInstructionBufferSize = kernelState->m_ishRegion.GetHeapSize();
4514 CODECHAL_DECODE_CHK_STATUS_RETURN(renderEngineInterface->AddStateBaseAddrCmd(&cmdBuffer, &stateBaseAddrParams));
4515
4516 MHW_VFE_PARAMS vfeParams = {};
4517 vfeParams.pKernelState = kernelState;
4518 CODECHAL_DECODE_CHK_STATUS_RETURN(renderEngineInterface->AddMediaVfeCmd(&cmdBuffer, &vfeParams));
4519
4520 MHW_CURBE_LOAD_PARAMS curbeLoadParams;
4521 MOS_ZeroMemory(&curbeLoadParams, sizeof(curbeLoadParams));
4522 curbeLoadParams.pKernelState = kernelState;
4523 CODECHAL_DECODE_CHK_STATUS_RETURN(renderEngineInterface->AddMediaCurbeLoadCmd(&cmdBuffer, &curbeLoadParams));
4524
4525 MHW_ID_LOAD_PARAMS idLoadParams;
4526 MOS_ZeroMemory(&idLoadParams, sizeof(idLoadParams));
4527 idLoadParams.pKernelState = kernelState;
4528 idLoadParams.dwNumKernelsLoaded = 1;
4529 CODECHAL_DECODE_CHK_STATUS_RETURN(renderEngineInterface->AddMediaIDLoadCmd(&cmdBuffer, &idLoadParams));
4530
4531 CODECHAL_DEBUG_TOOL(
4532 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpKernelRegion(
4533 CODECHAL_MEDIA_STATE_OLP,
4534 MHW_DSH_TYPE,
4535 kernelState));
4536 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpKernelRegion(
4537 CODECHAL_MEDIA_STATE_OLP,
4538 MHW_SSH_TYPE,
4539 kernelState));
4540 )
4541
4542 CODECHAL_DECODE_VC1_OLP_PARAMS vc1OlpParams;
4543 vc1OlpParams.pCmdBuffer = &cmdBuffer;
4544 vc1OlpParams.pPipeControlParams = &pipeControlParams;
4545 vc1OlpParams.pStateBaseAddrParams = &stateBaseAddrParams;
4546 vc1OlpParams.pVfeParams = &vfeParams;
4547 vc1OlpParams.pCurbeLoadParams = &curbeLoadParams;
4548 vc1OlpParams.pIdLoadParams = &idLoadParams;
4549 CODECHAL_DECODE_CHK_STATUS_RETURN(AddVc1OlpCmd(&vc1OlpParams));
4550
4551 // Check if destination surface needs to be synchronized, before command buffer submission
4552 syncParams = g_cInitSyncParams;
4553 syncParams.GpuContext = m_renderContext;
4554 syncParams.presSyncResource = &m_deblockSurface.OsResource;
4555 syncParams.bReadOnly = false;
4556 syncParams.bDisableDecodeSyncLock = m_disableDecodeSyncLock;
4557 syncParams.bDisableLockForTranscode = m_disableLockForTranscode;
4558
4559 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnPerformOverlaySync(m_osInterface, &syncParams));
4560 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceWait(m_osInterface, &syncParams));
4561
4562 // Update the resource tag (s/w tag) for On-Demand Sync
4563 m_osInterface->pfnSetResourceSyncTag(m_osInterface, &syncParams);
4564
4565 // Update GPU Sync tag for on demand synchronization
4566 if (m_osInterface->bTagResourceSync)
4567 {
4568
4569 pipeControlParams.dwFlushMode = MHW_FLUSH_WRITE_CACHE;
4570 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddPipeControl(&cmdBuffer, nullptr, &pipeControlParams));
4571 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->WriteSyncTagToResource(&cmdBuffer, &syncParams));
4572 }
4573 CODECHAL_DECODE_CHK_STATUS_RETURN(stateHeapInterface->pfnSubmitBlocks(
4574 stateHeapInterface,
4575 kernelState));
4576 CODECHAL_DECODE_CHK_STATUS_RETURN(stateHeapInterface->pfnUpdateGlobalCmdBufId(
4577 stateHeapInterface));
4578
4579 // Add PipeControl to invalidate ISP and MediaState to avoid PageFault issue
4580 // This code is temporal and it will be moved to batch buffer end in short
4581 if (GFX_IS_GEN_9_OR_LATER(m_hwInterface->GetPlatform()))
4582 {
4583 MHW_PIPE_CONTROL_PARAMS pipeControlParams;
4584
4585 MOS_ZeroMemory(&pipeControlParams, sizeof(pipeControlParams));
4586 pipeControlParams.dwFlushMode = MHW_FLUSH_WRITE_CACHE;
4587 pipeControlParams.bGenericMediaStateClear = true;
4588 pipeControlParams.bIndirectStatePointersDisable = true;
4589 pipeControlParams.bDisableCSStall = false;
4590 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddPipeControl(&cmdBuffer, nullptr, &pipeControlParams));
4591
4592 if (MEDIA_IS_WA(m_hwInterface->GetWaTable(), WaSendDummyVFEafterPipelineSelect))
4593 {
4594 MHW_VFE_PARAMS vfeStateParams = {};
4595 vfeStateParams.dwNumberofURBEntries = 1;
4596 CODECHAL_DECODE_CHK_STATUS_RETURN(renderEngineInterface->AddMediaVfeCmd(&cmdBuffer, &vfeStateParams));
4597 }
4598 }
4599
4600 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(&cmdBuffer, nullptr));
4601
4602 // To clear the SSEU values in the hw interface struct, so next kernel can be programmed correctly
4603 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->UpdateSSEuForCmdBuffer(&cmdBuffer, false, true));
4604
4605 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
4606
4607 CODECHAL_DEBUG_TOOL(
4608 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpCmdBuffer(
4609 &cmdBuffer,
4610 CODECHAL_MEDIA_STATE_OLP,
4611 "_DEC"));
4612 )
4613
4614 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(m_osInterface, &cmdBuffer, m_renderContextUsesNullHw));
4615
4616 if (m_statusQueryReportingEnabled)
4617 {
4618 CODECHAL_DECODE_CHK_STATUS_RETURN(ResetStatusReport(m_renderContextUsesNullHw));
4619 }
4620
4621 m_osInterface->pfnSetGpuContext(m_osInterface, m_videoContext);
4622
4623 return eStatus;
4624 }
4625
4626 MOS_STATUS CodechalDecodeVc1::UpdateVc1KernelState()
4627 {
4628 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
4629
4630 CODECHAL_DECODE_FUNCTION_ENTER;
4631
4632 PMHW_STATE_HEAP_INTERFACE stateHeapInterface = m_hwInterface->GetRenderInterface()->m_stateHeapInterface;
4633 PCODECHAL_DECODE_VC1_KERNEL_HEADER_CM decodeKernel;
4634 PMHW_KERNEL_STATE kernelState = &m_olpKernelState;
4635
4636 decodeKernel = (PCODECHAL_DECODE_VC1_KERNEL_HEADER_CM)kernelState->KernelParams.pBinary;
4637 CODECHAL_DECODE_CHK_NULL_RETURN(decodeKernel);
4638 kernelState->dwKernelBinaryOffset =
4639 decodeKernel->OLP.KernelStartPointer << MHW_KERNEL_OFFSET_SHIFT;
4640 m_olpDshSize =
4641 stateHeapInterface->pStateHeapInterface->GetSizeofCmdInterfaceDescriptorData() +
4642 (MOS_ALIGN_CEIL(m_olpCurbeStaticDataLength,
4643 stateHeapInterface->pStateHeapInterface->GetCurbeAlignment()) *
4644 2);
4645
4646 return eStatus;
4647 }
4648
4649 MOS_STATUS CodechalDecodeVc1::InitKernelStateVc1Olp()
4650 {
4651 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
4652
4653 CODECHAL_DECODE_FUNCTION_ENTER;
4654
4655 MhwRenderInterface *renderEngineInterface = m_hwInterface->GetRenderInterface();
4656 PMHW_STATE_HEAP_INTERFACE stateHeapInterface = renderEngineInterface->m_stateHeapInterface;
4657 CODECHAL_DECODE_CHK_NULL_RETURN(stateHeapInterface);
4658 PMHW_KERNEL_STATE kernelState = &m_olpKernelState;
4659
4660 kernelState->KernelParams.pBinary = m_olpKernelBase;
4661 kernelState->KernelParams.iSize = m_olpKernelSize;
4662 kernelState->KernelParams.iBTCount = CODECHAL_DECODE_VC1_OLP_NUM_SURFACES;
4663 kernelState->KernelParams.iThreadCount = renderEngineInterface->GetHwCaps()->dwMaxThreads;
4664 kernelState->KernelParams.iCurbeLength = m_olpCurbeStaticDataLength;
4665 kernelState->KernelParams.iBlockWidth = CODECHAL_MACROBLOCK_WIDTH;
4666 kernelState->KernelParams.iBlockHeight = CODECHAL_MACROBLOCK_HEIGHT;
4667 kernelState->KernelParams.iIdCount = 1;
4668
4669 kernelState->dwCurbeOffset = stateHeapInterface->pStateHeapInterface->GetSizeofCmdInterfaceDescriptorData();
4670 CODECHAL_DECODE_CHK_STATUS_RETURN(stateHeapInterface->pfnCalculateSshAndBtSizesRequested(
4671 stateHeapInterface,
4672 kernelState->KernelParams.iBTCount,
4673 &kernelState->dwSshSize,
4674 &kernelState->dwBindingTableSize));
4675
4676 CODECHAL_DECODE_CHK_STATUS_RETURN(UpdateVc1KernelState());
4677
4678 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->MhwInitISH(
4679 stateHeapInterface,
4680 &m_olpKernelState));
4681
4682 return eStatus;
4683 }
4684
4685 MOS_STATUS CodechalDecodeVc1::SetCurbeOlp()
4686 {
4687 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
4688
4689 CODECHAL_DECODE_FUNCTION_ENTER;
4690
4691 CODECHAL_DECODE_CHK_NULL_RETURN(m_hwInterface->GetRenderInterface());
4692 CODECHAL_DECODE_CHK_NULL_RETURN(m_hwInterface->GetRenderInterface()->m_stateHeapInterface);
4693
4694 PMHW_STATE_HEAP_INTERFACE stateHeapInterface = m_hwInterface->GetRenderInterface()->m_stateHeapInterface;
4695
4696 // Configure Curbe data for Y component
4697 CODECHAL_DECODE_VC1_OLP_STATIC_DATA cmd = g_cInit_CODECHAL_DECODE_VC1_OLP_STATIC_DATA;
4698
4699 cmd.DW2.InterlaceFieldFlag = CodecHal_PictureIsField(m_vc1PicParams->CurrPic);
4700 cmd.DW2.PictureUpsamplingFlag = m_vc1PicParams->UpsamplingFlag;
4701 cmd.DW2.RangeExpansionFlag = (m_vc1PicParams->range_mapping_fields.range_mapping_enabled != 0);
4702 cmd.DW2.Profile = m_vc1PicParams->sequence_fields.AdvancedProfileFlag;
4703 cmd.DW2.ComponentFlag = 0;
4704
4705 if (m_vc1PicParams->sequence_fields.AdvancedProfileFlag)
4706 {
4707 cmd.DW2.RangeMapUV = m_vc1PicParams->range_mapping_fields.chroma;
4708 cmd.DW2.RangeMapUVFlag = m_vc1PicParams->range_mapping_fields.chroma_flag;
4709 cmd.DW2.RangeMapY = m_vc1PicParams->range_mapping_fields.luma;
4710 cmd.DW2.RangeMapYFlag = m_vc1PicParams->range_mapping_fields.luma_flag;
4711 }
4712
4713 CODECHAL_DECODE_CHK_STATUS_RETURN(m_olpKernelState.m_dshRegion.AddData(
4714 &cmd,
4715 m_olpKernelState.dwCurbeOffset,
4716 sizeof(cmd)));
4717
4718 // Configure Curbe data for UV component
4719 cmd = g_cInit_CODECHAL_DECODE_VC1_OLP_STATIC_DATA;
4720
4721 cmd.DW2.InterlaceFieldFlag = CodecHal_PictureIsField(m_vc1PicParams->CurrPic);
4722 cmd.DW2.PictureUpsamplingFlag = m_vc1PicParams->UpsamplingFlag;
4723 cmd.DW2.RangeExpansionFlag = (m_vc1PicParams->range_mapping_fields.range_mapping_enabled != 0);
4724 cmd.DW2.Profile = m_vc1PicParams->sequence_fields.AdvancedProfileFlag;
4725 cmd.DW2.ComponentFlag = 1;
4726
4727 if (m_vc1PicParams->sequence_fields.AdvancedProfileFlag)
4728 {
4729 cmd.DW2.RangeMapUV = m_vc1PicParams->range_mapping_fields.chroma;
4730 cmd.DW2.RangeMapUVFlag = m_vc1PicParams->range_mapping_fields.chroma_flag;
4731 cmd.DW2.RangeMapY = m_vc1PicParams->range_mapping_fields.luma;
4732 cmd.DW2.RangeMapYFlag = m_vc1PicParams->range_mapping_fields.luma_flag;
4733 }
4734
4735 cmd.DW4.SourceDataBindingIndex = CODECHAL_DECODE_VC1_OLP_SRC_UV;
4736 cmd.DW5.DestDataBindingIndex = CODECHAL_DECODE_VC1_OLP_DST_UV;
4737
4738 CODECHAL_DECODE_CHK_STATUS_RETURN(m_olpKernelState.m_dshRegion.AddData(
4739 &cmd,
4740 m_olpKernelState.dwCurbeOffset +
4741 MOS_ALIGN_CEIL(m_olpCurbeStaticDataLength, stateHeapInterface->pStateHeapInterface->GetCurbeAlignment()),
4742 sizeof(cmd)));
4743
4744 return eStatus;
4745 }
4746
4747 MOS_STATUS CodechalDecodeVc1::InitMmcState()
4748 {
4749 m_mmc = MOS_New(CodechalMmcDecodeVc1, m_hwInterface, this);
4750 CODECHAL_DECODE_CHK_NULL_RETURN(m_mmc);
4751
4752 return MOS_STATUS_SUCCESS;
4753 }
4754
4755 MOS_STATUS CodechalDecodeVc1::AllocateStandard(
4756 CodechalSetting *settings)
4757 {
4758 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
4759
4760 CODECHAL_DECODE_FUNCTION_ENTER;
4761
4762 CODECHAL_DECODE_CHK_NULL_RETURN(settings);
4763
4764 CODECHAL_DECODE_CHK_STATUS_RETURN(InitMmcState());
4765
4766 bool isComputeContextEnabled = false;
4767 MOS_GPUCTX_CREATOPTIONS createOption;
4768
4769 #if (_DEBUG || _RELEASE_INTERNAL)
4770 MOS_USER_FEATURE_VALUE_DATA userFeatureData;
4771 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
4772 MOS_UserFeature_ReadValue_ID(
4773 nullptr,
4774 __MEDIA_USER_FEATURE_VALUE_DECODE_ENABLE_COMPUTE_CONTEXT_ID,
4775 &userFeatureData,
4776 m_osInterface->pOsContext);
4777 isComputeContextEnabled = (userFeatureData.u32Data) ? true : false;
4778 #endif
4779
4780 if (!MEDIA_IS_SKU(m_skuTable, FtrCCSNode))
4781 {
4782 isComputeContextEnabled = false;
4783 }
4784
4785 if (isComputeContextEnabled)
4786 {
4787 // Create Render Context for field scaling
4788 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnCreateGpuContext(
4789 m_osInterface,
4790 MOS_GPU_CONTEXT_COMPUTE,
4791 MOS_GPU_NODE_COMPUTE,
4792 &createOption));
4793 m_renderContext = MOS_GPU_CONTEXT_COMPUTE;
4794 }
4795 else
4796 {
4797 // Create Render Context for field scaling
4798 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnCreateGpuContext(
4799 m_osInterface,
4800 MOS_GPU_CONTEXT_RENDER,
4801 MOS_GPU_NODE_3D,
4802 &createOption));
4803 m_renderContext = MOS_GPU_CONTEXT_RENDER;
4804 }
4805
4806 m_intelEntrypointInUse = settings->intelEntrypointInUse;
4807 m_width = settings->width;
4808 m_height = settings->height;
4809 m_picWidthInMb = (uint16_t)CODECHAL_GET_WIDTH_IN_MACROBLOCKS(m_width);
4810 m_picHeightInMb = (uint16_t)CODECHAL_GET_HEIGHT_IN_MACROBLOCKS(m_height);
4811 m_shortFormatInUse = settings->shortFormatInUse;
4812 m_huCCopyInUse = false;
4813
4814 CODECHAL_DECODE_CHK_STATUS_RETURN(InitKernelStateVc1Olp());
4815
4816 CODECHAL_DEBUG_TOOL(
4817 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpKernelRegion(
4818 CODECHAL_MEDIA_STATE_OLP,
4819 MHW_ISH_TYPE,
4820 &m_olpKernelState));)
4821
4822 // Picture Level Commands
4823 m_hwInterface->GetMfxStateCommandsDataSize(
4824 m_mode,
4825 &m_commandBufferSizeNeeded,
4826 &m_commandPatchListSizeNeeded,
4827 m_shortFormatInUse);
4828
4829 // Primitive Level Commands
4830 m_hwInterface->GetMfxPrimitiveCommandsDataSize(
4831 m_mode,
4832 &m_standardDecodeSizeNeeded,
4833 &m_standardDecodePatchListSizeNeeded,
4834 m_shortFormatInUse);
4835
4836 CODECHAL_DECODE_CHK_STATUS_RETURN(AllocateResources());
4837
4838 return eStatus;
4839 }
4840
4841 CodechalDecodeVc1::CodechalDecodeVc1(
4842 CodechalHwInterface *hwInterface,
4843 CodechalDebugInterface* debugInterface,
4844 PCODECHAL_STANDARD_INFO standardInfo) :
4845 CodechalDecode(hwInterface, debugInterface, standardInfo),
4846 m_huCCopyInUse(0)
4847 {
4848 CODECHAL_DECODE_FUNCTION_ENTER;
4849
4850 MOS_ZeroMemory(&m_resMfdDeblockingFilterRowStoreScratchBuffer, sizeof(m_resMfdDeblockingFilterRowStoreScratchBuffer));
4851 MOS_ZeroMemory(&m_resBsdMpcRowStoreScratchBuffer, sizeof(m_resBsdMpcRowStoreScratchBuffer));
4852 MOS_ZeroMemory(m_resVc1BsdMvData, sizeof(m_resVc1BsdMvData));
4853 MOS_ZeroMemory(&m_resSyncObject, sizeof(m_resSyncObject));
4854 MOS_ZeroMemory(&m_resPrivateBistreamBuffer, sizeof(m_resPrivateBistreamBuffer));
4855 MOS_ZeroMemory(&m_bitstream, sizeof(m_bitstream));
4856 MOS_ZeroMemory(&m_itObjectBatchBuffer, sizeof(m_itObjectBatchBuffer));
4857 MOS_ZeroMemory(m_unequalFieldSurface, sizeof(m_unequalFieldSurface));
4858 MOS_ZeroMemory(m_unequalFieldRefListIdx, sizeof(m_unequalFieldRefListIdx));
4859 MOS_ZeroMemory(&m_destSurface, sizeof(m_destSurface));
4860 MOS_ZeroMemory(&m_deblockSurface, sizeof(m_deblockSurface));
4861 MOS_ZeroMemory(&m_resDataBuffer, sizeof(m_resDataBuffer));
4862 MOS_ZeroMemory(&m_resBitplaneBuffer, sizeof(m_resBitplaneBuffer));
4863 MOS_ZeroMemory(&m_resSyncObjectWaContextInUse, sizeof(m_resSyncObjectWaContextInUse));
4864 MOS_ZeroMemory(&m_resSyncObjectVideoContextInUse, sizeof(m_resSyncObjectVideoContextInUse));
4865 MOS_ZeroMemory(m_presReferences, (sizeof(PMOS_RESOURCE) * CODEC_MAX_NUM_REF_FRAME_NON_AVC));
4866 MOS_ZeroMemory(m_vc1RefList, (sizeof(PCODEC_REF_LIST) * CODECHAL_NUM_UNCOMPRESSED_SURFACE_VC1));
4867 #if (_DEBUG || _RELEASE_INTERNAL)
4868 m_reportFrameCrc = true;
4869 #endif
4870 m_hwInterface = hwInterface;
4871
4872 }
4873
4874 #if USE_CODECHAL_DEBUG_TOOL
4875 MOS_STATUS CodechalDecodeVc1::DumpPicParams(
4876 PCODEC_VC1_PIC_PARAMS vc1PicParams)
4877 {
4878 CODECHAL_DEBUG_FUNCTION_ENTER;
4879
4880 if (!m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrPicParams))
4881 {
4882 return MOS_STATUS_SUCCESS;
4883 }
4884
4885 CODECHAL_DEBUG_CHK_NULL(vc1PicParams);
4886
4887 std::ostringstream oss;
4888 oss.setf(std::ios::showbase | std::ios::uppercase);
4889 oss.setf(std::ios::hex, std::ios::basefield);
4890
4891 oss<< "CurrPic FrameIdx: "<< +vc1PicParams->CurrPic.FrameIdx<<std::endl;
4892 oss<< "CurrPic PicFlags: "<< +vc1PicParams->CurrPic.PicFlags<<std::endl;
4893 oss<< "DeblockedPicIdx: "<< +vc1PicParams->DeblockedPicIdx<<std::endl;
4894 oss<< "ForwardRefIdx: "<< +vc1PicParams->ForwardRefIdx<<std::endl;
4895 oss<< "BackwardRefIdx: "<< +vc1PicParams->BackwardRefIdx<<std::endl;
4896
4897 //Dump sequence_fields
4898 oss<< "sequence_fields value: "<< +vc1PicParams->sequence_fields.value<<std::endl;
4899 oss<< "pulldown: "<< +vc1PicParams->sequence_fields.pulldown<<std::endl;
4900 oss<< "interlace: "<< +vc1PicParams->sequence_fields.interlace<<std::endl;
4901 oss<< "tfcntrflag: "<< +vc1PicParams->sequence_fields.tfcntrflag<<std::endl;
4902 oss<< "finterpflag: "<< +vc1PicParams->sequence_fields.finterpflag<<std::endl;
4903 oss<< "psf: "<< +vc1PicParams->sequence_fields.psf<<std::endl;
4904 oss<< "multires: "<< +vc1PicParams->sequence_fields.multires<<std::endl;
4905 oss<< "overlap: "<< +vc1PicParams->sequence_fields.overlap<<std::endl;
4906 oss<< "syncmarker: "<< +vc1PicParams->sequence_fields.syncmarker<<std::endl;
4907 oss<< "rangered: "<< +vc1PicParams->sequence_fields.rangered<<std::endl;
4908 oss<< "max_b_frames: "<< +vc1PicParams->sequence_fields.max_b_frames<<std::endl;
4909 oss<< "AdvancedProfileFlag: "<< +vc1PicParams->sequence_fields.AdvancedProfileFlag<<std::endl;
4910 oss<< "coded_width: "<< +vc1PicParams->coded_width<<std::endl;
4911 oss<< "coded_height: "<< +vc1PicParams->coded_height<<std::endl;
4912
4913 //Dump entrypoint_fields
4914 oss<< "broken_link: "<< +vc1PicParams->entrypoint_fields.broken_link<<std::endl;
4915 oss<< "closed_entry: "<< +vc1PicParams->entrypoint_fields.closed_entry<<std::endl;
4916 oss<< "panscan_flag: "<< +vc1PicParams->entrypoint_fields.panscan_flag<<std::endl;
4917 oss<< "loopfilter: "<< +vc1PicParams->entrypoint_fields.loopfilter<<std::endl;
4918 oss<< "conditional_overlap_flag: "<< +vc1PicParams->conditional_overlap_flag<<std::endl;
4919 oss<< "fast_uvmc_flag: "<< +vc1PicParams->fast_uvmc_flag<<std::endl;
4920
4921 //Dump range_mapping_fields
4922 oss<< "range_mapping_fields range_mapping_enabled: "<< +vc1PicParams->range_mapping_fields.range_mapping_enabled<<std::endl;
4923 oss<< "luma_flag: "<< +vc1PicParams->range_mapping_fields.luma_flag<<std::endl;
4924 oss<< "luma: "<< +vc1PicParams->range_mapping_fields.luma<<std::endl;
4925 oss<< "chroma_flag: "<< +vc1PicParams->range_mapping_fields.chroma_flag<<std::endl;
4926 oss<< "chroma: "<< +vc1PicParams->range_mapping_fields.chroma<<std::endl;
4927 oss<< "UpsamplingFlag: "<< +vc1PicParams->UpsamplingFlag<<std::endl;
4928 oss<< "ScaleFactor: "<< +vc1PicParams->ScaleFactor<<std::endl;
4929 oss<< "b_picture_fraction: "<< +vc1PicParams->b_picture_fraction<<std::endl;
4930 oss<< "cbp_table: "<< +vc1PicParams->cbp_table<<std::endl;
4931 oss<< "mb_mode_table: "<< +vc1PicParams->mb_mode_table<<std::endl;
4932 oss<< "range_reduction_frame: "<< +vc1PicParams->range_reduction_frame<<std::endl;
4933 oss<< "rounding_control: "<< +vc1PicParams->rounding_control<<std::endl;
4934 oss<< "post_processing: "<< +vc1PicParams->post_processing<<std::endl;
4935 oss<< "picture_resolution_index: "<< +vc1PicParams->picture_resolution_index<<std::endl;
4936 oss<< "luma_scale: "<< +vc1PicParams->luma_scale<<std::endl;
4937 oss<< "luma_shift: "<< +vc1PicParams->luma_shift<<std::endl;
4938
4939 //Dump picture_fields
4940 oss<< "picture_fields value: "<< +vc1PicParams->picture_fields.value<<std::endl;
4941 oss<< "picture_type: "<< +vc1PicParams->picture_fields.picture_type<<std::endl;
4942 oss<< "frame_coding_mode: "<< +vc1PicParams->picture_fields.frame_coding_mode<<std::endl;
4943 oss<< "top_field_first: "<< +vc1PicParams->picture_fields.top_field_first<<std::endl;
4944 oss<< "is_first_field: "<< +vc1PicParams->picture_fields.is_first_field<<std::endl;
4945 oss<< "intensity_compensation: "<< +vc1PicParams->picture_fields.intensity_compensation<<std::endl;
4946
4947 //Dump raw_coding
4948 oss<< "raw_coding value: "<< +vc1PicParams->raw_coding.value<<std::endl;
4949 oss<< "bitplane_present: "<< +vc1PicParams->raw_coding.bitplane_present<<std::endl;
4950 oss<< "mv_type_mb: "<< +vc1PicParams->raw_coding.mv_type_mb<<std::endl;
4951 oss<< "direct_mb: "<< +vc1PicParams->raw_coding.direct_mb<<std::endl;
4952 oss<< "skip_mb: "<< +vc1PicParams->raw_coding.skip_mb<<std::endl;
4953 oss<< "field_tx: "<< +vc1PicParams->raw_coding.field_tx<<std::endl;
4954 oss<< "forward_mb: "<< +vc1PicParams->raw_coding.forward_mb<<std::endl;
4955 oss<< "ac_pred: "<< +vc1PicParams->raw_coding.ac_pred<<std::endl;
4956 oss<< "overflags: "<< +vc1PicParams->raw_coding.overflags<<std::endl;
4957
4958 //Dump reference_fields
4959 oss<< "reference_fields value: "<< +vc1PicParams->reference_fields.value<<std::endl;
4960 oss<< "reference_distance_flag: "<< +vc1PicParams->reference_fields.reference_distance_flag<<std::endl;
4961 oss<< "reference_distance: "<< +vc1PicParams->reference_fields.reference_distance<<std::endl;
4962 oss<< "BwdReferenceDistance: "<< +vc1PicParams->reference_fields.BwdReferenceDistance<<std::endl;
4963 oss<< "num_reference_pictures: "<< +vc1PicParams->reference_fields.num_reference_pictures<<std::endl;
4964 oss<< "reference_field_pic_indicator: "<< +vc1PicParams->reference_fields.reference_field_pic_indicator<<std::endl;
4965
4966 //Dump mv_fields
4967 oss<< "mv_fields value: "<< +vc1PicParams->mv_fields.value<<std::endl;
4968 oss<< "MvMode: "<< +vc1PicParams->mv_fields.MvMode<<std::endl;
4969 oss<< "UnifiedMvMode: "<< +vc1PicParams->mv_fields.UnifiedMvMode<<std::endl;
4970 oss<< "mv_table: "<< +vc1PicParams->mv_fields.mv_table<<std::endl;
4971 oss<< "two_mv_block_pattern_table: "<< +vc1PicParams->mv_fields.two_mv_block_pattern_table<<std::endl;
4972 oss<< "four_mv_switch: "<< +vc1PicParams->mv_fields.four_mv_switch<<std::endl;
4973 oss<< "four_mv_block_pattern_table: "<< +vc1PicParams->mv_fields.four_mv_block_pattern_table<<std::endl;
4974 oss<< "extended_mv_flag: "<< +vc1PicParams->mv_fields.extended_mv_flag<<std::endl;
4975 oss<< "extended_mv_range: "<< +vc1PicParams->mv_fields.extended_mv_range<<std::endl;
4976 oss<< "extended_dmv_flag: "<< +vc1PicParams->mv_fields.extended_dmv_flag<<std::endl;
4977 oss<< "extended_dmv_range: "<< +vc1PicParams->mv_fields.extended_dmv_range<<std::endl;
4978
4979 //Dump pic_quantizer_fields
4980 oss<< "pic_quantizer_fields value: "<< +vc1PicParams->pic_quantizer_fields.value<<std::endl;
4981 oss<< "dquant: "<< +vc1PicParams->pic_quantizer_fields.dquant<<std::endl;
4982 oss<< "quantizer: "<< +vc1PicParams->pic_quantizer_fields.quantizer<<std::endl;
4983 oss<< "half_qp: "<< +vc1PicParams->pic_quantizer_fields.half_qp<<std::endl;
4984 oss<< "AltPQuantEdgeMask: "<< +vc1PicParams->pic_quantizer_fields.AltPQuantEdgeMask<<std::endl;
4985 oss<< "AltPQuantConfig: "<< +vc1PicParams->pic_quantizer_fields.AltPQuantConfig<<std::endl;
4986 oss<< "pic_quantizer_scale: "<< +vc1PicParams->pic_quantizer_fields.pic_quantizer_scale<<std::endl;
4987 oss<< "pic_quantizer_type: "<< +vc1PicParams->pic_quantizer_fields.pic_quantizer_type<<std::endl;
4988 oss<< "alt_pic_quantizer: "<< +vc1PicParams->pic_quantizer_fields.alt_pic_quantizer<<std::endl;
4989
4990 //Dump transform_fields
4991 oss<< "transform_fields value: "<< +vc1PicParams->transform_fields.value<<std::endl;
4992 oss<< "variable_sized_transform_flag: "<< +vc1PicParams->transform_fields.variable_sized_transform_flag<<std::endl;
4993 oss<< "mb_level_transform_type_flag: "<< +vc1PicParams->transform_fields.mb_level_transform_type_flag<<std::endl;
4994 oss<< "frame_level_transform_type: "<< +vc1PicParams->transform_fields.frame_level_transform_type<<std::endl;
4995 oss<< "transform_ac_codingset_idx1: "<< +vc1PicParams->transform_fields.transform_ac_codingset_idx1<<std::endl;
4996 oss<< "transform_ac_codingset_idx2: "<< +vc1PicParams->transform_fields.transform_ac_codingset_idx2<<std::endl;
4997 oss<< "intra_transform_dc_table: "<< +vc1PicParams->transform_fields.intra_transform_dc_table<<std::endl;
4998 oss<< "StatusReportFeedbackNumber : "<< +vc1PicParams->StatusReportFeedbackNumber<<std::endl;
4999
5000 const char* fileName = m_debugInterface->CreateFileName(
5001 "_DEC",
5002 CodechalDbgBufferType::bufPicParams,
5003 CodechalDbgExtType::txt);
5004
5005 std::ofstream ofs(fileName, std::ios::out);
5006 ofs << oss.str();
5007 ofs.close();
5008 return MOS_STATUS_SUCCESS;
5009 }
5010
5011 MOS_STATUS CodechalDecodeVc1::DumpSliceParams(
5012 PCODEC_VC1_SLICE_PARAMS sliceControl)
5013 {
5014 CODECHAL_DEBUG_FUNCTION_ENTER;
5015
5016 if (!m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrSlcParams))
5017 {
5018 return MOS_STATUS_SUCCESS;
5019 }
5020
5021 CODECHAL_DEBUG_CHK_NULL(sliceControl);
5022
5023 std::ostringstream oss;
5024 oss.setf(std::ios::showbase | std::ios::uppercase);
5025 oss.setf(std::ios::hex, std::ios::basefield);
5026
5027 oss<< "slice_data_size: "<< +sliceControl->slice_data_size<<std::endl;
5028 oss<< "slice_data_offset: "<< +sliceControl->slice_data_offset<<std::endl;
5029 oss<< "macroblock_offset: "<< +sliceControl->macroblock_offset<<std::endl;
5030 oss<< "slice_vertical_position: "<< +sliceControl->slice_vertical_position<<std::endl;
5031
5032 const char* fileName = m_debugInterface->CreateFileName(
5033 "_DEC",
5034 CodechalDbgBufferType::bufSlcParams,
5035 CodechalDbgExtType::txt);
5036
5037 std::ofstream ofs(fileName, std::ios::out);
5038 ofs << oss.str();
5039 ofs.close();
5040 return MOS_STATUS_SUCCESS;
5041 }
5042
5043 MOS_STATUS CodechalDecodeVc1::DumpMbParams(
5044 PCODEC_VC1_MB_PARAMS mbParams)
5045 {
5046 CODECHAL_DEBUG_FUNCTION_ENTER;
5047
5048 if (!m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrMbParams))
5049 {
5050 return MOS_STATUS_SUCCESS;
5051 }
5052
5053 CODECHAL_DEBUG_CHK_NULL(mbParams);
5054
5055 std::ostringstream oss;
5056 oss.setf(std::ios::showbase | std::ios::uppercase);
5057 oss.setf(std::ios::hex, std::ios::basefield);
5058
5059 oss<< "mb_address: "<< +mbParams->mb_address<<std::endl;
5060 oss<< "mb_skips_following: "<< +mbParams->mb_skips_following<<std::endl;
5061 oss<< "data_offset: "<< +mbParams->data_offset<<std::endl;
5062 oss<< "data_length: "<< +mbParams->data_length<<std::endl;
5063
5064 //Dump num_coef[CODEC_NUM_BLOCK_PER_MB]
5065 for(uint16_t i=0;i<CODEC_NUM_BLOCK_PER_MB;++i)
5066 {
5067 oss<< "num_coef["<<+i<<"]: "<< +mbParams->num_coef[i]<<std::endl;
5068 }
5069 //Dump union mb_type
5070 oss<< "mb_type.value: "<< +mbParams->mb_type.value<<std::endl;
5071 oss<< "mb_type.intra_mb: "<< +mbParams->mb_type.intra_mb<<std::endl;
5072 oss<< "mb_type.motion_forward: "<< +mbParams->mb_type.motion_forward<<std::endl;
5073 oss<< "mb_type.motion_backward: "<< +mbParams->mb_type.motion_backward<<std::endl;
5074 oss<< "mb_type.motion_4mv: "<< +mbParams->mb_type.motion_4mv<<std::endl;
5075 oss<< "mb_type.h261_loopfilter: "<<+mbParams->mb_type.h261_loopfilter<<std::endl;
5076 oss<< "mb_type.field_residual: "<< +mbParams->mb_type.field_residual<<std::endl;
5077 oss<< "mb_type.mb_scan_method: "<< +mbParams->mb_type.mb_scan_method<<std::endl;
5078 oss<< "mb_type.motion_type: "<< +mbParams->mb_type.motion_type<<std::endl;
5079 oss<< "mb_type.host_resid_diff: "<< +mbParams->mb_type.host_resid_diff<<std::endl;
5080 oss<< "mb_type.reserved: "<< +mbParams->mb_type.reserved<<std::endl;
5081 oss<< "mb_type.mvert_field_sel_0: "<< +mbParams->mb_type.mvert_field_sel_0<<std::endl;
5082 oss<< "mb_type.mvert_field_sel_1: "<< +mbParams->mb_type.mvert_field_sel_1<<std::endl;
5083 oss<< "mb_type.mvert_field_sel_2: "<< +mbParams->mb_type.mvert_field_sel_2<<std::endl;
5084 oss<< "mb_type.mvert_field_sel_3: "<< +mbParams->mb_type.mvert_field_sel_3<<std::endl;
5085
5086 //Dump union pattern_code
5087 oss<< "pattern_code.value: "<< +mbParams->pattern_code.value<<std::endl;
5088 oss<< "pattern_code.block_coded_pattern: "<< +mbParams->pattern_code.block_coded_pattern<<std::endl;
5089 oss<< "pattern_code.block_luma_intra: "<< +mbParams->pattern_code.block_luma_intra<<std::endl;
5090 oss<< "pattern_code.block_chroma_intra: "<< +mbParams->pattern_code.block_chroma_intra<<std::endl;
5091
5092 //Dump union motion_vector[4]
5093 for(uint8_t i=0;i<4;++i)
5094 {
5095 oss<< "motion_vector["<<+i<<"].value: "<< +mbParams->motion_vector[i].value<<std::endl;
5096 oss<< "motion_vector["<<+i<<"].mv_x: "<< +mbParams->motion_vector[i].mv_x<<std::endl;
5097 oss<< "motion_vector["<<+i<<"].mv_y: "<< +mbParams->motion_vector[i].mv_y<<std::endl;
5098 }
5099
5100 const char* fileName = m_debugInterface->CreateFileName(
5101 "_DEC",
5102 CodechalDbgBufferType::bufMbParams,
5103 CodechalDbgExtType::txt);
5104
5105 std::ofstream ofs(fileName, std::ios::out);
5106 ofs << oss.str();
5107 ofs.close();
5108 return MOS_STATUS_SUCCESS;
5109 }
5110
5111 #endif