lavc/vp9: rename ctx to avctx
authorClément Bœsch <u@pkh.me>
Sat, 25 Mar 2017 11:25:28 +0000 (12:25 +0100)
committerClément Bœsch <u@pkh.me>
Mon, 27 Mar 2017 19:38:21 +0000 (21:38 +0200)
This reduces diff with Libav. It also prevents a potential confusion
between the private context and the AVCodecContext.

libavcodec/vp9.c
libavcodec/vp9_mc_template.c
libavcodec/vp9block.c

index 16f4c0d..a075a62 100644 (file)
 
 #define VP9_SYNCCODE 0x498342
 
-static void vp9_unref_frame(AVCodecContext *ctx, VP9Frame *f)
+static void vp9_unref_frame(AVCodecContext *avctx, VP9Frame *f)
 {
-    ff_thread_release_buffer(ctx, &f->tf);
+    ff_thread_release_buffer(avctx, &f->tf);
     av_buffer_unref(&f->extradata);
     av_buffer_unref(&f->hwaccel_priv_buf);
     f->segmentation_map = NULL;
     f->hwaccel_picture_private = NULL;
 }
 
-static int vp9_alloc_frame(AVCodecContext *ctx, VP9Frame *f)
+static int vp9_alloc_frame(AVCodecContext *avctx, VP9Frame *f)
 {
-    VP9Context *s = ctx->priv_data;
+    VP9Context *s = avctx->priv_data;
     int ret, sz;
 
-    if ((ret = ff_thread_get_buffer(ctx, &f->tf, AV_GET_BUFFER_FLAG_REF)) < 0)
+    if ((ret = ff_thread_get_buffer(avctx, &f->tf, AV_GET_BUFFER_FLAG_REF)) < 0)
         return ret;
     sz = 64 * s->sb_cols * s->sb_rows;
     if (!(f->extradata = av_buffer_allocz(sz * (1 + sizeof(struct VP9mvrefPair))))) {
@@ -60,8 +60,8 @@ static int vp9_alloc_frame(AVCodecContext *ctx, VP9Frame *f)
     f->segmentation_map = f->extradata->data;
     f->mv = (struct VP9mvrefPair *) (f->extradata->data + sz);
 
-    if (ctx->hwaccel) {
-        const AVHWAccel *hwaccel = ctx->hwaccel;
+    if (avctx->hwaccel) {
+        const AVHWAccel *hwaccel = avctx->hwaccel;
         av_assert0(!f->hwaccel_picture_private);
         if (hwaccel->frame_priv_data_size) {
             f->hwaccel_priv_buf = av_buffer_allocz(hwaccel->frame_priv_data_size);
@@ -74,11 +74,11 @@ static int vp9_alloc_frame(AVCodecContext *ctx, VP9Frame *f)
     return 0;
 
 fail:
-    vp9_unref_frame(ctx, f);
+    vp9_unref_frame(avctx, f);
     return AVERROR(ENOMEM);
 }
 
-static int vp9_ref_frame(AVCodecContext *ctx, VP9Frame *dst, VP9Frame *src)
+static int vp9_ref_frame(AVCodecContext *avctx, VP9Frame *dst, VP9Frame *src)
 {
     int res;
 
@@ -102,22 +102,22 @@ static int vp9_ref_frame(AVCodecContext *ctx, VP9Frame *dst, VP9Frame *src)
     return 0;
 
 fail:
-    vp9_unref_frame(ctx, dst);
+    vp9_unref_frame(avctx, dst);
     return AVERROR(ENOMEM);
 }
 
-static int update_size(AVCodecContext *ctx, int w, int h)
+static int update_size(AVCodecContext *avctx, int w, int h)
 {
 #define HWACCEL_MAX (CONFIG_VP9_DXVA2_HWACCEL + CONFIG_VP9_D3D11VA_HWACCEL + CONFIG_VP9_VAAPI_HWACCEL)
     enum AVPixelFormat pix_fmts[HWACCEL_MAX + 2], *fmtp = pix_fmts;
-    VP9Context *s = ctx->priv_data;
+    VP9Context *s = avctx->priv_data;
     uint8_t *p;
     int bytesperpixel = s->bytesperpixel, res, cols, rows;
 
     av_assert0(w > 0 && h > 0);
 
     if (!(s->pix_fmt == s->gf_fmt && w == s->w && h == s->h)) {
-        if ((res = ff_set_dimensions(ctx, w, h)) < 0)
+        if ((res = ff_set_dimensions(avctx, w, h)) < 0)
             return res;
 
         switch (s->pix_fmt) {
@@ -143,11 +143,11 @@ static int update_size(AVCodecContext *ctx, int w, int h)
         *fmtp++ = s->pix_fmt;
         *fmtp = AV_PIX_FMT_NONE;
 
-        res = ff_thread_get_format(ctx, pix_fmts);
+        res = ff_thread_get_format(avctx, pix_fmts);
         if (res < 0)
             return res;
 
-        ctx->pix_fmt = res;
+        avctx->pix_fmt = res;
         s->gf_fmt  = s->pix_fmt;
         s->w = w;
         s->h = h;
@@ -197,7 +197,7 @@ static int update_size(AVCodecContext *ctx, int w, int h)
     av_freep(&s->block_base);
 
     if (s->s.h.bpp != s->last_bpp) {
-        ff_vp9dsp_init(&s->dsp, s->s.h.bpp, ctx->flags & AV_CODEC_FLAG_BITEXACT);
+        ff_vp9dsp_init(&s->dsp, s->s.h.bpp, avctx->flags & AV_CODEC_FLAG_BITEXACT);
         ff_videodsp_init(&s->vdsp, s->s.h.bpp);
         s->last_bpp = s->s.h.bpp;
     }
@@ -205,9 +205,9 @@ static int update_size(AVCodecContext *ctx, int w, int h)
     return 0;
 }
 
-static int update_block_buffers(AVCodecContext *ctx)
+static int update_block_buffers(AVCodecContext *avctx)
 {
-    VP9Context *s = ctx->priv_data;
+    VP9Context *s = avctx->priv_data;
     int chroma_blocks, chroma_eobs, bytesperpixel = s->bytesperpixel;
 
     if (s->b_base && s->block_base && s->block_alloc_using_2pass == s->s.frames[CUR_FRAME].uses_2pass)
@@ -318,34 +318,34 @@ static int update_prob(VP56RangeCoder *c, int p)
                     255 - inv_recenter_nonneg(inv_map_table[d], 255 - p);
 }
 
-static int read_colorspace_details(AVCodecContext *ctx)
+static int read_colorspace_details(AVCodecContext *avctx)
 {
     static const enum AVColorSpace colorspaces[8] = {
         AVCOL_SPC_UNSPECIFIED, AVCOL_SPC_BT470BG, AVCOL_SPC_BT709, AVCOL_SPC_SMPTE170M,
         AVCOL_SPC_SMPTE240M, AVCOL_SPC_BT2020_NCL, AVCOL_SPC_RESERVED, AVCOL_SPC_RGB,
     };
-    VP9Context *s = ctx->priv_data;
-    int bits = ctx->profile <= 1 ? 0 : 1 + get_bits1(&s->gb); // 0:8, 1:10, 2:12
+    VP9Context *s = avctx->priv_data;
+    int bits = avctx->profile <= 1 ? 0 : 1 + get_bits1(&s->gb); // 0:8, 1:10, 2:12
 
     s->bpp_index = bits;
     s->s.h.bpp = 8 + bits * 2;
     s->bytesperpixel = (7 + s->s.h.bpp) >> 3;
-    ctx->colorspace = colorspaces[get_bits(&s->gb, 3)];
-    if (ctx->colorspace == AVCOL_SPC_RGB) { // RGB = profile 1
+    avctx->colorspace = colorspaces[get_bits(&s->gb, 3)];
+    if (avctx->colorspace == AVCOL_SPC_RGB) { // RGB = profile 1
         static const enum AVPixelFormat pix_fmt_rgb[3] = {
             AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRP12
         };
         s->ss_h = s->ss_v = 0;
-        ctx->color_range = AVCOL_RANGE_JPEG;
+        avctx->color_range = AVCOL_RANGE_JPEG;
         s->pix_fmt = pix_fmt_rgb[bits];
-        if (ctx->profile & 1) {
+        if (avctx->profile & 1) {
             if (get_bits1(&s->gb)) {
-                av_log(ctx, AV_LOG_ERROR, "Reserved bit set in RGB\n");
+                av_log(avctx, AV_LOG_ERROR, "Reserved bit set in RGB\n");
                 return AVERROR_INVALIDDATA;
             }
         } else {
-            av_log(ctx, AV_LOG_ERROR, "RGB not supported in profile %d\n",
-                   ctx->profile);
+            av_log(avctx, AV_LOG_ERROR, "RGB not supported in profile %d\n",
+                   avctx->profile);
             return AVERROR_INVALIDDATA;
         }
     } else {
@@ -357,18 +357,18 @@ static int read_colorspace_details(AVCodecContext *ctx)
             { { AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV422P12 },
               { AV_PIX_FMT_YUV440P12, AV_PIX_FMT_YUV420P12 } }
         };
-        ctx->color_range = get_bits1(&s->gb) ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;
-        if (ctx->profile & 1) {
+        avctx->color_range = get_bits1(&s->gb) ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;
+        if (avctx->profile & 1) {
             s->ss_h = get_bits1(&s->gb);
             s->ss_v = get_bits1(&s->gb);
             s->pix_fmt = pix_fmt_for_ss[bits][s->ss_v][s->ss_h];
             if (s->pix_fmt == AV_PIX_FMT_YUV420P) {
-                av_log(ctx, AV_LOG_ERROR, "YUV 4:2:0 not supported in profile %d\n",
-                       ctx->profile);
+                av_log(avctx, AV_LOG_ERROR, "YUV 4:2:0 not supported in profile %d\n",
+                       avctx->profile);
                 return AVERROR_INVALIDDATA;
             } else if (get_bits1(&s->gb)) {
-                av_log(ctx, AV_LOG_ERROR, "Profile %d color details reserved bit set\n",
-                       ctx->profile);
+                av_log(avctx, AV_LOG_ERROR, "Profile %d color details reserved bit set\n",
+                       avctx->profile);
                 return AVERROR_INVALIDDATA;
             }
         } else {
@@ -380,31 +380,31 @@ static int read_colorspace_details(AVCodecContext *ctx)
     return 0;
 }
 
-static int decode_frame_header(AVCodecContext *ctx,
+static int decode_frame_header(AVCodecContext *avctx,
                                const uint8_t *data, int size, int *ref)
 {
-    VP9Context *s = ctx->priv_data;
+    VP9Context *s = avctx->priv_data;
     int c, i, j, k, l, m, n, w, h, max, size2, res, sharp;
     int last_invisible;
     const uint8_t *data2;
 
     /* general header */
     if ((res = init_get_bits8(&s->gb, data, size)) < 0) {
-        av_log(ctx, AV_LOG_ERROR, "Failed to initialize bitstream reader\n");
+        av_log(avctx, AV_LOG_ERROR, "Failed to initialize bitstream reader\n");
         return res;
     }
     if (get_bits(&s->gb, 2) != 0x2) { // frame marker
-        av_log(ctx, AV_LOG_ERROR, "Invalid frame marker\n");
+        av_log(avctx, AV_LOG_ERROR, "Invalid frame marker\n");
         return AVERROR_INVALIDDATA;
     }
-    ctx->profile  = get_bits1(&s->gb);
-    ctx->profile |= get_bits1(&s->gb) << 1;
-    if (ctx->profile == 3) ctx->profile += get_bits1(&s->gb);
-    if (ctx->profile > 3) {
-        av_log(ctx, AV_LOG_ERROR, "Profile %d is not yet supported\n", ctx->profile);
+    avctx->profile  = get_bits1(&s->gb);
+    avctx->profile |= get_bits1(&s->gb) << 1;
+    if (avctx->profile == 3) avctx->profile += get_bits1(&s->gb);
+    if (avctx->profile > 3) {
+        av_log(avctx, AV_LOG_ERROR, "Profile %d is not yet supported\n", avctx->profile);
         return AVERROR_INVALIDDATA;
     }
-    s->s.h.profile = ctx->profile;
+    s->s.h.profile = avctx->profile;
     if (get_bits1(&s->gb)) {
         *ref = get_bits(&s->gb, 3);
         return 0;
@@ -417,10 +417,10 @@ static int decode_frame_header(AVCodecContext *ctx,
     s->s.h.use_last_frame_mvs = !s->s.h.errorres && !last_invisible;
     if (s->s.h.keyframe) {
         if (get_bits_long(&s->gb, 24) != VP9_SYNCCODE) { // synccode
-            av_log(ctx, AV_LOG_ERROR, "Invalid sync code\n");
+            av_log(avctx, AV_LOG_ERROR, "Invalid sync code\n");
             return AVERROR_INVALIDDATA;
         }
-        if ((res = read_colorspace_details(ctx)) < 0)
+        if ((res = read_colorspace_details(avctx)) < 0)
             return res;
         // for profile 1, here follows the subsampling bits
         s->s.h.refreshrefmask = 0xff;
@@ -433,11 +433,11 @@ static int decode_frame_header(AVCodecContext *ctx,
         s->s.h.resetctx   = s->s.h.errorres ? 0 : get_bits(&s->gb, 2);
         if (s->s.h.intraonly) {
             if (get_bits_long(&s->gb, 24) != VP9_SYNCCODE) { // synccode
-                av_log(ctx, AV_LOG_ERROR, "Invalid sync code\n");
+                av_log(avctx, AV_LOG_ERROR, "Invalid sync code\n");
                 return AVERROR_INVALIDDATA;
             }
-            if (ctx->profile >= 1) {
-                if ((res = read_colorspace_details(ctx)) < 0)
+            if (avctx->profile >= 1) {
+                if ((res = read_colorspace_details(avctx)) < 0)
                     return res;
             } else {
                 s->ss_h = s->ss_v = 1;
@@ -445,8 +445,8 @@ static int decode_frame_header(AVCodecContext *ctx,
                 s->bpp_index = 0;
                 s->bytesperpixel = 1;
                 s->pix_fmt = AV_PIX_FMT_YUV420P;
-                ctx->colorspace = AVCOL_SPC_BT470BG;
-                ctx->color_range = AVCOL_RANGE_JPEG;
+                avctx->colorspace = AVCOL_SPC_BT470BG;
+                avctx->color_range = AVCOL_RANGE_JPEG;
             }
             s->s.h.refreshrefmask = get_bits(&s->gb, 8);
             w = get_bits(&s->gb, 16) + 1;
@@ -464,7 +464,7 @@ static int decode_frame_header(AVCodecContext *ctx,
             if (!s->s.refs[s->s.h.refidx[0]].f->buf[0] ||
                 !s->s.refs[s->s.h.refidx[1]].f->buf[0] ||
                 !s->s.refs[s->s.h.refidx[2]].f->buf[0]) {
-                av_log(ctx, AV_LOG_ERROR, "Not all references are available\n");
+                av_log(avctx, AV_LOG_ERROR, "Not all references are available\n");
                 return AVERROR_INVALIDDATA;
             }
             if (get_bits1(&s->gb)) {
@@ -552,7 +552,7 @@ static int decode_frame_header(AVCodecContext *ctx,
     s->s.h.lossless    = s->s.h.yac_qi == 0 && s->s.h.ydc_qdelta == 0 &&
                        s->s.h.uvdc_qdelta == 0 && s->s.h.uvac_qdelta == 0;
     if (s->s.h.lossless)
-        ctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
+        avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
 
     /* segmentation header info */
     if ((s->s.h.segmentation.enabled = get_bits1(&s->gb))) {
@@ -631,8 +631,8 @@ static int decode_frame_header(AVCodecContext *ctx,
     }
 
     /* tiling info */
-    if ((res = update_size(ctx, w, h)) < 0) {
-        av_log(ctx, AV_LOG_ERROR, "Failed to initialize decoder for %dx%d @ %d\n",
+    if ((res = update_size(avctx, w, h)) < 0) {
+        av_log(avctx, AV_LOG_ERROR, "Failed to initialize decoder for %dx%d @ %d\n",
                w, h, s->pix_fmt);
         return res;
     }
@@ -654,7 +654,7 @@ static int decode_frame_header(AVCodecContext *ctx,
         s->c_b = av_fast_realloc(s->c_b, &s->c_b_size,
                                  sizeof(VP56RangeCoder) * s->s.h.tiling.tile_cols);
         if (!s->c_b) {
-            av_log(ctx, AV_LOG_ERROR, "Ran out of memory during range coder init\n");
+            av_log(avctx, AV_LOG_ERROR, "Ran out of memory during range coder init\n");
             return AVERROR(ENOMEM);
         }
     }
@@ -665,17 +665,17 @@ static int decode_frame_header(AVCodecContext *ctx,
             AVFrame *ref = s->s.refs[s->s.h.refidx[i]].f;
             int refw = ref->width, refh = ref->height;
 
-            if (ref->format != ctx->pix_fmt) {
-                av_log(ctx, AV_LOG_ERROR,
+            if (ref->format != avctx->pix_fmt) {
+                av_log(avctx, AV_LOG_ERROR,
                        "Ref pixfmt (%s) did not match current frame (%s)",
                        av_get_pix_fmt_name(ref->format),
-                       av_get_pix_fmt_name(ctx->pix_fmt));
+                       av_get_pix_fmt_name(avctx->pix_fmt));
                 return AVERROR_INVALIDDATA;
             } else if (refw == w && refh == h) {
                 s->mvscale[i][0] = s->mvscale[i][1] = 0;
             } else {
                 if (w * 2 < refw || h * 2 < refh || w > 16 * refw || h > 16 * refh) {
-                    av_log(ctx, AV_LOG_ERROR,
+                    av_log(avctx, AV_LOG_ERROR,
                            "Invalid ref frame dimensions %dx%d for frame size %dx%d\n",
                            refw, refh, w, h);
                     return AVERROR_INVALIDDATA;
@@ -711,7 +711,7 @@ static int decode_frame_header(AVCodecContext *ctx,
 
     data2 = align_get_bits(&s->gb);
     if (size2 > size - (data2 - data)) {
-        av_log(ctx, AV_LOG_ERROR, "Invalid compressed header size\n");
+        av_log(avctx, AV_LOG_ERROR, "Invalid compressed header size\n");
         return AVERROR_INVALIDDATA;
     }
     res = ff_vp56_init_range_decoder(&s->c, data2, size2);
@@ -719,7 +719,7 @@ static int decode_frame_header(AVCodecContext *ctx,
         return res;
 
     if (vp56_rac_get_prob_branchy(&s->c, 128)) { // marker bit
-        av_log(ctx, AV_LOG_ERROR, "Marker bit was set\n");
+        av_log(avctx, AV_LOG_ERROR, "Marker bit was set\n");
         return AVERROR_INVALIDDATA;
     }
 
@@ -915,10 +915,10 @@ static int decode_frame_header(AVCodecContext *ctx,
     return (data2 - data) + size2;
 }
 
-static void decode_sb(AVCodecContext *ctx, int row, int col, struct VP9Filter *lflvl,
+static void decode_sb(AVCodecContext *avctx, int row, int col, struct VP9Filter *lflvl,
                       ptrdiff_t yoff, ptrdiff_t uvoff, enum BlockLevel bl)
 {
-    VP9Context *s = ctx->priv_data;
+    VP9Context *s = avctx->priv_data;
     int c = ((s->above_partition_ctx[col] >> (3 - bl)) & 1) |
             (((s->left_partition_ctx[row & 0x7] >> (3 - bl)) & 1) << 1);
     const uint8_t *p = s->s.h.keyframe || s->s.h.intraonly ? ff_vp9_default_kf_partition_probs[bl][c] :
@@ -931,35 +931,35 @@ static void decode_sb(AVCodecContext *ctx, int row, int col, struct VP9Filter *l
 
     if (bl == BL_8X8) {
         bp = vp8_rac_get_tree(&s->c, ff_vp9_partition_tree, p);
-        ff_vp9_decode_block(ctx, row, col, lflvl, yoff, uvoff, bl, bp);
+        ff_vp9_decode_block(avctx, row, col, lflvl, yoff, uvoff, bl, bp);
     } else if (col + hbs < s->cols) { // FIXME why not <=?
         if (row + hbs < s->rows) { // FIXME why not <=?
             bp = vp8_rac_get_tree(&s->c, ff_vp9_partition_tree, p);
             switch (bp) {
             case PARTITION_NONE:
-                ff_vp9_decode_block(ctx, row, col, lflvl, yoff, uvoff, bl, bp);
+                ff_vp9_decode_block(avctx, row, col, lflvl, yoff, uvoff, bl, bp);
                 break;
             case PARTITION_H:
-                ff_vp9_decode_block(ctx, row, col, lflvl, yoff, uvoff, bl, bp);
+                ff_vp9_decode_block(avctx, row, col, lflvl, yoff, uvoff, bl, bp);
                 yoff  += hbs * 8 * y_stride;
                 uvoff += hbs * 8 * uv_stride >> s->ss_v;
-                ff_vp9_decode_block(ctx, row + hbs, col, lflvl, yoff, uvoff, bl, bp);
+                ff_vp9_decode_block(avctx, row + hbs, col, lflvl, yoff, uvoff, bl, bp);
                 break;
             case PARTITION_V:
-                ff_vp9_decode_block(ctx, row, col, lflvl, yoff, uvoff, bl, bp);
+                ff_vp9_decode_block(avctx, row, col, lflvl, yoff, uvoff, bl, bp);
                 yoff  += hbs * 8 * bytesperpixel;
                 uvoff += hbs * 8 * bytesperpixel >> s->ss_h;
-                ff_vp9_decode_block(ctx, row, col + hbs, lflvl, yoff, uvoff, bl, bp);
+                ff_vp9_decode_block(avctx, row, col + hbs, lflvl, yoff, uvoff, bl, bp);
                 break;
             case PARTITION_SPLIT:
-                decode_sb(ctx, row, col, lflvl, yoff, uvoff, bl + 1);
-                decode_sb(ctx, row, col + hbs, lflvl,
+                decode_sb(avctx, row, col, lflvl, yoff, uvoff, bl + 1);
+                decode_sb(avctx, row, col + hbs, lflvl,
                           yoff + 8 * hbs * bytesperpixel,
                           uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);
                 yoff  += hbs * 8 * y_stride;
                 uvoff += hbs * 8 * uv_stride >> s->ss_v;
-                decode_sb(ctx, row + hbs, col, lflvl, yoff, uvoff, bl + 1);
-                decode_sb(ctx, row + hbs, col + hbs, lflvl,
+                decode_sb(avctx, row + hbs, col, lflvl, yoff, uvoff, bl + 1);
+                decode_sb(avctx, row + hbs, col + hbs, lflvl,
                           yoff + 8 * hbs * bytesperpixel,
                           uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);
                 break;
@@ -968,36 +968,36 @@ static void decode_sb(AVCodecContext *ctx, int row, int col, struct VP9Filter *l
             }
         } else if (vp56_rac_get_prob_branchy(&s->c, p[1])) {
             bp = PARTITION_SPLIT;
-            decode_sb(ctx, row, col, lflvl, yoff, uvoff, bl + 1);
-            decode_sb(ctx, row, col + hbs, lflvl,
+            decode_sb(avctx, row, col, lflvl, yoff, uvoff, bl + 1);
+            decode_sb(avctx, row, col + hbs, lflvl,
                       yoff + 8 * hbs * bytesperpixel,
                       uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);
         } else {
             bp = PARTITION_H;
-            ff_vp9_decode_block(ctx, row, col, lflvl, yoff, uvoff, bl, bp);
+            ff_vp9_decode_block(avctx, row, col, lflvl, yoff, uvoff, bl, bp);
         }
     } else if (row + hbs < s->rows) { // FIXME why not <=?
         if (vp56_rac_get_prob_branchy(&s->c, p[2])) {
             bp = PARTITION_SPLIT;
-            decode_sb(ctx, row, col, lflvl, yoff, uvoff, bl + 1);
+            decode_sb(avctx, row, col, lflvl, yoff, uvoff, bl + 1);
             yoff  += hbs * 8 * y_stride;
             uvoff += hbs * 8 * uv_stride >> s->ss_v;
-            decode_sb(ctx, row + hbs, col, lflvl, yoff, uvoff, bl + 1);
+            decode_sb(avctx, row + hbs, col, lflvl, yoff, uvoff, bl + 1);
         } else {
             bp = PARTITION_V;
-            ff_vp9_decode_block(ctx, row, col, lflvl, yoff, uvoff, bl, bp);
+            ff_vp9_decode_block(avctx, row, col, lflvl, yoff, uvoff, bl, bp);
         }
     } else {
         bp = PARTITION_SPLIT;
-        decode_sb(ctx, row, col, lflvl, yoff, uvoff, bl + 1);
+        decode_sb(avctx, row, col, lflvl, yoff, uvoff, bl + 1);
     }
     s->counts.partition[bl][c][bp]++;
 }
 
-static void decode_sb_mem(AVCodecContext *ctx, int row, int col, struct VP9Filter *lflvl,
+static void decode_sb_mem(AVCodecContext *avctx, int row, int col, struct VP9Filter *lflvl,
                           ptrdiff_t yoff, ptrdiff_t uvoff, enum BlockLevel bl)
 {
-    VP9Context *s = ctx->priv_data;
+    VP9Context *s = avctx->priv_data;
     VP9Block *b = s->b;
     ptrdiff_t hbs = 4 >> bl;
     AVFrame *f = s->s.frames[CUR_FRAME].tf.f;
@@ -1006,39 +1006,39 @@ static void decode_sb_mem(AVCodecContext *ctx, int row, int col, struct VP9Filte
 
     if (bl == BL_8X8) {
         av_assert2(b->bl == BL_8X8);
-        ff_vp9_decode_block(ctx, row, col, lflvl, yoff, uvoff, b->bl, b->bp);
+        ff_vp9_decode_block(avctx, row, col, lflvl, yoff, uvoff, b->bl, b->bp);
     } else if (s->b->bl == bl) {
-        ff_vp9_decode_block(ctx, row, col, lflvl, yoff, uvoff, b->bl, b->bp);
+        ff_vp9_decode_block(avctx, row, col, lflvl, yoff, uvoff, b->bl, b->bp);
         if (b->bp == PARTITION_H && row + hbs < s->rows) {
             yoff  += hbs * 8 * y_stride;
             uvoff += hbs * 8 * uv_stride >> s->ss_v;
-            ff_vp9_decode_block(ctx, row + hbs, col, lflvl, yoff, uvoff, b->bl, b->bp);
+            ff_vp9_decode_block(avctx, row + hbs, col, lflvl, yoff, uvoff, b->bl, b->bp);
         } else if (b->bp == PARTITION_V && col + hbs < s->cols) {
             yoff  += hbs * 8 * bytesperpixel;
             uvoff += hbs * 8 * bytesperpixel >> s->ss_h;
-            ff_vp9_decode_block(ctx, row, col + hbs, lflvl, yoff, uvoff, b->bl, b->bp);
+            ff_vp9_decode_block(avctx, row, col + hbs, lflvl, yoff, uvoff, b->bl, b->bp);
         }
     } else {
-        decode_sb_mem(ctx, row, col, lflvl, yoff, uvoff, bl + 1);
+        decode_sb_mem(avctx, row, col, lflvl, yoff, uvoff, bl + 1);
         if (col + hbs < s->cols) { // FIXME why not <=?
             if (row + hbs < s->rows) {
-                decode_sb_mem(ctx, row, col + hbs, lflvl, yoff + 8 * hbs * bytesperpixel,
+                decode_sb_mem(avctx, row, col + hbs, lflvl, yoff + 8 * hbs * bytesperpixel,
                               uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);
                 yoff  += hbs * 8 * y_stride;
                 uvoff += hbs * 8 * uv_stride >> s->ss_v;
-                decode_sb_mem(ctx, row + hbs, col, lflvl, yoff, uvoff, bl + 1);
-                decode_sb_mem(ctx, row + hbs, col + hbs, lflvl,
+                decode_sb_mem(avctx, row + hbs, col, lflvl, yoff, uvoff, bl + 1);
+                decode_sb_mem(avctx, row + hbs, col + hbs, lflvl,
                               yoff + 8 * hbs * bytesperpixel,
                               uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);
             } else {
                 yoff  += hbs * 8 * bytesperpixel;
                 uvoff += hbs * 8 * bytesperpixel >> s->ss_h;
-                decode_sb_mem(ctx, row, col + hbs, lflvl, yoff, uvoff, bl + 1);
+                decode_sb_mem(avctx, row, col + hbs, lflvl, yoff, uvoff, bl + 1);
             }
         } else if (row + hbs < s->rows) {
             yoff  += hbs * 8 * y_stride;
             uvoff += hbs * 8 * uv_stride >> s->ss_v;
-            decode_sb_mem(ctx, row + hbs, col, lflvl, yoff, uvoff, bl + 1);
+            decode_sb_mem(avctx, row + hbs, col, lflvl, yoff, uvoff, bl + 1);
         }
     }
 }
@@ -1195,10 +1195,10 @@ static av_always_inline void filter_plane_rows(VP9Context *s, int row, int ss_h,
     }
 }
 
-static void loopfilter_sb(AVCodecContext *ctx, struct VP9Filter *lflvl,
+static void loopfilter_sb(AVCodecContext *avctx, struct VP9Filter *lflvl,
                           int row, int col, ptrdiff_t yoff, ptrdiff_t uvoff)
 {
-    VP9Context *s = ctx->priv_data;
+    VP9Context *s = avctx->priv_data;
     AVFrame *f = s->s.frames[CUR_FRAME].tf.f;
     uint8_t *dst = f->data[0] + yoff;
     ptrdiff_t ls_y = f->linesize[0], ls_uv = f->linesize[1];
@@ -1236,22 +1236,22 @@ static void free_buffers(VP9Context *s)
     av_freep(&s->block_base);
 }
 
-static av_cold int vp9_decode_free(AVCodecContext *ctx)
+static av_cold int vp9_decode_free(AVCodecContext *avctx)
 {
-    VP9Context *s = ctx->priv_data;
+    VP9Context *s = avctx->priv_data;
     int i;
 
     for (i = 0; i < 3; i++) {
         if (s->s.frames[i].tf.f->buf[0])
-            vp9_unref_frame(ctx, &s->s.frames[i]);
+            vp9_unref_frame(avctx, &s->s.frames[i]);
         av_frame_free(&s->s.frames[i].tf.f);
     }
     for (i = 0; i < 8; i++) {
         if (s->s.refs[i].f->buf[0])
-            ff_thread_release_buffer(ctx, &s->s.refs[i]);
+            ff_thread_release_buffer(avctx, &s->s.refs[i]);
         av_frame_free(&s->s.refs[i].f);
         if (s->next_refs[i].f->buf[0])
-            ff_thread_release_buffer(ctx, &s->next_refs[i]);
+            ff_thread_release_buffer(avctx, &s->next_refs[i]);
         av_frame_free(&s->next_refs[i].f);
     }
     free_buffers(s);
@@ -1262,12 +1262,12 @@ static av_cold int vp9_decode_free(AVCodecContext *ctx)
 }
 
 
-static int vp9_decode_frame(AVCodecContext *ctx, void *frame,
+static int vp9_decode_frame(AVCodecContext *avctx, void *frame,
                             int *got_frame, AVPacket *pkt)
 {
     const uint8_t *data = pkt->data;
     int size = pkt->size;
-    VP9Context *s = ctx->priv_data;
+    VP9Context *s = avctx->priv_data;
     int res, tile_row, tile_col, i, ref, row, col;
     int retain_segmap_ref = s->s.frames[REF_FRAME_SEGMAP].segmentation_map &&
                             (!s->s.h.segmentation.enabled || !s->s.h.segmentation.update_map);
@@ -1275,11 +1275,11 @@ static int vp9_decode_frame(AVCodecContext *ctx, void *frame,
     AVFrame *f;
     int bytesperpixel;
 
-    if ((res = decode_frame_header(ctx, data, size, &ref)) < 0) {
+    if ((res = decode_frame_header(avctx, data, size, &ref)) < 0) {
         return res;
     } else if (res == 0) {
         if (!s->s.refs[ref].f->buf[0]) {
-            av_log(ctx, AV_LOG_ERROR, "Requested reference %d not available\n", ref);
+            av_log(avctx, AV_LOG_ERROR, "Requested reference %d not available\n", ref);
             return AVERROR_INVALIDDATA;
         }
         if ((res = av_frame_ref(frame, s->s.refs[ref].f)) < 0)
@@ -1293,7 +1293,7 @@ FF_ENABLE_DEPRECATION_WARNINGS
         ((AVFrame *)frame)->pkt_dts = pkt->dts;
         for (i = 0; i < 8; i++) {
             if (s->next_refs[i].f->buf[0])
-                ff_thread_release_buffer(ctx, &s->next_refs[i]);
+                ff_thread_release_buffer(avctx, &s->next_refs[i]);
             if (s->s.refs[i].f->buf[0] &&
                 (res = ff_thread_ref_frame(&s->next_refs[i], &s->s.refs[i])) < 0)
                 return res;
@@ -1306,19 +1306,19 @@ FF_ENABLE_DEPRECATION_WARNINGS
 
     if (!retain_segmap_ref || s->s.h.keyframe || s->s.h.intraonly) {
         if (s->s.frames[REF_FRAME_SEGMAP].tf.f->buf[0])
-            vp9_unref_frame(ctx, &s->s.frames[REF_FRAME_SEGMAP]);
+            vp9_unref_frame(avctx, &s->s.frames[REF_FRAME_SEGMAP]);
         if (!s->s.h.keyframe && !s->s.h.intraonly && !s->s.h.errorres && s->s.frames[CUR_FRAME].tf.f->buf[0] &&
-            (res = vp9_ref_frame(ctx, &s->s.frames[REF_FRAME_SEGMAP], &s->s.frames[CUR_FRAME])) < 0)
+            (res = vp9_ref_frame(avctx, &s->s.frames[REF_FRAME_SEGMAP], &s->s.frames[CUR_FRAME])) < 0)
             return res;
     }
     if (s->s.frames[REF_FRAME_MVPAIR].tf.f->buf[0])
-        vp9_unref_frame(ctx, &s->s.frames[REF_FRAME_MVPAIR]);
+        vp9_unref_frame(avctx, &s->s.frames[REF_FRAME_MVPAIR]);
     if (!s->s.h.intraonly && !s->s.h.keyframe && !s->s.h.errorres && s->s.frames[CUR_FRAME].tf.f->buf[0] &&
-        (res = vp9_ref_frame(ctx, &s->s.frames[REF_FRAME_MVPAIR], &s->s.frames[CUR_FRAME])) < 0)
+        (res = vp9_ref_frame(avctx, &s->s.frames[REF_FRAME_MVPAIR], &s->s.frames[CUR_FRAME])) < 0)
         return res;
     if (s->s.frames[CUR_FRAME].tf.f->buf[0])
-        vp9_unref_frame(ctx, &s->s.frames[CUR_FRAME]);
-    if ((res = vp9_alloc_frame(ctx, &s->s.frames[CUR_FRAME])) < 0)
+        vp9_unref_frame(avctx, &s->s.frames[CUR_FRAME]);
+    if ((res = vp9_alloc_frame(avctx, &s->s.frames[CUR_FRAME])) < 0)
         return res;
     f = s->s.frames[CUR_FRAME].tf.f;
     f->key_frame = s->s.h.keyframe;
@@ -1329,13 +1329,13 @@ FF_ENABLE_DEPRECATION_WARNINGS
     if (s->s.frames[REF_FRAME_SEGMAP].tf.f->buf[0] &&
         (s->s.frames[REF_FRAME_MVPAIR].tf.f->width  != s->s.frames[CUR_FRAME].tf.f->width ||
          s->s.frames[REF_FRAME_MVPAIR].tf.f->height != s->s.frames[CUR_FRAME].tf.f->height)) {
-        vp9_unref_frame(ctx, &s->s.frames[REF_FRAME_SEGMAP]);
+        vp9_unref_frame(avctx, &s->s.frames[REF_FRAME_SEGMAP]);
     }
 
     // ref frame setup
     for (i = 0; i < 8; i++) {
         if (s->next_refs[i].f->buf[0])
-            ff_thread_release_buffer(ctx, &s->next_refs[i]);
+            ff_thread_release_buffer(avctx, &s->next_refs[i]);
         if (s->s.h.refreshrefmask & (1 << i)) {
             res = ff_thread_ref_frame(&s->next_refs[i], &s->s.frames[CUR_FRAME].tf);
         } else if (s->s.refs[i].f->buf[0]) {
@@ -1345,14 +1345,14 @@ FF_ENABLE_DEPRECATION_WARNINGS
             return res;
     }
 
-    if (ctx->hwaccel) {
-        res = ctx->hwaccel->start_frame(ctx, NULL, 0);
+    if (avctx->hwaccel) {
+        res = avctx->hwaccel->start_frame(avctx, NULL, 0);
         if (res < 0)
             return res;
-        res = ctx->hwaccel->decode_slice(ctx, pkt->data, pkt->size);
+        res = avctx->hwaccel->decode_slice(avctx, pkt->data, pkt->size);
         if (res < 0)
             return res;
-        res = ctx->hwaccel->end_frame(ctx);
+        res = avctx->hwaccel->end_frame(avctx);
         if (res < 0)
             return res;
         goto finish;
@@ -1372,9 +1372,9 @@ FF_ENABLE_DEPRECATION_WARNINGS
     memset(s->above_uv_nnz_ctx[1], 0, s->sb_cols * 16 >> s->ss_h);
     memset(s->above_segpred_ctx, 0, s->cols);
     s->pass = s->s.frames[CUR_FRAME].uses_2pass =
-        ctx->active_thread_type == FF_THREAD_FRAME && s->s.h.refreshctx && !s->s.h.parallelmode;
-    if ((res = update_block_buffers(ctx)) < 0) {
-        av_log(ctx, AV_LOG_ERROR,
+        avctx->active_thread_type == FF_THREAD_FRAME && s->s.h.refreshctx && !s->s.h.parallelmode;
+    if ((res = update_block_buffers(avctx)) < 0) {
+        av_log(avctx, AV_LOG_ERROR,
                "Failed to allocate block buffers\n");
         return res;
     }
@@ -1392,9 +1392,9 @@ FF_ENABLE_DEPRECATION_WARNINGS
                 break;
         }
         s->prob_ctx[s->s.h.framectxid].p = s->prob.p;
-        ff_thread_finish_setup(ctx);
+        ff_thread_finish_setup(avctx);
     } else if (!s->s.h.refreshctx) {
-        ff_thread_finish_setup(ctx);
+        ff_thread_finish_setup(avctx);
     }
 
     do {
@@ -1473,10 +1473,10 @@ FF_ENABLE_DEPRECATION_WARNINGS
                         }
 
                         if (s->pass == 2) {
-                            decode_sb_mem(ctx, row, col, lflvl_ptr,
+                            decode_sb_mem(avctx, row, col, lflvl_ptr,
                                           yoff2, uvoff2, BL_64X64);
                         } else {
-                            decode_sb(ctx, row, col, lflvl_ptr,
+                            decode_sb(avctx, row, col, lflvl_ptr,
                                       yoff2, uvoff2, BL_64X64);
                         }
                     }
@@ -1511,7 +1511,7 @@ FF_ENABLE_DEPRECATION_WARNINGS
                     for (col = 0; col < s->cols;
                          col += 8, yoff2 += 64 * bytesperpixel,
                          uvoff2 += 64 * bytesperpixel >> s->ss_h, lflvl_ptr++) {
-                        loopfilter_sb(ctx, lflvl_ptr, row, col, yoff2, uvoff2);
+                        loopfilter_sb(avctx, lflvl_ptr, row, col, yoff2, uvoff2);
                     }
                 }
 
@@ -1524,7 +1524,7 @@ FF_ENABLE_DEPRECATION_WARNINGS
 
         if (s->pass < 2 && s->s.h.refreshctx && !s->s.h.parallelmode) {
             ff_vp9_adapt_probs(s);
-            ff_thread_finish_setup(ctx);
+            ff_thread_finish_setup(avctx);
         }
     } while (s->pass++ == 1);
     ff_thread_report_progress(&s->s.frames[CUR_FRAME].tf, INT_MAX, 0);
@@ -1533,7 +1533,7 @@ finish:
     // ref frame setup
     for (i = 0; i < 8; i++) {
         if (s->s.refs[i].f->buf[0])
-            ff_thread_release_buffer(ctx, &s->s.refs[i]);
+            ff_thread_release_buffer(avctx, &s->s.refs[i]);
         if (s->next_refs[i].f->buf[0] &&
             (res = ff_thread_ref_frame(&s->s.refs[i], &s->next_refs[i])) < 0)
             return res;
@@ -1548,27 +1548,27 @@ finish:
     return pkt->size;
 }
 
-static void vp9_decode_flush(AVCodecContext *ctx)
+static void vp9_decode_flush(AVCodecContext *avctx)
 {
-    VP9Context *s = ctx->priv_data;
+    VP9Context *s = avctx->priv_data;
     int i;
 
     for (i = 0; i < 3; i++)
-        vp9_unref_frame(ctx, &s->s.frames[i]);
+        vp9_unref_frame(avctx, &s->s.frames[i]);
     for (i = 0; i < 8; i++)
-        ff_thread_release_buffer(ctx, &s->s.refs[i]);
+        ff_thread_release_buffer(avctx, &s->s.refs[i]);
 }
 
-static int init_frames(AVCodecContext *ctx)
+static int init_frames(AVCodecContext *avctx)
 {
-    VP9Context *s = ctx->priv_data;
+    VP9Context *s = avctx->priv_data;
     int i;
 
     for (i = 0; i < 3; i++) {
         s->s.frames[i].tf.f = av_frame_alloc();
         if (!s->s.frames[i].tf.f) {
-            vp9_decode_free(ctx);
-            av_log(ctx, AV_LOG_ERROR, "Failed to allocate frame buffer %d\n", i);
+            vp9_decode_free(avctx);
+            av_log(avctx, AV_LOG_ERROR, "Failed to allocate frame buffer %d\n", i);
             return AVERROR(ENOMEM);
         }
     }
@@ -1576,8 +1576,8 @@ static int init_frames(AVCodecContext *ctx)
         s->s.refs[i].f = av_frame_alloc();
         s->next_refs[i].f = av_frame_alloc();
         if (!s->s.refs[i].f || !s->next_refs[i].f) {
-            vp9_decode_free(ctx);
-            av_log(ctx, AV_LOG_ERROR, "Failed to allocate frame buffer %d\n", i);
+            vp9_decode_free(avctx);
+            av_log(avctx, AV_LOG_ERROR, "Failed to allocate frame buffer %d\n", i);
             return AVERROR(ENOMEM);
         }
     }
@@ -1585,15 +1585,15 @@ static int init_frames(AVCodecContext *ctx)
     return 0;
 }
 
-static av_cold int vp9_decode_init(AVCodecContext *ctx)
+static av_cold int vp9_decode_init(AVCodecContext *avctx)
 {
-    VP9Context *s = ctx->priv_data;
+    VP9Context *s = avctx->priv_data;
 
-    ctx->internal->allocate_progress = 1;
+    avctx->internal->allocate_progress = 1;
     s->last_bpp = 0;
     s->s.h.filter.sharpness = -1;
 
-    return init_frames(ctx);
+    return init_frames(avctx);
 }
 
 #if HAVE_THREADS
index e7f226c..2d1e9bf 100644 (file)
     (VP56mv) { .x = ROUNDED_DIV(a.x + b.x + c.x + d.x, 4), \
                .y = ROUNDED_DIV(a.y + b.y + c.y + d.y, 4) }
 
-static void FN(inter_pred)(AVCodecContext *ctx)
+static void FN(inter_pred)(AVCodecContext *avctx)
 {
     static const uint8_t bwlog_tab[2][N_BS_SIZES] = {
         { 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4 },
         { 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 4, 4 },
     };
-    VP9Context *s = ctx->priv_data;
+    VP9Context *s = avctx->priv_data;
     VP9Block *b = s->b;
     int row = s->row, col = s->col;
     ThreadFrame *tref1 = &s->s.refs[s->s.h.refidx[b->ref[0]]], *tref2;
index dd135aa..3d57913 100644 (file)
@@ -86,7 +86,7 @@ static av_always_inline void setctx_2d(uint8_t *ptr, int w, int h,
     }
 }
 
-static void decode_mode(AVCodecContext *ctx)
+static void decode_mode(AVCodecContext *avctx)
 {
     static const uint8_t left_ctx[N_BS_SIZES] = {
         0x0, 0x8, 0x0, 0x8, 0xc, 0x8, 0xc, 0xe, 0xc, 0xe, 0xf, 0xe, 0xf
@@ -98,7 +98,7 @@ static void decode_mode(AVCodecContext *ctx)
         TX_32X32, TX_32X32, TX_32X32, TX_32X32, TX_16X16, TX_16X16,
         TX_16X16, TX_8X8, TX_8X8, TX_8X8, TX_4X4, TX_4X4, TX_4X4
     };
-    VP9Context *s = ctx->priv_data;
+    VP9Context *s = avctx->priv_data;
     VP9Block *b = s->b;
     int row = s->row, col = s->col, row7 = s->row7;
     enum TxfmMode max_tx = max_tx_for_bl_bp[b->bs];
@@ -955,9 +955,9 @@ static int decode_coeffs_b32_16bpp(VP9Context *s, int16_t *coef, int n_coeffs,
                                    nnz, scan, nb, band_counts, qmul);
 }
 
-static av_always_inline int decode_coeffs(AVCodecContext *ctx, int is8bitsperpixel)
+static av_always_inline int decode_coeffs(AVCodecContext *avctx, int is8bitsperpixel)
 {
-    VP9Context *s = ctx->priv_data;
+    VP9Context *s = avctx->priv_data;
     VP9Block *b = s->b;
     int row = s->row, col = s->col;
     uint8_t (*p)[6][11] = s->prob.coef[b->tx][0 /* y */][!b->intra];
@@ -1122,14 +1122,14 @@ static av_always_inline int decode_coeffs(AVCodecContext *ctx, int is8bitsperpix
     return total_coeff;
 }
 
-static int decode_coeffs_8bpp(AVCodecContext *ctx)
+static int decode_coeffs_8bpp(AVCodecContext *avctx)
 {
-    return decode_coeffs(ctx, 1);
+    return decode_coeffs(avctx, 1);
 }
 
-static int decode_coeffs_16bpp(AVCodecContext *ctx)
+static int decode_coeffs_16bpp(AVCodecContext *avctx)
 {
-    return decode_coeffs(ctx, 0);
+    return decode_coeffs(avctx, 0);
 }
 
 static av_always_inline int check_intra_mode(VP9Context *s, int mode, uint8_t **a,
@@ -1313,10 +1313,10 @@ static av_always_inline int check_intra_mode(VP9Context *s, int mode, uint8_t **
     return mode;
 }
 
-static av_always_inline void intra_recon(AVCodecContext *ctx, ptrdiff_t y_off,
+static av_always_inline void intra_recon(AVCodecContext *avctx, ptrdiff_t y_off,
                                          ptrdiff_t uv_off, int bytesperpixel)
 {
-    VP9Context *s = ctx->priv_data;
+    VP9Context *s = avctx->priv_data;
     VP9Block *b = s->b;
     int row = s->row, col = s->col;
     int w4 = bwh_tab[1][b->bs][0] << 1, step1d = 1 << b->tx, n;
@@ -1383,14 +1383,14 @@ static av_always_inline void intra_recon(AVCodecContext *ctx, ptrdiff_t y_off,
     }
 }
 
-static void intra_recon_8bpp(AVCodecContext *ctx, ptrdiff_t y_off, ptrdiff_t uv_off)
+static void intra_recon_8bpp(AVCodecContext *avctx, ptrdiff_t y_off, ptrdiff_t uv_off)
 {
-    intra_recon(ctx, y_off, uv_off, 1);
+    intra_recon(avctx, y_off, uv_off, 1);
 }
 
-static void intra_recon_16bpp(AVCodecContext *ctx, ptrdiff_t y_off, ptrdiff_t uv_off)
+static void intra_recon_16bpp(AVCodecContext *avctx, ptrdiff_t y_off, ptrdiff_t uv_off)
 {
-    intra_recon(ctx, y_off, uv_off, 2);
+    intra_recon(avctx, y_off, uv_off, 2);
 }
 
 static av_always_inline void mc_luma_unscaled(VP9Context *s, vp9_mc_func (*mc)[2],
@@ -1660,23 +1660,23 @@ static av_always_inline void mc_chroma_scaled(VP9Context *s, vp9_scaled_mc_func
 #undef BYTES_PER_PIXEL
 #undef SCALED
 
-static av_always_inline void inter_recon(AVCodecContext *ctx, int bytesperpixel)
+static av_always_inline void inter_recon(AVCodecContext *avctx, int bytesperpixel)
 {
-    VP9Context *s = ctx->priv_data;
+    VP9Context *s = avctx->priv_data;
     VP9Block *b = s->b;
     int row = s->row, col = s->col;
 
     if (s->mvscale[b->ref[0]][0] || (b->comp && s->mvscale[b->ref[1]][0])) {
         if (bytesperpixel == 1) {
-            inter_pred_scaled_8bpp(ctx);
+            inter_pred_scaled_8bpp(avctx);
         } else {
-            inter_pred_scaled_16bpp(ctx);
+            inter_pred_scaled_16bpp(avctx);
         }
     } else {
         if (bytesperpixel == 1) {
-            inter_pred_8bpp(ctx);
+            inter_pred_8bpp(avctx);
         } else {
-            inter_pred_16bpp(ctx);
+            inter_pred_16bpp(avctx);
         }
     }
     if (!b->skip) {
@@ -1726,14 +1726,14 @@ static av_always_inline void inter_recon(AVCodecContext *ctx, int bytesperpixel)
     }
 }
 
-static void inter_recon_8bpp(AVCodecContext *ctx)
+static void inter_recon_8bpp(AVCodecContext *avctx)
 {
-    inter_recon(ctx, 1);
+    inter_recon(avctx, 1);
 }
 
-static void inter_recon_16bpp(AVCodecContext *ctx)
+static void inter_recon_16bpp(AVCodecContext *avctx)
 {
-    inter_recon(ctx, 2);
+    inter_recon(avctx, 2);
 }
 
 static av_always_inline void mask_edges(uint8_t (*mask)[8][4], int ss_h, int ss_v,
@@ -1858,11 +1858,11 @@ static av_always_inline void mask_edges(uint8_t (*mask)[8][4], int ss_h, int ss_
     }
 }
 
-void ff_vp9_decode_block(AVCodecContext *ctx, int row, int col,
+void ff_vp9_decode_block(AVCodecContext *avctx, int row, int col,
                          struct VP9Filter *lflvl, ptrdiff_t yoff, ptrdiff_t uvoff,
                          enum BlockLevel bl, enum BlockPartition bp)
 {
-    VP9Context *s = ctx->priv_data;
+    VP9Context *s = avctx->priv_data;
     VP9Block *b = s->b;
     enum BlockSize bs = bl * 3 + bp;
     int bytesperpixel = s->bytesperpixel;
@@ -1882,7 +1882,7 @@ void ff_vp9_decode_block(AVCodecContext *ctx, int row, int col,
         b->bs = bs;
         b->bl = bl;
         b->bp = bp;
-        decode_mode(ctx);
+        decode_mode(avctx);
         b->uvtx = b->tx - ((s->ss_h && w4 * 2 == (1 << b->tx)) ||
                            (s->ss_v && h4 * 2 == (1 << b->tx)));
 
@@ -1890,9 +1890,9 @@ void ff_vp9_decode_block(AVCodecContext *ctx, int row, int col,
             int has_coeffs;
 
             if (bytesperpixel == 1) {
-                has_coeffs = decode_coeffs_8bpp(ctx);
+                has_coeffs = decode_coeffs_8bpp(avctx);
             } else {
-                has_coeffs = decode_coeffs_16bpp(ctx);
+                has_coeffs = decode_coeffs_16bpp(avctx);
             }
             if (!has_coeffs && b->bs <= BS_8x8 && !b->intra) {
                 b->skip = 1;
@@ -1974,15 +1974,15 @@ void ff_vp9_decode_block(AVCodecContext *ctx, int row, int col,
     }
     if (b->intra) {
         if (s->s.h.bpp > 8) {
-            intra_recon_16bpp(ctx, yoff, uvoff);
+            intra_recon_16bpp(avctx, yoff, uvoff);
         } else {
-            intra_recon_8bpp(ctx, yoff, uvoff);
+            intra_recon_8bpp(avctx, yoff, uvoff);
         }
     } else {
         if (s->s.h.bpp > 8) {
-            inter_recon_16bpp(ctx);
+            inter_recon_16bpp(avctx);
         } else {
-            inter_recon_8bpp(ctx);
+            inter_recon_8bpp(avctx);
         }
     }
     if (emu[0]) {