lavc/ffv1dec: stop using per-slice FFV1Context

All remaining accesses to them are for fields that have the same value
in the main encoder context.

Drop now-unused FFV1Context.slice_contexts.

4 files changed, 33 insertions, 56 deletions

diff --git a/libavcodec/ffv1.c b/libavcodec/ffv1.c
index 4ef04f6b9b..07cf5564cc 100644
--- a/libavcodec/ffv1.c
+++ b/libavcodec/ffv1.c
@@ -102,7 +102,7 @@ av_cold int ff_ffv1_init_slices_state(FFV1Context *f)
 
 av_cold int ff_ffv1_init_slice_contexts(FFV1Context *f)
 {
-    int i, max_slice_count = f->num_h_slices * f->num_v_slices;
+    int max_slice_count = f->num_h_slices * f->num_v_slices;
 
     av_assert0(max_slice_count > 0);
 
@@ -112,7 +112,7 @@ av_cold int ff_ffv1_init_slice_contexts(FFV1Context *f)
 
     f->max_slice_count = max_slice_count;
 
-    for (i = 0; i < max_slice_count;) {
+    for (int i = 0; i < max_slice_count; i++) {
         FFV1SliceContext *sc = &f->slices[i];
         int sx          = i % f->num_h_slices;
         int sy          = i / f->num_h_slices;
@@ -120,22 +120,15 @@ av_cold int ff_ffv1_init_slice_contexts(FFV1Context *f)
         int sxe         = f->avctx->width  * (sx + 1) / f->num_h_slices;
         int sys         = f->avctx->height *  sy      / f->num_v_slices;
         int sye         = f->avctx->height * (sy + 1) / f->num_v_slices;
-        FFV1Context *fs = av_mallocz(sizeof(*fs));
-
-        if (!fs)
-            return AVERROR(ENOMEM);
-
-        f->slice_context[i++] = fs;
-        memcpy(fs, f, sizeof(*fs));
 
         sc->slice_width  = sxe - sxs;
         sc->slice_height = sye - sys;
         sc->slice_x      = sxs;
         sc->slice_y      = sys;
 
-        sc->sample_buffer = av_malloc_array((fs->width + 6), 3 * MAX_PLANES *
+        sc->sample_buffer = av_malloc_array((f->width + 6), 3 * MAX_PLANES *
                                             sizeof(*sc->sample_buffer));
-        sc->sample_buffer32 = av_malloc_array((fs->width + 6), 3 * MAX_PLANES *
+        sc->sample_buffer32 = av_malloc_array((f->width + 6), 3 * MAX_PLANES *
                                               sizeof(*sc->sample_buffer32));
         if (!sc->sample_buffer || !sc->sample_buffer32)
             return AVERROR(ENOMEM);
@@ -213,9 +206,6 @@ av_cold int ff_ffv1_close(AVCodecContext *avctx)
         av_freep(&s->rc_stat2[j]);
     }
 
-    for (i = 0; i < s->max_slice_count; i++)
-        av_freep(&s->slice_context[i]);
-
     av_freep(&s->slices);
 
     return 0;
diff --git a/libavcodec/ffv1.h b/libavcodec/ffv1.h
index c4803654f2..9d79219921 100644
--- a/libavcodec/ffv1.h
+++ b/libavcodec/ffv1.h
@@ -141,7 +141,6 @@ typedef struct FFV1Context {
     int gob_count;
     int quant_table_count;
 
-    struct FFV1Context *slice_context[MAX_SLICES];
     int slice_count;
     int max_slice_count;
     int num_v_slices;
diff --git a/libavcodec/ffv1dec.c b/libavcodec/ffv1dec.c
index 3d529ff4e9..1933efbfbc 100644
--- a/libavcodec/ffv1dec.c
+++ b/libavcodec/ffv1dec.c
@@ -116,8 +116,7 @@ static int is_input_end(RangeCoder *c, GetBitContext *gb, int ac)
 #define RENAME(name) name ## 32
 #include "ffv1dec_template.c"
 
-static int decode_plane(FFV1Context *f,
-                        FFV1Context *s, FFV1SliceContext *sc,
+static int decode_plane(FFV1Context *f, FFV1SliceContext *sc,
                         GetBitContext *gb,
                         uint8_t *src, int w, int h, int stride, int plane_index,
                          int pixel_stride)
@@ -141,23 +140,23 @@ static int decode_plane(FFV1Context *f,
         sample[1][-1] = sample[0][0];
         sample[0][w]  = sample[0][w - 1];
 
-        if (s->avctx->bits_per_raw_sample <= 8) {
-            int ret = decode_line(f, s, sc, gb, w, sample, plane_index, 8, ac);
+        if (f->avctx->bits_per_raw_sample <= 8) {
+            int ret = decode_line(f, sc, gb, w, sample, plane_index, 8, ac);
             if (ret < 0)
                 return ret;
             for (x = 0; x < w; x++)
                 src[x*pixel_stride + stride * y] = sample[1][x];
         } else {
-            int ret = decode_line(f, s, sc, gb, w, sample, plane_index, s->avctx->bits_per_raw_sample, ac);
+            int ret = decode_line(f, sc, gb, w, sample, plane_index, f->avctx->bits_per_raw_sample, ac);
             if (ret < 0)
                 return ret;
-            if (s->packed_at_lsb) {
+            if (f->packed_at_lsb) {
                 for (x = 0; x < w; x++) {
                     ((uint16_t*)(src + stride*y))[x*pixel_stride] = sample[1][x];
                 }
             } else {
                 for (x = 0; x < w; x++) {
-                    ((uint16_t*)(src + stride*y))[x*pixel_stride] = sample[1][x] << (16 - s->avctx->bits_per_raw_sample) | ((uint16_t **)sample)[1][x] >> (2 * s->avctx->bits_per_raw_sample - 16);
+                    ((uint16_t*)(src + stride*y))[x*pixel_stride] = sample[1][x] << (16 - f->avctx->bits_per_raw_sample) | ((uint16_t **)sample)[1][x] >> (2 * f->avctx->bits_per_raw_sample - 16);
                 }
             }
         }
@@ -165,7 +164,7 @@ static int decode_plane(FFV1Context *f,
     return 0;
 }
 
-static int decode_slice_header(const FFV1Context *f, FFV1Context *fs,
+static int decode_slice_header(const FFV1Context *f,
                                FFV1SliceContext *sc, AVFrame *frame)
 {
     RangeCoder *c = &sc->c;
@@ -238,7 +237,7 @@ static int decode_slice_header(const FFV1Context *f, FFV1Context *fs,
         frame->sample_aspect_ratio = (AVRational){ 0, 1 };
     }
 
-    if (fs->version > 3) {
+    if (f->version > 3) {
         sc->slice_reset_contexts = get_rac(c, state);
         sc->slice_coding_mode = get_symbol(c, state, 0);
         if (sc->slice_coding_mode != 1) {
@@ -256,13 +255,12 @@ static int decode_slice_header(const FFV1Context *f, FFV1Context *fs,
 
 static int decode_slice(AVCodecContext *c, void *arg)
 {
-    FFV1Context *fs   = *(void **)arg;
-    FFV1Context *f    = fs->avctx->priv_data;
+    FFV1Context *f    = c->priv_data;
+    FFV1SliceContext *sc = arg;
     int width, height, x, y, ret;
     const int ps      = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step;
     AVFrame * const p = f->picture.f;
-    const int      si = (FFV1Context**)arg - f->slice_context;
-    FFV1SliceContext *sc = &f->slices[si];
+    const int      si = sc - f->slices;
     GetBitContext gb;
 
     if (f->fsrc && !(p->flags & AV_FRAME_FLAG_KEY) && f->last_picture.f)
@@ -300,7 +298,7 @@ static int decode_slice(AVCodecContext *c, void *arg)
     if (f->version > 2) {
         if (ff_ffv1_init_slice_state(f, sc) < 0)
             return AVERROR(ENOMEM);
-        if (decode_slice_header(f, fs, sc, p) < 0) {
+        if (decode_slice_header(f, sc, p) < 0) {
             sc->slice_x = sc->slice_y = sc->slice_height = sc->slice_width = 0;
             sc->slice_damaged = 1;
             return AVERROR_INVALIDDATA;
@@ -334,29 +332,29 @@ static int decode_slice(AVCodecContext *c, void *arg)
         const int chroma_height = AV_CEIL_RSHIFT(height, f->chroma_v_shift);
         const int cx            = x >> f->chroma_h_shift;
         const int cy            = y >> f->chroma_v_shift;
-        decode_plane(f, fs, sc, &gb, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 1);
+        decode_plane(f, sc, &gb, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 1);
 
         if (f->chroma_planes) {
-            decode_plane(f, fs, sc, &gb, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1, 1);
-            decode_plane(f, fs, sc, &gb, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1, 1);
+            decode_plane(f, sc, &gb, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1, 1);
+            decode_plane(f, sc, &gb, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1, 1);
         }
         if (f->transparency)
-            decode_plane(f, fs, sc, &gb, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], (f->version >= 4 && !f->chroma_planes) ? 1 : 2, 1);
+            decode_plane(f, sc, &gb, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], (f->version >= 4 && !f->chroma_planes) ? 1 : 2, 1);
     } else if (f->colorspace == 0) {
-         decode_plane(f, fs, sc, &gb, p->data[0] + ps*x + y*p->linesize[0]    , width, height, p->linesize[0], 0, 2);
-         decode_plane(f, fs, sc, &gb, p->data[0] + ps*x + y*p->linesize[0] + 1, width, height, p->linesize[0], 1, 2);
+         decode_plane(f, sc, &gb, p->data[0] + ps*x + y*p->linesize[0]    , width, height, p->linesize[0], 0, 2);
+         decode_plane(f, sc, &gb, p->data[0] + ps*x + y*p->linesize[0] + 1, width, height, p->linesize[0], 1, 2);
     } else if (f->use32bit) {
         uint8_t *planes[4] = { p->data[0] + ps * x + y * p->linesize[0],
                                p->data[1] + ps * x + y * p->linesize[1],
                                p->data[2] + ps * x + y * p->linesize[2],
                                p->data[3] + ps * x + y * p->linesize[3] };
-        decode_rgb_frame32(f, fs, sc, &gb, planes, width, height, p->linesize);
+        decode_rgb_frame32(f, sc, &gb, planes, width, height, p->linesize);
     } else {
         uint8_t *planes[4] = { p->data[0] + ps * x + y * p->linesize[0],
                                p->data[1] + ps * x + y * p->linesize[1],
                                p->data[2] + ps * x + y * p->linesize[2],
                                p->data[3] + ps * x + y * p->linesize[3] };
-        decode_rgb_frame(f, fs, sc, &gb, planes, width, height, p->linesize);
+        decode_rgb_frame(f, sc, &gb, planes, width, height, p->linesize);
     }
     if (f->ac != AC_GOLOMB_RICE && f->version > 2) {
         int v;
@@ -789,9 +787,7 @@ static int read_header(FFV1Context *f)
     }
 
     for (int j = 0; j < f->slice_count; j++) {
-        FFV1Context *fs = f->slice_context[j];
         FFV1SliceContext *sc = &f->slices[j];
-        fs->packed_at_lsb = f->packed_at_lsb;
 
         sc->slice_damaged = 0;
 
@@ -937,7 +933,6 @@ static int decode_frame(AVCodecContext *avctx, AVFrame *rframe,
 
     buf_p = buf + buf_size;
     for (int i = f->slice_count - 1; i >= 0; i--) {
-        FFV1Context *fs = f->slice_context[i];
         FFV1SliceContext *sc = &f->slices[i];
         int trailer = 3 + 5*!!f->ec;
         int v;
@@ -978,15 +973,14 @@ static int decode_frame(AVCodecContext *avctx, AVFrame *rframe,
         } else
             sc->c.bytestream_end = buf_p + v;
 
-        fs->avctx = avctx;
     }
 
     avctx->execute(avctx,
                    decode_slice,
-                   &f->slice_context[0],
+                   f->slices,
                    NULL,
                    f->slice_count,
-                   sizeof(void*));
+                   sizeof(*f->slices));
 
     for (int i = f->slice_count - 1; i >= 0; i--) {
         FFV1SliceContext *sc = &f->slices[i];
@@ -1068,13 +1062,9 @@ static int update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
         memcpy(fdst->quant_tables[0], fsrc->quant_tables[0], sizeof(fsrc->quant_tables[0]));
 
     for (int i = 0; i < fdst->num_h_slices * fdst->num_v_slices; i++) {
-        FFV1Context *fssrc = fsrc->slice_context[i];
-        FFV1Context *fsdst = fdst->slice_context[i];
-
         FFV1SliceContext       *sc  = &fdst->slices[i];
         const FFV1SliceContext *sc0 = &fsrc->slices[i];
 
-        copy_fields(fsdst, fssrc, fsrc);
         sc->slice_damaged = sc0->slice_damaged;
 
         if (fsrc->version < 3) {
diff --git a/libavcodec/ffv1dec_template.c b/libavcodec/ffv1dec_template.c
index 9790fd7149..2da6bd935d 100644
--- a/libavcodec/ffv1dec_template.c
+++ b/libavcodec/ffv1dec_template.c
@@ -23,8 +23,7 @@
 #include "ffv1_template.c"
 
 static av_always_inline int
-RENAME(decode_line)(FFV1Context *f,
-                    FFV1Context *s, FFV1SliceContext *sc,
+RENAME(decode_line)(FFV1Context *f, FFV1SliceContext *sc,
                     GetBitContext *gb,
                     int w, TYPE *sample[2], int plane_index, int bits,
                     int ac)
@@ -119,7 +118,7 @@ RENAME(decode_line)(FFV1Context *f,
             } else
                 diff = get_vlc_symbol(gb, &p->vlc_state[context], bits);
 
-            ff_dlog(s->avctx, "count:%d index:%d, mode:%d, x:%d pos:%d\n",
+            ff_dlog(f->avctx, "count:%d index:%d, mode:%d, x:%d pos:%d\n",
                     run_count, run_index, run_mode, x, get_bits_count(gb));
         }
 
@@ -132,15 +131,14 @@ RENAME(decode_line)(FFV1Context *f,
     return 0;
 }
 
-static int RENAME(decode_rgb_frame)(FFV1Context *f,
-                                    FFV1Context *s, FFV1SliceContext *sc,
+static int RENAME(decode_rgb_frame)(FFV1Context *f, FFV1SliceContext *sc,
                                     GetBitContext *gb,
                                     uint8_t *src[4], int w, int h, int stride[4])
 {
     int x, y, p;
     TYPE *sample[4][2];
-    int lbd    = s->avctx->bits_per_raw_sample <= 8;
-    int bits   = s->avctx->bits_per_raw_sample > 0 ? s->avctx->bits_per_raw_sample : 8;
+    int lbd    = f->avctx->bits_per_raw_sample <= 8;
+    int bits   = f->avctx->bits_per_raw_sample > 0 ? f->avctx->bits_per_raw_sample : 8;
     int offset = 1 << bits;
     int transparency = f->transparency;
     int ac = f->ac;
@@ -165,9 +163,9 @@ static int RENAME(decode_rgb_frame)(FFV1Context *f,
             sample[p][1][-1]= sample[p][0][0  ];
             sample[p][0][ w]= sample[p][0][w-1];
             if (lbd && sc->slice_coding_mode == 0)
-                ret = RENAME(decode_line)(f, s, sc, gb, w, sample[p], (p + 1)/2, 9, ac);
+                ret = RENAME(decode_line)(f, sc, gb, w, sample[p], (p + 1)/2, 9, ac);
             else
-                ret = RENAME(decode_line)(f, s, sc, gb, w, sample[p], (p + 1)/2, bits + (sc->slice_coding_mode != 1), ac);
+                ret = RENAME(decode_line)(f, sc, gb, w, sample[p], (p + 1)/2, bits + (sc->slice_coding_mode != 1), ac);
             if (ret < 0)
                 return ret;
         }