Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

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