2 * H.26L/H.264/AVC/JVT/14496-10/... parameter set decoding
3 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24 * H.264 / AVC / MPEG4 part10 parameter set decoding.
25 * @author Michael Niedermayer <michaelni@gmx.at>
28 #include "libavutil/imgutils.h"
33 #include "h264data.h" //FIXME FIXME FIXME (just for zigzag_scan)
40 static const AVRational pixel_aspect[17]={
60 #define QP(qP,depth) ( (qP)+6*((depth)-8) )
62 #define CHROMA_QP_TABLE_END(d) \
63 QP(0,d), QP(1,d), QP(2,d), QP(3,d), QP(4,d), QP(5,d),\
64 QP(6,d), QP(7,d), QP(8,d), QP(9,d), QP(10,d), QP(11,d),\
65 QP(12,d), QP(13,d), QP(14,d), QP(15,d), QP(16,d), QP(17,d),\
66 QP(18,d), QP(19,d), QP(20,d), QP(21,d), QP(22,d), QP(23,d),\
67 QP(24,d), QP(25,d), QP(26,d), QP(27,d), QP(28,d), QP(29,d),\
68 QP(29,d), QP(30,d), QP(31,d), QP(32,d), QP(32,d), QP(33,d),\
69 QP(34,d), QP(34,d), QP(35,d), QP(35,d), QP(36,d), QP(36,d),\
70 QP(37,d), QP(37,d), QP(37,d), QP(38,d), QP(38,d), QP(38,d),\
71 QP(39,d), QP(39,d), QP(39,d), QP(39,d)
73 const uint8_t ff_h264_chroma_qp[7][QP_MAX_NUM+1] = {
75 CHROMA_QP_TABLE_END(8)
79 CHROMA_QP_TABLE_END(9)
84 CHROMA_QP_TABLE_END(10)
90 CHROMA_QP_TABLE_END(11)
97 CHROMA_QP_TABLE_END(12)
105 CHROMA_QP_TABLE_END(13)
114 CHROMA_QP_TABLE_END(14)
118 static const uint8_t default_scaling4[2][16]={
130 static const uint8_t default_scaling8[2][64]={
131 { 6,10,13,16,18,23,25,27,
132 10,11,16,18,23,25,27,29,
133 13,16,18,23,25,27,29,31,
134 16,18,23,25,27,29,31,33,
135 18,23,25,27,29,31,33,36,
136 23,25,27,29,31,33,36,38,
137 25,27,29,31,33,36,38,40,
138 27,29,31,33,36,38,40,42
140 9,13,15,17,19,21,22,24,
141 13,13,17,19,21,22,24,25,
142 15,17,19,21,22,24,25,27,
143 17,19,21,22,24,25,27,28,
144 19,21,22,24,25,27,28,30,
145 21,22,24,25,27,28,30,32,
146 22,24,25,27,28,30,32,33,
147 24,25,27,28,30,32,33,35
150 static inline int decode_hrd_parameters(H264Context *h, SPS *sps){
151 MpegEncContext * const s = &h->s;
153 cpb_count = get_ue_golomb_31(&s->gb) + 1;
156 av_log(h->s.avctx, AV_LOG_ERROR, "cpb_count %d invalid\n", cpb_count);
160 get_bits(&s->gb, 4); /* bit_rate_scale */
161 get_bits(&s->gb, 4); /* cpb_size_scale */
162 for(i=0; i<cpb_count; i++){
163 get_ue_golomb_long(&s->gb); /* bit_rate_value_minus1 */
164 get_ue_golomb_long(&s->gb); /* cpb_size_value_minus1 */
165 get_bits1(&s->gb); /* cbr_flag */
167 sps->initial_cpb_removal_delay_length = get_bits(&s->gb, 5) + 1;
168 sps->cpb_removal_delay_length = get_bits(&s->gb, 5) + 1;
169 sps->dpb_output_delay_length = get_bits(&s->gb, 5) + 1;
170 sps->time_offset_length = get_bits(&s->gb, 5);
171 sps->cpb_cnt = cpb_count;
175 static inline int decode_vui_parameters(H264Context *h, SPS *sps){
176 MpegEncContext * const s = &h->s;
177 int aspect_ratio_info_present_flag;
178 unsigned int aspect_ratio_idc;
180 aspect_ratio_info_present_flag= get_bits1(&s->gb);
182 if( aspect_ratio_info_present_flag ) {
183 aspect_ratio_idc= get_bits(&s->gb, 8);
184 if( aspect_ratio_idc == EXTENDED_SAR ) {
185 sps->sar.num= get_bits(&s->gb, 16);
186 sps->sar.den= get_bits(&s->gb, 16);
187 }else if(aspect_ratio_idc < FF_ARRAY_ELEMS(pixel_aspect)){
188 sps->sar= pixel_aspect[aspect_ratio_idc];
190 av_log(h->s.avctx, AV_LOG_ERROR, "illegal aspect ratio\n");
197 // s->avctx->aspect_ratio= sar_width*s->width / (float)(s->height*sar_height);
199 if(get_bits1(&s->gb)){ /* overscan_info_present_flag */
200 get_bits1(&s->gb); /* overscan_appropriate_flag */
203 sps->video_signal_type_present_flag = get_bits1(&s->gb);
204 if(sps->video_signal_type_present_flag){
205 get_bits(&s->gb, 3); /* video_format */
206 sps->full_range = get_bits1(&s->gb); /* video_full_range_flag */
208 sps->colour_description_present_flag = get_bits1(&s->gb);
209 if(sps->colour_description_present_flag){
210 sps->color_primaries = get_bits(&s->gb, 8); /* colour_primaries */
211 sps->color_trc = get_bits(&s->gb, 8); /* transfer_characteristics */
212 sps->colorspace = get_bits(&s->gb, 8); /* matrix_coefficients */
213 if (sps->color_primaries >= AVCOL_PRI_NB)
214 sps->color_primaries = AVCOL_PRI_UNSPECIFIED;
215 if (sps->color_trc >= AVCOL_TRC_NB)
216 sps->color_trc = AVCOL_TRC_UNSPECIFIED;
217 if (sps->colorspace >= AVCOL_SPC_NB)
218 sps->colorspace = AVCOL_SPC_UNSPECIFIED;
222 if(get_bits1(&s->gb)){ /* chroma_location_info_present_flag */
223 s->avctx->chroma_sample_location = get_ue_golomb(&s->gb)+1; /* chroma_sample_location_type_top_field */
224 get_ue_golomb(&s->gb); /* chroma_sample_location_type_bottom_field */
227 sps->timing_info_present_flag = get_bits1(&s->gb);
228 if(sps->timing_info_present_flag){
229 sps->num_units_in_tick = get_bits_long(&s->gb, 32);
230 sps->time_scale = get_bits_long(&s->gb, 32);
231 if(!sps->num_units_in_tick || !sps->time_scale){
232 av_log(h->s.avctx, AV_LOG_ERROR, "time_scale/num_units_in_tick invalid or unsupported (%d/%d)\n", sps->time_scale, sps->num_units_in_tick);
235 sps->fixed_frame_rate_flag = get_bits1(&s->gb);
238 sps->nal_hrd_parameters_present_flag = get_bits1(&s->gb);
239 if(sps->nal_hrd_parameters_present_flag)
240 if(decode_hrd_parameters(h, sps) < 0)
242 sps->vcl_hrd_parameters_present_flag = get_bits1(&s->gb);
243 if(sps->vcl_hrd_parameters_present_flag)
244 if(decode_hrd_parameters(h, sps) < 0)
246 if(sps->nal_hrd_parameters_present_flag || sps->vcl_hrd_parameters_present_flag)
247 get_bits1(&s->gb); /* low_delay_hrd_flag */
248 sps->pic_struct_present_flag = get_bits1(&s->gb);
249 if(!get_bits_left(&s->gb))
251 sps->bitstream_restriction_flag = get_bits1(&s->gb);
252 if(sps->bitstream_restriction_flag){
253 get_bits1(&s->gb); /* motion_vectors_over_pic_boundaries_flag */
254 get_ue_golomb(&s->gb); /* max_bytes_per_pic_denom */
255 get_ue_golomb(&s->gb); /* max_bits_per_mb_denom */
256 get_ue_golomb(&s->gb); /* log2_max_mv_length_horizontal */
257 get_ue_golomb(&s->gb); /* log2_max_mv_length_vertical */
258 sps->num_reorder_frames= get_ue_golomb(&s->gb);
259 get_ue_golomb(&s->gb); /*max_dec_frame_buffering*/
261 if (get_bits_left(&s->gb) < 0) {
262 sps->num_reorder_frames=0;
263 sps->bitstream_restriction_flag= 0;
266 if(sps->num_reorder_frames > 16U /*max_dec_frame_buffering || max_dec_frame_buffering > 16*/){
267 av_log(h->s.avctx, AV_LOG_ERROR, "illegal num_reorder_frames %d\n", sps->num_reorder_frames);
272 if (get_bits_left(&s->gb) < 0) {
273 av_log(h->s.avctx, AV_LOG_ERROR, "Overread VUI by %d bits\n", -get_bits_left(&s->gb));
274 return AVERROR_INVALIDDATA;
280 static void decode_scaling_list(H264Context *h, uint8_t *factors, int size,
281 const uint8_t *jvt_list, const uint8_t *fallback_list){
282 MpegEncContext * const s = &h->s;
283 int i, last = 8, next = 8;
284 const uint8_t *scan = size == 16 ? zigzag_scan : ff_zigzag_direct;
285 if(!get_bits1(&s->gb)) /* matrix not written, we use the predicted one */
286 memcpy(factors, fallback_list, size*sizeof(uint8_t));
290 next = (last + get_se_golomb(&s->gb)) & 0xff;
291 if(!i && !next){ /* matrix not written, we use the preset one */
292 memcpy(factors, jvt_list, size*sizeof(uint8_t));
295 last = factors[scan[i]] = next ? next : last;
299 static void decode_scaling_matrices(H264Context *h, SPS *sps, PPS *pps, int is_sps,
300 uint8_t (*scaling_matrix4)[16], uint8_t (*scaling_matrix8)[64]){
301 MpegEncContext * const s = &h->s;
302 int fallback_sps = !is_sps && sps->scaling_matrix_present;
303 const uint8_t *fallback[4] = {
304 fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0],
305 fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1],
306 fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0],
307 fallback_sps ? sps->scaling_matrix8[3] : default_scaling8[1]
309 if(get_bits1(&s->gb)){
310 sps->scaling_matrix_present |= is_sps;
311 decode_scaling_list(h,scaling_matrix4[0],16,default_scaling4[0],fallback[0]); // Intra, Y
312 decode_scaling_list(h,scaling_matrix4[1],16,default_scaling4[0],scaling_matrix4[0]); // Intra, Cr
313 decode_scaling_list(h,scaling_matrix4[2],16,default_scaling4[0],scaling_matrix4[1]); // Intra, Cb
314 decode_scaling_list(h,scaling_matrix4[3],16,default_scaling4[1],fallback[1]); // Inter, Y
315 decode_scaling_list(h,scaling_matrix4[4],16,default_scaling4[1],scaling_matrix4[3]); // Inter, Cr
316 decode_scaling_list(h,scaling_matrix4[5],16,default_scaling4[1],scaling_matrix4[4]); // Inter, Cb
317 if(is_sps || pps->transform_8x8_mode){
318 decode_scaling_list(h,scaling_matrix8[0],64,default_scaling8[0],fallback[2]); // Intra, Y
319 decode_scaling_list(h,scaling_matrix8[3],64,default_scaling8[1],fallback[3]); // Inter, Y
320 if(sps->chroma_format_idc == 3){
321 decode_scaling_list(h,scaling_matrix8[1],64,default_scaling8[0],scaling_matrix8[0]); // Intra, Cr
322 decode_scaling_list(h,scaling_matrix8[4],64,default_scaling8[1],scaling_matrix8[3]); // Inter, Cr
323 decode_scaling_list(h,scaling_matrix8[2],64,default_scaling8[0],scaling_matrix8[1]); // Intra, Cb
324 decode_scaling_list(h,scaling_matrix8[5],64,default_scaling8[1],scaling_matrix8[4]); // Inter, Cb
330 int ff_h264_decode_seq_parameter_set(H264Context *h){
331 MpegEncContext * const s = &h->s;
332 int profile_idc, level_idc, constraint_set_flags = 0;
337 profile_idc= get_bits(&s->gb, 8);
338 constraint_set_flags |= get_bits1(&s->gb) << 0; //constraint_set0_flag
339 constraint_set_flags |= get_bits1(&s->gb) << 1; //constraint_set1_flag
340 constraint_set_flags |= get_bits1(&s->gb) << 2; //constraint_set2_flag
341 constraint_set_flags |= get_bits1(&s->gb) << 3; //constraint_set3_flag
342 constraint_set_flags |= get_bits1(&s->gb) << 4; //constraint_set4_flag
343 constraint_set_flags |= get_bits1(&s->gb) << 5; //constraint_set5_flag
344 get_bits(&s->gb, 2); // reserved
345 level_idc= get_bits(&s->gb, 8);
346 sps_id= get_ue_golomb_31(&s->gb);
348 if(sps_id >= MAX_SPS_COUNT) {
349 av_log(h->s.avctx, AV_LOG_ERROR, "sps_id (%d) out of range\n", sps_id);
352 sps= av_mallocz(sizeof(SPS));
356 sps->time_offset_length = 24;
357 sps->profile_idc= profile_idc;
358 sps->constraint_set_flags = constraint_set_flags;
359 sps->level_idc= level_idc;
360 sps->full_range = -1;
362 memset(sps->scaling_matrix4, 16, sizeof(sps->scaling_matrix4));
363 memset(sps->scaling_matrix8, 16, sizeof(sps->scaling_matrix8));
364 sps->scaling_matrix_present = 0;
365 sps->colorspace = 2; //AVCOL_SPC_UNSPECIFIED
367 if(sps->profile_idc == 100 || sps->profile_idc == 110 ||
368 sps->profile_idc == 122 || sps->profile_idc == 244 || sps->profile_idc == 44 ||
369 sps->profile_idc == 83 || sps->profile_idc == 86 || sps->profile_idc == 118 ||
370 sps->profile_idc == 128 ) {
371 sps->chroma_format_idc= get_ue_golomb_31(&s->gb);
372 if (sps->chroma_format_idc > 3U) {
373 av_log(h->s.avctx, AV_LOG_ERROR, "chroma_format_idc %d is illegal\n", sps->chroma_format_idc);
375 } else if(sps->chroma_format_idc == 3) {
376 sps->residual_color_transform_flag = get_bits1(&s->gb);
377 if(sps->residual_color_transform_flag) {
378 av_log(h->s.avctx, AV_LOG_ERROR, "separate color planes are not supported\n");
382 sps->bit_depth_luma = get_ue_golomb(&s->gb) + 8;
383 sps->bit_depth_chroma = get_ue_golomb(&s->gb) + 8;
384 if (sps->bit_depth_luma > 14U || sps->bit_depth_chroma > 14U) {
385 av_log(h->s.avctx, AV_LOG_ERROR, "illegal bit depth value (%d, %d)\n",
386 sps->bit_depth_luma, sps->bit_depth_chroma);
389 sps->transform_bypass = get_bits1(&s->gb);
390 decode_scaling_matrices(h, sps, NULL, 1, sps->scaling_matrix4, sps->scaling_matrix8);
392 sps->chroma_format_idc= 1;
393 sps->bit_depth_luma = 8;
394 sps->bit_depth_chroma = 8;
397 sps->log2_max_frame_num= get_ue_golomb(&s->gb) + 4;
398 if (sps->log2_max_frame_num < 4 || sps->log2_max_frame_num > 16) {
399 av_log(h->s.avctx, AV_LOG_ERROR, "illegal log2_max_frame_num %d\n",
400 sps->log2_max_frame_num);
404 sps->poc_type= get_ue_golomb_31(&s->gb);
406 if(sps->poc_type == 0){ //FIXME #define
407 unsigned t = get_ue_golomb(&s->gb);
409 av_log(h->s.avctx, AV_LOG_ERROR, "log2_max_poc_lsb (%d) is out of range\n", t);
412 sps->log2_max_poc_lsb= t + 4;
413 } else if(sps->poc_type == 1){//FIXME #define
414 sps->delta_pic_order_always_zero_flag= get_bits1(&s->gb);
415 sps->offset_for_non_ref_pic= get_se_golomb(&s->gb);
416 sps->offset_for_top_to_bottom_field= get_se_golomb(&s->gb);
417 sps->poc_cycle_length = get_ue_golomb(&s->gb);
419 if((unsigned)sps->poc_cycle_length >= FF_ARRAY_ELEMS(sps->offset_for_ref_frame)){
420 av_log(h->s.avctx, AV_LOG_ERROR, "poc_cycle_length overflow %u\n", sps->poc_cycle_length);
424 for(i=0; i<sps->poc_cycle_length; i++)
425 sps->offset_for_ref_frame[i]= get_se_golomb(&s->gb);
426 }else if(sps->poc_type != 2){
427 av_log(h->s.avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
431 sps->ref_frame_count= get_ue_golomb_31(&s->gb);
432 if(sps->ref_frame_count > MAX_PICTURE_COUNT-2 || sps->ref_frame_count > 16U){
433 av_log(h->s.avctx, AV_LOG_ERROR, "too many reference frames\n");
436 sps->gaps_in_frame_num_allowed_flag= get_bits1(&s->gb);
437 sps->mb_width = get_ue_golomb(&s->gb) + 1;
438 sps->mb_height= get_ue_golomb(&s->gb) + 1;
439 if((unsigned)sps->mb_width >= INT_MAX/16 || (unsigned)sps->mb_height >= INT_MAX/16 ||
440 av_image_check_size(16*sps->mb_width, 16*sps->mb_height, 0, h->s.avctx)){
441 av_log(h->s.avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
445 sps->frame_mbs_only_flag= get_bits1(&s->gb);
446 if(!sps->frame_mbs_only_flag)
447 sps->mb_aff= get_bits1(&s->gb);
451 sps->direct_8x8_inference_flag= get_bits1(&s->gb);
453 #ifndef ALLOW_INTERLACE
455 av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF support not included; enable it at compile-time.\n");
457 sps->crop= get_bits1(&s->gb);
459 int crop_vertical_limit = sps->chroma_format_idc & 2 ? 16 : 8;
460 int crop_horizontal_limit = sps->chroma_format_idc == 3 ? 16 : 8;
461 sps->crop_left = get_ue_golomb(&s->gb);
462 sps->crop_right = get_ue_golomb(&s->gb);
463 sps->crop_top = get_ue_golomb(&s->gb);
464 sps->crop_bottom= get_ue_golomb(&s->gb);
465 if(sps->crop_left || sps->crop_top){
466 av_log(h->s.avctx, AV_LOG_ERROR, "insane cropping not completely supported, this could look slightly wrong ... (left: %d, top: %d)\n", sps->crop_left, sps->crop_top);
468 if(sps->crop_right >= crop_horizontal_limit || sps->crop_bottom >= crop_vertical_limit){
469 av_log(h->s.avctx, AV_LOG_ERROR, "brainfart cropping not supported, cropping disabled (right: %d, bottom: %d)\n", sps->crop_right, sps->crop_bottom);
470 /* It is very unlikely that partial cropping will make anybody happy.
471 * Not cropping at all fixes for example playback of Sisvel 3D streams
472 * in applications supporting Sisvel 3D. */
485 sps->vui_parameters_present_flag= get_bits1(&s->gb);
486 if( sps->vui_parameters_present_flag )
487 if (decode_vui_parameters(h, sps) < 0)
493 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
494 static const char csp[4][5] = { "Gray", "420", "422", "444" };
495 av_log(h->s.avctx, AV_LOG_DEBUG, "sps:%u profile:%d/%d poc:%d ref:%d %dx%d %s %s crop:%d/%d/%d/%d %s %s %d/%d b%d\n",
496 sps_id, sps->profile_idc, sps->level_idc,
498 sps->ref_frame_count,
499 sps->mb_width, sps->mb_height,
500 sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
501 sps->direct_8x8_inference_flag ? "8B8" : "",
502 sps->crop_left, sps->crop_right,
503 sps->crop_top, sps->crop_bottom,
504 sps->vui_parameters_present_flag ? "VUI" : "",
505 csp[sps->chroma_format_idc],
506 sps->timing_info_present_flag ? sps->num_units_in_tick : 0,
507 sps->timing_info_present_flag ? sps->time_scale : 0,
512 av_free(h->sps_buffers[sps_id]);
513 h->sps_buffers[sps_id]= sps;
522 build_qp_table(PPS *pps, int t, int index, const int depth)
525 const int max_qp = 51 + 6*(depth-8);
526 for(i = 0; i < max_qp+1; i++)
527 pps->chroma_qp_table[t][i] = ff_h264_chroma_qp[depth-8][av_clip(i + index, 0, max_qp)];
530 static int more_rbsp_data_in_pps(H264Context *h, PPS *pps)
532 const SPS *sps = h->sps_buffers[pps->sps_id];
533 int profile_idc = sps->profile_idc;
535 if ((profile_idc == 66 || profile_idc == 77 ||
536 profile_idc == 88) && (sps->constraint_set_flags & 7)) {
537 av_log(h->s.avctx, AV_LOG_VERBOSE,
538 "Current profile doesn't provide more RBSP data in PPS, skipping\n");
545 int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length){
546 MpegEncContext * const s = &h->s;
547 unsigned int pps_id= get_ue_golomb(&s->gb);
549 const int qp_bd_offset = 6*(h->sps.bit_depth_luma-8);
552 if(pps_id >= MAX_PPS_COUNT) {
553 av_log(h->s.avctx, AV_LOG_ERROR, "pps_id (%d) out of range\n", pps_id);
555 } else if (h->sps.bit_depth_luma > 14) {
556 av_log(h->s.avctx, AV_LOG_ERROR, "Invalid luma bit depth=%d\n", h->sps.bit_depth_luma);
557 return AVERROR_INVALIDDATA;
558 } else if (h->sps.bit_depth_luma == 11 || h->sps.bit_depth_luma == 13) {
559 av_log(h->s.avctx, AV_LOG_ERROR, "Unimplemented luma bit depth=%d\n", h->sps.bit_depth_luma);
560 return AVERROR_PATCHWELCOME;
563 pps= av_mallocz(sizeof(PPS));
566 pps->sps_id= get_ue_golomb_31(&s->gb);
567 if((unsigned)pps->sps_id>=MAX_SPS_COUNT || h->sps_buffers[pps->sps_id] == NULL){
568 av_log(h->s.avctx, AV_LOG_ERROR, "sps_id out of range\n");
572 pps->cabac= get_bits1(&s->gb);
573 pps->pic_order_present= get_bits1(&s->gb);
574 pps->slice_group_count= get_ue_golomb(&s->gb) + 1;
575 if(pps->slice_group_count > 1 ){
576 pps->mb_slice_group_map_type= get_ue_golomb(&s->gb);
577 av_log(h->s.avctx, AV_LOG_ERROR, "FMO not supported\n");
578 switch(pps->mb_slice_group_map_type){
581 | for( i = 0; i <= num_slice_groups_minus1; i++ ) | | |
582 | run_length[ i ] |1 |ue(v) |
587 | for( i = 0; i < num_slice_groups_minus1; i++ ) | | |
589 | top_left_mb[ i ] |1 |ue(v) |
590 | bottom_right_mb[ i ] |1 |ue(v) |
598 | slice_group_change_direction_flag |1 |u(1) |
599 | slice_group_change_rate_minus1 |1 |ue(v) |
604 | slice_group_id_cnt_minus1 |1 |ue(v) |
605 | for( i = 0; i <= slice_group_id_cnt_minus1; i++ | | |
607 | slice_group_id[ i ] |1 |u(v) |
612 pps->ref_count[0]= get_ue_golomb(&s->gb) + 1;
613 pps->ref_count[1]= get_ue_golomb(&s->gb) + 1;
614 if(pps->ref_count[0]-1 > 32-1 || pps->ref_count[1]-1 > 32-1){
615 av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
619 pps->weighted_pred= get_bits1(&s->gb);
620 pps->weighted_bipred_idc= get_bits(&s->gb, 2);
621 pps->init_qp= get_se_golomb(&s->gb) + 26 + qp_bd_offset;
622 pps->init_qs= get_se_golomb(&s->gb) + 26 + qp_bd_offset;
623 pps->chroma_qp_index_offset[0]= get_se_golomb(&s->gb);
624 pps->deblocking_filter_parameters_present= get_bits1(&s->gb);
625 pps->constrained_intra_pred= get_bits1(&s->gb);
626 pps->redundant_pic_cnt_present = get_bits1(&s->gb);
628 pps->transform_8x8_mode= 0;
629 h->dequant_coeff_pps= -1; //contents of sps/pps can change even if id doesn't, so reinit
630 memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4, sizeof(pps->scaling_matrix4));
631 memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8, sizeof(pps->scaling_matrix8));
633 bits_left = bit_length - get_bits_count(&s->gb);
634 if(bits_left > 0 && more_rbsp_data_in_pps(h, pps)){
635 pps->transform_8x8_mode= get_bits1(&s->gb);
636 decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0, pps->scaling_matrix4, pps->scaling_matrix8);
637 pps->chroma_qp_index_offset[1]= get_se_golomb(&s->gb); //second_chroma_qp_index_offset
639 pps->chroma_qp_index_offset[1]= pps->chroma_qp_index_offset[0];
642 build_qp_table(pps, 0, pps->chroma_qp_index_offset[0], h->sps.bit_depth_luma);
643 build_qp_table(pps, 1, pps->chroma_qp_index_offset[1], h->sps.bit_depth_luma);
644 if(pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
645 pps->chroma_qp_diff= 1;
647 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
648 av_log(h->s.avctx, AV_LOG_DEBUG, "pps:%u sps:%u %s slice_groups:%d ref:%d/%d %s qp:%d/%d/%d/%d %s %s %s %s\n",
650 pps->cabac ? "CABAC" : "CAVLC",
651 pps->slice_group_count,
652 pps->ref_count[0], pps->ref_count[1],
653 pps->weighted_pred ? "weighted" : "",
654 pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
655 pps->deblocking_filter_parameters_present ? "LPAR" : "",
656 pps->constrained_intra_pred ? "CONSTR" : "",
657 pps->redundant_pic_cnt_present ? "REDU" : "",
658 pps->transform_8x8_mode ? "8x8DCT" : ""
662 av_free(h->pps_buffers[pps_id]);
663 h->pps_buffers[pps_id]= pps;