vstream/h264.c

   1 /*
   2  * Copyright (C) 2011 Marcelina Kościelnicka <mwk@0x04.net>
   3  * All Rights Reserved.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9  * and/or sell copies of the Software, and to permit persons to whom the
  10  * Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice (including the next
  13  * paragraph) shall be included in all copies or substantial portions of the
  14  * Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  20  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  21  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  22  * OTHER DEALINGS IN THE SOFTWARE.
  23  */
  24
  25 #include "h264.h"
  26 #include "util.h"
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29
  30 void h264_del_seqparm(struct h264_seqparm *seqparm) {
  31         int i, j;
  32         if (seqparm->vui) {
  33                 free(seqparm->vui->nal_hrd_parameters);
  34                 free(seqparm->vui->vcl_hrd_parameters);
  35                 free(seqparm->vui);
  36         }
  37         if (seqparm->is_mvc) {
  38                 free(seqparm->views);
  39                 for (i = 0; i <= seqparm->num_level_values_signalled_minus1; i++) {
  40                         for (j = 0; j <= seqparm->levels[i].num_applicable_ops_minus1; j++) {
  41                                 free(seqparm->levels[i].applicable_ops[j].target_view_id);
  42                         }
  43                         free(seqparm->levels[i].applicable_ops);
  44                 }
  45                 free(seqparm->levels);
  46         }
  47         free(seqparm);
  48 }
  49
  50 void h264_del_picparm(struct h264_picparm *picparm) {
  51         free(picparm->slice_group_id);
  52         free(picparm);
  53 }
  54
  55 void h264_del_slice(struct h264_slice *slice) {
  56         free(slice->dec_ref_pic_marking.mmcos);
  57         free(slice->dec_ref_base_pic_marking.mmcos);
  58         free(slice->sgmap);
  59         free(slice->mbs);
  60         free(slice);
  61 }
  62
  63 int h264_scaling_list(struct bitstream *str, uint32_t *scaling_list, int size, uint32_t *use_default_flag) {
  64         uint32_t lastScale = 8;
  65         uint32_t nextScale = 8;
  66         int32_t delta_scale;
  67         int i;
  68         if (str->dir == VS_DECODE) {
  69                 for (i = 0; i < size; i++) {
  70                         if (nextScale != 0) {
  71                                 if (vs_se(str, &delta_scale)) return 1;
  72                                 nextScale = (lastScale + delta_scale + 256)%256;
  73                                 *use_default_flag = (i == 0 && nextScale == 0);
  74                         }
  75                         lastScale = scaling_list[i] = (nextScale?nextScale:lastScale);
  76                 }
  77         } else {
  78                 int haltidx = size;
  79                 if (*use_default_flag)
  80                         haltidx = 0;
  81                 while (haltidx >= 2 && scaling_list[haltidx-1] == scaling_list[haltidx-2])
  82                         haltidx--;
  83                 for (i = 0; i < haltidx; i++) {
  84                         delta_scale = (scaling_list[i] - lastScale + 256)%256;
  85                         if (delta_scale >= 128)
  86                                 delta_scale -= 256;
  87                         if (vs_se(str, &delta_scale)) return 1;
  88                         lastScale = scaling_list[i];
  89                 }
  90                 if (i != size) {
  91                         delta_scale = (0 - lastScale + 256)%256;
  92                         if (delta_scale >= 128)
  93                                 delta_scale -= 256;
  94                         if (vs_se(str, &delta_scale)) return 1;
  95                 }
  96         }
  97         return 0;
  98 }
  99
 100 int h264_hrd_parameters(struct bitstream *str, struct h264_hrd_parameters *hrd) {
 101         if (vs_ue(str, &hrd->cpb_cnt_minus1)) return 1;
 102         if (hrd->cpb_cnt_minus1 > 31) {
 103                 fprintf(stderr, "cpb_cnt_minus1 out of range\n");
 104                 return 1;
 105         }
 106         if (vs_u(str, &hrd->bit_rate_scale, 4)) return 1;
 107         if (vs_u(str, &hrd->cpb_size_scale, 4)) return 1;
 108         int i;
 109         for (i = 0; i <= hrd->cpb_cnt_minus1; i++) {
 110                 if (vs_ue(str, &hrd->bit_rate_value_minus1[i])) return 1;
 111                 if (vs_ue(str, &hrd->cpb_size_value_minus1[i])) return 1;
 112                 if (vs_u(str, &hrd->cbr_flag[i], 1)) return 1;
 113         }
 114         if (vs_u(str, &hrd->initial_cpb_removal_delay_length_minus1, 5)) return 1;
 115         if (vs_u(str, &hrd->cpb_removal_delay_length_minus1, 5)) return 1;
 116         if (vs_u(str, &hrd->dpb_output_delay_length_minus1, 5)) return 1;
 117         if (vs_u(str, &hrd->time_offset_length, 5)) return 1;
 118         return 0;
 119 }
 120
 121 static const uint32_t aspect_ratios[][2] = {
 122         { 0, 0 },
 123         { 1, 1 },
 124         { 12, 11 },
 125         { 10, 11 },
 126         { 16, 11 },
 127         { 40, 33 },
 128         { 24, 11 },
 129         { 20, 11 },
 130         { 32, 11 },
 131         { 80, 33 },
 132         { 18, 11 },
 133         { 15, 11 },
 134         { 64, 33 },
 135         { 160, 99 },
 136         { 4, 3 },
 137         { 3, 2 },
 138         { 2, 1 },
 139 };
 140
 141 int h264_vui_parameters(struct bitstream *str, struct h264_vui *vui) {
 142         if (vs_u(str, &vui->aspect_ratio_present_flag, 1)) return 1;
 143         if (vui->aspect_ratio_present_flag) {
 144                 if (vs_u(str, &vui->aspect_ratio_idc, 8)) return 1;
 145                 if (vui->aspect_ratio_idc == 255) {
 146                         if (vs_u(str, &vui->sar_width, 16)) return 1;
 147                         if (vs_u(str, &vui->sar_height, 16)) return 1;
 148                 } else {
 149                         if (vui->aspect_ratio_idc < ARRAY_SIZE(aspect_ratios)) {
 150                                 if (vs_infer(str, &vui->sar_width, aspect_ratios[vui->aspect_ratio_idc][0])) return 1;
 151                                 if (vs_infer(str, &vui->sar_width, aspect_ratios[vui->aspect_ratio_idc][1])) return 1;
 152                         } else {
 153                                 fprintf(stderr, "WARNING: unknown aspect_ratio_idc %d\n", vui->aspect_ratio_idc);
 154                                 if (vs_infer(str, &vui->sar_width, 0)) return 1;
 155                                 if (vs_infer(str, &vui->sar_width, 0)) return 1;
 156                         }
 157                 }
 158         } else {
 159                 if (vs_infer(str, &vui->aspect_ratio_idc, 0)) return 1;
 160                 if (vs_infer(str, &vui->sar_width, 0)) return 1;
 161                 if (vs_infer(str, &vui->sar_width, 0)) return 1;
 162         }
 163         if (vs_u(str, &vui->overscan_info_present_flag, 1)) return 1;
 164         if (vui->overscan_info_present_flag) {
 165                 if (vs_u(str, &vui->overscan_appropriate_flag, 1)) return 1;
 166         }
 167         if (vs_u(str, &vui->video_signal_type_present_flag, 1)) return 1;
 168         if (vui->video_signal_type_present_flag) {
 169                 if (vs_u(str, &vui->video_format, 3)) return 1;
 170                 if (vs_u(str, &vui->video_full_range_flag, 1)) return 1;
 171                 if (vs_u(str, &vui->colour_description_present_flag, 1)) return 1;
 172         } else {
 173                 if (vs_infer(str, &vui->video_format, 5)) return 1;
 174                 if (vs_infer(str, &vui->video_full_range_flag, 0)) return 1;
 175                 if (vs_infer(str, &vui->colour_description_present_flag, 0)) return 1;
 176         }
 177         if (vui->colour_description_present_flag) {
 178                 if (vs_u(str, &vui->colour_primaries, 8)) return 1;
 179                 if (vs_u(str, &vui->transfer_characteristics, 8)) return 1;
 180                 if (vs_u(str, &vui->matrix_coefficients, 8)) return 1;
 181         } else {
 182                 if (vs_infer(str, &vui->colour_primaries, 2)) return 1;
 183                 if (vs_infer(str, &vui->transfer_characteristics, 2)) return 1;
 184                 if (vs_infer(str, &vui->matrix_coefficients, 2)) return 1;
 185         }
 186         if (vs_u(str, &vui->chroma_loc_info_present_flag, 1)) return 1;
 187         if (vui->chroma_loc_info_present_flag) {
 188                 if (vs_ue(str, &vui->chroma_sample_loc_type_top_field)) return 1;
 189                 if (vs_ue(str, &vui->chroma_sample_loc_type_bottom_field)) return 1;
 190         } else {
 191                 if (vs_infer(str, &vui->chroma_sample_loc_type_top_field, 0)) return 1;
 192                 if (vs_infer(str, &vui->chroma_sample_loc_type_bottom_field, 0)) return 1;
 193         }
 194         if (vs_u(str, &vui->timing_info_present_flag, 1)) return 1;
 195         if (vui->timing_info_present_flag) {
 196                 if (vs_u(str, &vui->num_units_in_tick, 32)) return 1;
 197                 if (vs_u(str, &vui->time_scale, 32)) return 1;
 198                 if (vs_u(str, &vui->fixed_frame_rate_flag, 1)) return 1;
 199         } else {
 200                 if (vs_infer(str, &vui->fixed_frame_rate_flag, 0)) return 1;
 201         }
 202         uint32_t tmp;
 203         tmp = !!vui->nal_hrd_parameters;
 204         if (vs_u(str, &tmp, 1)) return 1;
 205         if (tmp) {
 206                 if (str->dir == VS_DECODE)
 207                         vui->nal_hrd_parameters = calloc(sizeof *vui->nal_hrd_parameters, 1);
 208                 if (h264_hrd_parameters(str, vui->nal_hrd_parameters)) return 1;
 209         }
 210         tmp = !!vui->vcl_hrd_parameters;
 211         if (vs_u(str, &tmp, 1)) return 1;
 212         if (tmp) {
 213                 if (str->dir == VS_DECODE)
 214                         vui->vcl_hrd_parameters = calloc(sizeof *vui->vcl_hrd_parameters, 1);
 215                 if (h264_hrd_parameters(str, vui->vcl_hrd_parameters)) return 1;
 216         }
 217         if (vui->nal_hrd_parameters || vui->vcl_hrd_parameters) {
 218                 if (vs_u(str, &vui->low_delay_hrd_flag, 1)) return 1;
 219         }
 220         if (vs_u(str, &vui->pic_struct_present_flag, 1)) return 1;
 221         if (vs_u(str, &vui->bitstream_restriction_present_flag, 1)) return 1;
 222         if (vui->bitstream_restriction_present_flag) {
 223                 if (vs_u(str, &vui->motion_vectors_over_pic_bounduaries_flag, 1)) return 1;
 224                 if (vs_ue(str, &vui->max_bytes_per_pic_denom)) return 1;
 225                 if (vs_ue(str, &vui->max_bits_per_mb_denom)) return 1;
 226                 if (vs_ue(str, &vui->log2_max_mv_length_horizontal)) return 1;
 227                 if (vs_ue(str, &vui->log2_max_mv_length_vertical)) return 1;
 228                 if (vs_ue(str, &vui->num_reorder_frames)) return 1;
 229                 if (vs_ue(str, &vui->max_dec_frame_buffering)) return 1;
 230         } else {
 231                 if (vs_infer(str, &vui->motion_vectors_over_pic_bounduaries_flag, 1)) return 1;
 232                 if (vs_infer(str, &vui->max_bytes_per_pic_denom, 2)) return 1;
 233                 if (vs_infer(str, &vui->max_bits_per_mb_denom, 1)) return 1;
 234                 if (vs_infer(str, &vui->log2_max_mv_length_horizontal, 16)) return 1;
 235                 if (vs_infer(str, &vui->log2_max_mv_length_vertical, 16)) return 1;
 236                 /* XXX: not entirely correct */
 237                 if (vs_infer(str, &vui->num_reorder_frames, 16)) return 1;
 238                 if (vs_infer(str, &vui->max_dec_frame_buffering, 16)) return 1;
 239         }
 240         return 0;
 241 }
 242
 243 int h264_seqparm(struct bitstream *str, struct h264_seqparm *seqparm) {
 244         int i;
 245         if (vs_u(str, &seqparm->profile_idc, 8)) return 1;
 246         if (vs_u(str, &seqparm->constraint_set, 8)) return 1;
 247         if (vs_u(str, &seqparm->level_idc, 8)) return 1;
 248         if (vs_ue(str, &seqparm->seq_parameter_set_id)) return 1;
 249         switch (seqparm->profile_idc) {
 250                 case H264_PROFILE_BASELINE:
 251                 case H264_PROFILE_MAIN:
 252                 case H264_PROFILE_EXTENDED:
 253                         if (vs_infer(str, &seqparm->chroma_format_idc, 1)) return 1;
 254                         if (vs_infer(str, &seqparm->separate_colour_plane_flag, 0)) return 1;
 255                         if (vs_infer(str, &seqparm->bit_depth_luma_minus8, 0)) return 1;
 256                         if (vs_infer(str, &seqparm->bit_depth_chroma_minus8, 0)) return 1;
 257                         if (vs_infer(str, &seqparm->qpprime_y_zero_transform_bypass_flag, 0)) return 1;
 258                         if (vs_infer(str, &seqparm->seq_scaling_matrix_present_flag, 0)) return 1;
 259                         break;
 260                 case H264_PROFILE_HIGH:
 261                 case H264_PROFILE_HIGH_10:
 262                 case H264_PROFILE_HIGH_422:
 263                 case H264_PROFILE_HIGH_444_PRED:
 264                 case H264_PROFILE_CAVLC_444:
 265                 case H264_PROFILE_SCALABLE_BASELINE:
 266                 case H264_PROFILE_SCALABLE_HIGH:
 267                 case H264_PROFILE_MULTIVIEW_HIGH:
 268                 case H264_PROFILE_STEREO_HIGH:
 269                         if (vs_ue(str, &seqparm->chroma_format_idc)) return 1;
 270                         if (seqparm->chroma_format_idc == 3) {
 271                                 if (vs_u(str, &seqparm->separate_colour_plane_flag, 1)) return 1;
 272                         } else {
 273                                 if (vs_infer(str, &seqparm->separate_colour_plane_flag, 0)) return 1;
 274                         }
 275                         if (vs_ue(str, &seqparm->bit_depth_luma_minus8)) return 1;
 276                         if (vs_ue(str, &seqparm->bit_depth_chroma_minus8)) return 1;
 277                         if (vs_u(str, &seqparm->qpprime_y_zero_transform_bypass_flag, 1)) return 1;
 278                         if (vs_u(str, &seqparm->seq_scaling_matrix_present_flag, 1)) return 1;
 279                         if (seqparm->seq_scaling_matrix_present_flag) {
 280                                 for (i = 0; i < (seqparm->chroma_format_idc == 3 ? 12 : 8); i++) {
 281                                         if (vs_u(str, &seqparm->seq_scaling_list_present_flag[i], 1)) return 1;
 282                                         if (seqparm->seq_scaling_list_present_flag[i]) {
 283                                                 if (i < 6) {
 284                                                         if (h264_scaling_list(str, seqparm->seq_scaling_list_4x4[i], 16, &seqparm->use_default_scaling_matrix_flag[i])) return 1;;
 285                                                 } else {
 286                                                         if (h264_scaling_list(str, seqparm->seq_scaling_list_8x8[i-6], 64, &seqparm->use_default_scaling_matrix_flag[i])) return 1;;
 287                                                 }
 288                                         }
 289                                 }
 290                         }
 291                         break;
 292                 default:
 293                         fprintf (stderr, "Unknown profile\n");
 294                         return 1;
 295         }
 296         if (vs_ue(str, &seqparm->log2_max_frame_num_minus4)) return 1;
 297         if (vs_ue(str, &seqparm->pic_order_cnt_type)) return 1;
 298         switch (seqparm->pic_order_cnt_type) {
 299                 case 0:
 300                         if (vs_ue(str, &seqparm->log2_max_pic_order_cnt_lsb_minus4)) return 1;
 301                         break;
 302                 case 1:
 303                         if (vs_u(str, &seqparm->delta_pic_order_always_zero_flag, 1)) return 1;
 304                         if (vs_se(str, &seqparm->offset_for_non_ref_pic)) return 1;
 305                         if (vs_se(str, &seqparm->offset_for_top_to_bottom_field)) return 1;
 306                         if (vs_ue(str, &seqparm->num_ref_frames_in_pic_order_cnt_cycle)) return 1;
 307                         for (i = 0; i < seqparm->num_ref_frames_in_pic_order_cnt_cycle; i++) {
 308                                 if (vs_se(str, &seqparm->offset_for_ref_frame[i])) return 1;
 309                         }
 310                         break;
 311         }
 312         if (vs_ue(str, &seqparm->max_num_ref_frames)) return 1;
 313         if (vs_u(str, &seqparm->gaps_in_frame_num_value_allowed_flag, 1)) return 1;
 314         if (vs_ue(str, &seqparm->pic_width_in_mbs_minus1)) return 1;
 315         if (vs_ue(str, &seqparm->pic_height_in_map_units_minus1)) return 1;
 316         if (vs_u(str, &seqparm->frame_mbs_only_flag, 1)) return 1;
 317         if (!seqparm->frame_mbs_only_flag) {
 318                 if (vs_u(str, &seqparm->mb_adaptive_frame_field_flag, 1)) return 1;
 319         } else {
 320                 if (vs_infer(str, &seqparm->mb_adaptive_frame_field_flag, 0)) return 1;
 321         }
 322         if (vs_u(str, &seqparm->direct_8x8_inference_flag, 1)) return 1;
 323         if (vs_u(str, &seqparm->frame_cropping_flag, 1)) return 1;
 324         if (seqparm->frame_cropping_flag) {
 325                 if (vs_ue(str, &seqparm->frame_crop_left_offset)) return 1;
 326                 if (vs_ue(str, &seqparm->frame_crop_right_offset)) return 1;
 327                 if (vs_ue(str, &seqparm->frame_crop_top_offset)) return 1;
 328                 if (vs_ue(str, &seqparm->frame_crop_bottom_offset)) return 1;
 329         } else {
 330                 if (vs_infer(str, &seqparm->frame_crop_left_offset, 0)) return 1;
 331                 if (vs_infer(str, &seqparm->frame_crop_right_offset, 0)) return 1;
 332                 if (vs_infer(str, &seqparm->frame_crop_top_offset, 0)) return 1;
 333                 if (vs_infer(str, &seqparm->frame_crop_bottom_offset, 0)) return 1;
 334         }
 335         uint32_t vui_parameters_present_flag = !!(seqparm->vui);
 336         if (vs_u(str, &vui_parameters_present_flag, 1)) return 1;
 337         if (vui_parameters_present_flag) {
 338                 if (str->dir == VS_DECODE) {
 339                         seqparm->vui = calloc (sizeof *seqparm->vui, 1);
 340                 }
 341                 if (h264_vui_parameters(str, seqparm->vui)) return 1;
 342         } else {
 343                 seqparm->vui = 0;
 344         }
 345         return 0;
 346 }
 347
 348 int h264_svc_vui_parameters(struct bitstream *str, struct h264_vui *vui) {
 349         /* XXX */
 350         abort();
 351         return 0;
 352 }
 353
 354 int h264_seqparm_svc(struct bitstream *str, struct h264_seqparm *seqparm) {
 355         if (str->dir == VS_DECODE)
 356                 seqparm->is_svc = 1;
 357         if (vs_u(str, &seqparm->inter_layer_deblocking_filter_control_present_flag, 1)) return 1;
 358         if (vs_u(str, &seqparm->extended_spatial_scalability_idc, 2)) return 1;
 359         if (seqparm->chroma_format_idc == 1 || seqparm->chroma_format_idc == 2) {
 360                 if (vs_u(str, &seqparm->chroma_phase_x_plus1_flag, 1)) return 1;
 361         } else {
 362                 if (vs_infer(str, &seqparm->chroma_phase_x_plus1_flag, 1)) return 1;
 363         }
 364         if (seqparm->chroma_format_idc == 1) {
 365                 if (vs_u(str, &seqparm->chroma_phase_y_plus1, 2)) return 1;
 366         } else {
 367                 if (vs_infer(str, &seqparm->chroma_phase_y_plus1, 1)) return 1;
 368         }
 369         if (seqparm->extended_spatial_scalability_idc == 1) {
 370                 if (seqparm->chroma_format_idc && !seqparm->separate_colour_plane_flag) {
 371                         if (vs_u(str, &seqparm->seq_ref_layer_chroma_phase_x_plus1_flag, 1)) return 1;
 372                         if (vs_u(str, &seqparm->seq_ref_layer_chroma_phase_y_plus1, 2)) return 1;
 373                 } else {
 374                         if (vs_infer(str, &seqparm->seq_ref_layer_chroma_phase_x_plus1_flag, 1)) return 1;
 375                         if (vs_infer(str, &seqparm->seq_ref_layer_chroma_phase_y_plus1, 1)) return 1;
 376                 }
 377                 if (vs_se(str, &seqparm->seq_ref_layer_left_offset)) return 1;
 378                 if (vs_se(str, &seqparm->seq_ref_layer_top_offset)) return 1;
 379                 if (vs_se(str, &seqparm->seq_ref_layer_right_offset)) return 1;
 380                 if (vs_se(str, &seqparm->seq_ref_layer_bottom_offset)) return 1;
 381         } else {
 382                 if (vs_infer(str, &seqparm->seq_ref_layer_chroma_phase_x_plus1_flag, seqparm->chroma_phase_x_plus1_flag)) return 1;
 383                 if (vs_infer(str, &seqparm->seq_ref_layer_chroma_phase_y_plus1, seqparm->chroma_phase_y_plus1)) return 1;
 384                 if (vs_infers(str, &seqparm->seq_ref_layer_left_offset, 0)) return 1;
 385                 if (vs_infers(str, &seqparm->seq_ref_layer_top_offset, 0)) return 1;
 386                 if (vs_infers(str, &seqparm->seq_ref_layer_right_offset, 0)) return 1;
 387                 if (vs_infers(str, &seqparm->seq_ref_layer_bottom_offset, 0)) return 1;
 388         }
 389         if (vs_u(str, &seqparm->seq_tcoeff_level_prediction_flag, 1)) return 1;
 390         if (seqparm->seq_tcoeff_level_prediction_flag) {
 391                 if (vs_u(str, &seqparm->adaptive_tcoeff_level_prediction_flag, 1)) return 1;
 392         } else {
 393                 if (vs_infer(str, &seqparm->adaptive_tcoeff_level_prediction_flag, 0)) return 1;
 394         }
 395         if (vs_u(str, &seqparm->slice_header_restriction_flag, 1)) return 1;
 396         uint32_t svc_vui_parameters_present_flag = !!(seqparm->svc_vui);
 397         if (vs_u(str, &svc_vui_parameters_present_flag, 1)) return 1;
 398         if (svc_vui_parameters_present_flag) {
 399                 if (str->dir == VS_DECODE) {
 400                         seqparm->svc_vui = calloc (sizeof *seqparm->svc_vui, 1);
 401                 }
 402                 if (h264_svc_vui_parameters(str, seqparm->svc_vui)) return 1;
 403         } else {
 404                 seqparm->svc_vui = 0;
 405         }
 406         return 0;
 407 }
 408
 409 int h264_mvc_vui_parameters(struct bitstream *str, struct h264_vui *vui) {
 410         /* XXX */
 411         abort();
 412         return 0;
 413 }
 414
 415 int h264_seqparm_mvc(struct bitstream *str, struct h264_seqparm *seqparm) {
 416         uint32_t bit_equal_to_one = 1;
 417         int i, j, k;
 418         if (str->dir == VS_DECODE)
 419                 seqparm->is_mvc = 1;
 420         if (vs_u(str, &bit_equal_to_one, 1)) return 1;
 421         if (!bit_equal_to_one) {
 422                 fprintf(stderr, "bit_equal_to_one invalid\n");
 423                 return 1;
 424         }
 425         if (vs_ue(str, &seqparm->num_views_minus1)) return 1;
 426         if (str->dir == VS_DECODE)
 427                 seqparm->views = calloc(sizeof *seqparm->views, seqparm->num_views_minus1 + 1);
 428         for (i = 0; i <= seqparm->num_views_minus1; i++)
 429                 if (vs_ue(str, &seqparm->views[i].view_id)) return 1;
 430         for (i = 1; i <= seqparm->num_views_minus1; i++) {
 431                 if (vs_ue(str, &seqparm->views[i].num_anchor_refs_l0)) return 1;
 432                 if (seqparm->views[i].num_anchor_refs_l0 > 15) {
 433                         fprintf (stderr, "num_anchor_refs_l0 over limit\n");
 434                         return 1;
 435                 }
 436                 for (j = 0; j < seqparm->views[i].num_anchor_refs_l0; j++)
 437                         if (vs_ue(str, &seqparm->views[i].anchor_ref_l0[j])) return 1;
 438                 if (vs_ue(str, &seqparm->views[i].num_anchor_refs_l1)) return 1;
 439                 if (seqparm->views[i].num_anchor_refs_l1 > 15) {
 440                         fprintf (stderr, "num_anchor_refs_l1 over limit\n");
 441                         return 1;
 442                 }
 443                 for (j = 0; j < seqparm->views[i].num_anchor_refs_l1; j++)
 444                         if (vs_ue(str, &seqparm->views[i].anchor_ref_l1[j])) return 1;
 445         }
 446         for (i = 1; i <= seqparm->num_views_minus1; i++) {
 447                 if (vs_ue(str, &seqparm->views[i].num_non_anchor_refs_l0)) return 1;
 448                 if (seqparm->views[i].num_non_anchor_refs_l0 > 15) {
 449                         fprintf (stderr, "num_non_anchor_refs_l0 over limit\n");
 450                         return 1;
 451                 }
 452                 for (j = 0; j < seqparm->views[i].num_non_anchor_refs_l0; j++)
 453                         if (vs_ue(str, &seqparm->views[i].non_anchor_ref_l0[j])) return 1;
 454                 if (vs_ue(str, &seqparm->views[i].num_non_anchor_refs_l1)) return 1;
 455                 if (seqparm->views[i].num_non_anchor_refs_l1 > 15) {
 456                         fprintf (stderr, "num_non_anchor_refs_l1 over limit\n");
 457                         return 1;
 458                 }
 459                 for (j = 0; j < seqparm->views[i].num_non_anchor_refs_l1; j++)
 460                         if (vs_ue(str, &seqparm->views[i].non_anchor_ref_l1[j])) return 1;
 461         }
 462         if (vs_ue(str, &seqparm->num_level_values_signalled_minus1)) return 1;
 463         if (str->dir == VS_DECODE)
 464                 seqparm->levels = calloc(sizeof *seqparm->levels, seqparm->num_level_values_signalled_minus1 + 1);
 465         for (i = 0; i <= seqparm->num_level_values_signalled_minus1; i++) {
 466                 if (vs_u(str, &seqparm->levels[i].level_idc, 8)) return 1;
 467                 if (vs_ue(str, &seqparm->levels[i].num_applicable_ops_minus1)) return 1;
 468                 if (str->dir == VS_DECODE)
 469                         seqparm->levels[i].applicable_ops = calloc(sizeof *seqparm->levels[i].applicable_ops, seqparm->levels[i].num_applicable_ops_minus1 + 1);
 470                 for (j = 0; j <= seqparm->levels[i].num_applicable_ops_minus1; j++) {
 471                         if (vs_u(str, &seqparm->levels[i].applicable_ops[j].temporal_id, 3)) return 1;
 472                         if (vs_ue(str, &seqparm->levels[i].applicable_ops[j].num_target_views_minus1)) return 1;
 473                         if (str->dir == VS_DECODE)
 474                                 seqparm->levels[i].applicable_ops[j].target_view_id = calloc(sizeof *seqparm->levels[i].applicable_ops[j].target_view_id, seqparm->levels[i].applicable_ops[j].num_target_views_minus1 + 1);
 475                         for (k = 0; k <= seqparm->levels[i].applicable_ops[j].num_target_views_minus1; k++)
 476                                 if (vs_ue(str, &seqparm->levels[i].applicable_ops[j].target_view_id[k])) return 1;
 477                         if (vs_ue(str, &seqparm->levels[i].applicable_ops[j].num_views_minus1)) return 1;
 478                 }
 479         }
 480         uint32_t mvc_vui_parameters_present_flag = !!(seqparm->mvc_vui);
 481         if (vs_u(str, &mvc_vui_parameters_present_flag, 1)) return 1;
 482         if (mvc_vui_parameters_present_flag) {
 483                 if (str->dir == VS_DECODE) {
 484                         seqparm->mvc_vui = calloc (sizeof *seqparm->mvc_vui, 1);
 485                 }
 486                 if (h264_mvc_vui_parameters(str, seqparm->mvc_vui)) return 1;
 487         } else {
 488                 seqparm->mvc_vui = 0;
 489         }
 490         return 0;
 491 }
 492
 493 int h264_seqparm_ext(struct bitstream *str, struct h264_seqparm **seqparms, uint32_t *pseq_parameter_set_id) {
 494         if (vs_ue(str, pseq_parameter_set_id)) return 1;
 495         if (*pseq_parameter_set_id > 31) {
 496                 fprintf(stderr, "seq_parameter_set_id out of bounds\n");
 497                 return 1;
 498         }
 499         struct h264_seqparm *seqparm = seqparms[*pseq_parameter_set_id];
 500         if (!seqparm) {
 501                 fprintf(stderr, "seqparm extension for nonexistent seqparm\n");
 502                 return 1;
 503         }
 504         if (vs_ue(str, &seqparm->aux_format_idc)) return 1;
 505         if (seqparm->aux_format_idc) {
 506                 if (vs_ue(str, &seqparm->bit_depth_aux_minus8)) return 1;
 507                 if (vs_u(str, &seqparm->alpha_incr_flag, 1)) return 1;
 508                 if (vs_u(str, &seqparm->alpha_opaque_value, seqparm->bit_depth_aux_minus8 + 9)) return 1;
 509                 if (vs_u(str, &seqparm->alpha_transparent_value, seqparm->bit_depth_aux_minus8 + 9)) return 1;
 510         }
 511         uint32_t additional_extension_flag = 0;
 512         if (vs_u(str, &additional_extension_flag, 1)) return 1;
 513         if (additional_extension_flag) {
 514                 fprintf(stderr, "WARNING: additional data in seqparm extension\n");
 515                 while (vs_has_more_data(str)) {
 516                         if (vs_u(str, &additional_extension_flag, 1)) return 1;
 517                 }
 518         }
 519         if (str->dir == VS_DECODE)
 520                 seqparm->has_ext = 1;
 521         return 0;
 522 }
 523
 524 int h264_picparm(struct bitstream *str, struct h264_seqparm **seqparms, struct h264_seqparm **subseqparms, struct h264_picparm *picparm) {
 525         int i;
 526         if (vs_ue(str, &picparm->pic_parameter_set_id)) return 1;
 527         if (vs_ue(str, &picparm->seq_parameter_set_id)) return 1;
 528         if (picparm->seq_parameter_set_id > 31) {
 529                 fprintf(stderr, "seq_parameter_set_id out of bounds\n");
 530                 return 1;
 531         }
 532         if (vs_u(str, &picparm->entropy_coding_mode_flag, 1)) return 1;
 533         if (vs_u(str, &picparm->bottom_field_pic_order_in_frame_present_flag, 1)) return 1;
 534         if (vs_ue(str, &picparm->num_slice_groups_minus1)) return 1;
 535         if (picparm->num_slice_groups_minus1) {
 536                 if (picparm->num_slice_groups_minus1 > 7) {
 537                         fprintf(stderr, "num_slice_groups_minus1 over limit\n");
 538                         return 1;
 539                 }
 540                 if (vs_ue(str, &picparm->slice_group_map_type)) return 1;
 541                 switch (picparm->slice_group_map_type) {
 542                         case H264_SLICE_GROUP_MAP_INTERLEAVED:
 543                                 for (i = 0; i <= picparm->num_slice_groups_minus1; i++)
 544                                         if (vs_ue(str, &picparm->run_length_minus1[i])) return 1;
 545
 546                                 break;
 547                         case H264_SLICE_GROUP_MAP_DISPERSED:
 548                                 break;
 549                         case H264_SLICE_GROUP_MAP_FOREGROUND:
 550                                 for (i = 0; i < picparm->num_slice_groups_minus1; i++) {
 551                                         if (vs_ue(str, &picparm->top_left[i])) return 1;
 552                                         if (vs_ue(str, &picparm->bottom_right[i])) return 1;
 553
 554                                 }
 555                                 break;
 556                         case H264_SLICE_GROUP_MAP_CHANGING_BOX:
 557                         case H264_SLICE_GROUP_MAP_CHANGING_VERTICAL:
 558                         case H264_SLICE_GROUP_MAP_CHANGING_HORIZONTAL:
 559                                 if (vs_u(str, &picparm->slice_group_change_direction_flag, 1)) return 1;
 560                                 if (vs_ue(str, &picparm->slice_group_change_rate_minus1)) return 1;
 561                                 break;
 562                         case H264_SLICE_GROUP_MAP_EXPLICIT:
 563                                 if (vs_ue(str, &picparm->pic_size_in_map_units_minus1)) return 1;
 564                                 if (str->dir == VS_DECODE)
 565                                         picparm->slice_group_id = calloc(sizeof *picparm->slice_group_id, picparm->pic_size_in_map_units_minus1 + 1);
 566                                 static const int sizes[8] = { 0, 1, 2, 2, 3, 3, 3, 3 };
 567                                 for (i = 0; i <= picparm->pic_size_in_map_units_minus1; i++)
 568                                         if (vs_u(str, &picparm->slice_group_id[i], sizes[picparm->num_slice_groups_minus1])) return 1;
 569                                 break;
 570                         default:
 571                                 fprintf(stderr, "Unknown slice_group_map_type %d!\n", picparm->slice_group_map_type);
 572                                 return 1;
 573                 }
 574         }
 575         if (vs_ue(str, &picparm->num_ref_idx_l0_default_active_minus1)) return 1;
 576         if (vs_ue(str, &picparm->num_ref_idx_l1_default_active_minus1)) return 1;
 577         if (vs_u(str, &picparm->weighted_pred_flag, 1)) return 1;
 578         if (vs_u(str, &picparm->weighted_bipred_idc, 2)) return 1;
 579         if (vs_se(str, &picparm->pic_init_qp_minus26)) return 1;
 580         if (vs_se(str, &picparm->pic_init_qs_minus26)) return 1;
 581         if (vs_se(str, &picparm->chroma_qp_index_offset)) return 1;
 582         if (vs_u(str, &picparm->deblocking_filter_control_present_flag, 1)) return 1;
 583         if (vs_u(str, &picparm->constrained_intra_pred_flag, 1)) return 1;
 584         if (vs_u(str, &picparm->redundant_pic_cnt_present_flag, 1)) return 1;
 585         int more;
 586         if (str->dir == VS_ENCODE) {
 587                 more = picparm->transform_8x8_mode_flag || picparm->pic_scaling_matrix_present_flag || picparm->second_chroma_qp_index_offset != picparm->chroma_qp_index_offset;
 588         } else {
 589                 more = vs_has_more_data(str);
 590         }
 591         if (more) {
 592                 if (vs_u(str, &picparm->transform_8x8_mode_flag, 1)) return 1;
 593                 if (vs_u(str, &picparm->pic_scaling_matrix_present_flag, 1)) return 1;
 594                 if (picparm->pic_scaling_matrix_present_flag) {
 595                         /* brain damage workaround start */
 596                         struct h264_seqparm *seqparm = seqparms[picparm->seq_parameter_set_id], *subseqparm = subseqparms[picparm->seq_parameter_set_id];;
 597                         if (seqparm) {
 598                                 picparm->chroma_format_idc = seqparm->chroma_format_idc;
 599                                 if (subseqparm) {
 600                                         if (subseqparm->chroma_format_idc != picparm->chroma_format_idc) {
 601                                                 fprintf(stderr, "conflicting chroma_format_idc between seqparm and subseqparm, please complain to ITU/ISO about retarded spec and to bitstream source about retarded bitstream.\n");
 602                                                 return 1;
 603                                         }
 604                                 }
 605                         } else if (subseqparm) {
 606                                 picparm->chroma_format_idc = subseqparm->chroma_format_idc;
 607                         } else {
 608                                 fprintf(stderr, "picparm for nonexistent seqparm/subseqparm!\n");
 609                                 return 1;
 610                         }
 611                         /* brain damage workaround end */
 612                         int i;
 613                         for (i = 0; i < (picparm->chroma_format_idc == 3 ? 12 : 8); i++) {
 614                                 if (vs_u(str, &picparm->pic_scaling_list_present_flag[i], 1)) return 1;
 615                                 if (picparm->pic_scaling_list_present_flag[i]) {
 616                                         if (i < 6) {
 617                                                 if (h264_scaling_list(str, picparm->pic_scaling_list_4x4[i], 16, &picparm->use_default_scaling_matrix_flag[i])) return 1;;
 618                                         } else {
 619                                                 if (h264_scaling_list(str, picparm->pic_scaling_list_8x8[i-6], 64, &picparm->use_default_scaling_matrix_flag[i])) return 1;;
 620                                         }
 621                                 }
 622                         }
 623                 }
 624                 if (vs_se(str, &picparm->second_chroma_qp_index_offset)) return 1;
 625         } else {
 626                 if (vs_infer(str, &picparm->transform_8x8_mode_flag, 0)) return 1;
 627                 if (vs_infer(str, &picparm->pic_scaling_matrix_present_flag, 0)) return 1;
 628                 if (vs_infers(str, &picparm->second_chroma_qp_index_offset, picparm->chroma_qp_index_offset)) return 1;
 629         }
 630         return 0;
 631 }
 632
 633 int h264_ref_pic_list_modification(struct bitstream *str, struct h264_slice *slice, struct h264_ref_pic_list_modification *list) {
 634         int i;
 635         if (vs_u(str, &list->flag, 1)) return 1;
 636         if (list->flag) {
 637                 i = 0;
 638                 do {
 639                         if (vs_ue(str, &list->list[i].op)) return 1;
 640                         if (list->list[i].op != 3) {
 641                                 if (vs_ue(str, &list->list[i].param)) return 1;
 642                                 if (i == 32) {
 643                                         fprintf(stderr, "Too many ref_pic_list_modification entries\n");
 644                                         return 1;
 645                                 }
 646                         }
 647                 } while (list->list[i++].op != 3);
 648         } else {
 649                 if (vs_infer(str, &list->list[0].op, 3)) return 1;
 650         }
 651         return 0;
 652 }
 653
 654 int h264_dec_ref_pic_marking(struct bitstream *str, int idr_pic_flag, struct h264_dec_ref_pic_marking *ref) {
 655         if (idr_pic_flag) {
 656                 if (vs_u(str, &ref->no_output_of_prior_pics_flag, 1)) return 1;
 657                 if (vs_u(str, &ref->long_term_reference_flag, 1)) return 1;
 658         } else {
 659                 if (vs_u(str, &ref->adaptive_ref_pic_marking_mode_flag, 1)) return 1;
 660                 if (ref->adaptive_ref_pic_marking_mode_flag) {
 661                         struct h264_mmco_entry mmco;
 662                         int i = 0;
 663                         do {
 664                                 if (str->dir == VS_ENCODE)
 665                                         mmco = ref->mmcos[i];
 666                                 if (vs_ue(str, &mmco.memory_management_control_operation)) return 1;
 667                                 switch (mmco.memory_management_control_operation) {
 668                                         case H264_MMCO_END:
 669                                                 break;
 670                                         case H264_MMCO_FORGET_SHORT:
 671                                                 if (vs_ue(str, &mmco.difference_of_pic_nums_minus1)) return 1;
 672                                                 break;
 673                                         case H264_MMCO_FORGET_LONG:
 674                                                 if (vs_ue(str, &mmco.long_term_pic_num)) return 1;
 675                                                 break;
 676                                         case H264_MMCO_SHORT_TO_LONG:
 677                                                 if (vs_ue(str, &mmco.difference_of_pic_nums_minus1)) return 1;
 678                                                 if (vs_ue(str, &mmco.long_term_frame_idx)) return 1;
 679                                                 break;
 680                                         case H264_MMCO_FORGET_LONG_MANY:
 681                                                 if (vs_ue(str, &mmco.max_long_term_frame_idx_plus1)) return 1;
 682                                                 break;
 683                                         case H264_MMCO_FORGET_ALL:
 684                                                 break;
 685                                         case H264_MMCO_THIS_TO_LONG:
 686                                                 if (vs_ue(str, &mmco.long_term_frame_idx)) return 1;
 687                                                 break;
 688                                         default:
 689                                                 fprintf (stderr, "Unknown MMCO %d\n", mmco.memory_management_control_operation);
 690                                                 return 1;
 691                                 }
 692                                 if (str->dir == VS_DECODE)
 693                                         ADDARRAY(ref->mmcos, mmco);
 694                                 i++;
 695                         } while (mmco.memory_management_control_operation != H264_MMCO_END);
 696                 }
 697         }
 698         return 0;
 699 }
 700
 701 int h264_dec_ref_base_pic_marking(struct bitstream *str, struct h264_nal_svc_header *svc, struct h264_dec_ref_base_pic_marking *ref) {
 702         if (vs_u(str, &ref->store_ref_base_pic_flag, 1)) return 1;
 703         if ((svc->use_ref_base_pic_flag || ref->store_ref_base_pic_flag) && !svc->idr_flag) {
 704                 if (vs_u(str, &ref->adaptive_ref_base_pic_marking_mode_flag, 1)) return 1;
 705                 if (ref->adaptive_ref_base_pic_marking_mode_flag) {
 706                         struct h264_mmco_entry mmco;
 707                         int i = 0;
 708                         do {
 709                                 if (str->dir == VS_ENCODE)
 710                                         mmco = ref->mmcos[i];
 711                                 if (vs_ue(str, &mmco.memory_management_control_operation)) return 1;
 712                                 switch (mmco.memory_management_control_operation) {
 713                                         case H264_MMCO_END:
 714                                                 break;
 715                                         case H264_MMCO_FORGET_SHORT:
 716                                                 if (vs_ue(str, &mmco.difference_of_pic_nums_minus1)) return 1;
 717                                                 break;
 718                                         case H264_MMCO_FORGET_LONG:
 719                                                 if (vs_ue(str, &mmco.long_term_pic_num)) return 1;
 720                                                 break;
 721                                         default:
 722                                                 fprintf (stderr, "Unknown MMCO %d\n", mmco.memory_management_control_operation);
 723                                                 return 1;
 724                                 }
 725                                 if (str->dir == VS_DECODE)
 726                                         ADDARRAY(ref->mmcos, mmco);
 727                                 i++;
 728                         } while (mmco.memory_management_control_operation != H264_MMCO_END);
 729                 }
 730         }
 731         return 0;
 732 }
 733
 734 int h264_prep_sgmap(struct h264_slice *slice) {
 735         if (slice->sgmap)
 736                 return 0;
 737         int width = slice->seqparm->pic_width_in_mbs_minus1 + 1;
 738         int height = slice->seqparm->pic_height_in_map_units_minus1 + 1;
 739         int i, j, k;
 740         int num = slice->picparm->num_slice_groups_minus1 + 1;
 741         slice->sgmap = calloc(sizeof *slice->sgmap, width * height);
 742         j = 0, k = 0;
 743         int musg0 = slice->slice_group_change_cycle * (slice->picparm->slice_group_change_rate_minus1 + 1);
 744         if (musg0 > width * height)
 745                 musg0 = width * height;
 746         int sulg = musg0;
 747         if (slice->picparm->slice_group_change_direction_flag)
 748                 sulg = width * height - sulg;
 749         for (i = 0; i < width * height; i++) {
 750                 int x = i % width;
 751                 int y = i / width;
 752                 switch (slice->picparm->slice_group_map_type) {
 753                         case H264_SLICE_GROUP_MAP_INTERLEAVED:
 754                                 slice->sgmap[i] = j;
 755                                 if (k == slice->picparm->run_length_minus1[j]) {
 756                                         k = 0;
 757                                         j++;
 758                                         j %= num;
 759                                 } else {
 760                                         k++;
 761                                 }
 762                                 break;
 763                         case H264_SLICE_GROUP_MAP_DISPERSED:
 764                                 slice->sgmap[i] = (x + ((y * num) / 2)) % num;
 765                                 break;
 766                         case H264_SLICE_GROUP_MAP_FOREGROUND:
 767                                 slice->sgmap[i] = num-1;
 768                                 for (j = num - 2; j >= 0; j--) {
 769                                         int xtl = slice->picparm->top_left[j] % slice->pic_width_in_mbs;
 770                                         int ytl = slice->picparm->top_left[j] / slice->pic_width_in_mbs;
 771                                         int xbr = slice->picparm->bottom_right[j] % slice->pic_width_in_mbs;
 772                                         int ybr = slice->picparm->bottom_right[j] / slice->pic_width_in_mbs;
 773                                         if (x >= xtl && x <= xbr && y >= ytl && y <= ybr)
 774                                                 slice->sgmap[i] = j;
 775                                 }
 776                                 break;
 777                         case H264_SLICE_GROUP_MAP_CHANGING_BOX:
 778                                 slice->sgmap[i] = 1;
 779                                 /* will be fixed below */
 780                                 break;
 781                         case H264_SLICE_GROUP_MAP_CHANGING_VERTICAL:
 782                                 slice->sgmap[i] = slice->picparm->slice_group_change_direction_flag ^ (i >= sulg);
 783                                 break;
 784                         case H264_SLICE_GROUP_MAP_CHANGING_HORIZONTAL:
 785                                 k = x * height + y;
 786                                 slice->sgmap[i] = slice->picparm->slice_group_change_direction_flag ^ (k >= sulg);
 787                                 break;
 788                         case H264_SLICE_GROUP_MAP_EXPLICIT:
 789                                 if (width * height != slice->picparm->pic_size_in_map_units_minus1 + 1) {
 790                                         fprintf(stderr, "pic_size_in_map_units_minus1 mismatch!\n");
 791                                         return 1;
 792                                 }
 793                                 slice->sgmap[i] = slice->picparm->slice_group_id[i];
 794                                 break;
 795                         default:
 796                                 abort();
 797                 }
 798         }
 799         if (slice->picparm->slice_group_map_type == H264_SLICE_GROUP_MAP_CHANGING_BOX) {
 800                 int cdf = slice->picparm->slice_group_change_direction_flag;
 801                 int x = (width - cdf) / 2;
 802                 int y = (height - cdf) / 2;
 803                 int xmin = x, xmax = x;
 804                 int ymin = y, ymax = y;
 805                 int xdir = cdf - 1;
 806                 int ydir = cdf;
 807                 int muv;
 808                 for (k = 0; k < musg0; k += muv) {
 809                         muv = slice->sgmap[y * width + x];
 810                         slice->sgmap[y * width + x] = 0;
 811                         if (xdir == -1 && x == xmin) {
 812                                 if (xmin)
 813                                         xmin--;
 814                                 x = xmin;
 815                                 xdir = 0;
 816                                 ydir = 2 * cdf - 1;
 817                         } else if (xdir == 1 && x == xmax) {
 818                                 if (xmax != width - 1)
 819                                         xmax++;
 820                                 x = xmax;
 821                                 xdir = 0;
 822                                 ydir = 1 - 2 * cdf;
 823                         } else if (ydir == -1 && y == ymin) {
 824                                 if (ymin)
 825                                         ymin--;
 826                                 y = ymin;
 827                                 xdir = 1 - 2 * cdf;
 828                                 ydir = 0;
 829                         } else if (ydir == 1 && y == ymax) {
 830                                 if (ymax != height - 1)
 831                                         ymax++;
 832                                 y = ymax;
 833                                 xdir = 2 * cdf - 1;
 834                                 ydir = 0;
 835                         } else {
 836                                 x += xdir;
 837                                 y += ydir;
 838                         }
 839                 }
 840         }
 841         return 0;
 842 }
 843
 844 int h264_slice_header(struct bitstream *str, struct h264_seqparm **seqparms, struct h264_picparm **picparms, struct h264_slice *slice) {
 845         if (vs_ue(str, &slice->first_mb_in_slice)) return 1;
 846         uint32_t slice_type = slice->slice_type + slice->slice_all_same * 5;
 847         if (vs_ue(str, &slice_type)) return 1;
 848         slice->slice_type = slice_type % 5;
 849         slice->slice_all_same = slice_type / 5;
 850         uint32_t pic_parameter_set_id;
 851         if (str->dir == VS_ENCODE)
 852                 pic_parameter_set_id = slice->picparm->pic_parameter_set_id;
 853         if (vs_ue(str, &pic_parameter_set_id)) return 1;
 854         if (str->dir == VS_DECODE) {
 855                 if (pic_parameter_set_id > 255) {
 856                         fprintf(stderr, "pic_parameter_set_id out of range\n");
 857                         return 1;
 858                 }
 859                 slice->picparm = picparms[pic_parameter_set_id];
 860                 if (!slice->picparm) {
 861                         fprintf(stderr, "pic_parameter_set_id doesn't specify a picparm\n");
 862                         return 1;
 863                 }
 864                 slice->seqparm = seqparms[slice->picparm->seq_parameter_set_id];
 865                 if (!slice->seqparm) {
 866                         fprintf(stderr, "seq_parameter_set_id doesn't specify a seqparm\n");
 867                         return 1;
 868                 }
 869                 if (slice->nal_unit_type == H264_NAL_UNIT_TYPE_SLICE_AUX) {
 870                         slice->chroma_array_type = 0;
 871                         slice->bit_depth_luma_minus8 = slice->seqparm->bit_depth_aux_minus8;
 872                         slice->bit_depth_chroma_minus8 = 0;
 873                 } else {
 874                         slice->chroma_array_type = (slice->seqparm->separate_colour_plane_flag?0:slice->seqparm->chroma_format_idc);
 875                         slice->bit_depth_luma_minus8 = slice->seqparm->bit_depth_luma_minus8;
 876                         slice->bit_depth_chroma_minus8 = slice->seqparm->bit_depth_chroma_minus8;
 877                 }
 878                 slice->pic_width_in_mbs = slice->seqparm->pic_width_in_mbs_minus1 + 1;
 879         }
 880         if (slice->seqparm->separate_colour_plane_flag)
 881                 if (vs_u(str, &slice->colour_plane_id, 2)) return 1;
 882         if (vs_u(str, &slice->frame_num, slice->seqparm->log2_max_frame_num_minus4 + 4)) return 1;
 883         if (!slice->seqparm->frame_mbs_only_flag) {
 884                 if (vs_u(str, &slice->field_pic_flag, 1)) return 1;
 885         } else {
 886                 if (vs_infer(str, &slice->field_pic_flag, 0)) return 1;
 887         }
 888         if (slice->field_pic_flag) {
 889                 if (vs_u(str, &slice->bottom_field_flag, 1)) return 1;
 890         } else {
 891                 if (vs_infer(str, &slice->bottom_field_flag, 0)) return 1;
 892         }
 893         slice->pic_height_in_mbs = (slice->seqparm->pic_height_in_map_units_minus1 + 1);
 894         if (!slice->seqparm->frame_mbs_only_flag)
 895                 slice->pic_height_in_mbs *= 2;
 896         if (slice->field_pic_flag)
 897                 slice->pic_height_in_mbs /= 2;
 898         slice->pic_size_in_mbs = slice->pic_width_in_mbs * slice->pic_height_in_mbs;
 899         if (str->dir == VS_DECODE) {
 900                 slice->mbaff_frame_flag = slice->seqparm->mb_adaptive_frame_field_flag && !slice->field_pic_flag;
 901         }
 902         if (slice->idr_pic_flag) {
 903                 if (vs_ue(str, &slice->idr_pic_id)) return 1;
 904         }
 905         switch (slice->seqparm->pic_order_cnt_type) {
 906                 case 0:
 907                         if (vs_u(str, &slice->pic_order_cnt_lsb, slice->seqparm->log2_max_pic_order_cnt_lsb_minus4 + 4)) return 1;
 908                         if (slice->picparm->bottom_field_pic_order_in_frame_present_flag && !slice->field_pic_flag) {
 909                                 if (vs_se(str, &slice->delta_pic_order_cnt_bottom)) return 1;
 910                         } else {
 911                                 if (vs_infers(str, &slice->delta_pic_order_cnt_bottom, 0)) return 1;
 912                         }
 913                         break;
 914                 case 1:
 915                         if (!slice->seqparm->delta_pic_order_always_zero_flag) {
 916                                 if (vs_se(str, &slice->delta_pic_order_cnt[0])) return 1;
 917                                 if (slice->picparm->bottom_field_pic_order_in_frame_present_flag && !slice->field_pic_flag) {
 918                                         if (vs_se(str, &slice->delta_pic_order_cnt[1])) return 1;
 919                                 } else {
 920                                         if (vs_infers(str, &slice->delta_pic_order_cnt[1], 0)) return 1;
 921                                 }
 922                         } else {
 923                                 if (vs_infers(str, &slice->delta_pic_order_cnt[0], 0)) return 1;
 924                                 if (vs_infers(str, &slice->delta_pic_order_cnt[1], 0)) return 1;
 925                         }
 926                         break;
 927         }
 928         if (slice->picparm->redundant_pic_cnt_present_flag) {
 929                 if (vs_ue(str, &slice->redundant_pic_cnt)) return 1;
 930         } else {
 931                 if (vs_infer(str, &slice->redundant_pic_cnt, 0)) return 1;
 932         }
 933         if (!slice->seqparm->is_svc || slice->svc.quality_id == 0) {
 934                 if (slice->slice_type == H264_SLICE_TYPE_B)
 935                         if (vs_u(str, &slice->direct_spatial_mb_pred_flag, 1)) return 1;
 936                 if (slice->slice_type != H264_SLICE_TYPE_I && slice->slice_type != H264_SLICE_TYPE_SI) {
 937                         if (vs_u(str, &slice->num_ref_idx_active_override_flag, 1)) return 1;
 938                         if (slice->num_ref_idx_active_override_flag) {
 939                                 if (vs_ue(str, &slice->num_ref_idx_l0_active_minus1)) return 1;
 940                                 if (slice->slice_type == H264_SLICE_TYPE_B)
 941                                         if (vs_ue(str, &slice->num_ref_idx_l1_active_minus1)) return 1;
 942                         } else {
 943                                 if (vs_infer(str, &slice->num_ref_idx_l0_active_minus1, slice->picparm->num_ref_idx_l0_default_active_minus1)) return 1;
 944                                 if (slice->slice_type == H264_SLICE_TYPE_B)
 945                                         if (vs_infer(str, &slice->num_ref_idx_l1_active_minus1, slice->picparm->num_ref_idx_l1_default_active_minus1)) return 1;
 946
 947                         }
 948                         if (slice->num_ref_idx_l0_active_minus1 > 31) {
 949                                 fprintf(stderr, "num_ref_idx_l0_active_minus1 out of range\n");
 950                                 return 1;
 951                         }
 952                         if (slice->num_ref_idx_l1_active_minus1 > 31) {
 953                                 fprintf(stderr, "num_ref_idx_l1_active_minus1 out of range\n");
 954                                 return 1;
 955                         }
 956                         /* ref_pic_list_modification */
 957                         if (h264_ref_pic_list_modification(str, slice, &slice->ref_pic_list_modification_l0)) return 1;
 958                         if (slice->slice_type == H264_SLICE_TYPE_B) {
 959                                 if (h264_ref_pic_list_modification(str, slice, &slice->ref_pic_list_modification_l1)) return 1;
 960                         }
 961                 }
 962                 if ((slice->picparm->weighted_pred_flag && (slice->slice_type == H264_SLICE_TYPE_P || slice->slice_type == H264_SLICE_TYPE_SP)) || (slice->picparm->weighted_bipred_idc == 1 && slice->slice_type == H264_SLICE_TYPE_B)) {
 963                         if (slice->seqparm->is_svc && !slice->svc.no_inter_layer_pred_flag) {
 964                                 if (vs_u(str, &slice->base_pred_weight_table_flag, 1)) return 1;
 965                         } else {
 966                                 if (vs_infer(str, &slice->base_pred_weight_table_flag, 0)) return 1;
 967                         }
 968                         if (!slice->base_pred_weight_table_flag)
 969                                 if (h264_pred_weight_table(str, slice, &slice->pred_weight_table)) return 1;
 970                 }
 971                 if (slice->nal_ref_idc) {
 972                         if (h264_dec_ref_pic_marking(str, slice->idr_pic_flag, &slice->dec_ref_pic_marking)) return 1;
 973                         if (slice->seqparm->is_svc && !slice->seqparm->slice_header_restriction_flag) {
 974                                 if (h264_dec_ref_base_pic_marking(str, &slice->svc, &slice->dec_ref_base_pic_marking)) return 1;
 975                         }
 976                 }
 977         } else {
 978                 /* XXX: infer me */
 979         }
 980         if (slice->picparm->entropy_coding_mode_flag && slice->slice_type != H264_SLICE_TYPE_I && slice->slice_type != H264_SLICE_TYPE_SI) {
 981                 if (vs_ue(str, &slice->cabac_init_idc)) return 1;
 982                 if (slice->cabac_init_idc > 2) {
 983                         fprintf(stderr, "cabac_init_idc out of range!\n");
 984                         return 1;
 985                 }
 986         }
 987         if (vs_se(str, &slice->slice_qp_delta)) return 1;
 988         slice->sliceqpy = slice->picparm->pic_init_qp_minus26 + 26 + slice->slice_qp_delta;
 989         if (slice->slice_type == H264_SLICE_TYPE_SP)
 990                 if (vs_u(str, &slice->sp_for_switch_flag, 1)) return 1;
 991         if (slice->slice_type == H264_SLICE_TYPE_SP || slice->slice_type == H264_SLICE_TYPE_SI)
 992                 if (vs_se(str, &slice->slice_qs_delta)) return 1;
 993         if (slice->picparm->deblocking_filter_control_present_flag) {
 994                 if (vs_ue(str, &slice->disable_deblocking_filter_idc)) return 1;
 995                 if (slice->disable_deblocking_filter_idc != 1) {
 996                         if (vs_se(str, &slice->slice_alpha_c0_offset_div2)) return 1;
 997                         if (vs_se(str, &slice->slice_beta_offset_div2)) return 1;
 998                 } else {
 999                         if (vs_infers(str, &slice->slice_alpha_c0_offset_div2, 0)) return 1;
1000                         if (vs_infers(str, &slice->slice_beta_offset_div2, 0)) return 1;
1001                 }
1002         } else {
1003                 if (vs_infer(str, &slice->disable_deblocking_filter_idc, 0)) return 1;
1004                 if (vs_infers(str, &slice->slice_alpha_c0_offset_div2, 0)) return 1;
1005                 if (vs_infers(str, &slice->slice_beta_offset_div2, 0)) return 1;
1006         }
1007         if (slice->picparm->num_slice_groups_minus1 && slice->picparm->slice_group_map_type >= 3 && slice->picparm->slice_group_map_type <= 5)
1008                 if (vs_u(str, &slice->slice_group_change_cycle, clog2(((slice->seqparm->pic_width_in_mbs_minus1 + 1) * (slice->seqparm->pic_height_in_map_units_minus1 + 1) + slice->picparm->slice_group_change_rate_minus1) / (slice->picparm->slice_group_change_rate_minus1 + 1) + 1))) return 1;
1009         if (slice->picparm->num_slice_groups_minus1)
1010                 if (h264_prep_sgmap(slice)) return 1;
1011         if (slice->seqparm->is_svc) {
1012                 /* XXX */
1013                 fprintf(stderr, "SVC\n");
1014                 return 1;
1015         }
1016         return 0;
1017 }
1018
1019 int h264_pred_weight_table_entry(struct bitstream *str, struct h264_pred_weight_table *table, struct h264_pred_weight_table_entry *entry) {
1020         int ret = 0;
1021         ret |= vs_u(str, &entry->luma_weight_flag, 1);
1022         if (entry->luma_weight_flag) {
1023                 ret |= vs_se(str, &entry->luma_weight);
1024                 ret |= vs_se(str, &entry->luma_offset);
1025         } else {
1026                 ret |= vs_infers(str, &entry->luma_weight, 1 << table->luma_log2_weight_denom);
1027                 ret |= vs_infers(str, &entry->luma_offset, 0);
1028         }
1029         ret |= vs_u(str, &entry->chroma_weight_flag, 1);
1030         if (entry->chroma_weight_flag) {
1031                 ret |= vs_se(str, &entry->chroma_weight[0]);
1032                 ret |= vs_se(str, &entry->chroma_offset[0]);
1033                 ret |= vs_se(str, &entry->chroma_weight[1]);
1034                 ret |= vs_se(str, &entry->chroma_offset[1]);
1035         } else {
1036                 ret |= vs_infers(str, &entry->chroma_weight[0], 1 << table->chroma_log2_weight_denom);
1037                 ret |= vs_infers(str, &entry->chroma_offset[0], 0);
1038                 ret |= vs_infers(str, &entry->chroma_weight[1], 1 << table->chroma_log2_weight_denom);
1039                 ret |= vs_infers(str, &entry->chroma_offset[1], 0);
1040         }
1041         return ret;
1042 }
1043
1044 int h264_pred_weight_table(struct bitstream *str, struct h264_slice *slice, struct h264_pred_weight_table *table) {
1045         int ret = 0;
1046         ret |= vs_ue(str, &table->luma_log2_weight_denom);
1047         ret |= vs_ue(str, &table->chroma_log2_weight_denom);
1048         int i;
1049         for (i = 0; i <= slice->num_ref_idx_l0_active_minus1; i++)
1050                 ret |= h264_pred_weight_table_entry(str, table, &table->l0[i]);
1051         if (slice->slice_type % 5 == 1)
1052                 for (i = 0; i <= slice->num_ref_idx_l1_active_minus1; i++)
1053                         ret |= h264_pred_weight_table_entry(str, table, &table->l1[i]);
1054         return ret;
1055 }