Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues 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.
release/7.1
Anton Khirnov 7 months ago
parent d845ea49c5
commit 54aa33f116
4 changed files with 76 additions and 53 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 15
      libavcodec/ffv1.c
  2. 13
      libavcodec/ffv1.h
  3. 76
      libavcodec/ffv1dec.c
  4. 25
      libavcodec/ffv1enc.c

15
libavcodec/ffv1.c
Unescape 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
Unescape 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
Unescape 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
Unescape 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;

Write Preview
Loading…
Cancel
Save