@@ -42,7 +42,6 @@ typedef struct HEVCParserContext {

     H2645Packet pkt;

     HEVCParamSets ps;

     HEVCSEI sei;

-    SliceHeader sh;

     int is_avc;

     int nal_length_size;

@@ -58,26 +57,28 @@ static int hevc_parse_slice_header(AVCodecParserContext *s, H2645NAL *nal,

     HEVCParserContext *ctx = s->priv_data;

     HEVCParamSets *ps = &ctx->ps;

     HEVCSEI *sei = &ctx->sei;

-    SliceHeader *sh = &ctx->sh;

     GetBitContext *gb = &nal->gb;

     const HEVCWindow *ow;

     int i, num = 0, den = 0;

-    sh->first_slice_in_pic_flag = get_bits1(gb);

+    unsigned int pps_id, first_slice_in_pic_flag, dependent_slice_segment_flag;

+    enum HEVCSliceType slice_type;

+

+    first_slice_in_pic_flag = get_bits1(gb);

     s->picture_structure = sei->picture_timing.picture_struct;

     s->field_order = sei->picture_timing.picture_struct;

     if (IS_IRAP_NAL(nal)) {

         s->key_frame = 1;

-        sh->no_output_of_prior_pics_flag = get_bits1(gb);

+        skip_bits1(gb); // no_output_of_prior_pics_flag

     }

-    sh->pps_id = get_ue_golomb(gb);

-    if (sh->pps_id >= HEVC_MAX_PPS_COUNT || !ps->pps_list[sh->pps_id]) {

-        av_log(avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", sh->pps_id);

+    pps_id = get_ue_golomb(gb);

+    if (pps_id >= HEVC_MAX_PPS_COUNT || !ps->pps_list[pps_id]) {

+        av_log(avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", pps_id);

         return AVERROR_INVALIDDATA;

     }

-    ps->pps = (HEVCPPS*)ps->pps_list[sh->pps_id]->data;

+    ps->pps = (HEVCPPS*)ps->pps_list[pps_id]->data;

     if (ps->pps->sps_id >= HEVC_MAX_SPS_COUNT || !ps->sps_list[ps->pps->sps_id]) {

         av_log(avctx, AV_LOG_ERROR, "SPS id out of range: %d\n", ps->pps->sps_id);

@@ -109,51 +110,53 @@ static int hevc_parse_slice_header(AVCodecParserContext *s, H2645NAL *nal,

         av_reduce(&avctx->framerate.den, &avctx->framerate.num,

                   num, den, 1 << 30);

-    if (!sh->first_slice_in_pic_flag) {

+    if (!first_slice_in_pic_flag) {

+        unsigned int slice_segment_addr;

         int slice_address_length;

         if (ps->pps->dependent_slice_segments_enabled_flag)

-            sh->dependent_slice_segment_flag = get_bits1(gb);

+            dependent_slice_segment_flag = get_bits1(gb);

         else

-            sh->dependent_slice_segment_flag = 0;

+            dependent_slice_segment_flag = 0;

         slice_address_length = av_ceil_log2_c(ps->sps->ctb_width *

                                               ps->sps->ctb_height);

-        sh->slice_segment_addr = get_bitsz(gb, slice_address_length);

-        if (sh->slice_segment_addr >= ps->sps->ctb_width * ps->sps->ctb_height) {

+        slice_segment_addr = get_bitsz(gb, slice_address_length);

+        if (slice_segment_addr >= ps->sps->ctb_width * ps->sps->ctb_height) {

             av_log(avctx, AV_LOG_ERROR, "Invalid slice segment address: %u.\n",

-                   sh->slice_segment_addr);

+                   slice_segment_addr);

             return AVERROR_INVALIDDATA;

         }

     } else

-        sh->dependent_slice_segment_flag = 0;

+        dependent_slice_segment_flag = 0;

-    if (sh->dependent_slice_segment_flag)

+    if (dependent_slice_segment_flag)

         return 0; /* break; */

     for (i = 0; i < ps->pps->num_extra_slice_header_bits; i++)

         skip_bits(gb, 1); // slice_reserved_undetermined_flag[]

-    sh->slice_type = get_ue_golomb(gb);

-    if (!(sh->slice_type == HEVC_SLICE_I || sh->slice_type == HEVC_SLICE_P ||

-          sh->slice_type == HEVC_SLICE_B)) {

+    slice_type = get_ue_golomb(gb);

+    if (!(slice_type == HEVC_SLICE_I || slice_type == HEVC_SLICE_P ||

+          slice_type == HEVC_SLICE_B)) {

         av_log(avctx, AV_LOG_ERROR, "Unknown slice type: %d.\n",

-               sh->slice_type);

+               slice_type);

         return AVERROR_INVALIDDATA;

     }

-    s->pict_type = sh->slice_type == HEVC_SLICE_B ? AV_PICTURE_TYPE_B :

-                   sh->slice_type == HEVC_SLICE_P ? AV_PICTURE_TYPE_P :

-                                               AV_PICTURE_TYPE_I;

+    s->pict_type = slice_type == HEVC_SLICE_B ? AV_PICTURE_TYPE_B :

+                   slice_type == HEVC_SLICE_P ? AV_PICTURE_TYPE_P :

+                                                AV_PICTURE_TYPE_I;

     if (ps->pps->output_flag_present_flag)

-        sh->pic_output_flag = get_bits1(gb);

+        skip_bits1(gb); // pic_output_flag

     if (ps->sps->separate_colour_plane_flag)

-        sh->colour_plane_id = get_bits(gb, 2);

+        skip_bits(gb, 2);   // colour_plane_id

     if (!IS_IDR_NAL(nal)) {

-        sh->pic_order_cnt_lsb = get_bits(gb, ps->sps->log2_max_poc_lsb);

-        s->output_picture_number = ctx->poc = ff_hevc_compute_poc(ps->sps, ctx->pocTid0, sh->pic_order_cnt_lsb, nal->type);

+        int pic_order_cnt_lsb = get_bits(gb, ps->sps->log2_max_poc_lsb);

+        s->output_picture_number = ctx->poc =

+            ff_hevc_compute_poc(ps->sps, ctx->pocTid0, pic_order_cnt_lsb, nal->type);

     } else

         s->output_picture_number = ctx->poc = 0;