@@ -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);
@@ -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)
@@ -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);
@@ -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;
@@ -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);
}
@@ -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;