*/
#include "avcodec.h"
+#include "internal.h"
#include "get_bits.h"
#include "put_bits.h"
#include "dsputil.h"
#include "mathops.h"
#include "libavutil/pixdesc.h"
#include "libavutil/avassert.h"
+#include "libavutil/crc.h"
+
+#ifdef __INTEL_COMPILER
+#undef av_flatten
+#define av_flatten
+#endif
#define MAX_PLANES 4
#define CONTEXT_SIZE 32
uint64_t rc_stat[256][2];
uint64_t (*rc_stat2[MAX_QUANT_TABLES])[32][2];
int version;
+ int minor_version;
int width, height;
int chroma_h_shift, chroma_v_shift;
int chroma_planes;
AVFrame picture;
int plane_count;
int ac; ///< 1=range coder <-> 0=golomb rice
+ int ac_byte_count; ///< number of bytes used for AC coding
PlaneContext plane[MAX_PLANES];
int16_t quant_table[MAX_CONTEXT_INPUTS][256];
int16_t quant_tables[MAX_QUANT_TABLES][MAX_CONTEXT_INPUTS][256];
int16_t *sample_buffer;
int gob_count;
int packed_at_lsb;
+ int ec;
+ int key_frame_ok;
int quant_table_count;
#undef put_rac
}
-static void av_noinline put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed){
+static av_noinline void put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed){
put_symbol_inline(c, state, v, is_signed, NULL, NULL);
}
}
}
-static int av_noinline get_symbol(RangeCoder *c, uint8_t *state, int is_signed){
+static av_noinline int get_symbol(RangeCoder *c, uint8_t *state, int is_signed){
return get_symbol_inline(c, state, is_signed);
}
#if CONFIG_FFV1_ENCODER
static av_always_inline int encode_line(FFV1Context *s, int w,
- int16_t *sample[2],
+ int16_t *sample[3],
int plane_index, int bits)
{
PlaneContext * const p= &s->plane[plane_index];
put_rac(c, state, f->transparency);
write_quant_tables(c, f->quant_table);
- }else{
+ }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];
return 0;
}
-static int init_slice_state(FFV1Context *f){
- int i, j;
+static int init_slice_state(FFV1Context *f, FFV1Context *fs){
+ int j;
- for(i=0; i<f->slice_count; i++){
- FFV1Context *fs= f->slice_context[i];
fs->plane_count= f->plane_count;
fs->transparency= f->transparency;
for(j=0; j<f->plane_count; j++){
fs->c.zero_state[256-j]= 256-fs->c.one_state [j];
}
}
- }
return 0;
}
+static int init_slices_state(FFV1Context *f){
+ int i;
+ for(i=0; i<f->slice_count; i++){
+ FFV1Context *fs= f->slice_context[i];
+ if(init_slice_state(f, fs) < 0)
+ return -1;
+ }
+ return 0;
+}
+
static av_cold int init_slice_contexts(FFV1Context *f){
int i;
uint8_t state[CONTEXT_SIZE];
int i, j, k;
uint8_t state2[32][CONTEXT_SIZE];
+ unsigned v;
memset(state2, 128, sizeof(state2));
memset(state, 128, sizeof(state));
ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
put_symbol(c, state, f->version, 0);
+ if(f->version > 2)
+ put_symbol(c, state, f->minor_version, 0);
put_symbol(c, state, f->ac, 0);
if(f->ac>1){
for(i=1; i<256; i++){
}
}
+ if(f->version > 2){
+ put_symbol(c, state, f->ec, 0);
+ }
+
f->avctx->extradata_size= ff_rac_terminate(c);
+ 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;
return 0;
}
common_init(avctx);
s->version=0;
+
+ if((avctx->flags & (CODEC_FLAG_PASS1|CODEC_FLAG_PASS2)) || avctx->slices>1)
+ s->version = FFMAX(s->version, 2);
+
+ if(avctx->level == 3){
+ s->version = 3;
+ s->ec = 1;
+ }
+
+ if(s->version >= 2 && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
+ av_log(avctx, AV_LOG_ERROR, "Version 2 needed for requested features but version 2 is experimental and not enabled\n");
+ return -1;
+ }
+
s->ac= avctx->coder_type ? 2:0;
if(s->ac>1)
if (s->transparency) {
av_log(avctx, AV_LOG_WARNING, "Storing alpha plane, this will require a recent FFV1 decoder to playback!\n");
}
+ if (avctx->context_model > 1U) {
+ av_log(avctx, AV_LOG_ERROR, "Invalid context model %d, valid values are 0 and 1\n", avctx->context_model);
+ return AVERROR(EINVAL);
+ }
for(i=0; i<256; i++){
s->quant_table_count=2;
}
if(s->version>1){
- s->num_h_slices=2;
- s->num_v_slices=2;
+ for(s->num_v_slices=2; s->num_v_slices<9; s->num_v_slices++){
+ for(s->num_h_slices=s->num_v_slices; s->num_h_slices<2*s->num_v_slices; s->num_h_slices++){
+ if(avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= 64)
+ goto slices_ok;
+ }
+ }
+ av_log(avctx, AV_LOG_ERROR, "Unsupported number %d of slices requested, please specify a supported number with -slices (ex:4,6,9,12,16, ...)\n", avctx->slices);
+ return -1;
+ slices_ok:
write_extra_header(s);
}
if(init_slice_contexts(s) < 0)
return -1;
- if(init_slice_state(s) < 0)
+ if(init_slices_state(s) < 0)
return -1;
#define STATS_OUT_SIZE 1024*1024*6
#endif /* CONFIG_FFV1_ENCODER */
-static void clear_state(FFV1Context *f){
- int i, si, j;
+static void clear_slice_state(FFV1Context *f, FFV1Context *fs){
+ int i, j;
- for(si=0; si<f->slice_count; si++){
- FFV1Context *fs= f->slice_context[si];
for(i=0; i<f->plane_count; i++){
PlaneContext *p= &fs->plane[i];
}
}
}
- }
}
#if CONFIG_FFV1_ENCODER
+
+static void encode_slice_header(FFV1Context *f, FFV1Context *fs){
+ 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);
+ 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->avctx->context_model);
+ }
+ if(!f->picture.interlaced_frame) put_symbol(c, state, 3, 0);
+ else put_symbol(c, state, 1 + !f->picture.top_field_first, 0);
+ put_symbol(c, state, f->picture.sample_aspect_ratio.num, 0);
+ put_symbol(c, state, f->picture.sample_aspect_ratio.den, 0);
+}
+
static int encode_slice(AVCodecContext *c, void *arg){
FFV1Context *fs= *(void**)arg;
FFV1Context *f= fs->avctx->priv_data;
AVFrame * const p= &f->picture;
const int ps= (f->bits_per_raw_sample>8)+1;
+ if(p->key_frame)
+ clear_slice_state(f, fs);
+ if(f->version > 2){
+ encode_slice_header(f, fs);
+ }
+ if(!fs->ac){
+ fs->ac_byte_count = f->version > 2 || (!x&&!y) ? ff_rac_terminate(&fs->c) : 0;
+ init_put_bits(&fs->pb, fs->c.bytestream_start + fs->ac_byte_count, fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count);
+ }
+
if(f->colorspace==0){
const int chroma_width = -((-width )>>f->chroma_h_shift);
const int chroma_height= -((-height)>>f->chroma_v_shift);
uint8_t *buf_p;
int i, ret;
- if (!pkt->data &&
- (ret = av_new_packet(pkt, avctx->width*avctx->height*((8*2+1+1)*4)/8
- + FF_MIN_BUFFER_SIZE)) < 0) {
- av_log(avctx, AV_LOG_ERROR, "Error getting output packet.\n");
+ if ((ret = ff_alloc_packet2(avctx, pkt, avctx->width*avctx->height*((8*2+1+1)*4)/8
+ + FF_MIN_BUFFER_SIZE)) < 0)
return ret;
- }
ff_init_range_encoder(c, pkt->data, pkt->size);
ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
p->key_frame= 1;
f->gob_count++;
write_header(f);
- clear_state(f);
}else{
put_rac(c, &keystate, 0);
p->key_frame= 0;
}
- if(!f->ac){
- used_count += ff_rac_terminate(c);
-//printf("pos=%d\n", used_count);
- init_put_bits(&f->slice_context[0]->pb, pkt->data + used_count, pkt->size - used_count);
- }else if (f->ac>1){
+ if (f->ac>1){
int i;
for(i=1; i<256; i++){
c->one_state[i]= f->state_transition[i];
uint8_t *start = pkt->data + (pkt->size-used_count)*i/f->slice_count;
int len = pkt->size/f->slice_count;
- if(fs->ac){
- ff_init_range_encoder(&fs->c, start, len);
- }else{
- init_put_bits(&fs->pb, start, len);
- }
+ ff_init_range_encoder(&fs->c, start, len);
}
avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL, f->slice_count, sizeof(void*));
bytes= ff_rac_terminate(&fs->c);
}else{
flush_put_bits(&fs->pb); //nicer padding FIXME
- bytes= used_count + (put_bits_count(&fs->pb)+7)/8;
- used_count= 0;
+ bytes= fs->ac_byte_count + (put_bits_count(&fs->pb)+7)/8;
}
- if(i>0){
+ if(i>0 || f->version>2){
av_assert0(bytes < pkt->size/f->slice_count);
- memmove(buf_p, fs->ac ? fs->c.bytestream_start : fs->pb.buf, bytes);
+ memmove(buf_p, fs->c.bytestream_start, bytes);
av_assert0(bytes < (1<<24));
AV_WB24(buf_p+bytes, bytes);
bytes+=3;
}
+ if(f->ec){
+ unsigned v;
+ buf_p[bytes++] = 0;
+ v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);
+ AV_WL32(buf_p + bytes, v); bytes += 4;
+ }
buf_p += bytes;
}
}
}
+static int decode_slice_header(FFV1Context *f, FFV1Context *fs){
+ RangeCoder *c = &fs->c;
+ uint8_t state[CONTEXT_SIZE];
+ unsigned ps, i, context_count;
+ memset(state, 128, sizeof(state));
+
+ av_assert0(f->version > 2);
+
+ fs->slice_x = get_symbol(c, state, 0) *f->width ;
+ fs->slice_y = get_symbol(c, state, 0) *f->height;
+ fs->slice_width =(get_symbol(c, state, 0)+1)*f->width + fs->slice_x;
+ fs->slice_height=(get_symbol(c, state, 0)+1)*f->height + fs->slice_y;
+
+ fs->slice_x /= f->num_h_slices;
+ fs->slice_y /= f->num_v_slices;
+ fs->slice_width = fs->slice_width /f->num_h_slices - fs->slice_x;
+ fs->slice_height = fs->slice_height/f->num_v_slices - fs->slice_y;
+ if((unsigned)fs->slice_width > f->width || (unsigned)fs->slice_height > f->height)
+ return -1;
+ if( (unsigned)fs->slice_x + (uint64_t)fs->slice_width > f->width
+ || (unsigned)fs->slice_y + (uint64_t)fs->slice_height > f->height)
+ return -1;
+
+ for(i=0; i<f->plane_count; i++){
+ PlaneContext * const p= &fs->plane[i];
+ int idx=get_symbol(c, state, 0);
+ if(idx > (unsigned)f->quant_table_count){
+ av_log(f->avctx, AV_LOG_ERROR, "quant_table_index out of range\n");
+ return -1;
+ }
+ p->quant_table_index= idx;
+ memcpy(p->quant_table, f->quant_tables[idx], sizeof(p->quant_table));
+ context_count= f->context_count[idx];
+
+ if(p->context_count < context_count){
+ av_freep(&p->state);
+ av_freep(&p->vlc_state);
+ }
+ p->context_count= context_count;
+ }
+
+ ps = get_symbol(c, state, 0);
+ if(ps==1){
+ f->picture.interlaced_frame = 1;
+ f->picture.top_field_first = 1;
+ } else if(ps==2){
+ f->picture.interlaced_frame = 1;
+ f->picture.top_field_first = 0;
+ } else if(ps==3){
+ f->picture.interlaced_frame = 0;
+ }
+ f->picture.sample_aspect_ratio.num = get_symbol(c, state, 0);
+ f->picture.sample_aspect_ratio.den = get_symbol(c, state, 0);
+
+ return 0;
+}
+
static int decode_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;
+ int width, height, x, y;
const int ps= (c->bits_per_raw_sample>8)+1;
AVFrame * const p= &f->picture;
+ if(f->version > 2){
+ if(init_slice_state(f, fs) < 0)
+ return AVERROR(ENOMEM);
+ if(decode_slice_header(f, fs) < 0)
+ return AVERROR_INVALIDDATA;
+ }
+ if(init_slice_state(f, fs) < 0)
+ return AVERROR(ENOMEM);
+ if(f->picture.key_frame)
+ clear_slice_state(f, fs);
+ width = fs->slice_width;
+ height= fs->slice_height;
+ x= fs->slice_x;
+ y= fs->slice_y;
+
+ if(!fs->ac){
+ fs->ac_byte_count = f->version > 2 || (!x&&!y) ? fs->c.bytestream - fs->c.bytestream_start - 1 : 0;
+ init_get_bits(&fs->gb,
+ fs->c.bytestream_start + fs->ac_byte_count,
+ (fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count) * 8);
+ }
+
av_assert1(width && height);
if(f->colorspace==0){
const int chroma_width = -((-width )>>f->chroma_h_shift);
ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
f->version= get_symbol(c, state, 0);
+ if(f->version > 2)
+ f->minor_version= get_symbol(c, state, 0);
f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
if(f->ac>1){
for(i=1; i<256; i++){
}
f->colorspace= get_symbol(c, state, 0); //YUV cs type
f->avctx->bits_per_raw_sample= get_symbol(c, state, 0);
- get_rac(c, state); //no chroma = false
+ 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);
}
}
+ if(f->version > 2){
+ f->ec = get_symbol(c, state, 0);
+ }
+
+ if(f->version > 2){
+ unsigned v;
+ v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, f->avctx->extradata, f->avctx->extradata_size);
+ if(v){
+ av_log(f->avctx, AV_LOG_ERROR, "CRC mismatch %X!\n", v);
+ return AVERROR_INVALIDDATA;
+ }
+ }
+
return 0;
}
av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
return -1;
}
- }else{
+ }else if(f->version < 3){
f->slice_count= get_symbol(c, state, 0);
- if(f->slice_count > (unsigned)MAX_SLICES)
- return -1;
+ }else{
+ const uint8_t *p= c->bytestream_end;
+ for(f->slice_count = 0; f->slice_count < MAX_SLICES && 3 < p - c->bytestream_start; f->slice_count++){
+ int trailer = 3 + 5*!!f->ec;
+ int size = AV_RB24(p-trailer);
+ if(size + trailer > p - c->bytestream_start)
+ break;
+ p -= size + trailer;
+ }
+ }
+ if(f->slice_count > (unsigned)MAX_SLICES || f->slice_count <= 0){
+ av_log(f->avctx, AV_LOG_ERROR, "slice count %d is invalid\n", f->slice_count);
+ return -1;
}
for(j=0; j<f->slice_count; j++){
fs->ac= f->ac;
fs->packed_at_lsb= f->packed_at_lsb;
- if(f->version >= 2){
+ if(f->version == 2){
fs->slice_x = get_symbol(c, state, 0) *f->width ;
fs->slice_y = get_symbol(c, state, 0) *f->height;
fs->slice_width =(get_symbol(c, state, 0)+1)*f->width + fs->slice_x;
for(i=0; i<f->plane_count; i++){
PlaneContext * const p= &fs->plane[i];
- if(f->version >= 2){
+ if(f->version == 2){
int idx=get_symbol(c, state, 0);
if(idx > (unsigned)f->quant_table_count){
av_log(f->avctx, AV_LOG_ERROR, "quant_table_index out of range\n");
memcpy(p->quant_table, f->quant_table, sizeof(p->quant_table));
}
- if(p->context_count < context_count){
- av_freep(&p->state);
- av_freep(&p->vlc_state);
+ if(f->version <= 2){
+ if(p->context_count < context_count){
+ av_freep(&p->state);
+ av_freep(&p->vlc_state);
+ }
+ p->context_count= context_count;
}
- p->context_count= context_count;
}
}
-
return 0;
}
p->pict_type= AV_PICTURE_TYPE_I; //FIXME I vs. P
if(get_rac(c, &keystate)){
p->key_frame= 1;
+ f->key_frame_ok = 0;
if(read_header(f) < 0)
return -1;
- if(init_slice_state(f) < 0)
- return -1;
-
- clear_state(f);
+ f->key_frame_ok = 1;
}else{
- p->key_frame= 0;
- }
- if(f->ac>1){
- int i;
- for(i=1; i<256; i++){
- c->one_state[i]= f->state_transition[i];
- c->zero_state[256-i]= 256-c->one_state[i];
+ if (!f->key_frame_ok) {
+ av_log(avctx, AV_LOG_ERROR, "Cant decode non keyframe without valid keyframe\n");
+ return AVERROR_INVALIDDATA;
}
+ p->key_frame= 0;
}
p->reference= 0;
if(avctx->debug&FF_DEBUG_PICT_INFO)
av_log(avctx, AV_LOG_ERROR, "keyframe:%d coder:%d\n", p->key_frame, f->ac);
- if(!f->ac){
- bytes_read = c->bytestream - c->bytestream_start - 1;
- if(bytes_read ==0) av_log(avctx, AV_LOG_ERROR, "error at end of AC stream\n"); //FIXME
-//printf("pos=%d\n", bytes_read);
- init_get_bits(&f->slice_context[0]->gb, buf + bytes_read, (buf_size - bytes_read) * 8);
- } else {
- bytes_read = 0; /* avoid warning */
- }
-
buf_p= buf + buf_size;
- for(i=f->slice_count-1; i>0; i--){
+ for(i=f->slice_count-1; i>=0; i--){
FFV1Context *fs= f->slice_context[i];
- int v= AV_RB24(buf_p-3)+3;
- if(buf_p - buf <= v){
+ int trailer = 3 + 5*!!f->ec;
+ int v;
+
+ if(i || f->version>2) v = AV_RB24(buf_p-trailer)+trailer;
+ else v = buf_p - c->bytestream_start;
+ if(buf_p - c->bytestream_start < v){
av_log(avctx, AV_LOG_ERROR, "Slice pointer chain broken\n");
return -1;
}
buf_p -= v;
- if(fs->ac){
+
+ if(f->ec){
+ unsigned crc = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, v);
+ if(crc){
+ av_log(f->avctx, AV_LOG_ERROR, "CRC mismatch %X!\n", crc);
+ }
+ }
+
+ if(i){
ff_init_range_decoder(&fs->c, buf_p, v);
- }else{
- init_get_bits(&fs->gb, buf_p, v * 8);
}
}
.init = decode_init,
.close = common_end,
.decode = decode_frame,
- .capabilities = CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/ | CODEC_CAP_SLICE_THREADS,
- .long_name= NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
+ .capabilities = CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/ |
+ CODEC_CAP_SLICE_THREADS,
+ .long_name = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
};
#if CONFIG_FFV1_ENCODER
.init = encode_init,
.encode2 = encode_frame,
.close = common_end,
- .capabilities = CODEC_CAP_SLICE_THREADS,
+ .capabilities = CODEC_CAP_SLICE_THREADS,
.pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_YUVA420P, PIX_FMT_YUV444P, PIX_FMT_YUVA444P, PIX_FMT_YUV440P, PIX_FMT_YUV422P, PIX_FMT_YUV411P, PIX_FMT_YUV410P, PIX_FMT_0RGB32, PIX_FMT_RGB32, PIX_FMT_YUV420P16, PIX_FMT_YUV422P16, PIX_FMT_YUV444P16, PIX_FMT_YUV444P9, PIX_FMT_YUV422P9, PIX_FMT_YUV420P9, PIX_FMT_YUV420P10, PIX_FMT_YUV422P10, PIX_FMT_YUV444P10, PIX_FMT_GRAY16, PIX_FMT_GRAY8, PIX_FMT_NONE},
- .long_name= NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
+ .long_name = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
};
#endif