1 /**************************************************************************
2 *
3 * Copyright 2018 Advanced Micro Devices, Inc.
4 * All Rights Reserved.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the
8 * "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, sub license, and/or sell copies of the Software, and to
11 * permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
13 *
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
16 * of the Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
21 * IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR
22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 *
26 **************************************************************************/
27
28 #include "util/vl_vlc.h"
29 #include "va_private.h"
30
31 #define NUM_VP9_REFS 8
32
vlVaHandlePictureParameterBufferVP9(vlVaDriver * drv,vlVaContext * context,vlVaBuffer * buf)33 void vlVaHandlePictureParameterBufferVP9(vlVaDriver *drv, vlVaContext *context, vlVaBuffer *buf)
34 {
35 VADecPictureParameterBufferVP9 *vp9 = buf->data;
36 int i;
37
38 assert(buf->size >= sizeof(VADecPictureParameterBufferVP9) && buf->num_elements == 1);
39
40 context->desc.vp9.picture_parameter.prev_frame_width = context->desc.vp9.picture_parameter.frame_width;
41 context->desc.vp9.picture_parameter.prev_frame_height = context->desc.vp9.picture_parameter.frame_height;
42 context->desc.vp9.picture_parameter.frame_width = vp9->frame_width;
43 context->desc.vp9.picture_parameter.frame_height = vp9->frame_height;
44
45 context->desc.vp9.picture_parameter.pic_fields.subsampling_x = vp9->pic_fields.bits.subsampling_x;
46 context->desc.vp9.picture_parameter.pic_fields.subsampling_y = vp9->pic_fields.bits.subsampling_y;
47 context->desc.vp9.picture_parameter.pic_fields.frame_type = vp9->pic_fields.bits.frame_type;
48 context->desc.vp9.picture_parameter.pic_fields.prev_show_frame = context->desc.vp9.picture_parameter.pic_fields.show_frame;
49 context->desc.vp9.picture_parameter.pic_fields.show_frame = vp9->pic_fields.bits.show_frame;
50 context->desc.vp9.picture_parameter.pic_fields.error_resilient_mode = vp9->pic_fields.bits.error_resilient_mode;
51 context->desc.vp9.picture_parameter.pic_fields.intra_only = vp9->pic_fields.bits.intra_only;
52 context->desc.vp9.picture_parameter.pic_fields.allow_high_precision_mv = vp9->pic_fields.bits.allow_high_precision_mv;
53 context->desc.vp9.picture_parameter.pic_fields.mcomp_filter_type = vp9->pic_fields.bits.mcomp_filter_type;
54 context->desc.vp9.picture_parameter.pic_fields.frame_parallel_decoding_mode = vp9->pic_fields.bits.frame_parallel_decoding_mode;
55 context->desc.vp9.picture_parameter.pic_fields.reset_frame_context = vp9->pic_fields.bits.reset_frame_context;
56 context->desc.vp9.picture_parameter.pic_fields.refresh_frame_context = vp9->pic_fields.bits.refresh_frame_context;
57 context->desc.vp9.picture_parameter.pic_fields.frame_context_idx = vp9->pic_fields.bits.frame_context_idx;
58 context->desc.vp9.picture_parameter.pic_fields.segmentation_enabled = vp9->pic_fields.bits.segmentation_enabled;
59 context->desc.vp9.picture_parameter.pic_fields.segmentation_temporal_update =
60 vp9->pic_fields.bits.segmentation_enabled && vp9->pic_fields.bits.segmentation_temporal_update;
61 context->desc.vp9.picture_parameter.pic_fields.segmentation_update_map =
62 vp9->pic_fields.bits.segmentation_enabled && vp9->pic_fields.bits.segmentation_update_map;
63 context->desc.vp9.picture_parameter.pic_fields.last_ref_frame = vp9->pic_fields.bits.last_ref_frame;
64 context->desc.vp9.picture_parameter.pic_fields.last_ref_frame_sign_bias = vp9->pic_fields.bits.last_ref_frame_sign_bias;
65 context->desc.vp9.picture_parameter.pic_fields.golden_ref_frame = vp9->pic_fields.bits.golden_ref_frame;
66 context->desc.vp9.picture_parameter.pic_fields.golden_ref_frame_sign_bias = vp9->pic_fields.bits.golden_ref_frame_sign_bias;
67 context->desc.vp9.picture_parameter.pic_fields.alt_ref_frame = vp9->pic_fields.bits.alt_ref_frame;
68 context->desc.vp9.picture_parameter.pic_fields.alt_ref_frame_sign_bias = vp9->pic_fields.bits.alt_ref_frame_sign_bias;
69 context->desc.vp9.picture_parameter.pic_fields.lossless_flag = vp9->pic_fields.bits.lossless_flag;
70
71 context->desc.vp9.picture_parameter.filter_level = vp9->filter_level;
72 context->desc.vp9.picture_parameter.sharpness_level = vp9->sharpness_level;
73
74 context->desc.vp9.picture_parameter.log2_tile_rows = vp9->log2_tile_rows;
75 context->desc.vp9.picture_parameter.log2_tile_columns = vp9->log2_tile_columns;
76
77 context->desc.vp9.picture_parameter.frame_header_length_in_bytes = vp9->frame_header_length_in_bytes;
78 context->desc.vp9.picture_parameter.first_partition_size = vp9->first_partition_size;
79
80 for (i = 0; i < 7; ++i)
81 context->desc.vp9.picture_parameter.mb_segment_tree_probs[i] = vp9->mb_segment_tree_probs[i];
82 for (i = 0; i < 3; ++i)
83 context->desc.vp9.picture_parameter.segment_pred_probs[i] = vp9->segment_pred_probs[i];
84
85 context->desc.vp9.picture_parameter.profile = vp9->profile;
86
87 context->desc.vp9.picture_parameter.bit_depth = vp9->bit_depth;
88
89 for (i = 0 ; i < NUM_VP9_REFS ; i++) {
90 if (vp9->pic_fields.bits.frame_type == 0)
91 context->desc.vp9.ref[i] = NULL;
92 else
93 vlVaGetReferenceFrame(drv, vp9->reference_frames[i], &context->desc.vp9.ref[i]);
94 }
95
96 if (!context->decoder && !context->templat.max_references)
97 context->templat.max_references = NUM_VP9_REFS;
98
99 context->desc.vp9.slice_parameter.slice_count = 0;
100 context->desc.vp9.slice_parameter.slice_info_present = false;
101 memset(context->desc.vp9.slice_parameter.slice_data_flag, 0,
102 sizeof(context->desc.vp9.slice_parameter.slice_data_flag));
103 memset(context->desc.vp9.slice_parameter.slice_data_offset, 0,
104 sizeof(context->desc.vp9.slice_parameter.slice_data_offset));
105 memset(context->desc.vp9.slice_parameter.slice_data_size, 0,
106 sizeof(context->desc.vp9.slice_parameter.slice_data_size));
107 }
108
vlVaHandleSliceParameterBufferVP9(vlVaContext * context,vlVaBuffer * buf)109 void vlVaHandleSliceParameterBufferVP9(vlVaContext *context, vlVaBuffer *buf)
110 {
111 VASliceParameterBufferVP9 *vp9 = buf->data;
112 int i;
113
114 assert(buf->size >= sizeof(VASliceParameterBufferVP9) && buf->num_elements == 1);
115
116 ASSERTED const size_t max_pipe_vp9_slices = ARRAY_SIZE(context->desc.vp9.slice_parameter.slice_data_offset);
117 assert(context->desc.vp9.slice_parameter.slice_count < max_pipe_vp9_slices);
118
119 context->desc.vp9.slice_parameter.slice_info_present = true;
120 context->desc.vp9.slice_parameter.slice_data_size[context->desc.vp9.slice_parameter.slice_count] =
121 vp9->slice_data_size;
122 context->desc.vp9.slice_parameter.slice_data_offset[context->desc.vp9.slice_parameter.slice_count] =
123 vp9->slice_data_offset;
124
125 switch (vp9->slice_data_flag) {
126 case VA_SLICE_DATA_FLAG_ALL:
127 context->desc.vp9.slice_parameter.slice_data_flag[context->desc.vp9.slice_parameter.slice_count] =
128 PIPE_SLICE_BUFFER_PLACEMENT_TYPE_WHOLE;
129 break;
130 case VA_SLICE_DATA_FLAG_BEGIN:
131 context->desc.vp9.slice_parameter.slice_data_flag[context->desc.vp9.slice_parameter.slice_count] =
132 PIPE_SLICE_BUFFER_PLACEMENT_TYPE_BEGIN;
133 break;
134 case VA_SLICE_DATA_FLAG_MIDDLE:
135 context->desc.vp9.slice_parameter.slice_data_flag[context->desc.vp9.slice_parameter.slice_count] =
136 PIPE_SLICE_BUFFER_PLACEMENT_TYPE_MIDDLE;
137 break;
138 case VA_SLICE_DATA_FLAG_END:
139 context->desc.vp9.slice_parameter.slice_data_flag[context->desc.vp9.slice_parameter.slice_count] =
140 PIPE_SLICE_BUFFER_PLACEMENT_TYPE_END;
141 break;
142 default:
143 break;
144 }
145
146 /* assert(buf->num_elements == 1) above; */
147 context->desc.vp9.slice_parameter.slice_count++;
148
149 for (i = 0; i < 8; ++i) {
150 context->desc.vp9.slice_parameter.seg_param[i].segment_flags.segment_reference_enabled =
151 vp9->seg_param[i].segment_flags.fields.segment_reference_enabled;
152 context->desc.vp9.slice_parameter.seg_param[i].segment_flags.segment_reference =
153 vp9->seg_param[i].segment_flags.fields.segment_reference;
154 context->desc.vp9.slice_parameter.seg_param[i].segment_flags.segment_reference_skipped =
155 vp9->seg_param[i].segment_flags.fields.segment_reference_skipped;
156
157 memcpy(context->desc.vp9.slice_parameter.seg_param[i].filter_level, vp9->seg_param[i].filter_level, 4 * 2);
158
159 context->desc.vp9.slice_parameter.seg_param[i].luma_ac_quant_scale = vp9->seg_param[i].luma_ac_quant_scale;
160 context->desc.vp9.slice_parameter.seg_param[i].luma_dc_quant_scale = vp9->seg_param[i].luma_dc_quant_scale;
161 context->desc.vp9.slice_parameter.seg_param[i].chroma_ac_quant_scale = vp9->seg_param[i].chroma_ac_quant_scale;
162 context->desc.vp9.slice_parameter.seg_param[i].chroma_dc_quant_scale = vp9->seg_param[i].chroma_dc_quant_scale;
163 }
164 }
165
vp9_u(struct vl_vlc * vlc,unsigned n)166 static unsigned vp9_u(struct vl_vlc *vlc, unsigned n)
167 {
168 unsigned valid = vl_vlc_valid_bits(vlc);
169
170 if (n == 0)
171 return 0;
172
173 if (valid < 32)
174 vl_vlc_fillbits(vlc);
175
176 return vl_vlc_get_uimsbf(vlc, n);
177 }
178
vp9_s(struct vl_vlc * vlc,unsigned n)179 static signed vp9_s(struct vl_vlc *vlc, unsigned n)
180 {
181 unsigned v;
182 bool s;
183
184 v = vp9_u(vlc, n);
185 s = vp9_u(vlc, 1);
186
187 return s ? -v : v;
188 }
189
bitdepth_colorspace_sampling(struct vl_vlc * vlc,unsigned profile)190 static void bitdepth_colorspace_sampling(struct vl_vlc *vlc, unsigned profile)
191 {
192 unsigned cs;
193
194 if (profile == 2)
195 /* bit_depth */
196 vp9_u(vlc, 1);
197
198 cs = vp9_u(vlc, 3);
199 if (cs != 7)
200 /* yuv_range_flag */
201 vp9_u(vlc, 1);
202 }
203
frame_size(struct vl_vlc * vlc)204 static void frame_size(struct vl_vlc *vlc)
205 {
206 /* width_minus_one */
207 vp9_u(vlc, 16);
208 /* height_minus_one */
209 vp9_u(vlc, 16);
210
211 /* has_scaling */
212 if (vp9_u(vlc, 1)) {
213 /* render_width_minus_one */
214 vp9_u(vlc, 16);
215 /* render_height_minus_one */
216 vp9_u(vlc, 16);
217 }
218 }
219
vlVaDecoderVP9BitstreamHeader(vlVaContext * context,vlVaBuffer * buf)220 void vlVaDecoderVP9BitstreamHeader(vlVaContext *context, vlVaBuffer *buf)
221 {
222 struct vl_vlc vlc;
223 unsigned profile;
224 bool frame_type, show_frame, error_resilient_mode;
225 bool mode_ref_delta_enabled, mode_ref_delta_update = false;
226 int i;
227
228 vl_vlc_init(&vlc, 1, (const void * const*)&buf->data,
229 (const unsigned *)&context->desc.vp9.picture_parameter.frame_header_length_in_bytes);
230
231 /* frame_marker */
232 if (vp9_u(&vlc, 2) != 0x2)
233 return;
234
235 profile = vp9_u(&vlc, 1) | vp9_u(&vlc, 1) << 1;
236
237 if (profile == 3)
238 profile += vp9_u(&vlc, 1);
239
240 if (profile != 0 && profile != 2)
241 return;
242
243 /* show_existing_frame */
244 if (vp9_u(&vlc, 1))
245 return;
246
247 frame_type = vp9_u(&vlc, 1);
248 show_frame = vp9_u(&vlc, 1);
249 error_resilient_mode = vp9_u(&vlc, 1);
250
251 if (frame_type == 0) {
252 /* sync_code */
253 if (vp9_u(&vlc, 24) != 0x498342)
254 return;
255
256 bitdepth_colorspace_sampling(&vlc, profile);
257 frame_size(&vlc);
258 } else {
259 bool intra_only, size_in_refs = false;
260
261 intra_only = show_frame ? 0 : vp9_u(&vlc, 1);
262 if (!error_resilient_mode)
263 /* reset_frame_context */
264 vp9_u(&vlc, 2);
265
266 if (intra_only) {
267 /* sync_code */
268 if (vp9_u(&vlc, 24) != 0x498342)
269 return;
270
271 bitdepth_colorspace_sampling(&vlc, profile);
272 /* refresh_frame_flags */
273 vp9_u(&vlc, 8);
274 frame_size(&vlc);
275 } else {
276 /* refresh_frame_flags */
277 vp9_u(&vlc, 8);
278
279 for (i = 0; i < 3; ++i) {
280 /* frame refs */
281 vp9_u(&vlc, 3);
282 vp9_u(&vlc, 1);
283 }
284
285 for (i = 0; i < 3; ++i) {
286 size_in_refs = vp9_u(&vlc, 1);
287 if (size_in_refs)
288 break;
289 }
290
291 if (!size_in_refs) {
292 /* width/height_minus_one */
293 vp9_u(&vlc, 16);
294 vp9_u(&vlc, 16);
295 }
296
297 if (vp9_u(&vlc, 1)) {
298 /* render_width/height_minus_one */
299 vp9_u(&vlc, 16);
300 vp9_u(&vlc, 16);
301 }
302
303 /* high_precision_mv */
304 vp9_u(&vlc, 1);
305 /* filter_switchable */
306 if (!vp9_u(&vlc, 1))
307 /* filter_index */
308 vp9_u(&vlc, 2);
309 }
310 }
311 if (!error_resilient_mode) {
312 /* refresh_frame_context */
313 vp9_u(&vlc, 1);
314 /* frame_parallel_decoding_mode */
315 vp9_u(&vlc, 1);
316 }
317 /* frame_context_index */
318 vp9_u(&vlc, 2);
319
320 /* loop filter */
321
322 /* filter_level */
323 vp9_u(&vlc, 6);
324 /* sharpness_level */
325 vp9_u(&vlc, 3);
326
327 mode_ref_delta_enabled = vp9_u(&vlc, 1);
328 if (mode_ref_delta_enabled) {
329 mode_ref_delta_update = vp9_u(&vlc, 1);
330 if (mode_ref_delta_update) {
331 for (i = 0; i < 4; ++i) {
332 /* update_ref_delta */
333 if (vp9_u(&vlc, 1))
334 /* ref_deltas */
335 context->desc.vp9.picture_parameter.ref_deltas[i] = vp9_s(&vlc, 6);
336 }
337 for (i = 0; i < 2; ++i) {
338 /* update_mode_delta */
339 if (vp9_u(&vlc, 1))
340 /* mode_deltas */
341 context->desc.vp9.picture_parameter.mode_deltas[i] = vp9_s(&vlc, 6);
342 }
343 }
344 }
345 context->desc.vp9.picture_parameter.mode_ref_delta_enabled = mode_ref_delta_enabled;
346 context->desc.vp9.picture_parameter.mode_ref_delta_update = mode_ref_delta_update;
347
348 /* quantization */
349
350 context->desc.vp9.picture_parameter.base_qindex = vp9_u(&vlc, 8);
351 context->desc.vp9.picture_parameter.y_dc_delta_q = vp9_u(&vlc, 1) ? vp9_s(&vlc, 4) : 0;
352 context->desc.vp9.picture_parameter.uv_ac_delta_q = vp9_u(&vlc, 1) ? vp9_s(&vlc, 4) : 0;
353 context->desc.vp9.picture_parameter.uv_dc_delta_q = vp9_u(&vlc, 1) ? vp9_s(&vlc, 4) : 0;
354
355 /* segmentation */
356
357 /* enabled */
358 if (!vp9_u(&vlc, 1))
359 return;
360
361 /* update_map */
362 if (vp9_u(&vlc, 1)) {
363 for (i = 0; i < 7; ++i) {
364 /* tree_probs_set */
365 if (vp9_u(&vlc, 1)) {
366 /* tree_probs */
367 vp9_u(&vlc, 8);
368 }
369 }
370
371 /* temporal_update */
372 if (vp9_u(&vlc, 1)) {
373 for (i = 0; i < 3; ++i) {
374 /* pred_probs_set */
375 if (vp9_u(&vlc, 1))
376 /* pred_probs */
377 vp9_u(&vlc, 8);
378 }
379 }
380 }
381
382 /* update_data */
383 if (vp9_u(&vlc, 1)) {
384 /* abs_delta */
385 context->desc.vp9.picture_parameter.abs_delta = vp9_u(&vlc, 1);
386 for (i = 0; i < 8; ++i) {
387 /* Use alternate quantizer */
388 if ((context->desc.vp9.slice_parameter.seg_param[i].alt_quant_enabled = vp9_u(&vlc, 1)))
389 context->desc.vp9.slice_parameter.seg_param[i].alt_quant = vp9_s(&vlc, 8);
390 /* Use alternate loop filter value */
391 if ((context->desc.vp9.slice_parameter.seg_param[i].alt_lf_enabled = vp9_u(&vlc, 1)))
392 context->desc.vp9.slice_parameter.seg_param[i].alt_lf = vp9_s(&vlc, 6);
393 /* Optional Segment reference frame */
394 if (vp9_u(&vlc, 1))
395 vp9_u(&vlc, 2);
396 /* Optional Segment skip mode */
397 vp9_u(&vlc, 1);
398 }
399 }
400 }
401