src/gallium/state_trackers/omx_bellagio/vid_dec_h264.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2013 Advanced Micro Devices, Inc.
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sub license, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the
  15  * next paragraph) shall be included in all copies or substantial portions
  16  * of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  21  * IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR
  22  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  **************************************************************************/
  27
  28 /*
  29  * Authors:
  30  *      Christian König <christian.koenig@amd.com>
  31  *
  32  */
  33
  34 #include "pipe/p_video_codec.h"
  35 #include "util/u_memory.h"
  36 #include "util/u_video.h"
  37 #include "vl/vl_rbsp.h"
  38 #include "vl/vl_zscan.h"
  39
  40 #include "entrypoint.h"
  41 #include "vid_dec.h"
  42
  43 #define DPB_MAX_SIZE 5
  44
  45 struct dpb_list {
  46    struct list_head list;
  47    struct pipe_video_buffer *buffer;
  48    OMX_TICKS timestamp;
  49    int poc;
  50 };
  51
  52 static const uint8_t Default_4x4_Intra[16] = {
  53     6, 13, 20, 28, 13, 20, 28, 32,
  54    20, 28, 32, 37, 28, 32, 37, 42
  55 };
  56
  57 static const uint8_t Default_4x4_Inter[16] = {
  58    10, 14, 20, 24, 14, 20, 24, 27,
  59    20, 24, 27, 30, 24, 27, 30, 34
  60 };
  61
  62 static const uint8_t Default_8x8_Intra[64] = {
  63     6, 10, 13, 16, 18, 23, 25, 27,
  64    10, 11, 16, 18, 23, 25, 27, 29,
  65    13, 16, 18, 23, 25, 27, 29, 31,
  66    16, 18, 23, 25, 27, 29, 31, 33,
  67    18, 23, 25, 27, 29, 31, 33, 36,
  68    23, 25, 27, 29, 31, 33, 36, 38,
  69    25, 27, 29, 31, 33, 36, 38, 40,
  70    27, 29, 31, 33, 36, 38, 40, 42
  71 };
  72
  73 static const uint8_t Default_8x8_Inter[64] = {
  74     9, 13, 15, 17, 19, 21, 22, 24,
  75    13, 13, 17, 19, 21, 22, 24, 25,
  76    15, 17, 19, 21, 22, 24, 25, 27,
  77    17, 19, 21, 22, 24, 25, 27, 28,
  78    19, 21, 22, 24, 25, 27, 28, 30,
  79    21, 22, 24, 25, 27, 28, 30, 32,
  80    22, 24, 25, 27, 28, 30, 32, 33,
  81    24, 25, 27, 28, 30, 32, 33, 35
  82 };
  83
  84 static void vid_dec_h264_Decode(vid_dec_PrivateType *priv, struct vl_vlc *vlc, unsigned min_bits_left);
  85 static void vid_dec_h264_EndFrame(vid_dec_PrivateType *priv);
  86 static struct pipe_video_buffer *vid_dec_h264_Flush(vid_dec_PrivateType *priv, OMX_TICKS *timestamp);
  87
  88 void vid_dec_h264_Init(vid_dec_PrivateType *priv)
  89 {
  90    priv->picture.base.profile = PIPE_VIDEO_PROFILE_MPEG4_AVC_HIGH;
  91
  92    priv->Decode = vid_dec_h264_Decode;
  93    priv->EndFrame = vid_dec_h264_EndFrame;
  94    priv->Flush = vid_dec_h264_Flush;
  95
  96    LIST_INITHEAD(&priv->codec_data.h264.dpb_list);
  97    priv->picture.h264.field_order_cnt[0] = priv->picture.h264.field_order_cnt[1] = INT_MAX;
  98    priv->first_buf_in_frame = true;
  99 }
 100
 101 static void vid_dec_h264_BeginFrame(vid_dec_PrivateType *priv)
 102 {
 103    //TODO: sane buffer handling
 104
 105    if (priv->frame_started)
 106       return;
 107
 108    if (!priv->codec) {
 109       struct pipe_video_codec templat = {};
 110       omx_base_video_PortType *port;
 111
 112       port = (omx_base_video_PortType *)priv->ports[OMX_BASE_FILTER_INPUTPORT_INDEX];
 113       templat.profile = priv->profile;
 114       templat.entrypoint = PIPE_VIDEO_ENTRYPOINT_BITSTREAM;
 115       templat.chroma_format = PIPE_VIDEO_CHROMA_FORMAT_420;
 116       templat.max_references = priv->picture.h264.num_ref_frames;
 117       templat.expect_chunked_decode = true;
 118       templat.width = port->sPortParam.format.video.nFrameWidth;
 119       templat.height = port->sPortParam.format.video.nFrameHeight;
 120       templat.level = priv->picture.h264.pps->sps->level_idc;
 121
 122       priv->codec = priv->pipe->create_video_codec(priv->pipe, &templat);
 123    }
 124
 125    vid_dec_NeedTarget(priv);
 126
 127    if (priv->first_buf_in_frame)
 128       priv->timestamp = priv->timestamps[0];
 129    priv->first_buf_in_frame = false;
 130
 131    priv->picture.h264.num_ref_frames = priv->picture.h264.pps->sps->max_num_ref_frames;
 132
 133    priv->picture.h264.slice_count = 0;
 134    priv->codec->begin_frame(priv->codec, priv->target, &priv->picture.base);
 135    priv->frame_started = true;
 136 }
 137
 138 static struct pipe_video_buffer *vid_dec_h264_Flush(vid_dec_PrivateType *priv,
 139                                                     OMX_TICKS *timestamp)
 140 {
 141    struct dpb_list *entry, *result = NULL;
 142    struct pipe_video_buffer *buf;
 143
 144    /* search for the lowest poc and break on zeros */
 145    LIST_FOR_EACH_ENTRY(entry, &priv->codec_data.h264.dpb_list, list) {
 146
 147       if (result && entry->poc == 0)
 148          break;
 149
 150       if (!result || entry->poc < result->poc)
 151          result = entry;
 152    }
 153
 154    if (!result)
 155       return NULL;
 156
 157    buf = result->buffer;
 158    if (timestamp)
 159       *timestamp = result->timestamp;
 160
 161    --priv->codec_data.h264.dpb_num;
 162    LIST_DEL(&result->list);
 163    FREE(result);
 164
 165    return buf;
 166 }
 167
 168 static void vid_dec_h264_EndFrame(vid_dec_PrivateType *priv)
 169 {
 170    struct dpb_list *entry;
 171    struct pipe_video_buffer *tmp;
 172    bool top_field_first;
 173    OMX_TICKS timestamp;
 174
 175    if (!priv->frame_started)
 176       return;
 177
 178    priv->codec->end_frame(priv->codec, priv->target, &priv->picture.base);
 179    priv->frame_started = false;
 180
 181    // TODO: implement frame number handling
 182    priv->picture.h264.frame_num_list[0] = priv->picture.h264.frame_num;
 183    priv->picture.h264.field_order_cnt_list[0][0] = priv->picture.h264.frame_num;
 184    priv->picture.h264.field_order_cnt_list[0][1] = priv->picture.h264.frame_num;
 185
 186    top_field_first = priv->picture.h264.field_order_cnt[0] <  priv->picture.h264.field_order_cnt[1];
 187
 188    if (priv->picture.h264.field_pic_flag && priv->picture.h264.bottom_field_flag != top_field_first)
 189       return;
 190
 191    /* add the decoded picture to the dpb list */
 192    entry = CALLOC_STRUCT(dpb_list);
 193    if (!entry)
 194       return;
 195
 196    priv->first_buf_in_frame = true;
 197    entry->buffer = priv->target;
 198    entry->timestamp = priv->timestamp;
 199    entry->poc = MIN2(priv->picture.h264.field_order_cnt[0], priv->picture.h264.field_order_cnt[1]);
 200    LIST_ADDTAIL(&entry->list, &priv->codec_data.h264.dpb_list);
 201    ++priv->codec_data.h264.dpb_num;
 202    priv->target = NULL;
 203    priv->picture.h264.field_order_cnt[0] = priv->picture.h264.field_order_cnt[1] = INT_MAX;
 204
 205    if (priv->codec_data.h264.dpb_num <= DPB_MAX_SIZE)
 206       return;
 207
 208    tmp = priv->in_buffers[0]->pInputPortPrivate;
 209    priv->in_buffers[0]->pInputPortPrivate = vid_dec_h264_Flush(priv, &timestamp);
 210    priv->in_buffers[0]->nTimeStamp = timestamp;
 211    priv->target = tmp;
 212    priv->frame_finished = priv->in_buffers[0]->pInputPortPrivate != NULL;
 213 }
 214
 215 static void vui_parameters(struct vl_rbsp *rbsp)
 216 {
 217    // TODO
 218 }
 219
 220 static void scaling_list(struct vl_rbsp *rbsp, uint8_t *scalingList, unsigned sizeOfScalingList,
 221                          const uint8_t *defaultList, const uint8_t *fallbackList)
 222 {
 223    unsigned lastScale = 8, nextScale = 8;
 224    const int *list;
 225    unsigned i;
 226
 227    /* (pic|seq)_scaling_list_present_flag[i] */
 228    if (!vl_rbsp_u(rbsp, 1)) {
 229       if (fallbackList)
 230          memcpy(scalingList, fallbackList, sizeOfScalingList);
 231       return;
 232    }
 233
 234    list = (sizeOfScalingList == 16) ? vl_zscan_normal_16 : vl_zscan_normal;
 235    for (i = 0; i < sizeOfScalingList; ++i ) {
 236
 237       if (nextScale != 0) {
 238          signed delta_scale = vl_rbsp_se(rbsp);
 239          nextScale = (lastScale + delta_scale + 256) % 256;
 240          if (i == 0 && nextScale == 0) {
 241             memcpy(scalingList, defaultList, sizeOfScalingList);
 242             return;
 243          }
 244       }
 245       scalingList[list[i]] = nextScale == 0 ? lastScale : nextScale;
 246       lastScale = scalingList[list[i]];
 247    }
 248 }
 249
 250 static struct pipe_h264_sps *seq_parameter_set_id(vid_dec_PrivateType *priv, struct vl_rbsp *rbsp)
 251 {
 252    unsigned id = vl_rbsp_ue(rbsp);
 253    if (id >= ARRAY_SIZE(priv->codec_data.h264.sps))
 254       return NULL; /* invalid seq_parameter_set_id */
 255
 256    return &priv->codec_data.h264.sps[id];
 257 }
 258
 259 static void seq_parameter_set(vid_dec_PrivateType *priv, struct vl_rbsp *rbsp)
 260 {
 261    struct pipe_h264_sps *sps;
 262    unsigned profile_idc, level_idc;
 263    unsigned i;
 264
 265    /* Sequence parameter set */
 266    profile_idc = vl_rbsp_u(rbsp, 8);
 267
 268    /* constraint_set0_flag */
 269    vl_rbsp_u(rbsp, 1);
 270
 271    /* constraint_set1_flag */
 272    vl_rbsp_u(rbsp, 1);
 273
 274    /* constraint_set2_flag */
 275    vl_rbsp_u(rbsp, 1);
 276
 277    /* constraint_set3_flag */
 278    vl_rbsp_u(rbsp, 1);
 279
 280    /* constraint_set4_flag */
 281    vl_rbsp_u(rbsp, 1);
 282
 283    /* constraint_set5_flag */
 284    vl_rbsp_u(rbsp, 1);
 285
 286    /* reserved_zero_2bits */
 287    vl_rbsp_u(rbsp, 2);
 288
 289    /* level_idc */
 290    level_idc = vl_rbsp_u(rbsp, 8);
 291
 292    sps = seq_parameter_set_id(priv, rbsp);
 293    if (!sps)
 294       return;
 295
 296    memset(sps, 0, sizeof(*sps));
 297    memset(sps->ScalingList4x4, 16, sizeof(sps->ScalingList4x4));
 298    memset(sps->ScalingList8x8, 16, sizeof(sps->ScalingList8x8));
 299
 300    sps->level_idc = level_idc;
 301
 302    if (profile_idc == 100 || profile_idc == 110 || profile_idc == 122 || profile_idc == 244 ||
 303        profile_idc == 44 || profile_idc == 83 || profile_idc == 86 || profile_idc == 118 ||
 304        profile_idc == 128 || profile_idc == 138) {
 305
 306       sps->chroma_format_idc = vl_rbsp_ue(rbsp);
 307
 308       if (sps->chroma_format_idc == 3)
 309          sps->separate_colour_plane_flag = vl_rbsp_u(rbsp, 1);
 310
 311       sps->bit_depth_luma_minus8 = vl_rbsp_ue(rbsp);
 312
 313       sps->bit_depth_chroma_minus8 = vl_rbsp_ue(rbsp);
 314
 315       /* qpprime_y_zero_transform_bypass_flag */
 316       vl_rbsp_u(rbsp, 1);
 317
 318       sps->seq_scaling_matrix_present_flag = vl_rbsp_u(rbsp, 1);
 319       if (sps->seq_scaling_matrix_present_flag) {
 320
 321          scaling_list(rbsp, sps->ScalingList4x4[0], 16, Default_4x4_Intra, Default_4x4_Intra);
 322          scaling_list(rbsp, sps->ScalingList4x4[1], 16, Default_4x4_Intra, sps->ScalingList4x4[0]);
 323          scaling_list(rbsp, sps->ScalingList4x4[2], 16, Default_4x4_Intra, sps->ScalingList4x4[1]);
 324          scaling_list(rbsp, sps->ScalingList4x4[3], 16, Default_4x4_Inter, Default_4x4_Inter);
 325          scaling_list(rbsp, sps->ScalingList4x4[4], 16, Default_4x4_Inter, sps->ScalingList4x4[3]);
 326          scaling_list(rbsp, sps->ScalingList4x4[5], 16, Default_4x4_Inter, sps->ScalingList4x4[4]);
 327
 328          scaling_list(rbsp, sps->ScalingList8x8[0], 64, Default_8x8_Intra, Default_8x8_Intra);
 329          scaling_list(rbsp, sps->ScalingList8x8[1], 64, Default_8x8_Inter, Default_8x8_Inter);
 330          if (sps->chroma_format_idc == 3) {
 331             scaling_list(rbsp, sps->ScalingList8x8[2], 64, Default_8x8_Intra, sps->ScalingList8x8[0]);
 332             scaling_list(rbsp, sps->ScalingList8x8[3], 64, Default_8x8_Inter, sps->ScalingList8x8[1]);
 333             scaling_list(rbsp, sps->ScalingList8x8[4], 64, Default_8x8_Intra, sps->ScalingList8x8[2]);
 334             scaling_list(rbsp, sps->ScalingList8x8[5], 64, Default_8x8_Inter, sps->ScalingList8x8[3]);
 335          }
 336       }
 337    } else if (profile_idc == 183)
 338       sps->chroma_format_idc = 0;
 339    else
 340       sps->chroma_format_idc = 1;
 341
 342    sps->log2_max_frame_num_minus4 = vl_rbsp_ue(rbsp);
 343
 344    sps->pic_order_cnt_type = vl_rbsp_ue(rbsp);
 345
 346    if (sps->pic_order_cnt_type == 0)
 347       sps->log2_max_pic_order_cnt_lsb_minus4 = vl_rbsp_ue(rbsp);
 348    else if (sps->pic_order_cnt_type == 1) {
 349       sps->delta_pic_order_always_zero_flag = vl_rbsp_u(rbsp, 1);
 350
 351       sps->offset_for_non_ref_pic = vl_rbsp_se(rbsp);
 352
 353       sps->offset_for_top_to_bottom_field = vl_rbsp_se(rbsp);
 354
 355       sps->num_ref_frames_in_pic_order_cnt_cycle = vl_rbsp_ue(rbsp);
 356
 357       for (i = 0; i < sps->num_ref_frames_in_pic_order_cnt_cycle; ++i)
 358          sps->offset_for_ref_frame[i] = vl_rbsp_se(rbsp);
 359    }
 360
 361    sps->max_num_ref_frames = vl_rbsp_ue(rbsp);
 362
 363    /* gaps_in_frame_num_value_allowed_flag */
 364    vl_rbsp_u(rbsp, 1);
 365
 366    /* pic_width_in_mbs_minus1 */
 367    vl_rbsp_ue(rbsp);
 368
 369    /* pic_height_in_map_units_minus1 */
 370    vl_rbsp_ue(rbsp);
 371
 372    sps->frame_mbs_only_flag = vl_rbsp_u(rbsp, 1);
 373    if (!sps->frame_mbs_only_flag)
 374       sps->mb_adaptive_frame_field_flag = vl_rbsp_u(rbsp, 1);
 375
 376    sps->direct_8x8_inference_flag = vl_rbsp_u(rbsp, 1);
 377
 378    /* frame_cropping_flag */
 379    if (vl_rbsp_u(rbsp, 1)) {
 380       /* frame_crop_left_offset */
 381       vl_rbsp_ue(rbsp);
 382
 383       /* frame_crop_right_offset */
 384       vl_rbsp_ue(rbsp);
 385
 386       /* frame_crop_top_offset */
 387       vl_rbsp_ue(rbsp);
 388
 389       /* frame_crop_bottom_offset */
 390       vl_rbsp_ue(rbsp);
 391    }
 392
 393    /* vui_parameters_present_flag */
 394    if (vl_rbsp_u(rbsp, 1))
 395       vui_parameters(rbsp);
 396 }
 397
 398 static struct pipe_h264_pps *pic_parameter_set_id(vid_dec_PrivateType *priv, struct vl_rbsp *rbsp)
 399 {
 400    unsigned id = vl_rbsp_ue(rbsp);
 401    if (id >= ARRAY_SIZE(priv->codec_data.h264.pps))
 402       return NULL; /* invalid pic_parameter_set_id */
 403
 404    return &priv->codec_data.h264.pps[id];
 405 }
 406
 407 static void picture_parameter_set(vid_dec_PrivateType *priv, struct vl_rbsp *rbsp)
 408 {
 409    struct pipe_h264_sps *sps;
 410    struct pipe_h264_pps *pps;
 411    unsigned i;
 412
 413    pps = pic_parameter_set_id(priv, rbsp);
 414    if (!pps)
 415       return;
 416
 417    memset(pps, 0, sizeof(*pps));
 418
 419    sps = pps->sps = seq_parameter_set_id(priv, rbsp);
 420    if (!sps)
 421       return;
 422
 423    memcpy(pps->ScalingList4x4, sps->ScalingList4x4, sizeof(pps->ScalingList4x4));
 424    memcpy(pps->ScalingList8x8, sps->ScalingList8x8, sizeof(pps->ScalingList8x8));
 425
 426    pps->entropy_coding_mode_flag = vl_rbsp_u(rbsp, 1);
 427
 428    pps->bottom_field_pic_order_in_frame_present_flag = vl_rbsp_u(rbsp, 1);
 429
 430    pps->num_slice_groups_minus1 = vl_rbsp_ue(rbsp);
 431    if (pps->num_slice_groups_minus1 > 0) {
 432       pps->slice_group_map_type = vl_rbsp_ue(rbsp);
 433
 434       if (pps->slice_group_map_type == 0) {
 435
 436          for (i = 0; i <= pps->num_slice_groups_minus1; ++i)
 437             /* run_length_minus1[i] */
 438             vl_rbsp_ue(rbsp);
 439
 440       } else if (pps->slice_group_map_type == 2) {
 441
 442          for (i = 0; i <= pps->num_slice_groups_minus1; ++i) {
 443             /* top_left[i] */
 444             vl_rbsp_ue(rbsp);
 445
 446             /* bottom_right[i] */
 447             vl_rbsp_ue(rbsp);
 448          }
 449
 450       } else if (pps->slice_group_map_type >= 3 && pps->slice_group_map_type <= 5) {
 451
 452          /* slice_group_change_direction_flag */
 453          vl_rbsp_u(rbsp, 1);
 454
 455          pps->slice_group_change_rate_minus1 = vl_rbsp_ue(rbsp);
 456
 457       } else if (pps->slice_group_map_type == 6) {
 458
 459          unsigned pic_size_in_map_units_minus1;
 460
 461          pic_size_in_map_units_minus1 = vl_rbsp_ue(rbsp);
 462
 463          for (i = 0; i <= pic_size_in_map_units_minus1; ++i)
 464             /* slice_group_id[i] */
 465             vl_rbsp_u(rbsp, log2(pps->num_slice_groups_minus1 + 1));
 466       }
 467    }
 468
 469    pps->num_ref_idx_l0_default_active_minus1 = vl_rbsp_ue(rbsp);
 470
 471    pps->num_ref_idx_l1_default_active_minus1 = vl_rbsp_ue(rbsp);
 472
 473    pps->weighted_pred_flag = vl_rbsp_u(rbsp, 1);
 474
 475    pps->weighted_bipred_idc = vl_rbsp_u(rbsp, 2);
 476
 477    pps->pic_init_qp_minus26 = vl_rbsp_se(rbsp);
 478
 479    /* pic_init_qs_minus26 */
 480    vl_rbsp_se(rbsp);
 481
 482    pps->chroma_qp_index_offset = vl_rbsp_se(rbsp);
 483
 484    pps->deblocking_filter_control_present_flag = vl_rbsp_u(rbsp, 1);
 485
 486    pps->constrained_intra_pred_flag = vl_rbsp_u(rbsp, 1);
 487
 488    pps->redundant_pic_cnt_present_flag = vl_rbsp_u(rbsp, 1);
 489
 490    if (vl_rbsp_more_data(rbsp)) {
 491       pps->transform_8x8_mode_flag = vl_rbsp_u(rbsp, 1);
 492
 493       /* pic_scaling_matrix_present_flag */
 494       if (vl_rbsp_u(rbsp, 1)) {
 495
 496          scaling_list(rbsp, pps->ScalingList4x4[0], 16, Default_4x4_Intra,
 497                       sps->seq_scaling_matrix_present_flag ? NULL : Default_4x4_Intra);
 498          scaling_list(rbsp, pps->ScalingList4x4[1], 16, Default_4x4_Intra, pps->ScalingList4x4[0]);
 499          scaling_list(rbsp, pps->ScalingList4x4[2], 16, Default_4x4_Intra, pps->ScalingList4x4[1]);
 500          scaling_list(rbsp, pps->ScalingList4x4[3], 16, Default_4x4_Inter,
 501                       sps->seq_scaling_matrix_present_flag ? NULL : Default_4x4_Inter);
 502          scaling_list(rbsp, pps->ScalingList4x4[4], 16, Default_4x4_Inter, pps->ScalingList4x4[3]);
 503          scaling_list(rbsp, pps->ScalingList4x4[5], 16, Default_4x4_Inter, pps->ScalingList4x4[4]);
 504
 505          if (pps->transform_8x8_mode_flag) {
 506             scaling_list(rbsp, pps->ScalingList8x8[0], 64, Default_8x8_Intra,
 507                          sps->seq_scaling_matrix_present_flag ? NULL : Default_8x8_Intra);
 508             scaling_list(rbsp, pps->ScalingList8x8[1], 64, Default_8x8_Inter,
 509                          sps->seq_scaling_matrix_present_flag ? NULL :  Default_8x8_Inter);
 510             if (sps->chroma_format_idc == 3) {
 511                scaling_list(rbsp, pps->ScalingList8x8[2], 64, Default_8x8_Intra, pps->ScalingList8x8[0]);
 512                scaling_list(rbsp, pps->ScalingList8x8[3], 64, Default_8x8_Inter, pps->ScalingList8x8[1]);
 513                scaling_list(rbsp, pps->ScalingList8x8[4], 64, Default_8x8_Intra, pps->ScalingList8x8[2]);
 514                scaling_list(rbsp, pps->ScalingList8x8[5], 64, Default_8x8_Inter, pps->ScalingList8x8[3]);
 515             }
 516          }
 517       }
 518
 519       pps->second_chroma_qp_index_offset = vl_rbsp_se(rbsp);
 520    }
 521 }
 522
 523 static void ref_pic_list_mvc_modification(vid_dec_PrivateType *priv, struct vl_rbsp *rbsp)
 524 {
 525    // TODO
 526    assert(0);
 527 }
 528
 529 static void ref_pic_list_modification(vid_dec_PrivateType *priv, struct vl_rbsp *rbsp,
 530                                       enum pipe_h264_slice_type slice_type)
 531 {
 532    unsigned modification_of_pic_nums_idc;
 533
 534    if (slice_type != 2 && slice_type != 4) {
 535       /* ref_pic_list_modification_flag_l0 */
 536       if (vl_rbsp_u(rbsp, 1)) {
 537          do {
 538             modification_of_pic_nums_idc = vl_rbsp_ue(rbsp);
 539             if (modification_of_pic_nums_idc == 0 ||
 540                 modification_of_pic_nums_idc == 1)
 541                /* abs_diff_pic_num_minus1 */
 542                vl_rbsp_ue(rbsp);
 543             else if (modification_of_pic_nums_idc == 2)
 544                /* long_term_pic_num */
 545                vl_rbsp_ue(rbsp);
 546          } while (modification_of_pic_nums_idc != 3);
 547       }
 548    }
 549
 550    if (slice_type == 1) {
 551       /* ref_pic_list_modification_flag_l1 */
 552       if (vl_rbsp_u(rbsp, 1)) {
 553          do {
 554             modification_of_pic_nums_idc = vl_rbsp_ue(rbsp);
 555             if (modification_of_pic_nums_idc == 0 ||
 556                 modification_of_pic_nums_idc == 1)
 557                /* abs_diff_pic_num_minus1 */
 558                vl_rbsp_ue(rbsp);
 559             else if (modification_of_pic_nums_idc == 2)
 560                /* long_term_pic_num */
 561                vl_rbsp_ue(rbsp);
 562          } while (modification_of_pic_nums_idc != 3);
 563       }
 564    }
 565 }
 566
 567 static void pred_weight_table(vid_dec_PrivateType *priv, struct vl_rbsp *rbsp,
 568                               struct pipe_h264_sps *sps, enum pipe_h264_slice_type slice_type)
 569 {
 570    unsigned ChromaArrayType = sps->separate_colour_plane_flag ? 0 : sps->chroma_format_idc;
 571    unsigned i, j;
 572
 573    /* luma_log2_weight_denom */
 574    vl_rbsp_ue(rbsp);
 575
 576    if (ChromaArrayType != 0)
 577       /* chroma_log2_weight_denom */
 578       vl_rbsp_ue(rbsp);
 579
 580    for (i = 0; i <= priv->picture.h264.num_ref_idx_l0_active_minus1; ++i) {
 581       /* luma_weight_l0_flag */
 582       if (vl_rbsp_u(rbsp, 1)) {
 583          /* luma_weight_l0[i] */
 584          vl_rbsp_se(rbsp);
 585          /* luma_offset_l0[i] */
 586          vl_rbsp_se(rbsp);
 587       }
 588       if (ChromaArrayType != 0) {
 589          /* chroma_weight_l0_flag */
 590          if (vl_rbsp_u(rbsp, 1)) {
 591             for (j = 0; j < 2; ++j) {
 592                /* chroma_weight_l0[i][j] */
 593                vl_rbsp_se(rbsp);
 594                /* chroma_offset_l0[i][j] */
 595                vl_rbsp_se(rbsp);
 596             }
 597          }
 598       }
 599    }
 600
 601    if (slice_type == 1) {
 602       for (i = 0; i <= priv->picture.h264.num_ref_idx_l1_active_minus1; ++i) {
 603          /* luma_weight_l1_flag */
 604          if (vl_rbsp_u(rbsp, 1)) {
 605             /* luma_weight_l1[i] */
 606             vl_rbsp_se(rbsp);
 607             /* luma_offset_l1[i] */
 608             vl_rbsp_se(rbsp);
 609          }
 610          if (ChromaArrayType != 0) {
 611             /* chroma_weight_l1_flag */
 612             if (vl_rbsp_u(rbsp, 1)) {
 613                for (j = 0; j < 2; ++j) {
 614                   /* chroma_weight_l1[i][j] */
 615                   vl_rbsp_se(rbsp);
 616                   /* chroma_offset_l1[i][j] */
 617                   vl_rbsp_se(rbsp);
 618                }
 619             }
 620          }
 621       }
 622    }
 623 }
 624
 625 static void dec_ref_pic_marking(vid_dec_PrivateType *priv, struct vl_rbsp *rbsp,
 626                                 bool IdrPicFlag)
 627 {
 628    unsigned memory_management_control_operation;
 629
 630    if (IdrPicFlag) {
 631       /* no_output_of_prior_pics_flag */
 632       vl_rbsp_u(rbsp, 1);
 633       /* long_term_reference_flag */
 634       vl_rbsp_u(rbsp, 1);
 635    } else {
 636       /* adaptive_ref_pic_marking_mode_flag */
 637       if (vl_rbsp_u(rbsp, 1)) {
 638          do {
 639             memory_management_control_operation = vl_rbsp_ue(rbsp);
 640
 641             if (memory_management_control_operation == 1 ||
 642                 memory_management_control_operation == 3)
 643                /* difference_of_pic_nums_minus1 */
 644                vl_rbsp_ue(rbsp);
 645
 646             if (memory_management_control_operation == 2)
 647                /* long_term_pic_num */
 648                vl_rbsp_ue(rbsp);
 649
 650             if (memory_management_control_operation == 3 ||
 651                 memory_management_control_operation == 6)
 652                /* long_term_frame_idx */
 653                vl_rbsp_ue(rbsp);
 654
 655             if (memory_management_control_operation == 4)
 656                /* max_long_term_frame_idx_plus1 */
 657                vl_rbsp_ue(rbsp);
 658          } while (memory_management_control_operation != 0);
 659       }
 660    }
 661 }
 662
 663 static void slice_header(vid_dec_PrivateType *priv, struct vl_rbsp *rbsp,
 664                          unsigned nal_ref_idc, unsigned nal_unit_type)
 665 {
 666    enum pipe_h264_slice_type slice_type;
 667    struct pipe_h264_pps *pps;
 668    struct pipe_h264_sps *sps;
 669    unsigned frame_num, prevFrameNum;
 670    bool IdrPicFlag = nal_unit_type == 5;
 671
 672    if (IdrPicFlag != priv->codec_data.h264.IdrPicFlag)
 673       vid_dec_h264_EndFrame(priv);
 674
 675    priv->codec_data.h264.IdrPicFlag = IdrPicFlag;
 676
 677    /* first_mb_in_slice */
 678    vl_rbsp_ue(rbsp);
 679
 680    slice_type = vl_rbsp_ue(rbsp) % 5;
 681
 682    pps = pic_parameter_set_id(priv, rbsp);
 683    if (!pps)
 684       return;
 685
 686    sps = pps->sps;
 687    if (!sps)
 688       return;
 689
 690    if (pps != priv->picture.h264.pps)
 691       vid_dec_h264_EndFrame(priv);
 692
 693    priv->picture.h264.pps = pps;
 694
 695    if (sps->separate_colour_plane_flag == 1 )
 696       /* colour_plane_id */
 697       vl_rbsp_u(rbsp, 2);
 698
 699    frame_num = vl_rbsp_u(rbsp, sps->log2_max_frame_num_minus4 + 4);
 700
 701    if (frame_num != priv->picture.h264.frame_num)
 702       vid_dec_h264_EndFrame(priv);
 703
 704    prevFrameNum = priv->picture.h264.frame_num;
 705    priv->picture.h264.frame_num = frame_num;
 706
 707    priv->picture.h264.field_pic_flag = 0;
 708    priv->picture.h264.bottom_field_flag = 0;
 709
 710    if (!sps->frame_mbs_only_flag) {
 711       unsigned field_pic_flag = vl_rbsp_u(rbsp, 1);
 712
 713       if (!field_pic_flag && field_pic_flag != priv->picture.h264.field_pic_flag)
 714          vid_dec_h264_EndFrame(priv);
 715
 716       priv->picture.h264.field_pic_flag = field_pic_flag;
 717
 718       if (priv->picture.h264.field_pic_flag) {
 719          unsigned bottom_field_flag = vl_rbsp_u(rbsp, 1);
 720
 721          if (bottom_field_flag != priv->picture.h264.bottom_field_flag)
 722             vid_dec_h264_EndFrame(priv);
 723
 724          priv->picture.h264.bottom_field_flag = bottom_field_flag;
 725       }
 726    }
 727
 728    if (IdrPicFlag) {
 729       unsigned idr_pic_id = vl_rbsp_ue(rbsp);
 730
 731       if (idr_pic_id != priv->codec_data.h264.idr_pic_id)
 732          vid_dec_h264_EndFrame(priv);
 733
 734       priv->codec_data.h264.idr_pic_id = idr_pic_id;
 735    }
 736
 737    if (sps->pic_order_cnt_type == 0) {
 738       unsigned log2_max_pic_order_cnt_lsb = sps->log2_max_pic_order_cnt_lsb_minus4 + 4;
 739       unsigned max_pic_order_cnt_lsb = 1 << log2_max_pic_order_cnt_lsb;
 740       int pic_order_cnt_lsb = vl_rbsp_u(rbsp, log2_max_pic_order_cnt_lsb);
 741       int pic_order_cnt_msb;
 742
 743       if (pic_order_cnt_lsb != priv->codec_data.h264.pic_order_cnt_lsb)
 744          vid_dec_h264_EndFrame(priv);
 745
 746       if (IdrPicFlag) {
 747          priv->codec_data.h264.pic_order_cnt_msb = 0;
 748          priv->codec_data.h264.pic_order_cnt_lsb = 0;
 749       }
 750
 751       if ((pic_order_cnt_lsb < priv->codec_data.h264.pic_order_cnt_lsb) &&
 752           (priv->codec_data.h264.pic_order_cnt_lsb - pic_order_cnt_lsb) >= (max_pic_order_cnt_lsb / 2))
 753          pic_order_cnt_msb = priv->codec_data.h264.pic_order_cnt_msb + max_pic_order_cnt_lsb;
 754
 755       else if ((pic_order_cnt_lsb > priv->codec_data.h264.pic_order_cnt_lsb) &&
 756           (pic_order_cnt_lsb - priv->codec_data.h264.pic_order_cnt_lsb) > (max_pic_order_cnt_lsb / 2))
 757          pic_order_cnt_msb = priv->codec_data.h264.pic_order_cnt_msb - max_pic_order_cnt_lsb;
 758
 759       else
 760          pic_order_cnt_msb = priv->codec_data.h264.pic_order_cnt_msb;
 761
 762       priv->codec_data.h264.pic_order_cnt_msb = pic_order_cnt_msb;
 763       priv->codec_data.h264.pic_order_cnt_lsb = pic_order_cnt_lsb;
 764
 765       if (pps->bottom_field_pic_order_in_frame_present_flag && !priv->picture.h264.field_pic_flag) {
 766          unsigned delta_pic_order_cnt_bottom = vl_rbsp_se(rbsp);
 767
 768          if (delta_pic_order_cnt_bottom != priv->codec_data.h264.delta_pic_order_cnt_bottom)
 769             vid_dec_h264_EndFrame(priv);
 770
 771          priv->codec_data.h264.delta_pic_order_cnt_bottom = delta_pic_order_cnt_bottom;
 772       }
 773
 774       if (!priv->picture.h264.field_pic_flag) {
 775          priv->picture.h264.field_order_cnt[0] = pic_order_cnt_msb + pic_order_cnt_lsb;
 776          priv->picture.h264.field_order_cnt[1] = priv->picture.h264.field_order_cnt [0] +
 777                                           priv->codec_data.h264.delta_pic_order_cnt_bottom;
 778       } else if (!priv->picture.h264.bottom_field_flag)
 779          priv->picture.h264.field_order_cnt[0] = pic_order_cnt_msb + pic_order_cnt_lsb;
 780       else
 781          priv->picture.h264.field_order_cnt[1] = pic_order_cnt_msb + pic_order_cnt_lsb;
 782
 783    } else if (sps->pic_order_cnt_type == 1) {
 784       unsigned MaxFrameNum = 1 << (sps->log2_max_frame_num_minus4 + 4);
 785       unsigned FrameNumOffset, absFrameNum, expectedPicOrderCnt;
 786
 787       if (!sps->delta_pic_order_always_zero_flag) {
 788          unsigned delta_pic_order_cnt[2];
 789
 790          delta_pic_order_cnt[0] = vl_rbsp_se(rbsp);
 791
 792          if (delta_pic_order_cnt[0] != priv->codec_data.h264.delta_pic_order_cnt[0])
 793             vid_dec_h264_EndFrame(priv);
 794
 795          priv->codec_data.h264.delta_pic_order_cnt[0] = delta_pic_order_cnt[0];
 796
 797          if (pps->bottom_field_pic_order_in_frame_present_flag && !priv->picture.h264.field_pic_flag) {
 798             delta_pic_order_cnt[1] = vl_rbsp_se(rbsp);
 799
 800             if (delta_pic_order_cnt[1] != priv->codec_data.h264.delta_pic_order_cnt[1])
 801                vid_dec_h264_EndFrame(priv);
 802
 803             priv->codec_data.h264.delta_pic_order_cnt[1] = delta_pic_order_cnt[1];
 804          }
 805       }
 806
 807       if (IdrPicFlag)
 808          FrameNumOffset = 0;
 809       else if (prevFrameNum > frame_num)
 810          FrameNumOffset = priv->codec_data.h264.prevFrameNumOffset + MaxFrameNum;
 811       else
 812          FrameNumOffset = priv->codec_data.h264.prevFrameNumOffset;
 813
 814       priv->codec_data.h264.prevFrameNumOffset = FrameNumOffset;
 815
 816       if (sps->num_ref_frames_in_pic_order_cnt_cycle != 0)
 817          absFrameNum = FrameNumOffset + frame_num;
 818       else
 819          absFrameNum = 0;
 820
 821       if (nal_ref_idc == 0 && absFrameNum > 0)
 822          absFrameNum = absFrameNum - 1;
 823
 824       if (absFrameNum > 0) {
 825          unsigned picOrderCntCycleCnt = (absFrameNum - 1) / sps->num_ref_frames_in_pic_order_cnt_cycle;
 826          unsigned frameNumInPicOrderCntCycle = (absFrameNum - 1) % sps->num_ref_frames_in_pic_order_cnt_cycle;
 827          signed ExpectedDeltaPerPicOrderCntCycle = 0;
 828          unsigned i;
 829
 830          for (i = 0; i < sps->num_ref_frames_in_pic_order_cnt_cycle; ++i)
 831             ExpectedDeltaPerPicOrderCntCycle += sps->offset_for_ref_frame[i];
 832
 833          expectedPicOrderCnt = picOrderCntCycleCnt * ExpectedDeltaPerPicOrderCntCycle;
 834          for (i = 0; i <= frameNumInPicOrderCntCycle; ++i)
 835             expectedPicOrderCnt += sps->offset_for_ref_frame[i];
 836
 837       } else
 838          expectedPicOrderCnt = 0;
 839
 840       if (nal_ref_idc == 0)
 841          expectedPicOrderCnt += sps->offset_for_non_ref_pic;
 842
 843       if (!priv->picture.h264.field_pic_flag) {
 844          priv->picture.h264.field_order_cnt[0] = expectedPicOrderCnt + priv->codec_data.h264.delta_pic_order_cnt[0];
 845          priv->picture.h264.field_order_cnt[1] = priv->picture.h264.field_order_cnt[0] +
 846             sps->offset_for_top_to_bottom_field + priv->codec_data.h264.delta_pic_order_cnt[1];
 847
 848       } else if (!priv->picture.h264.bottom_field_flag)
 849          priv->picture.h264.field_order_cnt[0] = expectedPicOrderCnt + priv->codec_data.h264.delta_pic_order_cnt[0];
 850       else
 851          priv->picture.h264.field_order_cnt[1] = expectedPicOrderCnt + sps->offset_for_top_to_bottom_field +
 852             priv->codec_data.h264.delta_pic_order_cnt[0];
 853
 854    } else if (sps->pic_order_cnt_type == 2) {
 855       unsigned MaxFrameNum = 1 << (sps->log2_max_frame_num_minus4 + 4);
 856       unsigned FrameNumOffset, tempPicOrderCnt;
 857
 858       if (IdrPicFlag)
 859          FrameNumOffset = 0;
 860       else if (prevFrameNum > frame_num)
 861          FrameNumOffset = priv->codec_data.h264.prevFrameNumOffset + MaxFrameNum;
 862       else
 863          FrameNumOffset = priv->codec_data.h264.prevFrameNumOffset;
 864
 865       priv->codec_data.h264.prevFrameNumOffset = FrameNumOffset;
 866
 867       if (IdrPicFlag)
 868          tempPicOrderCnt = 0;
 869       else if (nal_ref_idc == 0)
 870          tempPicOrderCnt = 2 * (FrameNumOffset + frame_num) - 1;
 871       else
 872          tempPicOrderCnt = 2 * (FrameNumOffset + frame_num);
 873
 874       if (!priv->picture.h264.field_pic_flag) {
 875          priv->picture.h264.field_order_cnt[0] = tempPicOrderCnt;
 876          priv->picture.h264.field_order_cnt[1] = tempPicOrderCnt;
 877
 878       } else if (!priv->picture.h264.bottom_field_flag)
 879          priv->picture.h264.field_order_cnt[0] = tempPicOrderCnt;
 880       else
 881          priv->picture.h264.field_order_cnt[1] = tempPicOrderCnt;
 882    }
 883
 884    if (pps->redundant_pic_cnt_present_flag)
 885       /* redundant_pic_cnt */
 886       vl_rbsp_ue(rbsp);
 887
 888    if (slice_type == PIPE_H264_SLICE_TYPE_B)
 889       /* direct_spatial_mv_pred_flag */
 890       vl_rbsp_u(rbsp, 1);
 891
 892    priv->picture.h264.num_ref_idx_l0_active_minus1 = pps->num_ref_idx_l0_default_active_minus1;
 893    priv->picture.h264.num_ref_idx_l1_active_minus1 = pps->num_ref_idx_l1_default_active_minus1;
 894
 895    if (slice_type == PIPE_H264_SLICE_TYPE_P ||
 896        slice_type == PIPE_H264_SLICE_TYPE_SP ||
 897        slice_type == PIPE_H264_SLICE_TYPE_B) {
 898
 899       /* num_ref_idx_active_override_flag */
 900       if (vl_rbsp_u(rbsp, 1)) {
 901          priv->picture.h264.num_ref_idx_l0_active_minus1 = vl_rbsp_ue(rbsp);
 902
 903          if (slice_type == PIPE_H264_SLICE_TYPE_B)
 904             priv->picture.h264.num_ref_idx_l1_active_minus1 = vl_rbsp_ue(rbsp);
 905       }
 906    }
 907
 908    if (nal_unit_type == 20 || nal_unit_type == 21)
 909       ref_pic_list_mvc_modification(priv, rbsp);
 910    else
 911       ref_pic_list_modification(priv, rbsp, slice_type);
 912
 913    if ((pps->weighted_pred_flag && (slice_type == PIPE_H264_SLICE_TYPE_P || slice_type == PIPE_H264_SLICE_TYPE_SP)) ||
 914        (pps->weighted_bipred_idc == 1 && slice_type == PIPE_H264_SLICE_TYPE_B))
 915       pred_weight_table(priv, rbsp, sps, slice_type);
 916
 917    if (nal_ref_idc != 0)
 918       dec_ref_pic_marking(priv, rbsp, IdrPicFlag);
 919
 920    if (pps->entropy_coding_mode_flag && slice_type != PIPE_H264_SLICE_TYPE_I && slice_type != PIPE_H264_SLICE_TYPE_SI)
 921       /* cabac_init_idc */
 922       vl_rbsp_ue(rbsp);
 923
 924    /* slice_qp_delta */
 925    vl_rbsp_se(rbsp);
 926
 927    if (slice_type == PIPE_H264_SLICE_TYPE_SP || slice_type == PIPE_H264_SLICE_TYPE_SI) {
 928       if (slice_type == PIPE_H264_SLICE_TYPE_SP)
 929          /* sp_for_switch_flag */
 930          vl_rbsp_u(rbsp, 1);
 931
 932       /*slice_qs_delta */
 933       vl_rbsp_se(rbsp);
 934    }
 935
 936    if (pps->deblocking_filter_control_present_flag) {
 937       unsigned disable_deblocking_filter_idc = vl_rbsp_ue(rbsp);
 938
 939       if (disable_deblocking_filter_idc != 1) {
 940          /* slice_alpha_c0_offset_div2 */
 941          vl_rbsp_se(rbsp);
 942
 943          /* slice_beta_offset_div2 */
 944          vl_rbsp_se(rbsp);
 945       }
 946    }
 947
 948    if (pps->num_slice_groups_minus1 > 0 && pps->slice_group_map_type >= 3 && pps->slice_group_map_type <= 5)
 949       /* slice_group_change_cycle */
 950       vl_rbsp_u(rbsp, 2);
 951 }
 952
 953 static void vid_dec_h264_Decode(vid_dec_PrivateType *priv, struct vl_vlc *vlc, unsigned min_bits_left)
 954 {
 955    unsigned nal_ref_idc, nal_unit_type;
 956
 957    if (!vl_vlc_search_byte(vlc, vl_vlc_bits_left(vlc) - min_bits_left, 0x00))
 958       return;
 959
 960    if (vl_vlc_peekbits(vlc, 24) != 0x000001) {
 961       vl_vlc_eatbits(vlc, 8);
 962       return;
 963    }
 964
 965    if (priv->slice) {
 966       unsigned bytes = priv->bytes_left - (vl_vlc_bits_left(vlc) / 8);
 967       ++priv->picture.h264.slice_count;
 968       priv->codec->decode_bitstream(priv->codec, priv->target, &priv->picture.base,
 969                                     1, &priv->slice, &bytes);
 970       priv->slice = NULL;
 971    }
 972
 973    vl_vlc_eatbits(vlc, 24);
 974
 975    /* forbidden_zero_bit */
 976    vl_vlc_eatbits(vlc, 1);
 977
 978    nal_ref_idc = vl_vlc_get_uimsbf(vlc, 2);
 979
 980    if (nal_ref_idc != priv->codec_data.h264.nal_ref_idc &&
 981        (nal_ref_idc * priv->codec_data.h264.nal_ref_idc) == 0)
 982       vid_dec_h264_EndFrame(priv);
 983
 984    priv->codec_data.h264.nal_ref_idc = nal_ref_idc;
 985
 986    nal_unit_type = vl_vlc_get_uimsbf(vlc, 5);
 987
 988    if (nal_unit_type != 1 && nal_unit_type != 5)
 989       vid_dec_h264_EndFrame(priv);
 990
 991    if (nal_unit_type == 7) {
 992       struct vl_rbsp rbsp;
 993       vl_rbsp_init(&rbsp, vlc, ~0);
 994       seq_parameter_set(priv, &rbsp);
 995
 996    } else if (nal_unit_type == 8) {
 997       struct vl_rbsp rbsp;
 998       vl_rbsp_init(&rbsp, vlc, ~0);
 999       picture_parameter_set(priv, &rbsp);
1000
1001    } else if (nal_unit_type == 1 || nal_unit_type == 5) {
1002       /* Coded slice of a non-IDR or IDR picture */
1003       unsigned bits = vl_vlc_valid_bits(vlc);
1004       unsigned bytes = bits / 8 + 4;
1005       struct vl_rbsp rbsp;
1006       uint8_t buf[8];
1007       const void *ptr = buf;
1008       unsigned i;
1009
1010       buf[0] = 0x0;
1011       buf[1] = 0x0;
1012       buf[2] = 0x1;
1013       buf[3] = (nal_ref_idc << 5) | nal_unit_type;
1014       for (i = 4; i < bytes; ++i)
1015          buf[i] = vl_vlc_peekbits(vlc, bits) >> ((bytes - i - 1) * 8);
1016
1017       priv->bytes_left = (vl_vlc_bits_left(vlc) - bits) / 8;
1018       priv->slice = vlc->data;
1019
1020       vl_rbsp_init(&rbsp, vlc, 128);
1021       slice_header(priv, &rbsp, nal_ref_idc, nal_unit_type);
1022
1023       vid_dec_h264_BeginFrame(priv);
1024
1025       ++priv->picture.h264.slice_count;
1026       priv->codec->decode_bitstream(priv->codec, priv->target, &priv->picture.base,
1027                                     1, &ptr, &bytes);
1028    }
1029
1030    /* resync to byte boundary */
1031    vl_vlc_eatbits(vlc, vl_vlc_valid_bits(vlc) % 8);
1032 }