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

lavc/ffv1: move RangeCoder to per-slice context

Browse Source
release/7.1
Anton Khirnov 6 months ago
parent 28769f6bc1
commit 7b2bfba55d
6 changed files with 87 additions and 85 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. 9
      libavcodec/ffv1.c
  2. 5
      libavcodec/ffv1.h
  3. 72
      libavcodec/ffv1dec.c
  4. 2
      libavcodec/ffv1dec_template.c
  5. 82
      libavcodec/ffv1enc.c
  6. 2
      libavcodec/ffv1enc_template.c

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

82
libavcodec/ffv1enc.c
Unescape 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->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->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->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
Unescape 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;

Write Preview
Loading…
Cancel
Save