@@ -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;
@@ -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);
@@ -167,7 +167,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;
@@ -298,7 +298,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;
@@ -306,7 +306,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);
@@ -321,11 +321,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);
@@ -360,8 +360,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;
@@ -420,7 +420,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];
@@ -429,10 +429,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;
@@ -443,27 +443,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",
@@ -483,7 +483,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;
@@ -491,7 +491,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;
@@ -501,19 +501,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) {
@@ -549,7 +549,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));
@@ -867,7 +867,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;
@@ -938,6 +938,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;
@@ -972,9 +973,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;
}
@@ -29,7 +29,7 @@ RENAME(decode_line)(FFV1Context *f,
int w, TYPE *sample[2], int plane_index, int bits)
{
PlaneContext *const p = &sc->plane[plane_index];
- RangeCoder *const c = &s->c;
+ RangeCoder *const c = &sc->c;
int x;
int run_count = 0;
int run_mode = 0;
@@ -348,7 +348,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));
@@ -393,7 +393,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];
@@ -407,56 +407,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;
@@ -882,6 +882,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)
@@ -909,7 +911,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));
@@ -1036,7 +1038,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,
@@ -1057,10 +1059,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) {
@@ -1094,7 +1096,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;
}
@@ -1105,7 +1107,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;
@@ -1193,15 +1195,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,
@@ -1214,14 +1216,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;
@@ -28,7 +28,7 @@ RENAME(encode_line)(FFV1Context *f,
int w, TYPE *sample[3], int plane_index, int bits)
{
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;