1 /**************************************************************************
3 * Copyright 2016 Advanced Micro Devices, Inc.
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:
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
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.
26 **************************************************************************/
28 #include "pipe/p_video_codec.h"
29 #include "util/u_memory.h"
30 #include "util/u_video.h"
31 #include "vl/vl_rbsp.h"
33 #include "entrypoint.h"
36 #define DPB_MAX_SIZE 32
37 #define MAX_NUM_REF_PICS 16
40 NAL_UNIT_TYPE_TRAIL_N
= 0,
41 NAL_UNIT_TYPE_TRAIL_R
= 1,
42 NAL_UNIT_TYPE_TSA_N
= 2,
43 NAL_UNIT_TYPE_TSA_R
= 3,
44 NAL_UNIT_TYPE_STSA_N
= 4,
45 NAL_UNIT_TYPE_STSA_R
= 5,
46 NAL_UNIT_TYPE_RADL_N
= 6,
47 NAL_UNIT_TYPE_RADL_R
= 7,
48 NAL_UNIT_TYPE_RASL_N
= 8,
49 NAL_UNIT_TYPE_RASL_R
= 9,
50 NAL_UNIT_TYPE_BLA_W_LP
= 16,
51 NAL_UNIT_TYPE_BLA_W_RADL
= 17,
52 NAL_UNIT_TYPE_BLA_N_LP
= 18,
53 NAL_UNIT_TYPE_IDR_W_RADL
= 19,
54 NAL_UNIT_TYPE_IDR_N_LP
= 20,
55 NAL_UNIT_TYPE_CRA
= 21,
56 NAL_UNIT_TYPE_SPS
= 33,
57 NAL_UNIT_TYPE_PPS
= 34,
60 static const uint8_t Default_8x8_Intra
[64] = {
61 16, 16, 16, 16, 17, 18, 21, 24,
62 16, 16, 16, 16, 17, 19, 22, 25,
63 16, 16, 17, 18, 20, 22, 25, 29,
64 16, 16, 18, 21, 24, 27, 31, 36,
65 17, 17, 20, 24, 30, 35, 41, 47,
66 18, 19, 22, 27, 35, 44, 54, 65,
67 21, 22, 25, 31, 41, 54, 70, 88,
68 24, 25, 29, 36, 47, 65, 88, 115
71 static const uint8_t Default_8x8_Inter
[64] = {
72 16, 16, 16, 16, 17, 18, 20, 24,
73 16, 16, 16, 17, 18, 20, 24, 25,
74 16, 16, 17, 18, 20, 24, 25, 28,
75 16, 17, 18, 20, 24, 25, 28, 33,
76 17, 18, 20, 24, 25, 28, 33, 41,
77 18, 20, 24, 25, 28, 33, 41, 54,
78 20, 24, 25, 28, 33, 41, 54, 71,
79 24, 25, 28, 33, 41, 54, 71, 91
83 struct list_head list
;
84 struct pipe_video_buffer
*buffer
;
91 unsigned num_neg_pics
;
92 unsigned num_pos_pics
;
93 unsigned num_delta_poc
;
94 int delta_poc
[MAX_NUM_REF_PICS
];
95 bool used
[MAX_NUM_REF_PICS
];
98 static bool is_idr_picture(unsigned nal_unit_type
)
100 return (nal_unit_type
== NAL_UNIT_TYPE_IDR_W_RADL
||
101 nal_unit_type
== NAL_UNIT_TYPE_IDR_N_LP
);
104 /* broken link access picture */
105 static bool is_bla_picture(unsigned nal_unit_type
)
107 return (nal_unit_type
== NAL_UNIT_TYPE_BLA_W_LP
||
108 nal_unit_type
== NAL_UNIT_TYPE_BLA_W_RADL
||
109 nal_unit_type
== NAL_UNIT_TYPE_BLA_N_LP
);
112 /* random access point picture */
113 static bool is_rap_picture(unsigned nal_unit_type
)
115 return (nal_unit_type
>= NAL_UNIT_TYPE_BLA_W_LP
&&
116 nal_unit_type
<= NAL_UNIT_TYPE_CRA
);
119 static bool is_slice_picture(unsigned nal_unit_type
)
121 return (nal_unit_type
<= NAL_UNIT_TYPE_RASL_R
||
122 is_rap_picture(nal_unit_type
));
125 static void set_poc(vid_dec_PrivateType
*priv
,
126 unsigned nal_unit_type
, int i
)
128 priv
->picture
.h265
.CurrPicOrderCntVal
= i
;
130 if (priv
->codec_data
.h265
.temporal_id
== 0 &&
131 (nal_unit_type
== NAL_UNIT_TYPE_TRAIL_R
||
132 nal_unit_type
== NAL_UNIT_TYPE_TSA_R
||
133 nal_unit_type
== NAL_UNIT_TYPE_STSA_R
||
134 is_rap_picture(nal_unit_type
)))
135 priv
->codec_data
.h265
.slice_prev_poc
= i
;
138 static unsigned get_poc(vid_dec_PrivateType
*priv
)
140 return priv
->picture
.h265
.CurrPicOrderCntVal
;
143 static void profile_tier(struct vl_rbsp
*rbsp
)
147 /* general_profile_space */
150 /* general_tier_flag */
153 /* general_profile_idc */
156 /* general_profile_compatibility_flag */
157 for(i
= 0; i
< 32; ++i
)
160 /* general_progressive_source_flag */
163 /* general_interlaced_source_flag */
166 /* general_non_packed_constraint_flag */
169 /* general_frame_only_constraint_flag */
172 /* general_reserved_zero_44bits */
178 static unsigned profile_tier_level(struct vl_rbsp
*rbsp
,
179 int max_sublayers_minus1
)
181 bool sub_layer_profile_present_flag
[6];
182 bool sub_layer_level_present_flag
[6];
188 /* general_level_idc */
189 level_idc
= vl_rbsp_u(rbsp
, 8);
191 for (i
= 0; i
< max_sublayers_minus1
; ++i
) {
192 sub_layer_profile_present_flag
[i
] = vl_rbsp_u(rbsp
, 1);
193 sub_layer_level_present_flag
[i
] = vl_rbsp_u(rbsp
, 1);
196 if (max_sublayers_minus1
> 0)
197 for (i
= max_sublayers_minus1
; i
< 8; ++i
)
198 /* reserved_zero_2bits */
201 for (i
= 0; i
< max_sublayers_minus1
; ++i
) {
202 if (sub_layer_profile_present_flag
[i
])
205 if (sub_layer_level_present_flag
[i
])
206 /* sub_layer_level_idc */
213 static void scaling_list_data(vid_dec_PrivateType
*priv
,
214 struct vl_rbsp
*rbsp
, struct pipe_h265_sps
*sps
)
216 unsigned size_id
, matrix_id
;
217 unsigned scaling_list_len
[4] = { 16, 64, 64, 64 };
218 uint8_t scaling_list4x4
[6][64] = { };
221 uint8_t (*scaling_list_data
[4])[6][64] = {
222 (uint8_t (*)[6][64])scaling_list4x4
,
223 (uint8_t (*)[6][64])sps
->ScalingList8x8
,
224 (uint8_t (*)[6][64])sps
->ScalingList16x16
,
225 (uint8_t (*)[6][64])sps
->ScalingList32x32
227 uint8_t (*scaling_list_dc_coeff
[2])[6] = {
228 (uint8_t (*)[6])sps
->ScalingListDCCoeff16x16
,
229 (uint8_t (*)[6])sps
->ScalingListDCCoeff32x32
232 for (size_id
= 0; size_id
< 4; ++size_id
) {
234 for (matrix_id
= 0; matrix_id
< ((size_id
== 3) ? 2 : 6); ++matrix_id
) {
235 bool scaling_list_pred_mode_flag
= vl_rbsp_u(rbsp
, 1);
237 if (!scaling_list_pred_mode_flag
) {
238 /* scaling_list_pred_matrix_id_delta */;
239 unsigned matrix_id_with_delta
= matrix_id
- vl_rbsp_ue(rbsp
);
241 if (matrix_id
!= matrix_id_with_delta
) {
242 memcpy((*scaling_list_data
[size_id
])[matrix_id
],
243 (*scaling_list_data
[size_id
])[matrix_id_with_delta
],
244 scaling_list_len
[size_id
]);
246 (*scaling_list_dc_coeff
[size_id
- 2])[matrix_id
] =
247 (*scaling_list_dc_coeff
[size_id
- 2])[matrix_id_with_delta
];
252 memset((*scaling_list_data
[0])[matrix_id
], 16, 16);
255 d
= (matrix_id
< 3) ? Default_8x8_Intra
: Default_8x8_Inter
;
257 d
= (matrix_id
< 1) ? Default_8x8_Intra
: Default_8x8_Inter
;
258 memcpy((*scaling_list_data
[size_id
])[matrix_id
], d
,
259 scaling_list_len
[size_id
]);
262 (*scaling_list_dc_coeff
[size_id
- 2])[matrix_id
] = 16;
266 int coef_num
= MIN2(64, (1 << (4 + (size_id
<< 1))));
269 /* scaling_list_dc_coef_minus8 */
270 next_coef
= vl_rbsp_se(rbsp
) + 8;
271 (*scaling_list_dc_coeff
[size_id
- 2])[matrix_id
] = next_coef
;
274 for (i
= 0; i
< coef_num
; ++i
) {
275 /* scaling_list_delta_coef */
276 next_coef
= (next_coef
+ vl_rbsp_se(rbsp
) + 256) % 256;
277 (*scaling_list_data
[size_id
])[matrix_id
][i
] = next_coef
;
283 for (i
= 0; i
< 6; ++i
)
284 memcpy(sps
->ScalingList4x4
[i
], scaling_list4x4
[i
], 16);
289 static void st_ref_pic_set(vid_dec_PrivateType
*priv
, struct vl_rbsp
*rbsp
,
290 struct ref_pic_set
*rps
, struct pipe_h265_sps
*sps
,
293 bool inter_rps_pred_flag
;
294 unsigned delta_idx_minus1
;
298 inter_rps_pred_flag
= (idx
!= 0) ? (vl_rbsp_u(rbsp
, 1)) : false;
300 if (inter_rps_pred_flag
) {
301 struct ref_pic_set
*ref_rps
;
307 if (idx
== sps
->num_short_term_ref_pic_sets
)
308 delta_idx_minus1
= vl_rbsp_ue(rbsp
);
310 delta_idx_minus1
= 0;
312 ref_rps
= (struct ref_pic_set
*)
313 priv
->codec_data
.h265
.ref_pic_set_list
+ idx
- (delta_idx_minus1
+ 1);
316 sign
= vl_rbsp_u(rbsp
, 1);
317 /* abs_delta_rps_minus1 */
318 abs
= vl_rbsp_ue(rbsp
);
319 delta_rps
= (1 - 2 * sign
) * (abs
+ 1);
321 rps
->num_neg_pics
= 0;
322 rps
->num_pos_pics
= 0;
325 for(i
= 0 ; i
<= ref_rps
->num_pics
; ++i
) {
326 /* used_by_curr_pic_flag */
327 if (!vl_rbsp_u(rbsp
, 1))
331 delta_poc
= delta_rps
+
332 ((i
< ref_rps
->num_pics
)? ref_rps
->delta_poc
[i
] : 0);
333 rps
->delta_poc
[rps
->num_pics
] = delta_poc
;
334 rps
->used
[rps
->num_pics
] = true;
343 rps
->num_delta_poc
= ref_rps
->num_pics
;
346 for (i
= 1; i
< rps
->num_pics
; ++i
) {
347 delta_poc
= rps
->delta_poc
[i
];
349 for (j
= i
- 1; j
>= 0; j
--) {
350 if (delta_poc
< rps
->delta_poc
[j
]) {
351 rps
->delta_poc
[j
+ 1] = rps
->delta_poc
[j
];
352 rps
->used
[j
+ 1] = rps
->used
[j
];
353 rps
->delta_poc
[j
] = delta_poc
;
359 for (i
= 0 , j
= rps
->num_neg_pics
- 1;
360 i
< rps
->num_neg_pics
>> 1; i
++, j
--) {
361 delta_poc
= rps
->delta_poc
[i
];
363 rps
->delta_poc
[i
] = rps
->delta_poc
[j
];
364 rps
->used
[i
] = rps
->used
[j
];
365 rps
->delta_poc
[j
] = delta_poc
;
369 /* num_negative_pics */
370 rps
->num_neg_pics
= vl_rbsp_ue(rbsp
);
371 /* num_positive_pics */
372 rps
->num_pos_pics
= vl_rbsp_ue(rbsp
);
373 rps
->num_pics
= rps
->num_neg_pics
+ rps
->num_pos_pics
;
376 for(i
= 0 ; i
< rps
->num_neg_pics
; ++i
) {
377 /* delta_poc_s0_minus1 */
378 delta_poc
-= (vl_rbsp_ue(rbsp
) + 1);
379 rps
->delta_poc
[i
] = delta_poc
;
380 /* used_by_curr_pic_s0_flag */
381 rps
->used
[i
] = vl_rbsp_u(rbsp
, 1);
385 for(i
= rps
->num_neg_pics
; i
< rps
->num_pics
; ++i
) {
386 /* delta_poc_s1_minus1 */
387 delta_poc
+= (vl_rbsp_ue(rbsp
) + 1);
388 rps
->delta_poc
[i
] = delta_poc
;
389 /* used_by_curr_pic_s1_flag */
390 rps
->used
[i
] = vl_rbsp_u(rbsp
, 1);
395 static struct pipe_h265_sps
*seq_parameter_set_id(vid_dec_PrivateType
*priv
,
396 struct vl_rbsp
*rbsp
)
398 unsigned id
= vl_rbsp_ue(rbsp
);
400 if (id
>= ARRAY_SIZE(priv
->codec_data
.h265
.sps
))
403 return &priv
->codec_data
.h265
.sps
[id
];
406 static void seq_parameter_set(vid_dec_PrivateType
*priv
, struct vl_rbsp
*rbsp
)
408 struct pipe_h265_sps
*sps
;
409 int sps_max_sub_layers_minus1
;
412 /* sps_video_parameter_set_id */
415 /* sps_max_sub_layers_minus1 */
416 sps_max_sub_layers_minus1
= vl_rbsp_u(rbsp
, 3);
418 assert(sps_max_sub_layers_minus1
<= 6);
420 /* sps_temporal_id_nesting_flag */
423 priv
->codec_data
.h265
.level_idc
=
424 profile_tier_level(rbsp
, sps_max_sub_layers_minus1
);
426 sps
= seq_parameter_set_id(priv
, rbsp
);
430 memset(sps
, 0, sizeof(*sps
));
432 sps
->chroma_format_idc
= vl_rbsp_ue(rbsp
);
434 if (sps
->chroma_format_idc
== 3)
435 sps
->separate_colour_plane_flag
= vl_rbsp_u(rbsp
, 1);
437 priv
->codec_data
.h265
.pic_width_in_luma_samples
=
438 sps
->pic_width_in_luma_samples
= vl_rbsp_ue(rbsp
);
440 priv
->codec_data
.h265
.pic_height_in_luma_samples
=
441 sps
->pic_height_in_luma_samples
= vl_rbsp_ue(rbsp
);
443 /* conformance_window_flag */
444 if (vl_rbsp_u(rbsp
, 1)) {
445 /* conf_win_left_offset */
447 /* conf_win_right_offset */
449 /* conf_win_top_offset */
451 /* conf_win_bottom_offset */
455 sps
->bit_depth_luma_minus8
= vl_rbsp_ue(rbsp
);
456 sps
->bit_depth_chroma_minus8
= vl_rbsp_ue(rbsp
);
457 sps
->log2_max_pic_order_cnt_lsb_minus4
= vl_rbsp_ue(rbsp
);
459 /* sps_sub_layer_ordering_info_present_flag */
460 i
= vl_rbsp_u(rbsp
, 1) ? 0 : sps_max_sub_layers_minus1
;
461 for (; i
<= sps_max_sub_layers_minus1
; ++i
) {
462 sps
->sps_max_dec_pic_buffering_minus1
= vl_rbsp_ue(rbsp
);
463 /* sps_max_num_reorder_pics */
465 /* sps_max_latency_increase_plus */
469 sps
->log2_min_luma_coding_block_size_minus3
= vl_rbsp_ue(rbsp
);
470 sps
->log2_diff_max_min_luma_coding_block_size
= vl_rbsp_ue(rbsp
);
471 sps
->log2_min_transform_block_size_minus2
= vl_rbsp_ue(rbsp
);
472 sps
->log2_diff_max_min_transform_block_size
= vl_rbsp_ue(rbsp
);
473 sps
->max_transform_hierarchy_depth_inter
= vl_rbsp_ue(rbsp
);
474 sps
->max_transform_hierarchy_depth_intra
= vl_rbsp_ue(rbsp
);
476 sps
->scaling_list_enabled_flag
= vl_rbsp_u(rbsp
, 1);
477 if (sps
->scaling_list_enabled_flag
)
478 /* sps_scaling_list_data_present_flag */
479 if (vl_rbsp_u(rbsp
, 1))
480 scaling_list_data(priv
, rbsp
, sps
);
482 sps
->amp_enabled_flag
= vl_rbsp_u(rbsp
, 1);
483 sps
->sample_adaptive_offset_enabled_flag
= vl_rbsp_u(rbsp
, 1);
484 sps
->pcm_enabled_flag
= vl_rbsp_u(rbsp
, 1);
485 if (sps
->pcm_enabled_flag
) {
486 sps
->pcm_sample_bit_depth_luma_minus1
= vl_rbsp_u(rbsp
, 4);
487 sps
->pcm_sample_bit_depth_chroma_minus1
= vl_rbsp_u(rbsp
, 4);
488 sps
->log2_min_pcm_luma_coding_block_size_minus3
= vl_rbsp_ue(rbsp
);
489 sps
->log2_diff_max_min_pcm_luma_coding_block_size
= vl_rbsp_ue(rbsp
);
490 sps
->pcm_loop_filter_disabled_flag
= vl_rbsp_u(rbsp
, 1);
493 sps
->num_short_term_ref_pic_sets
= vl_rbsp_ue(rbsp
);
495 for (i
= 0; i
< sps
->num_short_term_ref_pic_sets
; ++i
) {
496 struct ref_pic_set
*rps
;
498 rps
= (struct ref_pic_set
*)
499 priv
->codec_data
.h265
.ref_pic_set_list
+ i
;
500 st_ref_pic_set(priv
, rbsp
, rps
, sps
, i
);
503 sps
->long_term_ref_pics_present_flag
= vl_rbsp_u(rbsp
, 1);
504 if (sps
->long_term_ref_pics_present_flag
) {
505 sps
->num_long_term_ref_pics_sps
= vl_rbsp_ue(rbsp
);
506 for (i
= 0; i
< sps
->num_long_term_ref_pics_sps
; ++i
) {
507 /* lt_ref_pic_poc_lsb_sps */
508 vl_rbsp_u(rbsp
, sps
->log2_max_pic_order_cnt_lsb_minus4
+ 4);
509 /* used_by_curr_pic_lt_sps_flag */
514 sps
->sps_temporal_mvp_enabled_flag
= vl_rbsp_u(rbsp
, 1);
515 sps
->strong_intra_smoothing_enabled_flag
= vl_rbsp_u(rbsp
, 1);
518 static struct pipe_h265_pps
*pic_parameter_set_id(vid_dec_PrivateType
*priv
,
519 struct vl_rbsp
*rbsp
)
521 unsigned id
= vl_rbsp_ue(rbsp
);
523 if (id
>= ARRAY_SIZE(priv
->codec_data
.h265
.pps
))
526 return &priv
->codec_data
.h265
.pps
[id
];
529 static void picture_parameter_set(vid_dec_PrivateType
*priv
,
530 struct vl_rbsp
*rbsp
)
532 struct pipe_h265_sps
*sps
;
533 struct pipe_h265_pps
*pps
;
536 pps
= pic_parameter_set_id(priv
, rbsp
);
540 memset(pps
, 0, sizeof(*pps
));
541 sps
= pps
->sps
= seq_parameter_set_id(priv
, rbsp
);
545 pps
->dependent_slice_segments_enabled_flag
= vl_rbsp_u(rbsp
, 1);
546 pps
->output_flag_present_flag
= vl_rbsp_u(rbsp
, 1);
547 pps
->num_extra_slice_header_bits
= vl_rbsp_u(rbsp
, 3);
548 pps
->sign_data_hiding_enabled_flag
= vl_rbsp_u(rbsp
, 1);
549 pps
->cabac_init_present_flag
= vl_rbsp_u(rbsp
, 1);
551 pps
->num_ref_idx_l0_default_active_minus1
= vl_rbsp_ue(rbsp
);
552 pps
->num_ref_idx_l1_default_active_minus1
= vl_rbsp_ue(rbsp
);
553 pps
->init_qp_minus26
= vl_rbsp_se(rbsp
);
554 pps
->constrained_intra_pred_flag
= vl_rbsp_u(rbsp
, 1);
555 pps
->transform_skip_enabled_flag
= vl_rbsp_u(rbsp
, 1);
557 pps
->cu_qp_delta_enabled_flag
= vl_rbsp_u(rbsp
, 1);
558 if (pps
->cu_qp_delta_enabled_flag
)
559 pps
->diff_cu_qp_delta_depth
= vl_rbsp_ue(rbsp
);
561 pps
->pps_cb_qp_offset
= vl_rbsp_se(rbsp
);
562 pps
->pps_cr_qp_offset
= vl_rbsp_se(rbsp
);
563 pps
->pps_slice_chroma_qp_offsets_present_flag
= vl_rbsp_u(rbsp
, 1);
565 pps
->weighted_pred_flag
= vl_rbsp_u(rbsp
, 1);
566 pps
->weighted_bipred_flag
= vl_rbsp_u(rbsp
, 1);
568 pps
->transquant_bypass_enabled_flag
= vl_rbsp_u(rbsp
, 1);
569 pps
->tiles_enabled_flag
= vl_rbsp_u(rbsp
, 1);
570 pps
->entropy_coding_sync_enabled_flag
= vl_rbsp_u(rbsp
, 1);
572 if (pps
->tiles_enabled_flag
) {
573 pps
->num_tile_columns_minus1
= vl_rbsp_ue(rbsp
);
574 pps
->num_tile_rows_minus1
= vl_rbsp_ue(rbsp
);
576 pps
->uniform_spacing_flag
= vl_rbsp_u(rbsp
, 1);
577 if (!pps
->uniform_spacing_flag
) {
578 for (i
= 0; i
< pps
->num_tile_columns_minus1
; ++i
)
579 pps
->column_width_minus1
[i
] = vl_rbsp_ue(rbsp
);
581 for (i
= 0; i
< pps
->num_tile_rows_minus1
; ++i
)
582 pps
->row_height_minus1
[i
] = vl_rbsp_ue(rbsp
);
585 if (!pps
->num_tile_columns_minus1
|| !pps
->num_tile_rows_minus1
)
586 pps
->loop_filter_across_tiles_enabled_flag
= vl_rbsp_u(rbsp
, 1);
589 pps
->pps_loop_filter_across_slices_enabled_flag
= vl_rbsp_u(rbsp
, 1);
591 pps
->deblocking_filter_control_present_flag
= vl_rbsp_u(rbsp
, 1);
592 if (pps
->deblocking_filter_control_present_flag
) {
593 pps
->deblocking_filter_override_enabled_flag
= vl_rbsp_u(rbsp
, 1);
594 pps
->pps_deblocking_filter_disabled_flag
= vl_rbsp_u(rbsp
, 1);
595 if (!pps
->pps_deblocking_filter_disabled_flag
) {
596 pps
->pps_beta_offset_div2
= vl_rbsp_se(rbsp
);
597 pps
->pps_tc_offset_div2
= vl_rbsp_se(rbsp
);
601 /* pps_scaling_list_data_present_flag */
602 if (vl_rbsp_u(rbsp
, 1))
603 scaling_list_data(priv
, rbsp
, sps
);
605 pps
->lists_modification_present_flag
= vl_rbsp_u(rbsp
, 1);
606 pps
->log2_parallel_merge_level_minus2
= vl_rbsp_ue(rbsp
);
607 pps
->slice_segment_header_extension_present_flag
= vl_rbsp_u(rbsp
, 1);
610 static void vid_dec_h265_BeginFrame(vid_dec_PrivateType
*priv
)
612 if (priv
->frame_started
)
616 struct pipe_video_codec templat
= {};
617 omx_base_video_PortType
*port
= (omx_base_video_PortType
*)
618 priv
->ports
[OMX_BASE_FILTER_INPUTPORT_INDEX
];
620 templat
.profile
= priv
->profile
;
621 templat
.entrypoint
= PIPE_VIDEO_ENTRYPOINT_BITSTREAM
;
622 templat
.chroma_format
= PIPE_VIDEO_CHROMA_FORMAT_420
;
623 templat
.expect_chunked_decode
= true;
624 templat
.width
= priv
->codec_data
.h265
.pic_width_in_luma_samples
;
625 templat
.height
= priv
->codec_data
.h265
.pic_height_in_luma_samples
;
626 templat
.level
= priv
->codec_data
.h265
.level_idc
;
627 priv
->codec
= priv
->pipe
->create_video_codec(priv
->pipe
, &templat
);
629 /* disable transcode tunnel if video size is different from coded size */
630 if (priv
->codec_data
.h265
.pic_width_in_luma_samples
!=
631 port
->sPortParam
.format
.video
.nFrameWidth
||
632 priv
->codec_data
.h265
.pic_height_in_luma_samples
!=
633 port
->sPortParam
.format
.video
.nFrameHeight
)
634 priv
->disable_tunnel
= true;
637 vid_dec_NeedTarget(priv
);
639 if (priv
->first_buf_in_frame
)
640 priv
->timestamp
= priv
->timestamps
[0];
641 priv
->first_buf_in_frame
= false;
643 priv
->codec
->begin_frame(priv
->codec
, priv
->target
, &priv
->picture
.base
);
644 priv
->frame_started
= true;
647 static struct pipe_video_buffer
*vid_dec_h265_Flush(vid_dec_PrivateType
*priv
,
648 OMX_TICKS
*timestamp
)
650 struct dpb_list
*entry
, *result
= NULL
;
651 struct pipe_video_buffer
*buf
;
653 /* search for the lowest poc and break on zeros */
654 LIST_FOR_EACH_ENTRY(entry
, &priv
->codec_data
.h265
.dpb_list
, list
) {
656 if (result
&& entry
->poc
== 0)
659 if (!result
|| entry
->poc
< result
->poc
)
666 buf
= result
->buffer
;
668 *timestamp
= result
->timestamp
;
670 --priv
->codec_data
.h265
.dpb_num
;
671 LIST_DEL(&result
->list
);
677 static void vid_dec_h265_EndFrame(vid_dec_PrivateType
*priv
)
679 struct dpb_list
*entry
= NULL
;
680 struct pipe_video_buffer
*tmp
;
681 struct ref_pic_set
*rps
;
685 if (!priv
->frame_started
)
688 priv
->picture
.h265
.NumPocStCurrBefore
= 0;
689 priv
->picture
.h265
.NumPocStCurrAfter
= 0;
690 memset(priv
->picture
.h265
.RefPicSetStCurrBefore
, 0, 8);
691 memset(priv
->picture
.h265
.RefPicSetStCurrAfter
, 0, 8);
692 for (i
= 0; i
< MAX_NUM_REF_PICS
; ++i
) {
693 priv
->picture
.h265
.ref
[i
] = NULL
;
694 priv
->picture
.h265
.PicOrderCntVal
[i
] = 0;
697 rps
= priv
->codec_data
.h265
.rps
;
700 unsigned bf
= 0, af
= 0;
702 priv
->picture
.h265
.NumDeltaPocsOfRefRpsIdx
= rps
->num_delta_poc
;
703 for (i
= 0; i
< rps
->num_pics
; ++i
) {
704 priv
->picture
.h265
.PicOrderCntVal
[i
] =
705 rps
->delta_poc
[i
] + get_poc(priv
);
707 LIST_FOR_EACH_ENTRY(entry
, &priv
->codec_data
.h265
.dpb_list
, list
) {
708 if (entry
->poc
== priv
->picture
.h265
.PicOrderCntVal
[i
]) {
709 priv
->picture
.h265
.ref
[i
] = entry
->buffer
;
715 if (i
< rps
->num_neg_pics
) {
716 priv
->picture
.h265
.NumPocStCurrBefore
++;
717 priv
->picture
.h265
.RefPicSetStCurrBefore
[bf
++] = i
;
719 priv
->picture
.h265
.NumPocStCurrAfter
++;
720 priv
->picture
.h265
.RefPicSetStCurrAfter
[af
++] = i
;
726 priv
->codec
->end_frame(priv
->codec
, priv
->target
, &priv
->picture
.base
);
727 priv
->frame_started
= false;
729 /* add the decoded picture to the dpb list */
730 entry
= CALLOC_STRUCT(dpb_list
);
734 priv
->first_buf_in_frame
= true;
735 entry
->buffer
= priv
->target
;
736 entry
->timestamp
= priv
->timestamp
;
737 entry
->poc
= get_poc(priv
);
739 list_addtail(&entry
->list
, &priv
->codec_data
.h265
.dpb_list
);
740 ++priv
->codec_data
.h265
.dpb_num
;
743 if (priv
->codec_data
.h265
.dpb_num
<= DPB_MAX_SIZE
)
746 tmp
= priv
->in_buffers
[0]->pInputPortPrivate
;
747 priv
->in_buffers
[0]->pInputPortPrivate
= vid_dec_h265_Flush(priv
, ×tamp
);
748 priv
->in_buffers
[0]->nTimeStamp
= timestamp
;
750 priv
->frame_finished
= priv
->in_buffers
[0]->pInputPortPrivate
!= NULL
;
751 if (priv
->frame_finished
&&
752 (priv
->in_buffers
[0]->nFlags
& OMX_BUFFERFLAG_EOS
))
753 FREE(priv
->codec_data
.h265
.ref_pic_set_list
);
756 static void slice_header(vid_dec_PrivateType
*priv
, struct vl_rbsp
*rbsp
,
757 unsigned nal_unit_type
)
759 struct pipe_h265_pps
*pps
;
760 struct pipe_h265_sps
*sps
;
761 bool first_slice_segment_in_pic_flag
;
762 bool dependent_slice_segment_flag
= false;
763 struct ref_pic_set
*rps
;
764 unsigned poc_lsb
, poc_msb
, slice_prev_poc
;
765 unsigned max_poc_lsb
, prev_poc_lsb
, prev_poc_msb
;
769 if (priv
->picture
.h265
.IDRPicFlag
!= is_idr_picture(nal_unit_type
))
770 vid_dec_h265_EndFrame(priv
);
772 priv
->picture
.h265
.IDRPicFlag
= is_idr_picture(nal_unit_type
);
774 first_slice_segment_in_pic_flag
= vl_rbsp_u(rbsp
, 1);
776 if (is_rap_picture(nal_unit_type
))
777 /* no_output_of_prior_pics_flag */
780 pps
= pic_parameter_set_id(priv
, rbsp
);
788 if (pps
!= priv
->picture
.h265
.pps
)
789 vid_dec_h265_EndFrame(priv
);
791 priv
->picture
.h265
.pps
= pps
;
793 if (priv
->picture
.h265
.RAPPicFlag
!= is_rap_picture(nal_unit_type
))
794 vid_dec_h265_EndFrame(priv
);
795 priv
->picture
.h265
.RAPPicFlag
= is_rap_picture(nal_unit_type
);
797 num_st_rps
= sps
->num_short_term_ref_pic_sets
;
799 if (priv
->picture
.h265
.CurrRpsIdx
!= num_st_rps
)
800 vid_dec_h265_EndFrame(priv
);
801 priv
->picture
.h265
.CurrRpsIdx
= num_st_rps
;
803 if (!first_slice_segment_in_pic_flag
) {
805 int bits_slice_segment_address
= 0;
807 if (pps
->dependent_slice_segments_enabled_flag
)
808 dependent_slice_segment_flag
= vl_rbsp_u(rbsp
, 1);
810 size
= 1 << (sps
->log2_min_luma_coding_block_size_minus3
+ 3 +
811 sps
->log2_diff_max_min_luma_coding_block_size
);
813 num
= ((sps
->pic_width_in_luma_samples
+ size
- 1) / size
) *
814 ((sps
->pic_height_in_luma_samples
+ size
- 1) / size
);
816 while (num
> (1 << bits_slice_segment_address
))
817 bits_slice_segment_address
++;
819 /* slice_segment_address */
820 vl_rbsp_u(rbsp
, bits_slice_segment_address
);
823 if (dependent_slice_segment_flag
)
826 for (i
= 0; i
< pps
->num_extra_slice_header_bits
; ++i
)
827 /* slice_reserved_flag */
833 if (pps
->output_flag_present_flag
)
834 /* pic output flag */
837 if (sps
->separate_colour_plane_flag
)
838 /* colour_plane_id */
841 if (is_idr_picture(nal_unit_type
)) {
842 set_poc(priv
, nal_unit_type
, 0);
846 /* slice_pic_order_cnt_lsb */
848 vl_rbsp_u(rbsp
, sps
->log2_max_pic_order_cnt_lsb_minus4
+ 4);
850 slice_prev_poc
= (int)priv
->codec_data
.h265
.slice_prev_poc
;
851 max_poc_lsb
= 1 << (sps
->log2_max_pic_order_cnt_lsb_minus4
+ 4);
853 prev_poc_lsb
= slice_prev_poc
& (max_poc_lsb
- 1);
854 prev_poc_msb
= slice_prev_poc
- prev_poc_lsb
;
856 if ((poc_lsb
< prev_poc_lsb
) &&
857 ((prev_poc_lsb
- poc_lsb
) >= (max_poc_lsb
/ 2)))
858 poc_msb
= prev_poc_msb
+ max_poc_lsb
;
860 else if ((poc_lsb
> prev_poc_lsb
) &&
861 ((poc_lsb
- prev_poc_lsb
) > (max_poc_lsb
/ 2)))
862 poc_msb
= prev_poc_msb
- max_poc_lsb
;
865 poc_msb
= prev_poc_msb
;
867 if (is_bla_picture(nal_unit_type
))
870 if (get_poc(priv
) != poc_msb
+ poc_lsb
)
871 vid_dec_h265_EndFrame(priv
);
873 set_poc(priv
, nal_unit_type
, (poc_msb
+ poc_lsb
));
875 /* short_term_ref_pic_set_sps_flag */
876 if (!vl_rbsp_u(rbsp
, 1)) {
877 rps
= (struct ref_pic_set
*)
878 priv
->codec_data
.h265
.ref_pic_set_list
+ num_st_rps
;
879 st_ref_pic_set(priv
, rbsp
, rps
, sps
, num_st_rps
);
881 } else if (num_st_rps
> 1) {
885 while ((1 << num_bits
) < num_st_rps
)
889 /* short_term_ref_pic_set_idx */
890 idx
= vl_rbsp_u(rbsp
, num_bits
);
894 rps
= (struct ref_pic_set
*)
895 priv
->codec_data
.h265
.ref_pic_set_list
+ idx
;
897 rps
= (struct ref_pic_set
*)
898 priv
->codec_data
.h265
.ref_pic_set_list
;
900 if (is_bla_picture(nal_unit_type
)) {
901 rps
->num_neg_pics
= 0;
902 rps
->num_pos_pics
= 0;
906 priv
->codec_data
.h265
.rps
= rps
;
911 static void vid_dec_h265_Decode(vid_dec_PrivateType
*priv
,
913 unsigned min_bits_left
)
915 unsigned nal_unit_type
;
916 unsigned nuh_layer_id
;
917 unsigned nuh_temporal_id_plus1
;
919 if (!vl_vlc_search_byte(vlc
, vl_vlc_bits_left(vlc
) - min_bits_left
, 0x00))
922 if (vl_vlc_peekbits(vlc
, 24) != 0x000001) {
923 vl_vlc_eatbits(vlc
, 8);
928 unsigned bytes
= priv
->bytes_left
- (vl_vlc_bits_left(vlc
) / 8);
930 priv
->codec
->decode_bitstream(priv
->codec
, priv
->target
,
931 &priv
->picture
.base
, 1,
932 &priv
->slice
, &bytes
);
936 vl_vlc_eatbits(vlc
, 24);
938 /* forbidden_zero_bit */
939 vl_vlc_eatbits(vlc
, 1);
941 if (vl_vlc_valid_bits(vlc
) < 15)
942 vl_vlc_fillbits(vlc
);
944 nal_unit_type
= vl_vlc_get_uimsbf(vlc
, 6);
947 nuh_layer_id
= vl_vlc_get_uimsbf(vlc
, 6);
949 /* nuh_temporal_id_plus1 */
950 nuh_temporal_id_plus1
= vl_vlc_get_uimsbf(vlc
, 3);
951 priv
->codec_data
.h265
.temporal_id
= nuh_temporal_id_plus1
- 1;
953 if (!is_slice_picture(nal_unit_type
))
954 vid_dec_h265_EndFrame(priv
);
956 if (nal_unit_type
== NAL_UNIT_TYPE_SPS
) {
959 vl_rbsp_init(&rbsp
, vlc
, ~0);
960 seq_parameter_set(priv
, &rbsp
);
962 } else if (nal_unit_type
== NAL_UNIT_TYPE_PPS
) {
965 vl_rbsp_init(&rbsp
, vlc
, ~0);
966 picture_parameter_set(priv
, &rbsp
);
968 } else if (is_slice_picture(nal_unit_type
)) {
969 unsigned bits
= vl_vlc_valid_bits(vlc
);
970 unsigned bytes
= bits
/ 8 + 5;
973 const void *ptr
= buf
;
979 buf
[3] = nal_unit_type
<< 1 | nuh_layer_id
>> 5;
980 buf
[4] = nuh_layer_id
<< 3 | nuh_temporal_id_plus1
;
981 for (i
= 5; i
< bytes
; ++i
)
982 buf
[i
] = vl_vlc_peekbits(vlc
, bits
) >> ((bytes
- i
- 1) * 8);
984 priv
->bytes_left
= (vl_vlc_bits_left(vlc
) - bits
) / 8;
985 priv
->slice
= vlc
->data
;
987 vl_rbsp_init(&rbsp
, vlc
, 128);
988 slice_header(priv
, &rbsp
, nal_unit_type
);
990 vid_dec_h265_BeginFrame(priv
);
992 priv
->codec
->decode_bitstream(priv
->codec
, priv
->target
,
993 &priv
->picture
.base
, 1,
997 /* resync to byte boundary */
998 vl_vlc_eatbits(vlc
, vl_vlc_valid_bits(vlc
) % 8);
1001 void vid_dec_h265_Init(vid_dec_PrivateType
*priv
)
1003 priv
->picture
.base
.profile
= PIPE_VIDEO_PROFILE_HEVC_MAIN
;
1005 list_inithead(&priv
->codec_data
.h265
.dpb_list
);
1006 priv
->codec_data
.h265
.ref_pic_set_list
= (struct ref_pic_set
*)
1007 CALLOC(MAX_NUM_REF_PICS
, sizeof(struct ref_pic_set
));
1009 priv
->Decode
= vid_dec_h265_Decode
;
1010 priv
->EndFrame
= vid_dec_h265_EndFrame
;
1011 priv
->Flush
= vid_dec_h265_Flush
;
1012 priv
->first_buf_in_frame
= true;