ffmpeg/FFmpeg
1
0
Fork 0
mirror of https://git.ffmpeg.org/ffmpeg.git synced 2024-09-20 05:16:38 +00:00
Code Issues Packages Projects Releases Wiki Activity

lavc/ffv1: add a per-slice context

Browse Source 
FFV1 decoder and encoder currently use the same struct - FFV1Context -
both as codec private data and per-slice context. For this purpose
FFV1Context contains an array of pointers to per-slice FFV1Context
instances.

This pattern is highly confusing, as it is not clear which fields are
per-slice and which per-codec.

Address this by adding a new struct storing only per-slice data. Start
by moving slice_{x,y,width,height} to it.
This commit is contained in:
Anton Khirnov 2024-07-04 10:22:53 +02:00
parent d845ea49c5
commit 54aa33f116
4 changed files with 76 additions and 53 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
libavcodec/ffv1.c
View File

@ -108,7 +108,12 @@ av_cold int ff_ffv1_init_slice_contexts(FFV1Context *f)
av_assert0(max_slice_count > 0);
f->slices = av_calloc(max_slice_count, sizeof(*f->slices));
if (!f->slices)
return AVERROR(ENOMEM);
for (i = 0; i < max_slice_count;) {
FFV1SliceContext *sc = &f->slices[i];
int sx = i % f->num_h_slices;
int sy = i / f->num_h_slices;
int sxs = f->avctx->width * sx / f->num_h_slices;
@ -124,10 +129,10 @@ av_cold int ff_ffv1_init_slice_contexts(FFV1Context *f)
memcpy(fs, f, sizeof(*fs));
memset(fs->rc_stat2, 0, sizeof(fs->rc_stat2));
fs->slice_width = sxe - sxs;
fs->slice_height = sye - sys;
fs->slice_x = sxs;
fs->slice_y = sys;
sc->slice_width = sxe - sxs;
sc->slice_height = sye - sys;
sc->slice_x = sxs;
sc->slice_y = sys;
fs->sample_buffer = av_malloc_array((fs->width + 6), 3 * MAX_PLANES *
sizeof(*fs->sample_buffer));
@ -217,5 +222,7 @@ av_cold int ff_ffv1_close(AVCodecContext *avctx)
for (i = 0; i < s->max_slice_count; i++)
av_freep(&s->slice_context[i]);
av_freep(&s->slices);
return 0;
}

13
libavcodec/ffv1.h
View File

@ -69,6 +69,13 @@ typedef struct PlaneContext {
#define MAX_SLICES 1024
typedef struct FFV1SliceContext {
int slice_width;
int slice_height;
int slice_x;
int slice_y;
} FFV1SliceContext;
typedef struct FFV1Context {
AVClass *class;
AVCodecContext *avctx;
@ -123,14 +130,12 @@ typedef struct FFV1Context {
int max_slice_count;
int num_v_slices;
int num_h_slices;
int slice_width;
int slice_height;
int slice_x;
int slice_y;
int slice_reset_contexts;
int slice_coding_mode;
int slice_rct_by_coef;
int slice_rct_ry_coef;
FFV1SliceContext *slices;
} FFV1Context;
int ff_ffv1_common_init(AVCodecContext *avctx);

76
libavcodec/ffv1dec.c
View File

@ -164,7 +164,7 @@ static int decode_plane(FFV1Context *s, uint8_t *src,
}
static int decode_slice_header(const FFV1Context *f, FFV1Context *fs,
AVFrame *frame)
FFV1SliceContext *sc, AVFrame *frame)
{
RangeCoder *c = &fs->c;
uint8_t state[CONTEXT_SIZE];
@ -185,17 +185,17 @@ static int decode_slice_header(const FFV1Context *f, FFV1Context *fs,
if (sx > f->num_h_slices - sw || sy > f->num_v_slices - sh)
return AVERROR_INVALIDDATA;
fs->slice_x = sx * (int64_t)f->width / f->num_h_slices;
fs->slice_y = sy * (int64_t)f->height / f->num_v_slices;
fs->slice_width = (sx + sw) * (int64_t)f->width / f->num_h_slices - fs->slice_x;
fs->slice_height = (sy + sh) * (int64_t)f->height / f->num_v_slices - fs->slice_y;
sc->slice_x = sx * (int64_t)f->width / f->num_h_slices;
sc->slice_y = sy * (int64_t)f->height / f->num_v_slices;
sc->slice_width = (sx + sw) * (int64_t)f->width / f->num_h_slices - sc->slice_x;
sc->slice_height = (sy + sh) * (int64_t)f->height / f->num_v_slices - sc->slice_y;
av_assert0((unsigned)fs->slice_width <= f->width &&
(unsigned)fs->slice_height <= f->height);
av_assert0 ( (unsigned)fs->slice_x + (uint64_t)fs->slice_width <= f->width
&& (unsigned)fs->slice_y + (uint64_t)fs->slice_height <= f->height);
av_assert0((unsigned)sc->slice_width <= f->width &&
(unsigned)sc->slice_height <= f->height);
av_assert0 ( (unsigned)sc->slice_x + (uint64_t)sc->slice_width <= f->width
&& (unsigned)sc->slice_y + (uint64_t)sc->slice_height <= f->height);
if (fs->ac == AC_GOLOMB_RICE && fs->slice_width >= (1<<23))
if (fs->ac == AC_GOLOMB_RICE && sc->slice_width >= (1<<23))
return AVERROR_INVALIDDATA;
for (unsigned i = 0; i < f->plane_count; i++) {
@ -261,6 +261,7 @@ static int decode_slice(AVCodecContext *c, void *arg)
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];
if (f->fsrc && !(p->flags & AV_FRAME_FLAG_KEY) && f->last_picture.f)
ff_progress_frame_await(&f->last_picture, si);
@ -298,8 +299,8 @@ static int decode_slice(AVCodecContext *c, void *arg)
if (f->version > 2) {
if (ff_ffv1_init_slice_state(f, fs) < 0)
return AVERROR(ENOMEM);
if (decode_slice_header(f, fs, p) < 0) {
fs->slice_x = fs->slice_y = fs->slice_height = fs->slice_width = 0;
if (decode_slice_header(f, fs, sc, p) < 0) {
sc->slice_x = sc->slice_y = sc->slice_height = sc->slice_width = 0;
fs->slice_damaged = 1;
return AVERROR_INVALIDDATA;
}
@ -312,10 +313,10 @@ static int decode_slice(AVCodecContext *c, void *arg)
return AVERROR_INVALIDDATA;
}
width = fs->slice_width;
height = fs->slice_height;
x = fs->slice_x;
y = fs->slice_y;
width = sc->slice_width;
height = sc->slice_height;
x = sc->slice_x;
y = sc->slice_y;
if (fs->ac == AC_GOLOMB_RICE) {
if (f->version == 3 && f->micro_version > 1 || f->version > 3)
@ -788,6 +789,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->ac = f->ac;
fs->packed_at_lsb = f->packed_at_lsb;
@ -804,15 +806,15 @@ static int read_header(FFV1Context *f)
if (sx > f->num_h_slices - sw || sy > f->num_v_slices - sh)
return AVERROR_INVALIDDATA;
fs->slice_x = sx * (int64_t)f->width / f->num_h_slices;
fs->slice_y = sy * (int64_t)f->height / f->num_v_slices;
fs->slice_width = (sx + sw) * (int64_t)f->width / f->num_h_slices - fs->slice_x;
fs->slice_height = (sy + sh) * (int64_t)f->height / f->num_v_slices - fs->slice_y;
sc->slice_x = sx * (int64_t)f->width / f->num_h_slices;
sc->slice_y = sy * (int64_t)f->height / f->num_v_slices;
sc->slice_width = (sx + sw) * (int64_t)f->width / f->num_h_slices - sc->slice_x;
sc->slice_height = (sy + sh) * (int64_t)f->height / f->num_v_slices - sc->slice_y;
av_assert0((unsigned)fs->slice_width <= f->width &&
(unsigned)fs->slice_height <= f->height);
av_assert0 ( (unsigned)fs->slice_x + (uint64_t)fs->slice_width <= f->width
&& (unsigned)fs->slice_y + (uint64_t)fs->slice_height <= f->height);
av_assert0((unsigned)sc->slice_width <= f->width &&
(unsigned)sc->slice_height <= f->height);
av_assert0 ( (unsigned)sc->slice_x + (uint64_t)sc->slice_width <= f->width
&& (unsigned)sc->slice_y + (uint64_t)sc->slice_height <= f->height);
}
for (int i = 0; i < f->plane_count; i++) {
@ -990,6 +992,7 @@ static int decode_frame(AVCodecContext *avctx, AVFrame *rframe,
for (int i = f->slice_count - 1; i >= 0; i--) {
FFV1Context *fs = f->slice_context[i];
FFV1SliceContext *sc = &f->slices[i];
if (fs->slice_damaged && f->last_picture.f) {
const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
const uint8_t *src[4];
@ -1000,9 +1003,9 @@ static int decode_frame(AVCodecContext *avctx, AVFrame *rframe,
int sh = (j == 1 || j == 2) ? f->chroma_h_shift : 0;
int sv = (j == 1 || j == 2) ? f->chroma_v_shift : 0;
dst[j] = p->data[j] + p->linesize[j] *
(fs->slice_y >> sv) + ((fs->slice_x >> sh) << pixshift);
(sc->slice_y >> sv) + ((sc->slice_x >> sh) << pixshift);
src[j] = f->last_picture.f->data[j] + f->last_picture.f->linesize[j] *
(fs->slice_y >> sv) + ((fs->slice_x >> sh) << pixshift);
(sc->slice_y >> sv) + ((sc->slice_x >> sh) << pixshift);
}
if (desc->flags & AV_PIX_FMT_FLAG_PAL) {
@ -1012,8 +1015,8 @@ static int decode_frame(AVCodecContext *avctx, AVFrame *rframe,
av_image_copy(dst, p->linesize, src,
f->last_picture.f->linesize,
avctx->pix_fmt,
fs->slice_width,
fs->slice_height);
sc->slice_width,
sc->slice_height);
}
}
ff_progress_frame_report(&f->picture, INT_MAX);
@ -1048,12 +1051,6 @@ static void copy_fields(FFV1Context *fsdst, const FFV1Context *fssrc,
fsdst->packed_at_lsb = fsrc->packed_at_lsb;
fsdst->slice_count = fsrc->slice_count;
if (fsrc->version<3){
fsdst->slice_x = fssrc->slice_x;
fsdst->slice_y = fssrc->slice_y;
fsdst->slice_width = fssrc->slice_width;
fsdst->slice_height = fssrc->slice_height;
}
}
static int update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
@ -1073,7 +1070,18 @@ static int update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
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);
if (fsrc->version < 3) {
sc->slice_x = sc0->slice_x;
sc->slice_y = sc0->slice_y;
sc->slice_width = sc0->slice_width;
sc->slice_height = sc0->slice_height;
}
}
av_assert0(!fdst->plane[0].state);
av_assert0(!fdst->sample_buffer);

25
libavcodec/ffv1enc.c
View File

@ -370,7 +370,7 @@ static void write_header(FFV1Context *f)
} else if (f->version < 3) {
put_symbol(c, state, f->slice_count, 0);
for (i = 0; i < f->slice_count; i++) {
FFV1Context *fs = f->slice_context[i];
FFV1SliceContext *fs = &f->slices[i];
put_symbol(c, state,
(fs->slice_x + 1) * f->num_h_slices / f->width, 0);
put_symbol(c, state,
@ -904,17 +904,18 @@ slices_ok:
return 0;
}
static void encode_slice_header(FFV1Context *f, FFV1Context *fs)
static void encode_slice_header(FFV1Context *f, FFV1Context *fs,
FFV1SliceContext *sc)
{
RangeCoder *c = &fs->c;
uint8_t state[CONTEXT_SIZE];
int j;
memset(state, 128, sizeof(state));
put_symbol(c, state, (fs->slice_x +1)*f->num_h_slices / f->width , 0);
put_symbol(c, state, (fs->slice_y +1)*f->num_v_slices / f->height , 0);
put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
put_symbol(c, state, (sc->slice_x +1)*f->num_h_slices / f->width , 0);
put_symbol(c, state, (sc->slice_y +1)*f->num_v_slices / f->height , 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);
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);
@ -1023,10 +1024,12 @@ static int encode_slice(AVCodecContext *c, void *arg)
{
FFV1Context *fs = *(void **)arg;
FFV1Context *f = fs->avctx->priv_data;
int width = fs->slice_width;
int height = fs->slice_height;
int x = fs->slice_x;
int y = fs->slice_y;
const int si = (FFV1Context**)arg - f->slice_context;
FFV1SliceContext *sc = &f->slices[si];
int width = sc->slice_width;
int height = sc->slice_height;
int x = sc->slice_x;
int y = sc->slice_y;
const AVFrame *const p = f->cur_enc_frame;
const int ps = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step;
int ret;
@ -1048,7 +1051,7 @@ retry:
if (f->key_frame)
ff_ffv1_clear_slice_state(f, fs);
if (f->version > 2) {
encode_slice_header(f, fs);
encode_slice_header(f, fs, sc);
}
if (fs->ac == AC_GOLOMB_RICE) {
fs->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&fs->c, f->version > 2) : 0;