RepoMirrors/ffmpeg
1
0
Fork 0
mirror of https://git.ffmpeg.org/ffmpeg.git synced 2025-01-20 14:20:51 +00:00
Code Issues Projects Releases Wiki Activity

lavc/ffv1: move RangeCoder to per-slice context

Browse Source
This commit is contained in:
Anton Khirnov 2024-07-09 08:45:16 +02:00
parent 28769f6bc1
commit 7b2bfba55d
6 changed files with 85 additions and 83 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
libavcodec/ffv1.c
View File

@ -53,7 +53,7 @@ av_cold int ff_ffv1_common_init(AVCodecContext *avctx)
}
av_cold int ff_ffv1_init_slice_state(const FFV1Context *f,
FFV1Context *fs, FFV1SliceContext *sc)
FFV1SliceContext *sc)
{
int j, i;
@ -82,8 +82,8 @@ av_cold int ff_ffv1_init_slice_state(const FFV1Context *f,
if (f->ac == AC_RANGE_CUSTOM_TAB) {
//FIXME only redo if state_transition changed
for (j = 1; j < 256; j++) {
fs->c. one_state[ j] = f->state_transition[j];
fs->c.zero_state[256 - j] = 256 - fs->c.one_state[j];
sc->c. one_state[ j] = f->state_transition[j];
sc->c.zero_state[256 - j] = 256 - sc->c.one_state[j];
}
}
@ -94,8 +94,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, &f->slices[i])) < 0)
if ((ret = ff_ffv1_init_slice_state(f, &f->slices[i])) < 0)
return AVERROR(ENOMEM);
}
return 0;

5
libavcodec/ffv1.h
View File

@ -83,12 +83,12 @@ typedef struct FFV1SliceContext {
PlaneContext plane[MAX_PLANES];
PutBitContext pb;
RangeCoder c;
} FFV1SliceContext;
typedef struct FFV1Context {
AVClass *class;
AVCodecContext *avctx;
RangeCoder c;
uint64_t rc_stat[256][2];
uint64_t (*rc_stat2[MAX_QUANT_TABLES])[32][2];
int version;
@ -138,8 +138,7 @@ typedef struct FFV1Context {
} FFV1Context;
int ff_ffv1_common_init(AVCodecContext *avctx);
int ff_ffv1_init_slice_state(const FFV1Context *f, FFV1Context *fs,
FFV1SliceContext *sc);
int ff_ffv1_init_slice_state(const FFV1Context *f, 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);

72
libavcodec/ffv1dec.c
View File

@ -168,7 +168,7 @@ static int decode_plane(FFV1Context *f,
static int decode_slice_header(const FFV1Context *f, FFV1Context *fs,
FFV1SliceContext *sc, AVFrame *frame)
{
RangeCoder *c = &fs->c;
RangeCoder *c = &sc->c;
uint8_t state[CONTEXT_SIZE];
unsigned ps, context_count;
int sx, sy, sw, sh;
@ -299,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, sc) < 0)
if (ff_ffv1_init_slice_state(f, 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;
@ -307,7 +307,7 @@ static int decode_slice(AVCodecContext *c, void *arg)
return AVERROR_INVALIDDATA;
}
}
if ((ret = ff_ffv1_init_slice_state(f, fs, sc)) < 0)
if ((ret = ff_ffv1_init_slice_state(f, sc)) < 0)
return ret;
if ((p->flags & AV_FRAME_FLAG_KEY) || fs->slice_reset_contexts) {
ff_ffv1_clear_slice_state(f, sc);
@ -322,11 +322,11 @@ static int decode_slice(AVCodecContext *c, void *arg)
if (f->ac == AC_GOLOMB_RICE) {
if (f->version == 3 && f->micro_version > 1 || f->version > 3)
get_rac(&fs->c, (uint8_t[]) { 129 });
fs->ac_byte_count = f->version > 2 || (!x && !y) ? fs->c.bytestream - fs->c.bytestream_start - 1 : 0;
get_rac(&sc->c, (uint8_t[]) { 129 });
fs->ac_byte_count = f->version > 2 || (!x && !y) ? sc->c.bytestream - sc->c.bytestream_start - 1 : 0;
init_get_bits(&gb,
fs->c.bytestream_start + fs->ac_byte_count,
(fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count) * 8);
sc->c.bytestream_start + fs->ac_byte_count,
(sc->c.bytestream_end - sc->c.bytestream_start - fs->ac_byte_count) * 8);
}
av_assert1(width && height);
@ -361,8 +361,8 @@ static int decode_slice(AVCodecContext *c, void *arg)
}
if (f->ac != AC_GOLOMB_RICE && f->version > 2) {
int v;
get_rac(&fs->c, (uint8_t[]) { 129 });
v = fs->c.bytestream_end - fs->c.bytestream - 2 - 5*f->ec;
get_rac(&sc->c, (uint8_t[]) { 129 });
v = sc->c.bytestream_end - sc->c.bytestream - 2 - 5*f->ec;
if (v) {
av_log(f->avctx, AV_LOG_ERROR, "bytestream end mismatching by %d\n", v);
fs->slice_damaged = 1;
@ -421,7 +421,7 @@ static int read_quant_tables(RangeCoder *c,
static int read_extra_header(FFV1Context *f)
{
RangeCoder *const c = &f->c;
RangeCoder c;
uint8_t state[CONTEXT_SIZE];
int ret;
uint8_t state2[32][CONTEXT_SIZE];
@ -430,10 +430,10 @@ static int read_extra_header(FFV1Context *f)
memset(state2, 128, sizeof(state2));
memset(state, 128, sizeof(state));
ff_init_range_decoder(c, f->avctx->extradata, f->avctx->extradata_size);
ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
ff_init_range_decoder(&c, f->avctx->extradata, f->avctx->extradata_size);
ff_build_rac_states(&c, 0.05 * (1LL << 32), 256 - 8);
f->version = get_symbol(c, state, 0);
f->version = get_symbol(&c, state, 0);
if (f->version < 2) {
av_log(f->avctx, AV_LOG_ERROR, "Invalid version in global header\n");
return AVERROR_INVALIDDATA;
@ -444,27 +444,27 @@ static int read_extra_header(FFV1Context *f)
return AVERROR_PATCHWELCOME;
}
if (f->version > 2) {
c->bytestream_end -= 4;
f->micro_version = get_symbol(c, state, 0);
c.bytestream_end -= 4;
f->micro_version = get_symbol(&c, state, 0);
if (f->micro_version < 0)
return AVERROR_INVALIDDATA;
}
f->ac = get_symbol(c, state, 0);
f->ac = get_symbol(&c, state, 0);
if (f->ac == AC_RANGE_CUSTOM_TAB) {
for (int i = 1; i < 256; i++)
f->state_transition[i] = get_symbol(c, state, 1) + c->one_state[i];
f->state_transition[i] = get_symbol(&c, state, 1) + c.one_state[i];
}
f->colorspace = get_symbol(c, state, 0); //YUV cs type
f->avctx->bits_per_raw_sample = get_symbol(c, state, 0);
f->chroma_planes = get_rac(c, state);
f->chroma_h_shift = get_symbol(c, state, 0);
f->chroma_v_shift = get_symbol(c, state, 0);
f->transparency = get_rac(c, state);
f->colorspace = get_symbol(&c, state, 0); //YUV cs type
f->avctx->bits_per_raw_sample = get_symbol(&c, state, 0);
f->chroma_planes = get_rac(&c, state);
f->chroma_h_shift = get_symbol(&c, state, 0);
f->chroma_v_shift = get_symbol(&c, state, 0);
f->transparency = get_rac(&c, state);
f->plane_count = 1 + (f->chroma_planes || f->version<4) + f->transparency;
f->num_h_slices = 1 + get_symbol(c, state, 0);
f->num_v_slices = 1 + get_symbol(c, state, 0);
f->num_h_slices = 1 + get_symbol(&c, state, 0);
f->num_v_slices = 1 + get_symbol(&c, state, 0);
if (f->chroma_h_shift > 4U || f->chroma_v_shift > 4U) {
av_log(f->avctx, AV_LOG_ERROR, "chroma shift parameters %d %d are invalid\n",
@ -484,7 +484,7 @@ static int read_extra_header(FFV1Context *f)
return AVERROR_PATCHWELCOME;
}
f->quant_table_count = get_symbol(c, state, 0);
f->quant_table_count = get_symbol(&c, state, 0);
if (f->quant_table_count > (unsigned)MAX_QUANT_TABLES || !f->quant_table_count) {
av_log(f->avctx, AV_LOG_ERROR, "quant table count %d is invalid\n", f->quant_table_count);
f->quant_table_count = 0;
@ -492,7 +492,7 @@ static int read_extra_header(FFV1Context *f)
}
for (int i = 0; i < f->quant_table_count; i++) {
f->context_count[i] = read_quant_tables(c, f->quant_tables[i]);
f->context_count[i] = read_quant_tables(&c, f->quant_tables[i]);
if (f->context_count[i] < 0) {
av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
return AVERROR_INVALIDDATA;
@ -502,19 +502,19 @@ static int read_extra_header(FFV1Context *f)
return ret;
for (int i = 0; i < f->quant_table_count; i++)
if (get_rac(c, state)) {
if (get_rac(&c, state)) {
for (int j = 0; j < f->context_count[i]; j++)
for (int k = 0; k < CONTEXT_SIZE; k++) {
int pred = j ? f->initial_states[i][j - 1][k] : 128;
f->initial_states[i][j][k] =
(pred + get_symbol(c, state2[k], 1)) & 0xFF;
(pred + get_symbol(&c, state2[k], 1)) & 0xFF;
}
}
if (f->version > 2) {
f->ec = get_symbol(c, state, 0);
f->ec = get_symbol(&c, state, 0);
if (f->micro_version > 2)
f->intra = get_symbol(c, state, 0);
f->intra = get_symbol(&c, state, 0);
}
if (f->version > 2) {
@ -550,7 +550,7 @@ static int read_header(FFV1Context *f)
{
uint8_t state[CONTEXT_SIZE];
int context_count = -1; //-1 to avoid warning
RangeCoder *const c = &f->slice_context[0]->c;
RangeCoder *const c = &f->slices[0].c;
memset(state, 128, sizeof(state));
@ -868,7 +868,7 @@ static int decode_frame(AVCodecContext *avctx, AVFrame *rframe,
uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
FFV1Context *f = avctx->priv_data;
RangeCoder *const c = &f->slice_context[0]->c;
RangeCoder *const c = &f->slices[0].c;
int ret, key_frame;
uint8_t keystate = 128;
uint8_t *buf_p;
@ -939,6 +939,7 @@ static int decode_frame(AVCodecContext *avctx, AVFrame *rframe,
buf_p = buf + buf_size;
for (int i = f->slice_count - 1; i >= 0; i--) {
FFV1Context *fs = f->slice_context[i];
FFV1SliceContext *sc = &f->slices[i];
int trailer = 3 + 5*!!f->ec;
int v;
@ -973,9 +974,10 @@ static int decode_frame(AVCodecContext *avctx, AVFrame *rframe,
}
if (i) {
ff_init_range_decoder(&fs->c, buf_p, v);
ff_init_range_decoder(&sc->c, buf_p, v);
ff_build_rac_states(&sc->c, 0.05 * (1LL << 32), 256 - 8);
} else
fs->c.bytestream_end = buf_p + v;
sc->c.bytestream_end = buf_p + v;
fs->avctx = avctx;
}

2
libavcodec/ffv1dec_template.c
View File

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

78
libavcodec/ffv1enc.c
View File

@ -349,7 +349,7 @@ static void write_header(FFV1Context *f)
{
uint8_t state[CONTEXT_SIZE];
int i, j;
RangeCoder *const c = &f->slice_context[0]->c;
RangeCoder *const c = &f->slices[0].c;
memset(state, 128, sizeof(state));
@ -394,7 +394,7 @@ static void write_header(FFV1Context *f)
static int write_extradata(FFV1Context *f)
{
RangeCoder *const c = &f->c;
RangeCoder c;
uint8_t state[CONTEXT_SIZE];
int i, j, k;
uint8_t state2[32][CONTEXT_SIZE];
@ -408,56 +408,56 @@ static int write_extradata(FFV1Context *f)
f->avctx->extradata = av_malloc(f->avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
if (!f->avctx->extradata)
return AVERROR(ENOMEM);
ff_init_range_encoder(c, f->avctx->extradata, f->avctx->extradata_size);
ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
ff_init_range_encoder(&c, f->avctx->extradata, f->avctx->extradata_size);
ff_build_rac_states(&c, 0.05 * (1LL << 32), 256 - 8);
put_symbol(c, state, f->version, 0);
put_symbol(&c, state, f->version, 0);
if (f->version > 2) {
if (f->version == 3) {
f->micro_version = 4;
} else if (f->version == 4)
f->micro_version = 2;
put_symbol(c, state, f->micro_version, 0);
put_symbol(&c, state, f->micro_version, 0);
}
put_symbol(c, state, f->ac, 0);
put_symbol(&c, state, f->ac, 0);
if (f->ac == AC_RANGE_CUSTOM_TAB)
for (i = 1; i < 256; i++)
put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
put_symbol(&c, state, f->state_transition[i] - c.one_state[i], 1);
put_symbol(c, state, f->colorspace, 0); // YUV cs type
put_symbol(c, state, f->bits_per_raw_sample, 0);
put_rac(c, state, f->chroma_planes);
put_symbol(c, state, f->chroma_h_shift, 0);
put_symbol(c, state, f->chroma_v_shift, 0);
put_rac(c, state, f->transparency);
put_symbol(c, state, f->num_h_slices - 1, 0);
put_symbol(c, state, f->num_v_slices - 1, 0);
put_symbol(&c, state, f->colorspace, 0); // YUV cs type
put_symbol(&c, state, f->bits_per_raw_sample, 0);
put_rac(&c, state, f->chroma_planes);
put_symbol(&c, state, f->chroma_h_shift, 0);
put_symbol(&c, state, f->chroma_v_shift, 0);
put_rac(&c, state, f->transparency);
put_symbol(&c, state, f->num_h_slices - 1, 0);
put_symbol(&c, state, f->num_v_slices - 1, 0);
put_symbol(c, state, f->quant_table_count, 0);
put_symbol(&c, state, f->quant_table_count, 0);
for (i = 0; i < f->quant_table_count; i++)
write_quant_tables(c, f->quant_tables[i]);
write_quant_tables(&c, f->quant_tables[i]);
for (i = 0; i < f->quant_table_count; i++) {
if (contains_non_128(f->initial_states[i], f->context_count[i])) {
put_rac(c, state, 1);
put_rac(&c, state, 1);
for (j = 0; j < f->context_count[i]; j++)
for (k = 0; k < CONTEXT_SIZE; k++) {
int pred = j ? f->initial_states[i][j - 1][k] : 128;
put_symbol(c, state2[k],
put_symbol(&c, state2[k],
(int8_t)(f->initial_states[i][j][k] - pred), 1);
}
} else {
put_rac(c, state, 0);
put_rac(&c, state, 0);
}
}
if (f->version > 2) {
put_symbol(c, state, f->ec, 0);
put_symbol(c, state, f->intra = (f->avctx->gop_size < 2), 0);
put_symbol(&c, state, f->ec, 0);
put_symbol(&c, state, f->intra = (f->avctx->gop_size < 2), 0);
}
f->avctx->extradata_size = ff_rac_terminate(c, 0);
f->avctx->extradata_size = ff_rac_terminate(&c, 0);
v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, f->avctx->extradata, f->avctx->extradata_size);
AV_WL32(f->avctx->extradata + f->avctx->extradata_size, v);
f->avctx->extradata_size += 4;
@ -883,6 +883,8 @@ slices_ok:
p->quant_table_index = s->context_model;
p->context_count = s->context_count[p->quant_table_index];
}
ff_build_rac_states(&s->slices[j].c, 0.05 * (1LL << 32), 256 - 8);
}
if ((ret = ff_ffv1_init_slices_state(s)) < 0)
@ -910,7 +912,7 @@ slices_ok:
static void encode_slice_header(FFV1Context *f, FFV1Context *fs,
FFV1SliceContext *sc)
{
RangeCoder *c = &fs->c;
RangeCoder *c = &sc->c;
uint8_t state[CONTEXT_SIZE];
int j;
memset(state, 128, sizeof(state));
@ -1037,7 +1039,7 @@ static int encode_slice(AVCodecContext *c, void *arg)
const AVFrame *const p = f->cur_enc_frame;
const int ps = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step;
int ret;
RangeCoder c_bak = fs->c;
RangeCoder c_bak = sc->c;
const uint8_t *planes[4] = {p->data[0] + ps*x + y*p->linesize[0],
p->data[1] ? p->data[1] + ps*x + y*p->linesize[1] : NULL,
p->data[2] ? p->data[2] + ps*x + y*p->linesize[2] : NULL,
@ -1058,10 +1060,10 @@ retry:
encode_slice_header(f, fs, sc);
}
if (f->ac == AC_GOLOMB_RICE) {
fs->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&fs->c, f->version > 2) : 0;
fs->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&sc->c, f->version > 2) : 0;
init_put_bits(&sc->pb,
fs->c.bytestream_start + fs->ac_byte_count,
fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count);
sc->c.bytestream_start + fs->ac_byte_count,
sc->c.bytestream_end - sc->c.bytestream_start - fs->ac_byte_count);
}
if (f->colorspace == 0 && c->pix_fmt != AV_PIX_FMT_YA8) {
@ -1095,7 +1097,7 @@ retry:
}
av_log(c, AV_LOG_DEBUG, "Coding slice as PCM\n");
sc->slice_coding_mode = 1;
fs->c = c_bak;
sc->c = c_bak;
goto retry;
}
@ -1106,7 +1108,7 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
const AVFrame *pict, int *got_packet)
{
FFV1Context *f = avctx->priv_data;
RangeCoder *const c = &f->slice_context[0]->c;
RangeCoder *const c = &f->slices[0].c;
uint8_t keystate = 128;
uint8_t *buf_p;
int i, ret;
@ -1194,15 +1196,15 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
}
for (i = 0; i < f->slice_count; i++) {
FFV1Context *fs = f->slice_context[i];
FFV1SliceContext *sc = &f->slices[i];
uint8_t *start = pkt->data + pkt->size * (int64_t)i / f->slice_count;
int len = pkt->size / f->slice_count;
if (i) {
ff_init_range_encoder(&fs->c, start, len);
ff_init_range_encoder(&sc->c, start, len);
} else {
av_assert0(fs->c.bytestream_end >= fs->c.bytestream_start + len);
av_assert0(fs->c.bytestream < fs->c.bytestream_start + len);
fs->c.bytestream_end = fs->c.bytestream_start + len;
av_assert0(sc->c.bytestream_end >= sc->c.bytestream_start + len);
av_assert0(sc->c.bytestream < sc->c.bytestream_start + len);
sc->c.bytestream_end = sc->c.bytestream_start + len;
}
}
avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL,
@ -1215,14 +1217,14 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
int bytes;
if (f->ac != AC_GOLOMB_RICE) {
bytes = ff_rac_terminate(&fs->c, 1);
bytes = ff_rac_terminate(&sc->c, 1);
} else {
flush_put_bits(&sc->pb); // FIXME: nicer padding
bytes = fs->ac_byte_count + put_bytes_output(&sc->pb);
}
if (i > 0 || f->version > 2) {
av_assert0(bytes < pkt->size / f->slice_count);
memmove(buf_p, fs->c.bytestream_start, bytes);
memmove(buf_p, sc->c.bytestream_start, bytes);
av_assert0(bytes < (1 << 24));
AV_WB24(buf_p + bytes, bytes);
bytes += 3;

2
libavcodec/ffv1enc_template.c
View File

@ -29,7 +29,7 @@ RENAME(encode_line)(FFV1Context *f,
int ac)
{
PlaneContext *const p = &sc->plane[plane_index];
RangeCoder *const c = &s->c;
RangeCoder *const c = &sc->c;
int x;
int run_index = sc->run_index;
int run_count = 0;