Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

lavc/ffv1: move FFV1Context.plane to per-slice context

Browse Source
release/7.1
Anton Khirnov 6 months ago
parent 9b86ba5a92
commit 28769f6bc1
6 changed files with 37 additions and 36 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 17
      libavcodec/ffv1.c
  2. 7
      libavcodec/ffv1.h
  3. 16
      libavcodec/ffv1dec.c
  4. 2
      libavcodec/ffv1dec_template.c
  5. 29
      libavcodec/ffv1enc.c
  6. 2
      libavcodec/ffv1enc_template.c

17
libavcodec/ffv1.c
Unescape View File

@ -52,12 +52,13 @@ av_cold int ff_ffv1_common_init(AVCodecContext *avctx)
return 0; 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; int j, i;
for (j = 0; j < f->plane_count; j++) { 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 (f->ac != AC_GOLOMB_RICE) {
if (!p->state) if (!p->state)
@ -94,7 +95,7 @@ av_cold int ff_ffv1_init_slices_state(FFV1Context *f)
int i, ret; int i, ret;
for (i = 0; i < f->max_slice_count; i++) { for (i = 0; i < f->max_slice_count; i++) {
FFV1Context *fs = f->slice_context[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 AVERROR(ENOMEM);
} }
return 0; return 0;
@ -160,12 +161,12 @@ int ff_ffv1_allocate_initial_states(FFV1Context *f)
return 0; 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; int i, j;
for (i = 0; i < f->plane_count; i++) { 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->ac != AC_GOLOMB_RICE) {
if (f->initial_states[p->quant_table_index]) { if (f->initial_states[p->quant_table_index]) {
@ -191,17 +192,13 @@ av_cold int ff_ffv1_close(AVCodecContext *avctx)
int i, j; int i, j;
for (j = 0; j < s->max_slice_count; j++) { for (j = 0; j < s->max_slice_count; j++) {
FFV1Context *fs = s->slice_context[j];
FFV1SliceContext *sc = &s->slices[j]; FFV1SliceContext *sc = &s->slices[j];
av_freep(&sc->sample_buffer); av_freep(&sc->sample_buffer);
av_freep(&sc->sample_buffer32); av_freep(&sc->sample_buffer32);
if (!fs)
continue;
for (i = 0; i < s->plane_count; i++) { 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->state);
av_freep(&p->vlc_state); av_freep(&p->vlc_state);

7
libavcodec/ffv1.h
Unescape View File

@ -81,6 +81,7 @@ typedef struct FFV1SliceContext {
int slice_rct_by_coef; int slice_rct_by_coef;
int slice_rct_ry_coef; int slice_rct_ry_coef;
PlaneContext plane[MAX_PLANES];
PutBitContext pb; PutBitContext pb;
} FFV1SliceContext; } FFV1SliceContext;
@ -106,7 +107,6 @@ typedef struct FFV1Context {
int plane_count; int plane_count;
int ac; ///< 1=range coder <-> 0=golomb rice int ac; ///< 1=range coder <-> 0=golomb rice
int ac_byte_count; ///< number of bytes used for AC coding 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]; int16_t quant_tables[MAX_QUANT_TABLES][MAX_CONTEXT_INPUTS][256];
int context_count[MAX_QUANT_TABLES]; int context_count[MAX_QUANT_TABLES];
uint8_t state_transition[256]; uint8_t state_transition[256];
@ -138,11 +138,12 @@ typedef struct FFV1Context {
} FFV1Context; } FFV1Context;
int ff_ffv1_common_init(AVCodecContext *avctx); 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_slices_state(FFV1Context *f);
int ff_ffv1_init_slice_contexts(FFV1Context *f); int ff_ffv1_init_slice_contexts(FFV1Context *f);
int ff_ffv1_allocate_initial_states(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); int ff_ffv1_close(AVCodecContext *avctx);
static av_always_inline int fold(int diff, int bits) static av_always_inline int fold(int diff, int bits)

16
libavcodec/ffv1dec.c
Unescape View File

@ -201,7 +201,7 @@ static int decode_slice_header(const FFV1Context *f, FFV1Context *fs,
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
for (unsigned i = 0; i < f->plane_count; i++) { 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); int idx = get_symbol(c, state, 0);
if (idx >= (unsigned)f->quant_table_count) { if (idx >= (unsigned)f->quant_table_count) {
av_log(f->avctx, AV_LOG_ERROR, "quant_table_index out of range\n"); av_log(f->avctx, AV_LOG_ERROR, "quant_table_index out of range\n");
@ -270,13 +270,14 @@ static int decode_slice(AVCodecContext *c, void *arg)
if(f->fsrc && !(p->flags & AV_FRAME_FLAG_KEY)) { if(f->fsrc && !(p->flags & AV_FRAME_FLAG_KEY)) {
FFV1Context *fssrc = f->fsrc->slice_context[si]; FFV1Context *fssrc = f->fsrc->slice_context[si];
const FFV1SliceContext *scsrc = &f->fsrc->slices[si];
if (!(p->flags & AV_FRAME_FLAG_KEY)) if (!(p->flags & AV_FRAME_FLAG_KEY))
fs->slice_damaged |= fssrc->slice_damaged; fs->slice_damaged |= fssrc->slice_damaged;
for (int i = 0; i < f->plane_count; i++) { for (int i = 0; i < f->plane_count; i++) {
PlaneContext *psrc = &fssrc->plane[i]; const PlaneContext *psrc = &scsrc->plane[i];
PlaneContext *pdst = &fs->plane[i]; PlaneContext *pdst = &sc->plane[i];
av_free(pdst->state); av_free(pdst->state);
av_free(pdst->vlc_state); av_free(pdst->vlc_state);
@ -298,7 +299,7 @@ static int decode_slice(AVCodecContext *c, void *arg)
sc->slice_rct_ry_coef = 1; sc->slice_rct_ry_coef = 1;
if (f->version > 2) { 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); return AVERROR(ENOMEM);
if (decode_slice_header(f, fs, sc, p) < 0) { if (decode_slice_header(f, fs, sc, p) < 0) {
sc->slice_x = sc->slice_y = sc->slice_height = sc->slice_width = 0; sc->slice_x = sc->slice_y = sc->slice_height = sc->slice_width = 0;
@ -306,10 +307,10 @@ static int decode_slice(AVCodecContext *c, void *arg)
return AVERROR_INVALIDDATA; 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; return ret;
if ((p->flags & AV_FRAME_FLAG_KEY) || fs->slice_reset_contexts) { 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) { } else if (fs->slice_damaged) {
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
@ -818,7 +819,7 @@ static int read_header(FFV1Context *f)
} }
for (int i = 0; i < f->plane_count; i++) { 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) { if (f->version == 2) {
int idx = get_symbol(c, state, 0); int idx = get_symbol(c, state, 0);
@ -1083,7 +1084,6 @@ static int update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
sc->slice_height = sc0->slice_height; sc->slice_height = sc0->slice_height;
} }
} }
av_assert0(!fdst->plane[0].state);
av_assert1(fdst->max_slice_count == fsrc->max_slice_count); av_assert1(fdst->max_slice_count == fsrc->max_slice_count);

2
libavcodec/ffv1dec_template.c
Unescape View File

@ -29,7 +29,7 @@ RENAME(decode_line)(FFV1Context *f,
int w, TYPE *sample[2], int plane_index, int bits, int w, TYPE *sample[2], int plane_index, int bits,
int ac) int ac)
{ {
PlaneContext *const p = &s->plane[plane_index]; PlaneContext *const p = &sc->plane[plane_index];
RangeCoder *const c = &s->c; RangeCoder *const c = &s->c;
const int16_t (*quant_table)[256] = f->quant_tables[p->quant_table_index]; const int16_t (*quant_table)[256] = f->quant_tables[p->quant_table_index];
int x; int x;

29
libavcodec/ffv1enc.c
Unescape View File

@ -385,8 +385,8 @@ static void write_header(FFV1Context *f)
(fs->slice_height + 1) * f->num_v_slices / f->height - 1, (fs->slice_height + 1) * f->num_v_slices / f->height - 1,
0); 0);
for (j = 0; j < f->plane_count; j++) { for (j = 0; j < f->plane_count; j++) {
put_symbol(c, state, f->plane[j].quant_table_index, 0); put_symbol(c, state, fs->plane[j].quant_table_index, 0);
av_assert0(f->plane[j].quant_table_index == f->context_model); av_assert0(fs->plane[j].quant_table_index == f->context_model);
} }
} }
} }
@ -738,13 +738,6 @@ static av_cold int encode_init(AVCodecContext *avctx)
s->context_count[0] = (11 * 11 * 11 + 1) / 2; s->context_count[0] = (11 * 11 * 11 + 1) / 2;
s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 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) if ((ret = ff_ffv1_allocate_initial_states(s)) < 0)
return ret; return ret;
@ -882,6 +875,16 @@ slices_ok:
if ((ret = ff_ffv1_init_slice_contexts(s)) < 0) if ((ret = ff_ffv1_init_slice_contexts(s)) < 0)
return ret; return ret;
s->slice_count = s->max_slice_count; 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) if ((ret = ff_ffv1_init_slices_state(s)) < 0)
return ret; return ret;
@ -917,8 +920,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_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); put_symbol(c, state, (sc->slice_height+1)*f->num_v_slices / f->height-1, 0);
for (j=0; j<f->plane_count; j++) { for (j=0; j<f->plane_count; j++) {
put_symbol(c, state, f->plane[j].quant_table_index, 0); put_symbol(c, state, sc->plane[j].quant_table_index, 0);
av_assert0(f->plane[j].quant_table_index == f->context_model); av_assert0(sc->plane[j].quant_table_index == f->context_model);
} }
if (!(f->cur_enc_frame->flags & AV_FRAME_FLAG_INTERLACED)) if (!(f->cur_enc_frame->flags & AV_FRAME_FLAG_INTERLACED))
put_symbol(c, state, 3, 0); put_symbol(c, state, 3, 0);
@ -929,7 +932,7 @@ static void encode_slice_header(FFV1Context *f, FFV1Context *fs,
if (f->version > 3) { if (f->version > 3) {
put_rac(c, state, sc->slice_coding_mode == 1); put_rac(c, state, sc->slice_coding_mode == 1);
if (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); put_symbol(c, state, sc->slice_coding_mode, 0);
if (sc->slice_coding_mode != 1) { if (sc->slice_coding_mode != 1) {
put_symbol(c, state, sc->slice_rct_by_coef, 0); put_symbol(c, state, sc->slice_rct_by_coef, 0);
@ -1050,7 +1053,7 @@ static int encode_slice(AVCodecContext *c, void *arg)
retry: retry:
if (f->key_frame) if (f->key_frame)
ff_ffv1_clear_slice_state(f, fs); ff_ffv1_clear_slice_state(f, sc);
if (f->version > 2) { if (f->version > 2) {
encode_slice_header(f, fs, sc); encode_slice_header(f, fs, sc);
} }

2
libavcodec/ffv1enc_template.c
Unescape View File

@ -28,7 +28,7 @@ RENAME(encode_line)(FFV1Context *f,
int w, TYPE *sample[3], int plane_index, int bits, int w, TYPE *sample[3], int plane_index, int bits,
int ac) int ac)
{ {
PlaneContext *const p = &s->plane[plane_index]; PlaneContext *const p = &sc->plane[plane_index];
RangeCoder *const c = &s->c; RangeCoder *const c = &s->c;
int x; int x;
int run_index = sc->run_index; int run_index = sc->run_index;

Write Preview
Loading…
Cancel
Save