diff mbox series

[FFmpeg-devel,3/7] avcodec/h264dec: replace FF_ALLOCZ{_ARRAY}_OR_GOTO with av_mallocz_array()

Message ID 1590674250-32571-3-git-send-email-lance.lmwang@gmail.com
State Superseded
Headers show
Series [FFmpeg-devel,1/7] avcodec/h264dec: cosmetics | expand

Checks

Context Check Description
andriy/default pending
andriy/make success Make finished
andriy/make_fate fail Make fate failed

Commit Message

Lance Wang May 28, 2020, 1:57 p.m. UTC
From: Limin Wang <lance.lmwang@gmail.com>

remove the fail goto label and return AVERROR(ENOMEM) directly

Signed-off-by: Limin Wang <lance.lmwang@gmail.com>
---
 libavcodec/h264dec.c | 60 +++++++++++++++-------------------------------------
 1 file changed, 17 insertions(+), 43 deletions(-)

Comments

Lance Wang May 28, 2020, 3:59 p.m. UTC | #1
On Thu, May 28, 2020 at 09:57:26PM +0800, lance.lmwang@gmail.com wrote:
> From: Limin Wang <lance.lmwang@gmail.com>
> 
> remove the fail goto label and return AVERROR(ENOMEM) directly
> 
> Signed-off-by: Limin Wang <lance.lmwang@gmail.com>
> ---
>  libavcodec/h264dec.c | 60 +++++++++++++++-------------------------------------
>  1 file changed, 17 insertions(+), 43 deletions(-)
> 
> diff --git a/libavcodec/h264dec.c b/libavcodec/h264dec.c
> index b03e6ed..974d324 100644
> --- a/libavcodec/h264dec.c
> +++ b/libavcodec/h264dec.c
> @@ -185,38 +185,24 @@ int ff_h264_alloc_tables(H264Context *h)
>      const int slice_tsize = big_mb_num + h->mb_stride;
>      int x, y;
>  
> -    FF_ALLOCZ_ARRAY_OR_GOTO(h->avctx, h->intra4x4_pred_mode,
> -                      row_mb_num, 8 * sizeof(uint8_t), fail)
> +    if (!(h->intra4x4_pred_mode     = av_mallocz_array(row_mb_num * 8, sizeof(uint8_t)))                ||
> +        !(h->non_zero_count         = av_mallocz_array(big_mb_num * 48, sizeof(uint8_t)))               ||
> +        !(h->slice_table_base       = av_mallocz_array(slice_tsize, sizeof(*h->slice_table_base)))      ||
> +        !(h->cbp_table              = av_mallocz_array(big_mb_num, sizeof(uint16_t)))                   ||
> +        !(h->chroma_pred_mode_table = av_mallocz_array(big_mb_num, sizeof(uint8_t)))                    ||
> +        !(h->mvd_table[0]           = av_mallocz_array(row_mb_num * 8, sizeof(uint8_t)))                ||
> +        !(h->mvd_table[1]           = av_mallocz_array(row_mb_num * 8, sizeof(uint8_t)))                ||
> +        !(h->direct_table           = av_mallocz_array(big_mb_num * 4, sizeof(uint8_t)))                ||
> +        !(h->list_counts            = av_mallocz_array(big_mb_num, sizeof(uint8_t)))                    ||
> +        !(h->mb2b_xy                = av_mallocz_array(big_mb_num, sizeof(uint32_t)))                   ||
> +        !(h->mb2br_xy               = av_mallocz_array(big_mb_num, sizeof(uint32_t))))
> +        return AVERROR(ENOMEM);
>      h->slice_ctx[0].intra4x4_pred_mode = h->intra4x4_pred_mode;
> -
> -    FF_ALLOCZ_OR_GOTO(h->avctx, h->non_zero_count,
> -                      big_mb_num * 48 * sizeof(uint8_t), fail)
> -    FF_ALLOCZ_OR_GOTO(h->avctx, h->slice_table_base,
> -                      slice_tsize * sizeof(*h->slice_table_base), fail)
> -    FF_ALLOCZ_OR_GOTO(h->avctx, h->cbp_table,
> -                      big_mb_num * sizeof(uint16_t), fail)
> -    FF_ALLOCZ_OR_GOTO(h->avctx, h->chroma_pred_mode_table,
> -                      big_mb_num * sizeof(uint8_t), fail)
> -    FF_ALLOCZ_ARRAY_OR_GOTO(h->avctx, h->mvd_table[0],
> -                      row_mb_num, 16 * sizeof(uint8_t), fail);
> -    FF_ALLOCZ_ARRAY_OR_GOTO(h->avctx, h->mvd_table[1],
> -                      row_mb_num, 16 * sizeof(uint8_t), fail);
>      h->slice_ctx[0].mvd_table[0] = h->mvd_table[0];
>      h->slice_ctx[0].mvd_table[1] = h->mvd_table[1];
> -
> -    FF_ALLOCZ_OR_GOTO(h->avctx, h->direct_table,
> -                      4 * big_mb_num * sizeof(uint8_t), fail);
> -    FF_ALLOCZ_OR_GOTO(h->avctx, h->list_counts,
> -                      big_mb_num * sizeof(uint8_t), fail)
> -
>      memset(h->slice_table_base, -1,
>             slice_tsize * sizeof(*h->slice_table_base));
>      h->slice_table = h->slice_table_base + h->mb_stride * 2 + 1;
> -
> -    FF_ALLOCZ_OR_GOTO(h->avctx, h->mb2b_xy,
> -                      big_mb_num * sizeof(uint32_t), fail);
> -    FF_ALLOCZ_OR_GOTO(h->avctx, h->mb2br_xy,
> -                      big_mb_num * sizeof(uint32_t), fail);
>      for (y = 0; y < h->mb_height; y++)
>          for (x = 0; x < h->mb_width; x++) {
>              const int mb_xy = x + y * h->mb_stride;
> @@ -227,9 +213,6 @@ int ff_h264_alloc_tables(H264Context *h)
>          }
>  
>      return 0;
> -
> -fail:
> -    return AVERROR(ENOMEM);
>  }
>  
>  /**
> @@ -269,8 +252,11 @@ int ff_h264_slice_context_init(H264Context *h, H264SliceContext *sl)
>          er->b8_stride   = h->mb_width * 2 + 1;
>  
>          // error resilience code looks cleaner with this
> -        FF_ALLOCZ_OR_GOTO(h->avctx, er->mb_index2xy,
> -                          (h->mb_num + 1) * sizeof(int), fail);
> +        if (!(er->mb_index2xy        = av_mallocz_array(h->mb_num + 1, sizeof(int)))                   ||
> +            !(er->error_status_table = av_mallocz_array(mb_array_size, sizeof(uint8_t)))               ||
> +            !(er->er_temp_buffer     = av_mallocz_array(h->mb_height * h->mb_stride + 1, sizeof(int))) ||
> +            !(sl->dc_val_base        = av_mallocz_array(yc_size, sizeof(int16_t))))
> +            return AVERROR(ENOMEM); // ff_h264_free_tables will clean up for us
>  
>          for (y = 0; y < h->mb_height; y++)
>              for (x = 0; x < h->mb_width; x++)
> @@ -278,15 +264,6 @@ int ff_h264_slice_context_init(H264Context *h, H264SliceContext *sl)
>  
>          er->mb_index2xy[h->mb_height * h->mb_width] = (h->mb_height - 1) *
>                                                        h->mb_stride + h->mb_width;
> -
> -        FF_ALLOCZ_OR_GOTO(h->avctx, er->error_status_table,
> -                          mb_array_size * sizeof(uint8_t), fail);
> -
> -        FF_ALLOC_OR_GOTO(h->avctx, er->er_temp_buffer,
> -                         h->mb_height * h->mb_stride * (4*sizeof(int) + 1), fail);
> -
> -        FF_ALLOCZ_OR_GOTO(h->avctx, sl->dc_val_base,
> -                          yc_size * sizeof(int16_t), fail);
>          er->dc_val[0] = sl->dc_val_base + h->mb_width * 2 + 2;
>          er->dc_val[1] = sl->dc_val_base + y_size + h->mb_stride + 1;
>          er->dc_val[2] = er->dc_val[1] + c_size;
> @@ -295,9 +272,6 @@ int ff_h264_slice_context_init(H264Context *h, H264SliceContext *sl)
>      }
>  
>      return 0;

Sorry, complete fate pass, but one of patch is failed. I'll fix it and update.


> -
> -fail:
> -    return AVERROR(ENOMEM); // ff_h264_free_tables will clean up for us
>  }
>  
>  static int h264_init_context(AVCodecContext *avctx, H264Context *h)
> -- 
> 1.8.3.1
>
diff mbox series

Patch

diff --git a/libavcodec/h264dec.c b/libavcodec/h264dec.c
index b03e6ed..974d324 100644
--- a/libavcodec/h264dec.c
+++ b/libavcodec/h264dec.c
@@ -185,38 +185,24 @@  int ff_h264_alloc_tables(H264Context *h)
     const int slice_tsize = big_mb_num + h->mb_stride;
     int x, y;
 
-    FF_ALLOCZ_ARRAY_OR_GOTO(h->avctx, h->intra4x4_pred_mode,
-                      row_mb_num, 8 * sizeof(uint8_t), fail)
+    if (!(h->intra4x4_pred_mode     = av_mallocz_array(row_mb_num * 8, sizeof(uint8_t)))                ||
+        !(h->non_zero_count         = av_mallocz_array(big_mb_num * 48, sizeof(uint8_t)))               ||
+        !(h->slice_table_base       = av_mallocz_array(slice_tsize, sizeof(*h->slice_table_base)))      ||
+        !(h->cbp_table              = av_mallocz_array(big_mb_num, sizeof(uint16_t)))                   ||
+        !(h->chroma_pred_mode_table = av_mallocz_array(big_mb_num, sizeof(uint8_t)))                    ||
+        !(h->mvd_table[0]           = av_mallocz_array(row_mb_num * 8, sizeof(uint8_t)))                ||
+        !(h->mvd_table[1]           = av_mallocz_array(row_mb_num * 8, sizeof(uint8_t)))                ||
+        !(h->direct_table           = av_mallocz_array(big_mb_num * 4, sizeof(uint8_t)))                ||
+        !(h->list_counts            = av_mallocz_array(big_mb_num, sizeof(uint8_t)))                    ||
+        !(h->mb2b_xy                = av_mallocz_array(big_mb_num, sizeof(uint32_t)))                   ||
+        !(h->mb2br_xy               = av_mallocz_array(big_mb_num, sizeof(uint32_t))))
+        return AVERROR(ENOMEM);
     h->slice_ctx[0].intra4x4_pred_mode = h->intra4x4_pred_mode;
-
-    FF_ALLOCZ_OR_GOTO(h->avctx, h->non_zero_count,
-                      big_mb_num * 48 * sizeof(uint8_t), fail)
-    FF_ALLOCZ_OR_GOTO(h->avctx, h->slice_table_base,
-                      slice_tsize * sizeof(*h->slice_table_base), fail)
-    FF_ALLOCZ_OR_GOTO(h->avctx, h->cbp_table,
-                      big_mb_num * sizeof(uint16_t), fail)
-    FF_ALLOCZ_OR_GOTO(h->avctx, h->chroma_pred_mode_table,
-                      big_mb_num * sizeof(uint8_t), fail)
-    FF_ALLOCZ_ARRAY_OR_GOTO(h->avctx, h->mvd_table[0],
-                      row_mb_num, 16 * sizeof(uint8_t), fail);
-    FF_ALLOCZ_ARRAY_OR_GOTO(h->avctx, h->mvd_table[1],
-                      row_mb_num, 16 * sizeof(uint8_t), fail);
     h->slice_ctx[0].mvd_table[0] = h->mvd_table[0];
     h->slice_ctx[0].mvd_table[1] = h->mvd_table[1];
-
-    FF_ALLOCZ_OR_GOTO(h->avctx, h->direct_table,
-                      4 * big_mb_num * sizeof(uint8_t), fail);
-    FF_ALLOCZ_OR_GOTO(h->avctx, h->list_counts,
-                      big_mb_num * sizeof(uint8_t), fail)
-
     memset(h->slice_table_base, -1,
            slice_tsize * sizeof(*h->slice_table_base));
     h->slice_table = h->slice_table_base + h->mb_stride * 2 + 1;
-
-    FF_ALLOCZ_OR_GOTO(h->avctx, h->mb2b_xy,
-                      big_mb_num * sizeof(uint32_t), fail);
-    FF_ALLOCZ_OR_GOTO(h->avctx, h->mb2br_xy,
-                      big_mb_num * sizeof(uint32_t), fail);
     for (y = 0; y < h->mb_height; y++)
         for (x = 0; x < h->mb_width; x++) {
             const int mb_xy = x + y * h->mb_stride;
@@ -227,9 +213,6 @@  int ff_h264_alloc_tables(H264Context *h)
         }
 
     return 0;
-
-fail:
-    return AVERROR(ENOMEM);
 }
 
 /**
@@ -269,8 +252,11 @@  int ff_h264_slice_context_init(H264Context *h, H264SliceContext *sl)
         er->b8_stride   = h->mb_width * 2 + 1;
 
         // error resilience code looks cleaner with this
-        FF_ALLOCZ_OR_GOTO(h->avctx, er->mb_index2xy,
-                          (h->mb_num + 1) * sizeof(int), fail);
+        if (!(er->mb_index2xy        = av_mallocz_array(h->mb_num + 1, sizeof(int)))                   ||
+            !(er->error_status_table = av_mallocz_array(mb_array_size, sizeof(uint8_t)))               ||
+            !(er->er_temp_buffer     = av_mallocz_array(h->mb_height * h->mb_stride + 1, sizeof(int))) ||
+            !(sl->dc_val_base        = av_mallocz_array(yc_size, sizeof(int16_t))))
+            return AVERROR(ENOMEM); // ff_h264_free_tables will clean up for us
 
         for (y = 0; y < h->mb_height; y++)
             for (x = 0; x < h->mb_width; x++)
@@ -278,15 +264,6 @@  int ff_h264_slice_context_init(H264Context *h, H264SliceContext *sl)
 
         er->mb_index2xy[h->mb_height * h->mb_width] = (h->mb_height - 1) *
                                                       h->mb_stride + h->mb_width;
-
-        FF_ALLOCZ_OR_GOTO(h->avctx, er->error_status_table,
-                          mb_array_size * sizeof(uint8_t), fail);
-
-        FF_ALLOC_OR_GOTO(h->avctx, er->er_temp_buffer,
-                         h->mb_height * h->mb_stride * (4*sizeof(int) + 1), fail);
-
-        FF_ALLOCZ_OR_GOTO(h->avctx, sl->dc_val_base,
-                          yc_size * sizeof(int16_t), fail);
         er->dc_val[0] = sl->dc_val_base + h->mb_width * 2 + 2;
         er->dc_val[1] = sl->dc_val_base + y_size + h->mb_stride + 1;
         er->dc_val[2] = er->dc_val[1] + c_size;
@@ -295,9 +272,6 @@  int ff_h264_slice_context_init(H264Context *h, H264SliceContext *sl)
     }
 
     return 0;
-
-fail:
-    return AVERROR(ENOMEM); // ff_h264_free_tables will clean up for us
 }
 
 static int h264_init_context(AVCodecContext *avctx, H264Context *h)