virtualenv/FFmpeg
1
0
Fork 0
mirror of https://github.com/FFmpeg/FFmpeg.git synced 2025-01-29 22:00:58 +02:00
Code Issues Releases Activity

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

Browse Source
This commit is contained in:
Anton Khirnov 2024-07-08 18:01:13 +02:00
parent 9b86ba5a92
commit 28769f6bc1
6 changed files with 37 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
libavcodec/ffv1.c
View File

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

7
libavcodec/ffv1.h
View File

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

16
libavcodec/ffv1dec.c
View File

@ -201,7 +201,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");
@ -270,13 +270,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);
@ -298,7 +299,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;
@ -306,10 +307,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;
}
@ -818,7 +819,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);
@ -1083,7 +1084,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);

2
libavcodec/ffv1dec_template.c
View File

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

29
libavcodec/ffv1enc.c
View File

@ -385,8 +385,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);
}
}
}
@ -738,13 +738,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;
@ -882,6 +875,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;
@ -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_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);
@ -929,7 +932,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);
@ -1050,7 +1053,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);
}

2
libavcodec/ffv1enc_template.c
View File

@ -28,7 +28,7 @@ RENAME(encode_line)(FFV1Context *f,
int w, TYPE *sample[3], int plane_index, int bits,
int ac)
{
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;