virtualenv/FFmpeg
1
0
Fork 0
mirror of https://github.com/FFmpeg/FFmpeg.git synced 2025-03-28 12:32:17 +02:00
Code Issues Releases 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, av_cold int ff_ffv1_init_slice_state(const FFV1Context *f,
FFV1Context *fs, FFV1SliceContext *sc) FFV1SliceContext *sc)
{ {
int j, i; 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) { if (f->ac == AC_RANGE_CUSTOM_TAB) {
//FIXME only redo if state_transition changed //FIXME only redo if state_transition changed
for (j = 1; j < 256; j++) { for (j = 1; j < 256; j++) {
fs->c. one_state[ j] = f->state_transition[j]; sc->c. one_state[ j] = f->state_transition[j];
fs->c.zero_state[256 - j] = 256 - fs->c.one_state[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; int i, ret;
for (i = 0; i < f->max_slice_count; i++) { for (i = 0; i < f->max_slice_count; i++) {
FFV1Context *fs = f->slice_context[i]; if ((ret = ff_ffv1_init_slice_state(f, &f->slices[i])) < 0)
if ((ret = ff_ffv1_init_slice_state(f, fs, &f->slices[i])) < 0)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
} }
return 0; return 0;

5
libavcodec/ffv1.h
View File

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

2
libavcodec/ffv1dec_template.c
View File

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

2
libavcodec/ffv1enc_template.c
View File

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