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);
- if(f->version < 3){
for(i=0; i<f->slice_count; i++){
FFV1Context *fs= f->slice_context[i];
put_symbol(c, state, (fs->slice_x +1)*f->num_h_slices / f->width , 0);
av_assert0(f->plane[j].quant_table_index == f->avctx->context_model);
}
}
- }
}
}
#endif /* CONFIG_FFV1_ENCODER */
goto slices_ok;
}
}
- av_log(avctx, AV_LOG_ERROR, "Unsupported number %d of slices requested\n", avctx->slices);
+ 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);
}
}
-static void clear_state(FFV1Context *f){
- int si;
-
- for(si=0; si<f->slice_count; si++){
- FFV1Context *fs= f->slice_context[si];
- clear_slice_state(f, fs);
- }
-}
-
#if CONFIG_FFV1_ENCODER
static void encode_slice_header(FFV1Context *f, FFV1Context *fs){
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);
}
p->key_frame= 1;
f->gob_count++;
write_header(f);
- clear_state(f);
}else{
put_rac(c, &keystate, 0);
p->key_frame= 0;
flush_put_bits(&fs->pb); //nicer padding FIXME
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 = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);
+ 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;
AVFrame * const p= &f->picture;
if(f->version > 2){
- if(decode_slice_header(f, fs) < 0)
- return AVERROR_INVALIDDATA;
-
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;
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);
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++){
}
if(f->version <= 2){
- if(p->context_count < context_count){
- av_freep(&p->state);
- av_freep(&p->vlc_state);
- }
- p->context_count= context_count;
+ if(p->context_count < context_count){
+ av_freep(&p->state);
+ av_freep(&p->vlc_state);
+ }
+ p->context_count= context_count;
}
}
}
f->key_frame_ok = 0;
if(read_header(f) < 0)
return -1;
- if(init_slices_state(f) < 0)
- return -1;
f->key_frame_ok = 1;
}else{
if (!f->key_frame_ok) {
}
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];
- }
- }
p->reference= 0;
if(avctx->get_buffer(avctx, p) < 0){
buf_p= buf + buf_size;
for(i=f->slice_count-1; i>=0; i--){
FFV1Context *fs= f->slice_context[i];
- int trailer = 3 + 4*!!f->ec;
+ int trailer = 3 + 5*!!f->ec;
int v;
- if(i) v = AV_RB24(buf_p-trailer)+trailer;
- else v = buf_p - c->bytestream_start;
+ 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;
}
if(i){
- if(fs->ac){
- ff_init_range_decoder(&fs->c, buf_p, v);
- }else{
- init_get_bits(&fs->gb, buf_p, v * 8);
- }
- }else{
- 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
- init_get_bits(&fs->gb, buf + bytes_read, (buf_size - bytes_read) * 8);
- }
+ ff_init_range_decoder(&fs->c, buf_p, v);
}
}