avcodec/hevc: Adjust white-spaces to reduce difference to 064698d3

Signed-off-by: Michael Niedermayer <michaelni@gmx.at>

libavcodec/hevc_parser.c

@@ -21,6 +21,7 @@
  */
 
 #include "libavutil/common.h"
+
 #include "parser.h"
 #include "hevc.h"
 #include "golomb.h"
@@ -36,7 +37,8 @@ typedef struct HEVCParseContext {
  * Find the end of the current frame in the bitstream.
  * @return the position of the first byte of the next frame, or END_NOT_FOUND
  */
-static int hevc_find_frame_end(AVCodecParserContext *s, const uint8_t *buf, int buf_size)
+static int hevc_find_frame_end(AVCodecParserContext *s, const uint8_t *buf,
+                               int buf_size)
 {
     int i;
     ParseContext *pc = &((HEVCParseContext *)s->priv_data)->pc;
@@ -82,9 +84,8 @@ static int hevc_find_frame_end(AVCodecParserContext *s, const uint8_t *buf, int
  * @param buf buffer with field/frame data.
  * @param buf_size size of the buffer.
  */
-static inline int parse_nal_units(AVCodecParserContext *s,
-                                  AVCodecContext *avctx,
-                                  const uint8_t *buf, int buf_size)
+static inline int parse_nal_units(AVCodecParserContext *s, AVCodecContext *avctx,
+                      const uint8_t *buf, int buf_size)
 {
     HEVCContext   *h  = &((HEVCParseContext *)s->priv_data)->h;
     GetBitContext *gb = &h->HEVClc->gb;
@@ -269,7 +270,7 @@ static int hevc_parse(AVCodecParserContext *s,
     } else {
         next = hevc_find_frame_end(s, buf, buf_size);
         if (ff_combine_frame(pc, next, &buf, &buf_size) < 0) {
-            *poutbuf = NULL;
+            *poutbuf      = NULL;
             *poutbuf_size = 0;
             return buf_size;
         }
@@ -299,9 +300,9 @@ static int hevc_split(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
                 return i - 3;
             } else { // no parameter set at the beginning of the stream
                 return 0;
-            }
         }
     }
+    }
     return 0;
 }
 

libavcodec/hevc_ps.c

@@ -229,7 +229,7 @@ static int decode_profile_tier_level(HEVCContext *s, PTL *ptl,
     }
     if (max_num_sub_layers - 1 > 0)
         for (i = max_num_sub_layers - 1; i < 8; i++)
-            skip_bits(gb, 2); // reserved_zero_2bits[i]
+            skip_bits(gb, 2);  // reserved_zero_2bits[i]
     for (i = 0; i < max_num_sub_layers - 1; i++) {
         if (ptl->sub_layer_profile_present_flag[i]) {
             ptl->sub_layer_profile_space[i] = get_bits(gb, 2);
@@ -273,7 +273,8 @@ static void decode_sublayer_hrd(HEVCContext *s, int nb_cpb,
     }
 }
 
-static void decode_hrd(HEVCContext *s, int common_inf_present, int max_sublayers)
+static void decode_hrd(HEVCContext *s, int common_inf_present,
+                       int max_sublayers)
 {
     GetBitContext *gb = &s->HEVClc->gb;
     int nal_params_present = 0, vcl_params_present = 0;
@@ -298,7 +299,7 @@ static void decode_hrd(HEVCContext *s, int common_inf_present, int max_sublayers
             skip_bits(gb, 4); // cpb_size_scale
 
             if (subpic_params_present)
-                skip_bits(gb, 4); // cpb_size_du_scale
+                skip_bits(gb, 4);  // cpb_size_du_scale
 
             skip_bits(gb, 5); // initial_cpb_removal_delay_length_minus1
             skip_bits(gb, 5); // au_cpb_removal_delay_length_minus1
@@ -315,7 +316,7 @@ static void decode_hrd(HEVCContext *s, int common_inf_present, int max_sublayers
             fixed_rate = get_bits1(gb);
 
         if (fixed_rate)
-            get_ue_golomb_long(gb); // elemental_duration_in_tc_minus1
+            get_ue_golomb_long(gb);  // elemental_duration_in_tc_minus1
         else
             low_delay = get_bits1(gb);
 
@@ -396,7 +397,7 @@ int ff_hevc_decode_nal_vps(HEVCContext *s)
     vps->vps_num_layer_sets = get_ue_golomb_long(gb) + 1;
     for (i = 1; i < vps->vps_num_layer_sets; i++)
         for (j = 0; j <= vps->vps_max_layer_id; j++)
-            skip_bits(gb, 1); // layer_id_included_flag[i][j]
+            skip_bits(gb, 1);  // layer_id_included_flag[i][j]
 
     vps->vps_timing_info_present_flag = get_bits1(gb);
     if (vps->vps_timing_info_present_flag) {
@@ -582,7 +583,7 @@ static int scaling_list_data(HEVCContext *s, ScalingList *sl)
                 int32_t scaling_list_delta_coef;
 
                 next_coef = 8;
-                coef_num  = FFMIN(64, 1  <<  (4 + (size_id  <<  1)));
+                coef_num  = FFMIN(64, 1 << (4 + (size_id << 1)));
                 if (size_id > 1) {
                     scaling_list_dc_coef[size_id - 2][matrix_id] = get_se_golomb(gb) + 8;
                     next_coef = scaling_list_dc_coef[size_id - 2][matrix_id];
@@ -643,7 +644,8 @@ int ff_hevc_decode_nal_sps(HEVCContext *s)
     }
 
     skip_bits1(gb); // temporal_id_nesting_flag
-    if (decode_profile_tier_level(s, &sps->ptl, sps->max_sub_layers) < 0) {
+    if (decode_profile_tier_level(s, &sps->ptl,
+                                  sps->max_sub_layers) < 0) {
         av_log(s->avctx, AV_LOG_ERROR, "error decoding profile tier level\n");
         ret = AVERROR_INVALIDDATA;
         goto err;
@@ -820,11 +822,12 @@ int ff_hevc_decode_nal_sps(HEVCContext *s)
 
     sps->nb_st_rps = get_ue_golomb_long(gb);
     if (sps->nb_st_rps > MAX_SHORT_TERM_RPS_COUNT) {
-        av_log(s->avctx, AV_LOG_ERROR, "Too many short term RPS: %d.\n",
+            av_log(s->avctx, AV_LOG_ERROR,
+                   "Too many short term RPS: %d.\n",
                sps->nb_st_rps);
         ret = AVERROR_INVALIDDATA;
-        goto err;
-    }
+            goto err;
+        }
     for (i = 0; i < sps->nb_st_rps; i++) {
         if ((ret = ff_hevc_decode_short_term_rps(s, &sps->st_rps[i],
                                                  sps, 0)) < 0)
@@ -870,10 +873,9 @@ int ff_hevc_decode_nal_sps(HEVCContext *s)
                sps->output_width, sps->output_height);
         if (s->avctx->err_recognition & AV_EF_EXPLODE) {
             ret = AVERROR_INVALIDDATA;
-            goto err;
-        }
-        av_log(s->avctx, AV_LOG_WARNING,
-               "Displaying the whole video surface.\n");
+        goto err;
+    }
+        av_log(s->avctx, AV_LOG_WARNING, "Displaying the whole video surface.\n");
         sps->pic_conf_win.left_offset   =
         sps->pic_conf_win.right_offset  =
         sps->pic_conf_win.top_offset    =
@@ -1016,8 +1018,8 @@ int ff_hevc_decode_nal_pps(HEVCContext *s)
     if (pps_id >= MAX_PPS_COUNT) {
         av_log(s->avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", pps_id);
         ret = AVERROR_INVALIDDATA;
-        goto err;
-    }
+            goto err;
+        }
     pps->sps_id = get_ue_golomb_long(gb);
     if (pps->sps_id >= MAX_SPS_COUNT) {
         av_log(s->avctx, AV_LOG_ERROR, "SPS id out of range: %d\n", pps->sps_id);
@@ -1080,11 +1082,11 @@ int ff_hevc_decode_nal_pps(HEVCContext *s)
         pps->num_tile_rows    = get_ue_golomb_long(gb) + 1;
         if (pps->num_tile_columns == 0 ||
             pps->num_tile_columns >= sps->width) {
-            av_log(s->avctx, AV_LOG_ERROR, "num_tile_columns_minus1 out of range: %d\n",
+        av_log(s->avctx, AV_LOG_ERROR, "num_tile_columns_minus1 out of range: %d\n",
                    pps->num_tile_columns - 1);
             ret = AVERROR_INVALIDDATA;
-            goto err;
-        }
+        goto err;
+    }
         if (pps->num_tile_rows == 0 ||
             pps->num_tile_rows >= sps->height) {
             av_log(s->avctx, AV_LOG_ERROR, "num_tile_rows_minus1 out of range: %d\n",
@@ -1110,8 +1112,8 @@ int ff_hevc_decode_nal_pps(HEVCContext *s)
             if (sum >= sps->ctb_width) {
                 av_log(s->avctx, AV_LOG_ERROR, "Invalid tile widths.\n");
                 ret = AVERROR_INVALIDDATA;
-                goto err;
-            }
+            goto err;
+        }
             pps->column_width[pps->num_tile_columns - 1] = sps->ctb_width - sum;
 
             sum = 0;
@@ -1166,8 +1168,8 @@ int ff_hevc_decode_nal_pps(HEVCContext *s)
         av_log(s->avctx, AV_LOG_ERROR, "log2_parallel_merge_level_minus2 out of range: %d\n",
                pps->log2_parallel_merge_level - 2);
         ret = AVERROR_INVALIDDATA;
-        goto err;
-    }
+                goto err;
+            }
 
     pps->slice_header_extension_present_flag = get_bits1(gb);
     pps->pps_extension_flag                  = get_bits1(gb);
@@ -1187,9 +1189,9 @@ int ff_hevc_decode_nal_pps(HEVCContext *s)
             pps->row_height   = av_malloc_array(pps->num_tile_rows,    sizeof(*pps->row_height));
         }
         if (!pps->column_width || !pps->row_height) {
-            ret = AVERROR(ENOMEM);
-            goto err;
-        }
+        ret = AVERROR(ENOMEM);
+        goto err;
+    }
 
         for (i = 0; i < pps->num_tile_columns; i++) {
             pps->column_width[i] = ((i + 1) * sps->ctb_width) / pps->num_tile_columns -
@@ -1230,9 +1232,9 @@ int ff_hevc_decode_nal_pps(HEVCContext *s)
     pps->min_tb_addr_zs    = av_malloc_array(pic_area_in_min_tbs, sizeof(*pps->min_tb_addr_zs));
     if (!pps->ctb_addr_rs_to_ts || !pps->ctb_addr_ts_to_rs ||
         !pps->tile_id || !pps->min_cb_addr_zs || !pps->min_tb_addr_zs) {
-        ret = AVERROR(ENOMEM);
-        goto err;
-    }
+            ret = AVERROR(ENOMEM);
+            goto err;
+        }
 
     for (ctb_addr_rs = 0; ctb_addr_rs < pic_area_in_ctbs; ctb_addr_rs++) {
         int tb_x   = ctb_addr_rs % sps->ctb_width;

libavcodec/hevc_refs.c

@@ -49,16 +49,17 @@ void ff_hevc_unref_frame(HEVCContext *s, HEVCFrame *frame, int flags)
     }
 }
 
-RefPicList* ff_hevc_get_ref_list(HEVCContext *s, HEVCFrame *ref, int x0, int y0)
+RefPicList *ff_hevc_get_ref_list(HEVCContext *s, HEVCFrame *ref, int x0, int y0)
 {
     if (x0 < 0 || y0 < 0) {
         return s->ref->refPicList;
     } else {
         int x_cb         = x0 >> s->sps->log2_ctb_size;
         int y_cb         = y0 >> s->sps->log2_ctb_size;
-        int pic_width_cb = (s->sps->width + (1<<s->sps->log2_ctb_size)-1 ) >> s->sps->log2_ctb_size;
+        int pic_width_cb = (s->sps->width + (1 << s->sps->log2_ctb_size) - 1) >>
+                           s->sps->log2_ctb_size;
         int ctb_addr_ts  = s->pps->ctb_addr_rs_to_ts[y_cb * pic_width_cb + x_cb];
-        return (RefPicList*) ref->rpl_tab[ctb_addr_ts];
+        return (RefPicList *)ref->rpl_tab[ctb_addr_ts];
     }
 }
 
@@ -67,7 +68,8 @@ void ff_hevc_clear_refs(HEVCContext *s)
     int i;
     for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++)
         ff_hevc_unref_frame(s, &s->DPB[i],
-                            HEVC_FRAME_FLAG_SHORT_REF | HEVC_FRAME_FLAG_LONG_REF);
+                            HEVC_FRAME_FLAG_SHORT_REF |
+                            HEVC_FRAME_FLAG_LONG_REF);
 }
 
 void ff_hevc_flush_dpb(HEVCContext *s)
@@ -85,7 +87,8 @@ static HEVCFrame *alloc_frame(HEVCContext *s)
         if (frame->frame->buf[0])
             continue;
 
-        ret = ff_thread_get_buffer(s->avctx, &frame->tf, AV_GET_BUFFER_FLAG_REF);
+        ret = ff_thread_get_buffer(s->avctx, &frame->tf,
+                                   AV_GET_BUFFER_FLAG_REF);
         if (ret < 0)
             return NULL;
 
@@ -96,15 +99,15 @@ static HEVCFrame *alloc_frame(HEVCContext *s)
         frame->tab_mvf_buf = av_buffer_pool_get(s->tab_mvf_pool);
         if (!frame->tab_mvf_buf)
             goto fail;
-        frame->tab_mvf = (MvField*)frame->tab_mvf_buf->data;
+        frame->tab_mvf = (MvField *)frame->tab_mvf_buf->data;
 
         frame->rpl_tab_buf = av_buffer_pool_get(s->rpl_tab_pool);
         if (!frame->rpl_tab_buf)
             goto fail;
-        frame->rpl_tab   = (RefPicListTab**)frame->rpl_tab_buf->data;
+        frame->rpl_tab   = (RefPicListTab **)frame->rpl_tab_buf->data;
         frame->ctb_count = s->sps->ctb_width * s->sps->ctb_height;
         for (j = 0; j < frame->ctb_count; j++)
-            frame->rpl_tab[j] = (RefPicListTab*)frame->rpl_buf->data;
+            frame->rpl_tab[j] = (RefPicListTab *)frame->rpl_buf->data;
 
         frame->frame->top_field_first  = s->picture_struct == AV_PICTURE_STRUCTURE_TOP_FIELD;
         frame->frame->interlaced_frame = (s->picture_struct == AV_PICTURE_STRUCTURE_TOP_FIELD) || (s->picture_struct == AV_PICTURE_STRUCTURE_BOTTOM_FIELD);
@@ -138,13 +141,13 @@ int ff_hevc_set_new_ref(HEVCContext *s, AVFrame **frame, int poc)
     if (!ref)
         return AVERROR(ENOMEM);
 
-    *frame              = ref->frame;
-    s->ref              = ref;
-    ref->poc            = poc;
+    *frame = ref->frame;
+    s->ref = ref;
 
-    ref->flags          = HEVC_FRAME_FLAG_OUTPUT | HEVC_FRAME_FLAG_SHORT_REF;
-    ref->sequence       = s->seq_decode;
-    ref->window         = s->sps->output_window;
+    ref->poc      = poc;
+    ref->flags    = HEVC_FRAME_FLAG_OUTPUT | HEVC_FRAME_FLAG_SHORT_REF;
+    ref->sequence = s->seq_decode;
+    ref->window   = s->sps->output_window;
 
     return 0;
 }
@@ -192,7 +195,8 @@ int ff_hevc_output_frame(HEVCContext *s, AVFrame *out, int flush)
                           (frame->window.top_offset   >> vshift) * dst->linesize[j];
                 dst->data[j] += off;
             }
-            av_log(s->avctx, AV_LOG_DEBUG, "Output frame with POC %d.\n", frame->poc);
+            av_log(s->avctx, AV_LOG_DEBUG,
+                   "Output frame with POC %d.\n", frame->poc);
             return 1;
         }
 
@@ -208,17 +212,17 @@ int ff_hevc_output_frame(HEVCContext *s, AVFrame *out, int flush)
 static int init_slice_rpl(HEVCContext *s)
 {
     HEVCFrame *frame = s->ref;
-    int ctb_count   = frame->ctb_count;
-    int ctb_addr_ts = s->pps->ctb_addr_rs_to_ts[s->sh.slice_segment_addr];
+    int ctb_count    = frame->ctb_count;
+    int ctb_addr_ts  = s->pps->ctb_addr_rs_to_ts[s->sh.slice_segment_addr];
     int i;
 
     if (s->slice_idx >= frame->rpl_buf->size / sizeof(RefPicListTab))
         return AVERROR_INVALIDDATA;
 
     for (i = ctb_addr_ts; i < ctb_count; i++)
-        frame->rpl_tab[i] = (RefPicListTab*)frame->rpl_buf->data + s->slice_idx;
+        frame->rpl_tab[i] = (RefPicListTab *)frame->rpl_buf->data + s->slice_idx;
 
-    frame->refPicList = (RefPicList*)frame->rpl_tab[ctb_addr_ts];
+    frame->refPicList = (RefPicList *)frame->rpl_tab[ctb_addr_ts];
 
     return 0;
 }
@@ -247,8 +251,7 @@ int ff_hevc_slice_rpl(HEVCContext *s)
 
         /* The order of the elements is
          * ST_CURR_BEF - ST_CURR_AFT - LT_CURR for the L0 and
-         * ST_CURR_AFT - ST_CURR_BEF - LT_CURR for the L1
-         */
+         * ST_CURR_AFT - ST_CURR_BEF - LT_CURR for the L1 */
         int cand_lists[3] = { list_idx ? ST_CURR_AFT : ST_CURR_BEF,
                               list_idx ? ST_CURR_BEF : ST_CURR_AFT,
                               LT_CURR };
@@ -258,8 +261,8 @@ int ff_hevc_slice_rpl(HEVCContext *s)
             for (i = 0; i < FF_ARRAY_ELEMS(cand_lists); i++) {
                 RefPicList *rps = &s->rps[cand_lists[i]];
                 for (j = 0; j < rps->nb_refs && rpl_tmp.nb_refs < MAX_REFS; j++) {
-                    rpl_tmp.list[rpl_tmp.nb_refs] = rps->list[j];
-                    rpl_tmp.ref[rpl_tmp.nb_refs]  = rps->ref[j];
+                    rpl_tmp.list[rpl_tmp.nb_refs]       = rps->list[j];
+                    rpl_tmp.ref[rpl_tmp.nb_refs]        = rps->ref[j];
                     rpl_tmp.isLongTerm[rpl_tmp.nb_refs] = (i == 2);
                     rpl_tmp.nb_refs++;
                 }
@@ -331,15 +334,14 @@ static HEVCFrame *generate_missing_ref(HEVCContext *s, int poc)
     HEVCFrame *frame;
     int i, x, y;
 
-
     frame = alloc_frame(s);
     if (!frame)
         return NULL;
 
     if (!s->sps->pixel_shift) {
         for (i = 0; frame->frame->buf[i]; i++)
-             memset(frame->frame->buf[i]->data, 1 << (s->sps->bit_depth - 1),
-                    frame->frame->buf[i]->size);
+            memset(frame->frame->buf[i]->data, 1 << (s->sps->bit_depth - 1),
+                   frame->frame->buf[i]->size);
     } else {
         for (i = 0; frame->frame->data[i]; i++)
             for (y = 0; y < (s->sps->height >> s->sps->vshift[i]); y++)
@@ -456,7 +458,7 @@ int ff_hevc_compute_poc(HEVCContext *s, int poc_lsb)
         poc_msb = prev_poc_msb;
 
     // For BLA picture types, POCmsb is set to 0.
-    if (s->nal_unit_type == NAL_BLA_W_LP ||
+    if (s->nal_unit_type == NAL_BLA_W_LP   ||
         s->nal_unit_type == NAL_BLA_W_RADL ||
         s->nal_unit_type == NAL_BLA_N_LP)
         poc_msb = 0;

libavcodec/hevc_sei.c

@@ -25,7 +25,8 @@
 #include "hevc.h"
 #include "golomb.h"
 
-static void decode_nal_sei_decoded_picture_hash(HEVCContext *s, int payload_size)
+static void decode_nal_sei_decoded_picture_hash(HEVCContext *s,
+                                                int payload_size)
 {
     int cIdx, i;
     uint8_t hash_type;
@@ -34,17 +35,16 @@ static void decode_nal_sei_decoded_picture_hash(HEVCContext *s, int payload_size
     GetBitContext *gb = &s->HEVClc->gb;
     hash_type = get_bits(gb, 8);
 
-
-    for( cIdx = 0; cIdx < 3/*((s->sps->chroma_format_idc == 0) ? 1 : 3)*/; cIdx++ ) {
-        if ( hash_type == 0 ) {
+    for (cIdx = 0; cIdx < 3/*((s->sps->chroma_format_idc == 0) ? 1 : 3)*/; cIdx++) {
+        if (hash_type == 0) {
             s->is_md5 = 1;
-            for( i = 0; i < 16; i++) {
+            for (i = 0; i < 16; i++) {
                 s->md5[cIdx][i] = get_bits(gb, 8);
-            }
-        } else if( hash_type == 1 ) {
+        }
+        } else if( hash_type == 1) {
             // picture_crc = get_bits(gb, 16);
             skip_bits(gb, 16);
-        } else if( hash_type == 2 ) {
+        } else if (hash_type == 2) {
             // picture_checksum = get_bits(gb, 32);
             skip_bits(gb, 32);
         }
@@ -101,7 +101,8 @@ static int decode_pic_timing(HEVCContext *s)
     return 1;
 }
 
-static void active_parameter_sets(HEVCContext *s) {
+static void active_parameter_sets(HEVCContext *s)
+{
     GetBitContext *gb = &s->HEVClc->gb;
     int num_sps_ids_minus1;
     int i;

libavcodec/hevcpred.c

@@ -40,16 +40,16 @@ void ff_hevc_pred_init(HEVCPredContext *hpc, int bit_depth)
 #undef FUNC
 #define FUNC(a, depth) a ## _ ## depth
 
-#define HEVC_PRED(depth)                            \
-    hpc->intra_pred   = FUNC(intra_pred, depth);   \
+#define HEVC_PRED(depth)                                \
+    hpc->intra_pred      = FUNC(intra_pred, depth);     \
     hpc->pred_planar[0]  = FUNC(pred_planar_0, depth);  \
     hpc->pred_planar[1]  = FUNC(pred_planar_1, depth);  \
     hpc->pred_planar[2]  = FUNC(pred_planar_2, depth);  \
     hpc->pred_planar[3]  = FUNC(pred_planar_3, depth);  \
-    hpc->pred_dc      = FUNC(pred_dc, depth);      \
-    hpc->pred_angular[0] = FUNC(pred_angular_0, depth);\
-    hpc->pred_angular[1] = FUNC(pred_angular_1, depth);\
-    hpc->pred_angular[2] = FUNC(pred_angular_2, depth);\
+    hpc->pred_dc         = FUNC(pred_dc, depth);        \
+    hpc->pred_angular[0] = FUNC(pred_angular_0, depth); \
+    hpc->pred_angular[1] = FUNC(pred_angular_1, depth); \
+    hpc->pred_angular[2] = FUNC(pred_angular_2, depth); \
     hpc->pred_angular[3] = FUNC(pred_angular_3, depth);
 
     switch (bit_depth) {