[FFmpeg-devel,18/39] lavc/ffv1: move FFV1Context.plane to per-slice context

diff --git a/libavcodec/ffv1.c b/libavcodec/ffv1.c
index 581e775ae2..7bc4f1b135 100644
--- a/libavcodec/ffv1.c
+++ b/libavcodec/ffv1.c
@@ -52,12 +52,13 @@  av_cold int ff_ffv1_common_init(AVCodecContext *avctx)
     return 0;
 }
 
-av_cold int ff_ffv1_init_slice_state(const FFV1Context *f, FFV1Context *fs)
+av_cold int ff_ffv1_init_slice_state(const FFV1Context *f,
+                                     FFV1Context *fs, FFV1SliceContext *sc)
 {
     int j, i;
 
     for (j = 0; j < f->plane_count; j++) {
-        PlaneContext *const p = &fs->plane[j];
+        PlaneContext *const p = &sc->plane[j];
 
         if (f->ac != AC_GOLOMB_RICE) {
             if (!p->state)
@@ -94,7 +95,7 @@  av_cold int ff_ffv1_init_slices_state(FFV1Context *f)
     int i, ret;
     for (i = 0; i < f->max_slice_count; i++) {
         FFV1Context *fs = f->slice_context[i];
-        if ((ret = ff_ffv1_init_slice_state(f, fs)) < 0)
+        if ((ret = ff_ffv1_init_slice_state(f, fs, &f->slices[i])) < 0)
             return AVERROR(ENOMEM);
     }
     return 0;
@@ -160,12 +161,12 @@  int ff_ffv1_allocate_initial_states(FFV1Context *f)
     return 0;
 }
 
-void ff_ffv1_clear_slice_state(const FFV1Context *f, FFV1Context *fs)
+void ff_ffv1_clear_slice_state(const FFV1Context *f, FFV1SliceContext *sc)
 {
     int i, j;
 
     for (i = 0; i < f->plane_count; i++) {
-        PlaneContext *p = &fs->plane[i];
+        PlaneContext *p = &sc->plane[i];
 
         if (f->ac != AC_GOLOMB_RICE) {
             if (f->initial_states[p->quant_table_index]) {
@@ -191,17 +192,13 @@  av_cold int ff_ffv1_close(AVCodecContext *avctx)
     int i, j;
 
     for (j = 0; j < s->max_slice_count; j++) {
-        FFV1Context *fs = s->slice_context[j];
         FFV1SliceContext *sc = &s->slices[j];
 
         av_freep(&sc->sample_buffer);
         av_freep(&sc->sample_buffer32);
 
-        if (!fs)
-            continue;
-
         for (i = 0; i < s->plane_count; i++) {
-            PlaneContext *p = &fs->plane[i];
+            PlaneContext *p = &sc->plane[i];
 
             av_freep(&p->state);
             av_freep(&p->vlc_state);
diff --git a/libavcodec/ffv1.h b/libavcodec/ffv1.h
index e466aedbbe..68e59b300b 100644
--- a/libavcodec/ffv1.h
+++ b/libavcodec/ffv1.h
@@ -81,6 +81,7 @@  typedef struct FFV1SliceContext {
     int slice_rct_by_coef;
     int slice_rct_ry_coef;
 
+    PlaneContext plane[MAX_PLANES];
     PutBitContext pb;
 } FFV1SliceContext;
 
@@ -106,7 +107,6 @@  typedef struct FFV1Context {
     int plane_count;
     int ac;                              ///< 1=range coder <-> 0=golomb rice
     int ac_byte_count;                   ///< number of bytes used for AC coding
-    PlaneContext plane[MAX_PLANES];
     int16_t quant_tables[MAX_QUANT_TABLES][MAX_CONTEXT_INPUTS][256];
     int context_count[MAX_QUANT_TABLES];
     uint8_t state_transition[256];
@@ -138,11 +138,12 @@  typedef struct FFV1Context {
 } FFV1Context;
 
 int ff_ffv1_common_init(AVCodecContext *avctx);
-int ff_ffv1_init_slice_state(const FFV1Context *f, FFV1Context *fs);
+int ff_ffv1_init_slice_state(const FFV1Context *f, FFV1Context *fs,
+                             FFV1SliceContext *sc);
 int ff_ffv1_init_slices_state(FFV1Context *f);
 int ff_ffv1_init_slice_contexts(FFV1Context *f);
 int ff_ffv1_allocate_initial_states(FFV1Context *f);
-void ff_ffv1_clear_slice_state(const FFV1Context *f, FFV1Context *fs);
+void ff_ffv1_clear_slice_state(const FFV1Context *f, FFV1SliceContext *sc);
 int ff_ffv1_close(AVCodecContext *avctx);
 
 static av_always_inline int fold(int diff, int bits)
diff --git a/libavcodec/ffv1dec.c b/libavcodec/ffv1dec.c
index 133baa895a..4d20512643 100644
--- a/libavcodec/ffv1dec.c
+++ b/libavcodec/ffv1dec.c
@@ -200,7 +200,7 @@  static int decode_slice_header(const FFV1Context *f, FFV1Context *fs,
         return AVERROR_INVALIDDATA;
 
     for (unsigned i = 0; i < f->plane_count; i++) {
-        PlaneContext * const p = &fs->plane[i];
+        PlaneContext * const p = &sc->plane[i];
         int idx = get_symbol(c, state, 0);
         if (idx >= (unsigned)f->quant_table_count) {
             av_log(f->avctx, AV_LOG_ERROR, "quant_table_index out of range\n");
@@ -269,13 +269,14 @@  static int decode_slice(AVCodecContext *c, void *arg)
 
     if(f->fsrc && !(p->flags & AV_FRAME_FLAG_KEY)) {
         FFV1Context *fssrc = f->fsrc->slice_context[si];
+        const FFV1SliceContext *scsrc = &f->fsrc->slices[si];
 
         if (!(p->flags & AV_FRAME_FLAG_KEY))
             fs->slice_damaged |= fssrc->slice_damaged;
 
         for (int i = 0; i < f->plane_count; i++) {
-            PlaneContext *psrc = &fssrc->plane[i];
-            PlaneContext *pdst = &fs->plane[i];
+            const PlaneContext *psrc = &scsrc->plane[i];
+            PlaneContext *pdst = &sc->plane[i];
 
             av_free(pdst->state);
             av_free(pdst->vlc_state);
@@ -297,7 +298,7 @@  static int decode_slice(AVCodecContext *c, void *arg)
     sc->slice_rct_ry_coef = 1;
 
     if (f->version > 2) {
-        if (ff_ffv1_init_slice_state(f, fs) < 0)
+        if (ff_ffv1_init_slice_state(f, fs, sc) < 0)
             return AVERROR(ENOMEM);
         if (decode_slice_header(f, fs, sc, p) < 0) {
             sc->slice_x = sc->slice_y = sc->slice_height = sc->slice_width = 0;
@@ -305,10 +306,10 @@  static int decode_slice(AVCodecContext *c, void *arg)
             return AVERROR_INVALIDDATA;
         }
     }
-    if ((ret = ff_ffv1_init_slice_state(f, fs)) < 0)
+    if ((ret = ff_ffv1_init_slice_state(f, fs, sc)) < 0)
         return ret;
     if ((p->flags & AV_FRAME_FLAG_KEY) || fs->slice_reset_contexts) {
-        ff_ffv1_clear_slice_state(f, fs);
+        ff_ffv1_clear_slice_state(f, sc);
     } else if (fs->slice_damaged) {
         return AVERROR_INVALIDDATA;
     }
@@ -817,7 +818,7 @@  static int read_header(FFV1Context *f)
         }
 
         for (int i = 0; i < f->plane_count; i++) {
-            PlaneContext *const p = &fs->plane[i];
+            PlaneContext *const p = &sc->plane[i];
 
             if (f->version == 2) {
                 int idx = get_symbol(c, state, 0);
@@ -1082,7 +1083,6 @@  static int update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
             sc->slice_height        = sc0->slice_height;
         }
     }
-    av_assert0(!fdst->plane[0].state);
 
     av_assert1(fdst->max_slice_count == fsrc->max_slice_count);
 
diff --git a/libavcodec/ffv1dec_template.c b/libavcodec/ffv1dec_template.c
index 30a13e0faf..42198b5e0b 100644
--- a/libavcodec/ffv1dec_template.c
+++ b/libavcodec/ffv1dec_template.c
@@ -28,7 +28,7 @@  RENAME(decode_line)(FFV1Context *f,
                     GetBitContext *gb,
                     int w, TYPE *sample[2], int plane_index, int bits)
 {
-    PlaneContext *const p = &s->plane[plane_index];
+    PlaneContext *const p = &sc->plane[plane_index];
     RangeCoder *const c   = &s->c;
     int x;
     int run_count = 0;
diff --git a/libavcodec/ffv1enc.c b/libavcodec/ffv1enc.c
index 7fb5b997cc..1c986927fe 100644
--- a/libavcodec/ffv1enc.c
+++ b/libavcodec/ffv1enc.c
@@ -384,8 +384,8 @@  static void write_header(FFV1Context *f)
                        (fs->slice_height + 1) * f->num_v_slices / f->height - 1,
                        0);
             for (j = 0; j < f->plane_count; j++) {
-                put_symbol(c, state, f->plane[j].quant_table_index, 0);
-                av_assert0(f->plane[j].quant_table_index == f->context_model);
+                put_symbol(c, state, fs->plane[j].quant_table_index, 0);
+                av_assert0(fs->plane[j].quant_table_index == f->context_model);
             }
         }
     }
@@ -737,13 +737,6 @@  static av_cold int encode_init(AVCodecContext *avctx)
     s->context_count[0] = (11 * 11 * 11        + 1) / 2;
     s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;
 
-    for (i = 0; i < s->plane_count; i++) {
-        PlaneContext *const p = &s->plane[i];
-
-        p->quant_table_index = s->context_model;
-        p->context_count     = s->context_count[p->quant_table_index];
-    }
-
     if ((ret = ff_ffv1_allocate_initial_states(s)) < 0)
         return ret;
 
@@ -881,6 +874,16 @@  slices_ok:
     if ((ret = ff_ffv1_init_slice_contexts(s)) < 0)
         return ret;
     s->slice_count = s->max_slice_count;
+
+    for (int j = 0; j < s->slice_count; j++) {
+        for (int i = 0; i < s->plane_count; i++) {
+            PlaneContext *const p = &s->slices[j].plane[i];
+
+            p->quant_table_index = s->context_model;
+            p->context_count     = s->context_count[p->quant_table_index];
+        }
+    }
+
     if ((ret = ff_ffv1_init_slices_state(s)) < 0)
         return ret;
 
@@ -916,8 +919,8 @@  static void encode_slice_header(FFV1Context *f, FFV1Context *fs,
     put_symbol(c, state, (sc->slice_width +1)*f->num_h_slices / f->width -1, 0);
     put_symbol(c, state, (sc->slice_height+1)*f->num_v_slices / f->height-1, 0);
     for (j=0; j<f->plane_count; j++) {
-        put_symbol(c, state, f->plane[j].quant_table_index, 0);
-        av_assert0(f->plane[j].quant_table_index == f->context_model);
+        put_symbol(c, state, sc->plane[j].quant_table_index, 0);
+        av_assert0(sc->plane[j].quant_table_index == f->context_model);
     }
     if (!(f->cur_enc_frame->flags & AV_FRAME_FLAG_INTERLACED))
         put_symbol(c, state, 3, 0);
@@ -928,7 +931,7 @@  static void encode_slice_header(FFV1Context *f, FFV1Context *fs,
     if (f->version > 3) {
         put_rac(c, state, sc->slice_coding_mode == 1);
         if (sc->slice_coding_mode == 1)
-            ff_ffv1_clear_slice_state(f, fs);
+            ff_ffv1_clear_slice_state(f, sc);
         put_symbol(c, state, sc->slice_coding_mode, 0);
         if (sc->slice_coding_mode != 1) {
             put_symbol(c, state, sc->slice_rct_by_coef, 0);
@@ -1049,7 +1052,7 @@  static int encode_slice(AVCodecContext *c, void *arg)
 
 retry:
     if (f->key_frame)
-        ff_ffv1_clear_slice_state(f, fs);
+        ff_ffv1_clear_slice_state(f, sc);
     if (f->version > 2) {
         encode_slice_header(f, fs, sc);
     }
diff --git a/libavcodec/ffv1enc_template.c b/libavcodec/ffv1enc_template.c
index 970c185e93..2116c9aee7 100644
--- a/libavcodec/ffv1enc_template.c
+++ b/libavcodec/ffv1enc_template.c
@@ -27,7 +27,7 @@  RENAME(encode_line)(FFV1Context *f,
                     FFV1Context *s, FFV1SliceContext *sc,
                     int w, TYPE *sample[3], int plane_index, int bits)
 {
-    PlaneContext *const p = &s->plane[plane_index];
+    PlaneContext *const p = &sc->plane[plane_index];
     RangeCoder *const c   = &s->c;
     int x;
     int run_index = sc->run_index;