2 * FFV1 codec for libavcodec
4 * Copyright (c) 2003-2012 Michael Niedermayer <michaelni@gmx.at>
6 * This file is part of FFmpeg.
8 * FFmpeg is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * FFmpeg is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with FFmpeg; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
25 * FF Video Codec 1 (a lossless codec)
33 #include "rangecoder.h"
36 #include "libavutil/pixdesc.h"
37 #include "libavutil/avassert.h"
38 #include "libavutil/crc.h"
39 #include "libavutil/opt.h"
40 #include "libavutil/imgutils.h"
41 #include "libavutil/timer.h"
43 #ifdef __INTEL_COMPILER
49 #define CONTEXT_SIZE 32
51 #define MAX_QUANT_TABLES 8
52 #define MAX_CONTEXT_INPUTS 5
54 extern const uint8_t ff_log2_run[41];
56 static const int8_t quant5_10bit[256]={
57 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
58 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
59 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
60 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
61 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
62 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
63 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
64 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
65 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
66 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
67 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
68 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
69 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-1,
70 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
71 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
72 -1,-1,-1,-1,-1,-1,-0,-0,-0,-0,-0,-0,-0,-0,-0,-0,
75 static const int8_t quant5[256]={
76 0, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
77 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
78 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
79 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
80 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
81 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
82 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
83 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
84 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
85 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
86 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
87 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
88 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
89 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
90 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
91 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-1,-1,-1,
94 static const int8_t quant9_10bit[256]={
95 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2,
96 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3,
97 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
98 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
99 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
100 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
101 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
102 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
103 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
104 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
105 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
106 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
107 -4,-4,-4,-4,-4,-4,-4,-4,-4,-3,-3,-3,-3,-3,-3,-3,
108 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
109 -3,-3,-3,-3,-3,-3,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
110 -2,-2,-2,-2,-1,-1,-1,-1,-1,-1,-1,-1,-0,-0,-0,-0,
113 static const int8_t quant11[256]={
114 0, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4,
115 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
116 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
117 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
118 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
119 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
120 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
121 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
122 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
123 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
124 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
125 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
126 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
127 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-4,-4,
128 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
129 -4,-4,-4,-4,-4,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-1,
132 static const uint8_t ver2_state[256]= {
133 0, 10, 10, 10, 10, 16, 16, 16, 28, 16, 16, 29, 42, 49, 20, 49,
134 59, 25, 26, 26, 27, 31, 33, 33, 33, 34, 34, 37, 67, 38, 39, 39,
135 40, 40, 41, 79, 43, 44, 45, 45, 48, 48, 64, 50, 51, 52, 88, 52,
136 53, 74, 55, 57, 58, 58, 74, 60, 101, 61, 62, 84, 66, 66, 68, 69,
137 87, 82, 71, 97, 73, 73, 82, 75, 111, 77, 94, 78, 87, 81, 83, 97,
138 85, 83, 94, 86, 99, 89, 90, 99, 111, 92, 93, 134, 95, 98, 105, 98,
139 105, 110, 102, 108, 102, 118, 103, 106, 106, 113, 109, 112, 114, 112, 116, 125,
140 115, 116, 117, 117, 126, 119, 125, 121, 121, 123, 145, 124, 126, 131, 127, 129,
141 165, 130, 132, 138, 133, 135, 145, 136, 137, 139, 146, 141, 143, 142, 144, 148,
142 147, 155, 151, 149, 151, 150, 152, 157, 153, 154, 156, 168, 158, 162, 161, 160,
143 172, 163, 169, 164, 166, 184, 167, 170, 177, 174, 171, 173, 182, 176, 180, 178,
144 175, 189, 179, 181, 186, 183, 192, 185, 200, 187, 191, 188, 190, 197, 193, 196,
145 197, 194, 195, 196, 198, 202, 199, 201, 210, 203, 207, 204, 205, 206, 208, 214,
146 209, 211, 221, 212, 213, 215, 224, 216, 217, 218, 219, 220, 222, 228, 223, 225,
147 226, 224, 227, 229, 240, 230, 231, 232, 233, 234, 235, 236, 238, 239, 237, 242,
148 241, 243, 242, 244, 245, 246, 247, 248, 249, 250, 251, 252, 252, 253, 254, 255,
151 typedef struct VlcState{
158 typedef struct PlaneContext{
159 int16_t quant_table[MAX_CONTEXT_INPUTS][256];
160 int quant_table_index;
162 uint8_t (*state)[CONTEXT_SIZE];
164 uint8_t interlace_bit_state[2];
167 #define MAX_SLICES 256
169 typedef struct FFV1Context{
171 AVCodecContext *avctx;
175 uint64_t rc_stat[256][2];
176 uint64_t (*rc_stat2[MAX_QUANT_TABLES])[32][2];
180 int chroma_h_shift, chroma_v_shift;
186 AVFrame last_picture;
188 int ac; ///< 1=range coder <-> 0=golomb rice
189 int ac_byte_count; ///< number of bytes used for AC coding
190 PlaneContext plane[MAX_PLANES];
191 int16_t quant_table[MAX_CONTEXT_INPUTS][256];
192 int16_t quant_tables[MAX_QUANT_TABLES][MAX_CONTEXT_INPUTS][256];
193 int context_count[MAX_QUANT_TABLES];
194 uint8_t state_transition[256];
195 uint8_t (*initial_states[MAX_QUANT_TABLES])[32];
198 int16_t *sample_buffer;
205 int quant_table_count;
209 struct FFV1Context *slice_context[MAX_SLICES];
217 int bits_per_raw_sample;
220 static av_always_inline int fold(int diff, int bits){
232 static inline int predict(int16_t *src, int16_t *last)
234 const int LT= last[-1];
235 const int T= last[ 0];
236 const int L = src[-1];
238 return mid_pred(L, L + T - LT, T);
241 static inline int get_context(PlaneContext *p, int16_t *src,
242 int16_t *last, int16_t *last2)
244 const int LT= last[-1];
245 const int T= last[ 0];
246 const int RT= last[ 1];
247 const int L = src[-1];
249 if(p->quant_table[3][127]){
250 const int TT= last2[0];
251 const int LL= src[-2];
252 return p->quant_table[0][(L-LT) & 0xFF] + p->quant_table[1][(LT-T) & 0xFF] + p->quant_table[2][(T-RT) & 0xFF]
253 +p->quant_table[3][(LL-L) & 0xFF] + p->quant_table[4][(TT-T) & 0xFF];
255 return p->quant_table[0][(L-LT) & 0xFF] + p->quant_table[1][(LT-T) & 0xFF] + p->quant_table[2][(T-RT) & 0xFF];
258 static void find_best_state(uint8_t best_state[256][256], const uint8_t one_state[256]){
263 l2tab[i]= log2(i/256.0);
265 for(i=0; i<256; i++){
266 double best_len[256];
272 for(j=FFMAX(i-10,1); j<FFMIN(i+11,256); j++){
276 for(k=0; k<256; k++){
277 double newocc[256]={0};
278 for(m=1; m<256; m++){
280 len -=occ[m]*( p *l2tab[ m]
281 + (1-p)*l2tab[256-m]);
284 if(len < best_len[k]){
288 for(m=0; m<256; m++){
290 newocc[ one_state[ m]] += occ[m]* p ;
291 newocc[256-one_state[256-m]] += occ[m]*(1-p);
294 memcpy(occ, newocc, sizeof(occ));
300 static av_always_inline av_flatten void put_symbol_inline(RangeCoder *c, uint8_t *state, int v, int is_signed, uint64_t rc_stat[256][2], uint64_t rc_stat2[32][2]){
303 #define put_rac(C,S,B) \
307 rc_stat2[(S)-state][B]++;\
313 const int a= FFABS(v);
314 const int e= av_log2(a);
315 put_rac(c, state+0, 0);
318 put_rac(c, state+1+i, 1); //1..10
320 put_rac(c, state+1+i, 0);
322 for(i=e-1; i>=0; i--){
323 put_rac(c, state+22+i, (a>>i)&1); //22..31
327 put_rac(c, state+11 + e, v < 0); //11..21
330 put_rac(c, state+1+FFMIN(i,9), 1); //1..10
332 put_rac(c, state+1+9, 0);
334 for(i=e-1; i>=0; i--){
335 put_rac(c, state+22+FFMIN(i,9), (a>>i)&1); //22..31
339 put_rac(c, state+11 + 10, v < 0); //11..21
342 put_rac(c, state+0, 1);
347 static av_noinline void put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed){
348 put_symbol_inline(c, state, v, is_signed, NULL, NULL);
351 static inline av_flatten int get_symbol_inline(RangeCoder *c, uint8_t *state, int is_signed){
352 if(get_rac(c, state+0))
357 while(get_rac(c, state+1 + FFMIN(e,9))){ //1..10
362 for(i=e-1; i>=0; i--){
363 a += a + get_rac(c, state+22 + FFMIN(i,9)); //22..31
366 e= -(is_signed && get_rac(c, state+11 + FFMIN(e, 10))); //11..21
371 static av_noinline int get_symbol(RangeCoder *c, uint8_t *state, int is_signed){
372 return get_symbol_inline(c, state, is_signed);
375 static inline void update_vlc_state(VlcState * const state, const int v){
376 int drift= state->drift;
377 int count= state->count;
378 state->error_sum += FFABS(v);
381 if(count == 128){ //FIXME variable
384 state->error_sum >>= 1;
389 if(state->bias > -128) state->bias--;
395 if(state->bias < 127) state->bias++;
406 static inline void put_vlc_symbol(PutBitContext *pb, VlcState * const state, int v, int bits){
408 v = fold(v - state->bias, bits);
412 while(i < state->error_sum){ //FIXME optimize
420 if(k==0 && 2*state->drift <= - state->count) code= v ^ (-1);
423 code= v ^ ((2*state->drift + state->count)>>31);
426 av_dlog(NULL, "v:%d/%d bias:%d error:%d drift:%d count:%d k:%d\n", v, code,
427 state->bias, state->error_sum, state->drift, state->count, k);
428 set_sr_golomb(pb, code, k, 12, bits);
430 update_vlc_state(state, v);
433 static inline int get_vlc_symbol(GetBitContext *gb, VlcState * const state, int bits){
438 while(i < state->error_sum){ //FIXME optimize
445 v= get_sr_golomb(gb, k, 12, bits);
446 av_dlog(NULL, "v:%d bias:%d error:%d drift:%d count:%d k:%d",
447 v, state->bias, state->error_sum, state->drift, state->count, k);
450 if(k==0 && 2*state->drift <= - state->count) v ^= (-1);
452 v ^= ((2*state->drift + state->count)>>31);
455 ret= fold(v + state->bias, bits);
457 update_vlc_state(state, v);
462 #if CONFIG_FFV1_ENCODER
463 static av_always_inline int encode_line(FFV1Context *s, int w,
465 int plane_index, int bits)
467 PlaneContext * const p= &s->plane[plane_index];
468 RangeCoder * const c= &s->c;
470 int run_index= s->run_index;
475 if(c->bytestream_end - c->bytestream < w*20){
476 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
480 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < w*4){
481 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
489 context= get_context(p, sample[0]+x, sample[1]+x, sample[2]+x);
490 diff= sample[0][x] - predict(sample[0]+x, sample[1]+x);
497 diff= fold(diff, bits);
500 if(s->flags & CODEC_FLAG_PASS1){
501 put_symbol_inline(c, p->state[context], diff, 1, s->rc_stat, s->rc_stat2[p->quant_table_index][context]);
503 put_symbol_inline(c, p->state[context], diff, 1, NULL, NULL);
506 if(context == 0) run_mode=1;
511 while(run_count >= 1<<ff_log2_run[run_index]){
512 run_count -= 1<<ff_log2_run[run_index];
514 put_bits(&s->pb, 1, 1);
517 put_bits(&s->pb, 1 + ff_log2_run[run_index], run_count);
518 if(run_index) run_index--;
527 av_dlog(s->avctx, "count:%d index:%d, mode:%d, x:%d pos:%d\n",
528 run_count, run_index, run_mode, x,
529 (int)put_bits_count(&s->pb));
532 put_vlc_symbol(&s->pb, &p->vlc_state[context], diff, bits);
536 while(run_count >= 1<<ff_log2_run[run_index]){
537 run_count -= 1<<ff_log2_run[run_index];
539 put_bits(&s->pb, 1, 1);
543 put_bits(&s->pb, 1, 1);
545 s->run_index= run_index;
550 static void encode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
552 const int ring_size= s->avctx->context_model ? 3 : 2;
556 memset(s->sample_buffer, 0, ring_size*(w+6)*sizeof(*s->sample_buffer));
559 for(i=0; i<ring_size; i++)
560 sample[i]= s->sample_buffer + (w+6)*((h+i-y)%ring_size) + 3;
562 sample[0][-1]= sample[1][0 ];
563 sample[1][ w]= sample[1][w-1];
565 if(s->bits_per_raw_sample<=8){
567 sample[0][x]= src[x + stride*y];
569 encode_line(s, w, sample, plane_index, 8);
571 if(s->packed_at_lsb){
573 sample[0][x]= ((uint16_t*)(src + stride*y))[x];
577 sample[0][x]= ((uint16_t*)(src + stride*y))[x] >> (16 - s->bits_per_raw_sample);
580 encode_line(s, w, sample, plane_index, s->bits_per_raw_sample);
582 //STOP_TIMER("encode line")}
586 static void encode_rgb_frame(FFV1Context *s, uint8_t *src[3], int w, int h, int stride[3]){
588 const int ring_size= s->avctx->context_model ? 3 : 2;
589 int16_t *sample[4][3];
590 int lbd= s->avctx->bits_per_raw_sample <= 8;
591 int bits= s->avctx->bits_per_raw_sample > 0 ? s->avctx->bits_per_raw_sample : 8;
592 int offset= 1 << bits;
595 memset(s->sample_buffer, 0, ring_size*4*(w+6)*sizeof(*s->sample_buffer));
598 for(i=0; i<ring_size; i++)
600 sample[p][i]= s->sample_buffer + p*ring_size*(w+6) + ((h+i-y)%ring_size)*(w+6) + 3;
603 int b,g,r,av_uninit(a);
605 unsigned v= *((uint32_t*)(src[0] + x*4 + stride[0]*y));
611 b= *((uint16_t*)(src[0] + x*2 + stride[0]*y));
612 g= *((uint16_t*)(src[1] + x*2 + stride[1]*y));
613 r= *((uint16_t*)(src[2] + x*2 + stride[2]*y));
627 for(p=0; p<3 + s->transparency; p++){
628 sample[p][0][-1]= sample[p][1][0 ];
629 sample[p][1][ w]= sample[p][1][w-1];
631 encode_line(s, w, sample[p], (p+1)/2, 9);
633 encode_line(s, w, sample[p], (p+1)/2, bits+1);
638 static void write_quant_table(RangeCoder *c, int16_t *quant_table){
641 uint8_t state[CONTEXT_SIZE];
642 memset(state, 128, sizeof(state));
644 for(i=1; i<128 ; i++){
645 if(quant_table[i] != quant_table[i-1]){
646 put_symbol(c, state, i-last-1, 0);
650 put_symbol(c, state, i-last-1, 0);
653 static void write_quant_tables(RangeCoder *c, int16_t quant_table[MAX_CONTEXT_INPUTS][256]){
656 write_quant_table(c, quant_table[i]);
659 static void write_header(FFV1Context *f){
660 uint8_t state[CONTEXT_SIZE];
662 RangeCoder * const c= &f->slice_context[0]->c;
664 memset(state, 128, sizeof(state));
667 put_symbol(c, state, f->version, 0);
668 put_symbol(c, state, f->ac, 0);
670 for(i=1; i<256; i++){
671 put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
674 put_symbol(c, state, f->colorspace, 0); //YUV cs type
676 put_symbol(c, state, f->bits_per_raw_sample, 0);
677 put_rac(c, state, f->chroma_planes);
678 put_symbol(c, state, f->chroma_h_shift, 0);
679 put_symbol(c, state, f->chroma_v_shift, 0);
680 put_rac(c, state, f->transparency);
682 write_quant_tables(c, f->quant_table);
683 }else if(f->version < 3){
684 put_symbol(c, state, f->slice_count, 0);
685 for(i=0; i<f->slice_count; i++){
686 FFV1Context *fs= f->slice_context[i];
687 put_symbol(c, state, (fs->slice_x +1)*f->num_h_slices / f->width , 0);
688 put_symbol(c, state, (fs->slice_y +1)*f->num_v_slices / f->height , 0);
689 put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
690 put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
691 for(j=0; j<f->plane_count; j++){
692 put_symbol(c, state, f->plane[j].quant_table_index, 0);
693 av_assert0(f->plane[j].quant_table_index == f->avctx->context_model);
698 #endif /* CONFIG_FFV1_ENCODER */
700 static av_cold int common_init(AVCodecContext *avctx){
701 FFV1Context *s = avctx->priv_data;
703 if(!avctx->width || !avctx->height)
704 return AVERROR_INVALIDDATA;
707 s->flags= avctx->flags;
709 avcodec_get_frame_defaults(&s->picture);
711 ff_dsputil_init(&s->dsp, avctx);
713 s->width = avctx->width;
714 s->height= avctx->height;
724 static int init_slice_state(FFV1Context *f, FFV1Context *fs){
727 fs->plane_count= f->plane_count;
728 fs->transparency= f->transparency;
729 for(j=0; j<f->plane_count; j++){
730 PlaneContext * const p= &fs->plane[j];
733 if(!p-> state) p-> state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
735 return AVERROR(ENOMEM);
737 if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
739 return AVERROR(ENOMEM);
744 //FIXME only redo if state_transition changed
745 for(j=1; j<256; j++){
746 fs->c.one_state [ j]= f->state_transition[j];
747 fs->c.zero_state[256-j]= 256-fs->c.one_state [j];
754 static int init_slices_state(FFV1Context *f){
756 for(i=0; i<f->slice_count; i++){
757 FFV1Context *fs= f->slice_context[i];
758 if(init_slice_state(f, fs) < 0)
764 static av_cold int init_slice_contexts(FFV1Context *f){
767 f->slice_count= f->num_h_slices * f->num_v_slices;
769 for(i=0; i<f->slice_count; i++){
770 FFV1Context *fs= av_mallocz(sizeof(*fs));
771 int sx= i % f->num_h_slices;
772 int sy= i / f->num_h_slices;
773 int sxs= f->avctx->width * sx / f->num_h_slices;
774 int sxe= f->avctx->width *(sx+1) / f->num_h_slices;
775 int sys= f->avctx->height* sy / f->num_v_slices;
776 int sye= f->avctx->height*(sy+1) / f->num_v_slices;
777 f->slice_context[i]= fs;
778 memcpy(fs, f, sizeof(*fs));
779 memset(fs->rc_stat2, 0, sizeof(fs->rc_stat2));
781 fs->slice_width = sxe - sxs;
782 fs->slice_height= sye - sys;
786 fs->sample_buffer = av_malloc(3*4 * (fs->width+6) * sizeof(*fs->sample_buffer));
787 if (!fs->sample_buffer)
788 return AVERROR(ENOMEM);
793 static int allocate_initial_states(FFV1Context *f){
796 for(i=0; i<f->quant_table_count; i++){
797 f->initial_states[i]= av_malloc(f->context_count[i]*sizeof(*f->initial_states[i]));
798 if(!f->initial_states[i])
799 return AVERROR(ENOMEM);
800 memset(f->initial_states[i], 128, f->context_count[i]*sizeof(*f->initial_states[i]));
805 #if CONFIG_FFV1_ENCODER
806 static int write_extra_header(FFV1Context *f){
807 RangeCoder * const c= &f->c;
808 uint8_t state[CONTEXT_SIZE];
810 uint8_t state2[32][CONTEXT_SIZE];
813 memset(state2, 128, sizeof(state2));
814 memset(state, 128, sizeof(state));
816 f->avctx->extradata= av_malloc(f->avctx->extradata_size= 10000 + (11*11*5*5*5+11*11*11)*32);
817 ff_init_range_encoder(c, f->avctx->extradata, f->avctx->extradata_size);
818 ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
820 put_symbol(c, state, f->version, 0);
823 f->minor_version = 2;
824 put_symbol(c, state, f->minor_version, 0);
826 put_symbol(c, state, f->ac, 0);
828 for(i=1; i<256; i++){
829 put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
832 put_symbol(c, state, f->colorspace, 0); //YUV cs type
833 put_symbol(c, state, f->bits_per_raw_sample, 0);
834 put_rac(c, state, f->chroma_planes);
835 put_symbol(c, state, f->chroma_h_shift, 0);
836 put_symbol(c, state, f->chroma_v_shift, 0);
837 put_rac(c, state, f->transparency);
838 put_symbol(c, state, f->num_h_slices-1, 0);
839 put_symbol(c, state, f->num_v_slices-1, 0);
841 put_symbol(c, state, f->quant_table_count, 0);
842 for(i=0; i<f->quant_table_count; i++)
843 write_quant_tables(c, f->quant_tables[i]);
845 for(i=0; i<f->quant_table_count; i++){
846 for(j=0; j<f->context_count[i]*CONTEXT_SIZE; j++)
847 if(f->initial_states[i] && f->initial_states[i][0][j] != 128)
849 if(j<f->context_count[i]*CONTEXT_SIZE){
850 put_rac(c, state, 1);
851 for(j=0; j<f->context_count[i]; j++){
852 for(k=0; k<CONTEXT_SIZE; k++){
853 int pred= j ? f->initial_states[i][j-1][k] : 128;
854 put_symbol(c, state2[k], (int8_t)(f->initial_states[i][j][k]-pred), 1);
858 put_rac(c, state, 0);
863 put_symbol(c, state, f->ec, 0);
866 f->avctx->extradata_size= ff_rac_terminate(c);
867 v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, f->avctx->extradata, f->avctx->extradata_size);
868 AV_WL32(f->avctx->extradata + f->avctx->extradata_size, v);
869 f->avctx->extradata_size += 4;
874 static int sort_stt(FFV1Context *s, uint8_t stt[256]){
875 int i,i2,changed,print=0;
879 for(i=12; i<244; i++){
880 for(i2=i+1; i2<245 && i2<i+4; i2++){
881 #define COST(old, new) \
882 s->rc_stat[old][0]*-log2((256-(new))/256.0)\
883 +s->rc_stat[old][1]*-log2( (new) /256.0)
885 #define COST2(old, new) \
887 +COST(256-(old), 256-(new))
889 double size0= COST2(i, i ) + COST2(i2, i2);
890 double sizeX= COST2(i, i2) + COST2(i2, i );
891 if(sizeX < size0 && i!=128 && i2!=128){
893 FFSWAP(int, stt[ i], stt[ i2]);
894 FFSWAP(int, s->rc_stat[i ][0],s->rc_stat[ i2][0]);
895 FFSWAP(int, s->rc_stat[i ][1],s->rc_stat[ i2][1]);
897 FFSWAP(int, stt[256-i], stt[256-i2]);
898 FFSWAP(int, s->rc_stat[256-i][0],s->rc_stat[256-i2][0]);
899 FFSWAP(int, s->rc_stat[256-i][1],s->rc_stat[256-i2][1]);
901 for(j=1; j<256; j++){
902 if (stt[j] == i ) stt[j] = i2;
903 else if(stt[j] == i2) stt[j] = i ;
905 if (stt[256-j] == 256-i ) stt[256-j] = 256-i2;
906 else if(stt[256-j] == 256-i2) stt[256-j] = 256-i ;
917 static av_cold int encode_init(AVCodecContext *avctx)
919 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
920 FFV1Context *s = avctx->priv_data;
927 if((avctx->flags & (CODEC_FLAG_PASS1|CODEC_FLAG_PASS2)) || avctx->slices>1)
928 s->version = FFMAX(s->version, 2);
930 if(avctx->level == 3){
935 s->ec = (s->version >= 3);
938 if(s->version >= 2 && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
939 av_log(avctx, AV_LOG_ERROR, "Version 2 needed for requested features but version 2 is experimental and not enabled\n");
940 return AVERROR_INVALIDDATA;
943 s->ac= avctx->coder_type > 0 ? 2 : 0;
946 switch(avctx->pix_fmt){
947 case AV_PIX_FMT_YUV444P9:
948 case AV_PIX_FMT_YUV422P9:
949 case AV_PIX_FMT_YUV420P9:
950 if (!avctx->bits_per_raw_sample)
951 s->bits_per_raw_sample = 9;
952 case AV_PIX_FMT_YUV444P10:
953 case AV_PIX_FMT_YUV420P10:
954 case AV_PIX_FMT_YUV422P10:
955 s->packed_at_lsb = 1;
956 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
957 s->bits_per_raw_sample = 10;
958 case AV_PIX_FMT_GRAY16:
959 case AV_PIX_FMT_YUV444P16:
960 case AV_PIX_FMT_YUV422P16:
961 case AV_PIX_FMT_YUV420P16:
962 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {
963 s->bits_per_raw_sample = 16;
964 } else if (!s->bits_per_raw_sample){
965 s->bits_per_raw_sample = avctx->bits_per_raw_sample;
967 if(s->bits_per_raw_sample <=8){
968 av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
969 return AVERROR_INVALIDDATA;
971 if(!s->ac && avctx->coder_type == -1) {
972 av_log(avctx, AV_LOG_INFO, "bits_per_raw_sample > 8, forcing coder 1\n");
976 av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample of more than 8 needs -coder 1 currently\n");
977 return AVERROR_INVALIDDATA;
979 s->version= FFMAX(s->version, 1);
980 case AV_PIX_FMT_GRAY8:
981 case AV_PIX_FMT_YUV444P:
982 case AV_PIX_FMT_YUV440P:
983 case AV_PIX_FMT_YUV422P:
984 case AV_PIX_FMT_YUV420P:
985 case AV_PIX_FMT_YUV411P:
986 case AV_PIX_FMT_YUV410P:
987 s->chroma_planes= desc->nb_components < 3 ? 0 : 1;
990 case AV_PIX_FMT_YUVA444P:
991 case AV_PIX_FMT_YUVA422P:
992 case AV_PIX_FMT_YUVA420P:
997 case AV_PIX_FMT_RGB32:
1001 case AV_PIX_FMT_0RGB32:
1004 case AV_PIX_FMT_GBRP9:
1005 if (!avctx->bits_per_raw_sample)
1006 s->bits_per_raw_sample = 9;
1007 case AV_PIX_FMT_GBRP10:
1008 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
1009 s->bits_per_raw_sample = 10;
1010 case AV_PIX_FMT_GBRP12:
1011 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
1012 s->bits_per_raw_sample = 12;
1013 case AV_PIX_FMT_GBRP14:
1014 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
1015 s->bits_per_raw_sample = 14;
1016 else if (!s->bits_per_raw_sample)
1017 s->bits_per_raw_sample = avctx->bits_per_raw_sample;
1019 s->chroma_planes= 1;
1020 s->version= FFMAX(s->version, 1);
1023 av_log(avctx, AV_LOG_ERROR, "format not supported\n");
1024 return AVERROR_INVALIDDATA;
1026 if (s->transparency) {
1027 av_log(avctx, AV_LOG_WARNING, "Storing alpha plane, this will require a recent FFV1 decoder to playback!\n");
1029 if (avctx->context_model > 1U) {
1030 av_log(avctx, AV_LOG_ERROR, "Invalid context model %d, valid values are 0 and 1\n", avctx->context_model);
1031 return AVERROR(EINVAL);
1035 for(i=1; i<256; i++)
1036 s->state_transition[i]=ver2_state[i];
1038 for(i=0; i<256; i++){
1039 s->quant_table_count=2;
1040 if(s->bits_per_raw_sample <=8){
1041 s->quant_tables[0][0][i]= quant11[i];
1042 s->quant_tables[0][1][i]= 11*quant11[i];
1043 s->quant_tables[0][2][i]= 11*11*quant11[i];
1044 s->quant_tables[1][0][i]= quant11[i];
1045 s->quant_tables[1][1][i]= 11*quant11[i];
1046 s->quant_tables[1][2][i]= 11*11*quant5 [i];
1047 s->quant_tables[1][3][i]= 5*11*11*quant5 [i];
1048 s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
1050 s->quant_tables[0][0][i]= quant9_10bit[i];
1051 s->quant_tables[0][1][i]= 11*quant9_10bit[i];
1052 s->quant_tables[0][2][i]= 11*11*quant9_10bit[i];
1053 s->quant_tables[1][0][i]= quant9_10bit[i];
1054 s->quant_tables[1][1][i]= 11*quant9_10bit[i];
1055 s->quant_tables[1][2][i]= 11*11*quant5_10bit[i];
1056 s->quant_tables[1][3][i]= 5*11*11*quant5_10bit[i];
1057 s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
1060 s->context_count[0]= (11*11*11+1)/2;
1061 s->context_count[1]= (11*11*5*5*5+1)/2;
1062 memcpy(s->quant_table, s->quant_tables[avctx->context_model], sizeof(s->quant_table));
1064 for(i=0; i<s->plane_count; i++){
1065 PlaneContext * const p= &s->plane[i];
1067 memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
1068 p->quant_table_index= avctx->context_model;
1069 p->context_count= s->context_count[p->quant_table_index];
1072 if(allocate_initial_states(s) < 0)
1073 return AVERROR(ENOMEM);
1075 avctx->coded_frame= &s->picture;
1076 if(!s->transparency)
1078 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
1080 s->picture_number=0;
1082 if(avctx->flags & (CODEC_FLAG_PASS1|CODEC_FLAG_PASS2)){
1083 for(i=0; i<s->quant_table_count; i++){
1084 s->rc_stat2[i]= av_mallocz(s->context_count[i]*sizeof(*s->rc_stat2[i]));
1086 return AVERROR(ENOMEM);
1089 if(avctx->stats_in){
1090 char *p= avctx->stats_in;
1091 uint8_t best_state[256][256];
1095 av_assert0(s->version>=2);
1098 for(j=0; j<256; j++){
1100 s->rc_stat[j][i]= strtol(p, &next, 0);
1102 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid at %d %d [%s]\n", j,i,p);
1108 for(i=0; i<s->quant_table_count; i++){
1109 for(j=0; j<s->context_count[i]; j++){
1110 for(k=0; k<32; k++){
1112 s->rc_stat2[i][j][k][m]= strtol(p, &next, 0);
1114 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid at %d %d %d %d [%s]\n", i,j,k,m,p);
1115 return AVERROR_INVALIDDATA;
1122 gob_count= strtol(p, &next, 0);
1123 if(next==p || gob_count <=0){
1124 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
1125 return AVERROR_INVALIDDATA;
1128 while(*p=='\n' || *p==' ') p++;
1131 sort_stt(s, s->state_transition);
1133 find_best_state(best_state, s->state_transition);
1135 for(i=0; i<s->quant_table_count; i++){
1136 for(j=0; j<s->context_count[i]; j++){
1137 for(k=0; k<32; k++){
1139 if(s->rc_stat2[i][j][k][0]+s->rc_stat2[i][j][k][1]){
1140 p=256.0*s->rc_stat2[i][j][k][1] / (s->rc_stat2[i][j][k][0]+s->rc_stat2[i][j][k][1]);
1142 s->initial_states[i][j][k]= best_state[av_clip(round(p), 1, 255)][av_clip((s->rc_stat2[i][j][k][0]+s->rc_stat2[i][j][k][1])/gob_count, 0, 255)];
1149 for(s->num_v_slices=2; s->num_v_slices<9; s->num_v_slices++){
1150 for(s->num_h_slices=s->num_v_slices; s->num_h_slices<2*s->num_v_slices; s->num_h_slices++){
1151 if(avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= 64 || !avctx->slices)
1155 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);
1158 write_extra_header(s);
1161 if(init_slice_contexts(s) < 0)
1163 if(init_slices_state(s) < 0)
1166 #define STATS_OUT_SIZE 1024*1024*6
1167 if(avctx->flags & CODEC_FLAG_PASS1){
1168 avctx->stats_out= av_mallocz(STATS_OUT_SIZE);
1169 for(i=0; i<s->quant_table_count; i++){
1170 for(j=0; j<s->slice_count; j++){
1171 FFV1Context *sf= s->slice_context[j];
1172 av_assert0(!sf->rc_stat2[i]);
1173 sf->rc_stat2[i]= av_mallocz(s->context_count[i]*sizeof(*sf->rc_stat2[i]));
1174 if(!sf->rc_stat2[i])
1175 return AVERROR(ENOMEM);
1182 #endif /* CONFIG_FFV1_ENCODER */
1185 static void clear_slice_state(FFV1Context *f, FFV1Context *fs){
1188 for(i=0; i<f->plane_count; i++){
1189 PlaneContext *p= &fs->plane[i];
1191 p->interlace_bit_state[0]= 128;
1192 p->interlace_bit_state[1]= 128;
1195 if(f->initial_states[p->quant_table_index]){
1196 memcpy(p->state, f->initial_states[p->quant_table_index], CONTEXT_SIZE*p->context_count);
1198 memset(p->state, 128, CONTEXT_SIZE*p->context_count);
1200 for(j=0; j<p->context_count; j++){
1201 p->vlc_state[j].drift= 0;
1202 p->vlc_state[j].error_sum= 4; //FFMAX((RANGE + 32)/64, 2);
1203 p->vlc_state[j].bias= 0;
1204 p->vlc_state[j].count= 1;
1210 #if CONFIG_FFV1_ENCODER
1212 static void encode_slice_header(FFV1Context *f, FFV1Context *fs){
1213 RangeCoder *c = &fs->c;
1214 uint8_t state[CONTEXT_SIZE];
1216 memset(state, 128, sizeof(state));
1218 put_symbol(c, state, (fs->slice_x +1)*f->num_h_slices / f->width , 0);
1219 put_symbol(c, state, (fs->slice_y +1)*f->num_v_slices / f->height , 0);
1220 put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
1221 put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
1222 for(j=0; j<f->plane_count; j++){
1223 put_symbol(c, state, f->plane[j].quant_table_index, 0);
1224 av_assert0(f->plane[j].quant_table_index == f->avctx->context_model);
1226 if(!f->picture.interlaced_frame) put_symbol(c, state, 3, 0);
1227 else put_symbol(c, state, 1 + !f->picture.top_field_first, 0);
1228 put_symbol(c, state, f->picture.sample_aspect_ratio.num, 0);
1229 put_symbol(c, state, f->picture.sample_aspect_ratio.den, 0);
1232 static int encode_slice(AVCodecContext *c, void *arg){
1233 FFV1Context *fs= *(void**)arg;
1234 FFV1Context *f= fs->avctx->priv_data;
1235 int width = fs->slice_width;
1236 int height= fs->slice_height;
1239 AVFrame * const p= &f->picture;
1240 const int ps= (f->bits_per_raw_sample>8)+1;
1243 clear_slice_state(f, fs);
1245 encode_slice_header(f, fs);
1249 put_rac(&fs->c, (uint8_t[]){129}, 0);
1250 fs->ac_byte_count = f->version > 2 || (!x&&!y) ? ff_rac_terminate(&fs->c) : 0;
1251 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);
1254 if(f->colorspace==0){
1255 const int chroma_width = -((-width )>>f->chroma_h_shift);
1256 const int chroma_height= -((-height)>>f->chroma_v_shift);
1257 const int cx= x>>f->chroma_h_shift;
1258 const int cy= y>>f->chroma_v_shift;
1260 encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0);
1262 if (f->chroma_planes){
1263 encode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
1264 encode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1);
1266 if (fs->transparency)
1267 encode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2);
1269 uint8_t *planes[3] = {p->data[0] + ps*x + y*p->linesize[0],
1270 p->data[1] + ps*x + y*p->linesize[1],
1271 p->data[2] + ps*x + y*p->linesize[2]};
1272 encode_rgb_frame(fs, planes, width, height, p->linesize);
1279 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1280 const AVFrame *pict, int *got_packet)
1282 FFV1Context *f = avctx->priv_data;
1283 RangeCoder * const c= &f->slice_context[0]->c;
1284 AVFrame * const p= &f->picture;
1286 uint8_t keystate=128;
1290 if ((ret = ff_alloc_packet2(avctx, pkt, avctx->width*avctx->height*((8*2+1+1)*4)/8
1291 + FF_MIN_BUFFER_SIZE)) < 0)
1294 ff_init_range_encoder(c, pkt->data, pkt->size);
1295 ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1298 p->pict_type= AV_PICTURE_TYPE_I;
1300 if(avctx->gop_size==0 || f->picture_number % avctx->gop_size == 0){
1301 put_rac(c, &keystate, 1);
1306 put_rac(c, &keystate, 0);
1312 for(i=1; i<256; i++){
1313 c->one_state[i]= f->state_transition[i];
1314 c->zero_state[256-i]= 256-c->one_state[i];
1318 for(i=1; i<f->slice_count; i++){
1319 FFV1Context *fs= f->slice_context[i];
1320 uint8_t *start = pkt->data + (pkt->size-used_count)*(int64_t)i/f->slice_count;
1321 int len = pkt->size/f->slice_count;
1322 ff_init_range_encoder(&fs->c, start, len);
1324 avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL, f->slice_count, sizeof(void*));
1327 for(i=0; i<f->slice_count; i++){
1328 FFV1Context *fs= f->slice_context[i];
1333 put_rac(&fs->c, &state, 0);
1334 bytes= ff_rac_terminate(&fs->c);
1336 flush_put_bits(&fs->pb); //nicer padding FIXME
1337 bytes= fs->ac_byte_count + (put_bits_count(&fs->pb)+7)/8;
1339 if(i>0 || f->version>2){
1340 av_assert0(bytes < pkt->size/f->slice_count);
1341 memmove(buf_p, fs->c.bytestream_start, bytes);
1342 av_assert0(bytes < (1<<24));
1343 AV_WB24(buf_p+bytes, bytes);
1349 v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);
1350 AV_WL32(buf_p + bytes, v); bytes += 4;
1355 if((avctx->flags&CODEC_FLAG_PASS1) && (f->picture_number&31)==0){
1357 char *p= avctx->stats_out;
1358 char *end= p + STATS_OUT_SIZE;
1360 memset(f->rc_stat, 0, sizeof(f->rc_stat));
1361 for(i=0; i<f->quant_table_count; i++)
1362 memset(f->rc_stat2[i], 0, f->context_count[i]*sizeof(*f->rc_stat2[i]));
1364 for(j=0; j<f->slice_count; j++){
1365 FFV1Context *fs= f->slice_context[j];
1366 for(i=0; i<256; i++){
1367 f->rc_stat[i][0] += fs->rc_stat[i][0];
1368 f->rc_stat[i][1] += fs->rc_stat[i][1];
1370 for(i=0; i<f->quant_table_count; i++){
1371 for(k=0; k<f->context_count[i]; k++){
1372 for(m=0; m<32; m++){
1373 f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1374 f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1380 for(j=0; j<256; j++){
1381 snprintf(p, end-p, "%"PRIu64" %"PRIu64" ", f->rc_stat[j][0], f->rc_stat[j][1]);
1384 snprintf(p, end-p, "\n");
1386 for(i=0; i<f->quant_table_count; i++){
1387 for(j=0; j<f->context_count[i]; j++){
1388 for(m=0; m<32; m++){
1389 snprintf(p, end-p, "%"PRIu64" %"PRIu64" ", f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1394 snprintf(p, end-p, "%d\n", f->gob_count);
1395 } else if(avctx->flags&CODEC_FLAG_PASS1)
1396 avctx->stats_out[0] = '\0';
1398 f->picture_number++;
1399 pkt->size = buf_p - pkt->data;
1400 pkt->flags |= AV_PKT_FLAG_KEY*p->key_frame;
1405 #endif /* CONFIG_FFV1_ENCODER */
1407 static av_cold int common_end(AVCodecContext *avctx){
1408 FFV1Context *s = avctx->priv_data;
1411 if (avctx->codec->decode && s->picture.data[0])
1412 avctx->release_buffer(avctx, &s->picture);
1413 if (avctx->codec->decode && s->last_picture.data[0])
1414 avctx->release_buffer(avctx, &s->last_picture);
1416 for(j=0; j<s->slice_count; j++){
1417 FFV1Context *fs= s->slice_context[j];
1418 for(i=0; i<s->plane_count; i++){
1419 PlaneContext *p= &fs->plane[i];
1421 av_freep(&p->state);
1422 av_freep(&p->vlc_state);
1424 av_freep(&fs->sample_buffer);
1427 av_freep(&avctx->stats_out);
1428 for(j=0; j<s->quant_table_count; j++){
1429 av_freep(&s->initial_states[j]);
1430 for(i=0; i<s->slice_count; i++){
1431 FFV1Context *sf= s->slice_context[i];
1432 av_freep(&sf->rc_stat2[j]);
1434 av_freep(&s->rc_stat2[j]);
1437 for(i=0; i<s->slice_count; i++){
1438 av_freep(&s->slice_context[i]);
1444 static av_always_inline void decode_line(FFV1Context *s, int w,
1446 int plane_index, int bits)
1448 PlaneContext * const p= &s->plane[plane_index];
1449 RangeCoder * const c= &s->c;
1453 int run_index= s->run_index;
1456 int diff, context, sign;
1458 context= get_context(p, sample[1] + x, sample[0] + x, sample[1] + x);
1465 av_assert2(context < p->context_count);
1468 diff= get_symbol_inline(c, p->state[context], 1);
1470 if(context == 0 && run_mode==0) run_mode=1;
1473 if(run_count==0 && run_mode==1){
1474 if(get_bits1(&s->gb)){
1475 run_count = 1<<ff_log2_run[run_index];
1476 if(x + run_count <= w) run_index++;
1478 if(ff_log2_run[run_index]) run_count = get_bits(&s->gb, ff_log2_run[run_index]);
1480 if(run_index) run_index--;
1488 diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
1493 diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
1495 av_dlog(s->avctx, "count:%d index:%d, mode:%d, x:%d pos:%d\n",
1496 run_count, run_index, run_mode, x, get_bits_count(&s->gb));
1499 if(sign) diff= -diff;
1501 sample[1][x]= (predict(sample[1] + x, sample[0] + x) + diff) & ((1<<bits)-1);
1503 s->run_index= run_index;
1506 static void decode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
1509 sample[0]=s->sample_buffer +3;
1510 sample[1]=s->sample_buffer+w+6+3;
1514 memset(s->sample_buffer, 0, 2*(w+6)*sizeof(*s->sample_buffer));
1517 int16_t *temp = sample[0]; //FIXME try a normal buffer
1519 sample[0]= sample[1];
1522 sample[1][-1]= sample[0][0 ];
1523 sample[0][ w]= sample[0][w-1];
1526 if(s->avctx->bits_per_raw_sample <= 8){
1527 decode_line(s, w, sample, plane_index, 8);
1529 src[x + stride*y]= sample[1][x];
1532 decode_line(s, w, sample, plane_index, s->avctx->bits_per_raw_sample);
1533 if(s->packed_at_lsb){
1535 ((uint16_t*)(src + stride*y))[x]= sample[1][x];
1539 ((uint16_t*)(src + stride*y))[x]= sample[1][x] << (16 - s->avctx->bits_per_raw_sample);
1543 //STOP_TIMER("decode-line")}
1547 static void decode_rgb_frame(FFV1Context *s, uint8_t *src[3], int w, int h, int stride[3]){
1549 int16_t *sample[4][2];
1550 int lbd= s->avctx->bits_per_raw_sample <= 8;
1551 int bits= s->avctx->bits_per_raw_sample > 0 ? s->avctx->bits_per_raw_sample : 8;
1552 int offset= 1 << bits;
1554 sample[x][0] = s->sample_buffer + x*2 *(w+6) + 3;
1555 sample[x][1] = s->sample_buffer + (x*2+1)*(w+6) + 3;
1560 memset(s->sample_buffer, 0, 8*(w+6)*sizeof(*s->sample_buffer));
1563 for(p=0; p<3 + s->transparency; p++){
1564 int16_t *temp = sample[p][0]; //FIXME try a normal buffer
1566 sample[p][0]= sample[p][1];
1569 sample[p][1][-1]= sample[p][0][0 ];
1570 sample[p][0][ w]= sample[p][0][w-1];
1572 decode_line(s, w, sample[p], (p+1)/2, 9);
1574 decode_line(s, w, sample[p], (p+1)/2, bits+1);
1577 int g= sample[0][1][x];
1578 int b= sample[1][1][x];
1579 int r= sample[2][1][x];
1580 int a= sample[3][1][x];
1589 *((uint32_t*)(src[0] + x*4 + stride[0]*y))= b + (g<<8) + (r<<16) + (a<<24);
1591 *((uint16_t*)(src[0] + x*2 + stride[0]*y)) = b;
1592 *((uint16_t*)(src[1] + x*2 + stride[1]*y)) = g;
1593 *((uint16_t*)(src[2] + x*2 + stride[2]*y)) = r;
1599 static int decode_slice_header(FFV1Context *f, FFV1Context *fs){
1600 RangeCoder *c = &fs->c;
1601 uint8_t state[CONTEXT_SIZE];
1602 unsigned ps, i, context_count;
1603 memset(state, 128, sizeof(state));
1605 av_assert0(f->version > 2);
1607 fs->slice_x = get_symbol(c, state, 0) *f->width ;
1608 fs->slice_y = get_symbol(c, state, 0) *f->height;
1609 fs->slice_width =(get_symbol(c, state, 0)+1)*f->width + fs->slice_x;
1610 fs->slice_height=(get_symbol(c, state, 0)+1)*f->height + fs->slice_y;
1612 fs->slice_x /= f->num_h_slices;
1613 fs->slice_y /= f->num_v_slices;
1614 fs->slice_width = fs->slice_width /f->num_h_slices - fs->slice_x;
1615 fs->slice_height = fs->slice_height/f->num_v_slices - fs->slice_y;
1616 if((unsigned)fs->slice_width > f->width || (unsigned)fs->slice_height > f->height)
1618 if( (unsigned)fs->slice_x + (uint64_t)fs->slice_width > f->width
1619 || (unsigned)fs->slice_y + (uint64_t)fs->slice_height > f->height)
1622 for(i=0; i<f->plane_count; i++){
1623 PlaneContext * const p= &fs->plane[i];
1624 int idx=get_symbol(c, state, 0);
1625 if(idx > (unsigned)f->quant_table_count){
1626 av_log(f->avctx, AV_LOG_ERROR, "quant_table_index out of range\n");
1629 p->quant_table_index= idx;
1630 memcpy(p->quant_table, f->quant_tables[idx], sizeof(p->quant_table));
1631 context_count= f->context_count[idx];
1633 if(p->context_count < context_count){
1634 av_freep(&p->state);
1635 av_freep(&p->vlc_state);
1637 p->context_count= context_count;
1640 ps = get_symbol(c, state, 0);
1642 f->picture.interlaced_frame = 1;
1643 f->picture.top_field_first = 1;
1645 f->picture.interlaced_frame = 1;
1646 f->picture.top_field_first = 0;
1648 f->picture.interlaced_frame = 0;
1650 f->picture.sample_aspect_ratio.num = get_symbol(c, state, 0);
1651 f->picture.sample_aspect_ratio.den = get_symbol(c, state, 0);
1656 static int decode_slice(AVCodecContext *c, void *arg){
1657 FFV1Context *fs= *(void**)arg;
1658 FFV1Context *f= fs->avctx->priv_data;
1659 int width, height, x, y;
1660 const int ps= (c->bits_per_raw_sample>8)+1;
1661 AVFrame * const p= &f->picture;
1664 if(init_slice_state(f, fs) < 0)
1665 return AVERROR(ENOMEM);
1666 if(decode_slice_header(f, fs) < 0) {
1667 fs->slice_damaged = 1;
1668 return AVERROR_INVALIDDATA;
1671 if(init_slice_state(f, fs) < 0)
1672 return AVERROR(ENOMEM);
1673 if(f->picture.key_frame)
1674 clear_slice_state(f, fs);
1675 width = fs->slice_width;
1676 height= fs->slice_height;
1681 if (f->version == 3 && f->minor_version > 1 || f->version > 3)
1682 get_rac(&fs->c, (uint8_t[]){129});
1683 fs->ac_byte_count = f->version > 2 || (!x&&!y) ? fs->c.bytestream - fs->c.bytestream_start - 1 : 0;
1684 init_get_bits(&fs->gb,
1685 fs->c.bytestream_start + fs->ac_byte_count,
1686 (fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count) * 8);
1689 av_assert1(width && height);
1690 if(f->colorspace==0){
1691 const int chroma_width = -((-width )>>f->chroma_h_shift);
1692 const int chroma_height= -((-height)>>f->chroma_v_shift);
1693 const int cx= x>>f->chroma_h_shift;
1694 const int cy= y>>f->chroma_v_shift;
1695 decode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0);
1697 if (f->chroma_planes){
1698 decode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
1699 decode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1);
1701 if (fs->transparency)
1702 decode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2);
1704 uint8_t *planes[3] = {p->data[0] + ps*x + y*p->linesize[0],
1705 p->data[1] + ps*x + y*p->linesize[1],
1706 p->data[2] + ps*x + y*p->linesize[2]};
1707 decode_rgb_frame(fs, planes, width, height, p->linesize);
1709 if(fs->ac && f->version > 2) {
1711 get_rac(&fs->c, (uint8_t[]){129});
1712 v = fs->c.bytestream_end - fs->c.bytestream - 2 - 5*f->ec;
1714 av_log(f->avctx, AV_LOG_ERROR, "bytestream end mismatching by %d\n", v);
1715 fs->slice_damaged = 1;
1724 static int read_quant_table(RangeCoder *c, int16_t *quant_table, int scale){
1727 uint8_t state[CONTEXT_SIZE];
1729 memset(state, 128, sizeof(state));
1731 for(v=0; i<128 ; v++){
1732 unsigned len= get_symbol(c, state, 0) + 1;
1734 if(len > 128 - i) return -1;
1737 quant_table[i] = scale*v;
1742 for(i=1; i<128; i++){
1743 quant_table[256-i]= -quant_table[i];
1745 quant_table[128]= -quant_table[127];
1750 static int read_quant_tables(RangeCoder *c, int16_t quant_table[MAX_CONTEXT_INPUTS][256]){
1752 int context_count=1;
1755 context_count*= read_quant_table(c, quant_table[i], context_count);
1756 if(context_count > 32768U){
1760 return (context_count+1)/2;
1763 static int read_extra_header(FFV1Context *f){
1764 RangeCoder * const c= &f->c;
1765 uint8_t state[CONTEXT_SIZE];
1767 uint8_t state2[32][CONTEXT_SIZE];
1769 memset(state2, 128, sizeof(state2));
1770 memset(state, 128, sizeof(state));
1772 ff_init_range_decoder(c, f->avctx->extradata, f->avctx->extradata_size);
1773 ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1775 f->version= get_symbol(c, state, 0);
1776 if(f->version > 2) {
1777 c->bytestream_end -= 4;
1778 f->minor_version= get_symbol(c, state, 0);
1780 f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
1782 for(i=1; i<256; i++){
1783 f->state_transition[i]= get_symbol(c, state, 1) + c->one_state[i];
1786 f->colorspace= get_symbol(c, state, 0); //YUV cs type
1787 f->avctx->bits_per_raw_sample= get_symbol(c, state, 0);
1788 f->chroma_planes= get_rac(c, state);
1789 f->chroma_h_shift= get_symbol(c, state, 0);
1790 f->chroma_v_shift= get_symbol(c, state, 0);
1791 f->transparency= get_rac(c, state);
1792 f->plane_count= 2 + f->transparency;
1793 f->num_h_slices= 1 + get_symbol(c, state, 0);
1794 f->num_v_slices= 1 + get_symbol(c, state, 0);
1795 if(f->num_h_slices > (unsigned)f->width || f->num_v_slices > (unsigned)f->height){
1796 av_log(f->avctx, AV_LOG_ERROR, "too many slices\n");
1800 f->quant_table_count= get_symbol(c, state, 0);
1801 if(f->quant_table_count > (unsigned)MAX_QUANT_TABLES)
1803 for(i=0; i<f->quant_table_count; i++){
1804 if((f->context_count[i]= read_quant_tables(c, f->quant_tables[i])) < 0){
1805 av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
1810 if(allocate_initial_states(f) < 0)
1811 return AVERROR(ENOMEM);
1813 for(i=0; i<f->quant_table_count; i++){
1814 if(get_rac(c, state)){
1815 for(j=0; j<f->context_count[i]; j++){
1816 for(k=0; k<CONTEXT_SIZE; k++){
1817 int pred= j ? f->initial_states[i][j-1][k] : 128;
1818 f->initial_states[i][j][k]= (pred+get_symbol(c, state2[k], 1))&0xFF;
1825 f->ec = get_symbol(c, state, 0);
1830 v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, f->avctx->extradata, f->avctx->extradata_size);
1832 av_log(f->avctx, AV_LOG_ERROR, "CRC mismatch %X!\n", v);
1833 return AVERROR_INVALIDDATA;
1840 static int read_header(FFV1Context *f){
1841 uint8_t state[CONTEXT_SIZE];
1842 int i, j, context_count = -1; //-1 to avoid warning
1843 RangeCoder * const c= &f->slice_context[0]->c;
1845 memset(state, 128, sizeof(state));
1848 unsigned v= get_symbol(c, state, 0);
1850 av_log(f->avctx, AV_LOG_ERROR, "invalid version %d in ver01 header\n", v);
1851 return AVERROR_INVALIDDATA;
1854 f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
1856 for(i=1; i<256; i++){
1857 f->state_transition[i]= get_symbol(c, state, 1) + c->one_state[i];
1860 f->colorspace= get_symbol(c, state, 0); //YUV cs type
1862 f->avctx->bits_per_raw_sample= get_symbol(c, state, 0);
1863 f->chroma_planes= get_rac(c, state);
1864 f->chroma_h_shift= get_symbol(c, state, 0);
1865 f->chroma_v_shift= get_symbol(c, state, 0);
1866 f->transparency= get_rac(c, state);
1867 f->plane_count= 2 + f->transparency;
1870 if(f->colorspace==0){
1871 if(!f->transparency && !f->chroma_planes){
1872 if (f->avctx->bits_per_raw_sample<=8)
1873 f->avctx->pix_fmt= AV_PIX_FMT_GRAY8;
1875 f->avctx->pix_fmt= AV_PIX_FMT_GRAY16;
1876 }else if(f->avctx->bits_per_raw_sample<=8 && !f->transparency){
1877 switch(16*f->chroma_h_shift + f->chroma_v_shift){
1878 case 0x00: f->avctx->pix_fmt= AV_PIX_FMT_YUV444P; break;
1879 case 0x01: f->avctx->pix_fmt= AV_PIX_FMT_YUV440P; break;
1880 case 0x10: f->avctx->pix_fmt= AV_PIX_FMT_YUV422P; break;
1881 case 0x11: f->avctx->pix_fmt= AV_PIX_FMT_YUV420P; break;
1882 case 0x20: f->avctx->pix_fmt= AV_PIX_FMT_YUV411P; break;
1883 case 0x22: f->avctx->pix_fmt= AV_PIX_FMT_YUV410P; break;
1885 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1888 }else if(f->avctx->bits_per_raw_sample<=8 && f->transparency){
1889 switch(16*f->chroma_h_shift + f->chroma_v_shift){
1890 case 0x00: f->avctx->pix_fmt= AV_PIX_FMT_YUVA444P; break;
1891 case 0x10: f->avctx->pix_fmt= AV_PIX_FMT_YUVA422P; break;
1892 case 0x11: f->avctx->pix_fmt= AV_PIX_FMT_YUVA420P; break;
1894 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1897 }else if(f->avctx->bits_per_raw_sample==9) {
1899 switch(16*f->chroma_h_shift + f->chroma_v_shift){
1900 case 0x00: f->avctx->pix_fmt= AV_PIX_FMT_YUV444P9; break;
1901 case 0x10: f->avctx->pix_fmt= AV_PIX_FMT_YUV422P9; break;
1902 case 0x11: f->avctx->pix_fmt= AV_PIX_FMT_YUV420P9; break;
1904 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1907 }else if(f->avctx->bits_per_raw_sample==10) {
1909 switch(16*f->chroma_h_shift + f->chroma_v_shift){
1910 case 0x00: f->avctx->pix_fmt= AV_PIX_FMT_YUV444P10; break;
1911 case 0x10: f->avctx->pix_fmt= AV_PIX_FMT_YUV422P10; break;
1912 case 0x11: f->avctx->pix_fmt= AV_PIX_FMT_YUV420P10; break;
1914 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1918 switch(16*f->chroma_h_shift + f->chroma_v_shift){
1919 case 0x00: f->avctx->pix_fmt= AV_PIX_FMT_YUV444P16; break;
1920 case 0x10: f->avctx->pix_fmt= AV_PIX_FMT_YUV422P16; break;
1921 case 0x11: f->avctx->pix_fmt= AV_PIX_FMT_YUV420P16; break;
1923 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1927 }else if(f->colorspace==1){
1928 if(f->chroma_h_shift || f->chroma_v_shift){
1929 av_log(f->avctx, AV_LOG_ERROR, "chroma subsampling not supported in this colorspace\n");
1932 if(f->avctx->bits_per_raw_sample==9)
1933 f->avctx->pix_fmt= AV_PIX_FMT_GBRP9;
1934 else if(f->avctx->bits_per_raw_sample==10)
1935 f->avctx->pix_fmt= AV_PIX_FMT_GBRP10;
1936 else if(f->avctx->bits_per_raw_sample==12)
1937 f->avctx->pix_fmt= AV_PIX_FMT_GBRP12;
1938 else if(f->avctx->bits_per_raw_sample==14)
1939 f->avctx->pix_fmt= AV_PIX_FMT_GBRP14;
1941 if(f->transparency) f->avctx->pix_fmt= AV_PIX_FMT_RGB32;
1942 else f->avctx->pix_fmt= AV_PIX_FMT_0RGB32;
1944 av_log(f->avctx, AV_LOG_ERROR, "colorspace not supported\n");
1948 av_dlog(f->avctx, "%d %d %d\n",
1949 f->chroma_h_shift, f->chroma_v_shift, f->avctx->pix_fmt);
1951 context_count= read_quant_tables(c, f->quant_table);
1952 if(context_count < 0){
1953 av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
1956 }else if(f->version < 3){
1957 f->slice_count= get_symbol(c, state, 0);
1959 const uint8_t *p= c->bytestream_end;
1960 for(f->slice_count = 0; f->slice_count < MAX_SLICES && 3 < p - c->bytestream_start; f->slice_count++){
1961 int trailer = 3 + 5*!!f->ec;
1962 int size = AV_RB24(p-trailer);
1963 if(size + trailer > p - c->bytestream_start)
1965 p -= size + trailer;
1968 if(f->slice_count > (unsigned)MAX_SLICES || f->slice_count <= 0){
1969 av_log(f->avctx, AV_LOG_ERROR, "slice count %d is invalid\n", f->slice_count);
1973 for(j=0; j<f->slice_count; j++){
1974 FFV1Context *fs= f->slice_context[j];
1976 fs->packed_at_lsb= f->packed_at_lsb;
1978 fs->slice_damaged = 0;
1980 if(f->version == 2){
1981 fs->slice_x = get_symbol(c, state, 0) *f->width ;
1982 fs->slice_y = get_symbol(c, state, 0) *f->height;
1983 fs->slice_width =(get_symbol(c, state, 0)+1)*f->width + fs->slice_x;
1984 fs->slice_height=(get_symbol(c, state, 0)+1)*f->height + fs->slice_y;
1986 fs->slice_x /= f->num_h_slices;
1987 fs->slice_y /= f->num_v_slices;
1988 fs->slice_width = fs->slice_width /f->num_h_slices - fs->slice_x;
1989 fs->slice_height = fs->slice_height/f->num_v_slices - fs->slice_y;
1990 if((unsigned)fs->slice_width > f->width || (unsigned)fs->slice_height > f->height)
1992 if( (unsigned)fs->slice_x + (uint64_t)fs->slice_width > f->width
1993 || (unsigned)fs->slice_y + (uint64_t)fs->slice_height > f->height)
1997 for(i=0; i<f->plane_count; i++){
1998 PlaneContext * const p= &fs->plane[i];
2000 if(f->version == 2){
2001 int idx=get_symbol(c, state, 0);
2002 if(idx > (unsigned)f->quant_table_count){
2003 av_log(f->avctx, AV_LOG_ERROR, "quant_table_index out of range\n");
2006 p->quant_table_index= idx;
2007 memcpy(p->quant_table, f->quant_tables[idx], sizeof(p->quant_table));
2008 context_count= f->context_count[idx];
2010 memcpy(p->quant_table, f->quant_table, sizeof(p->quant_table));
2013 if(f->version <= 2){
2014 av_assert0(context_count>=0);
2015 if(p->context_count < context_count){
2016 av_freep(&p->state);
2017 av_freep(&p->vlc_state);
2019 p->context_count= context_count;
2026 static av_cold int decode_init(AVCodecContext *avctx)
2028 FFV1Context *f = avctx->priv_data;
2032 if(avctx->extradata && read_extra_header(f) < 0)
2035 if(init_slice_contexts(f) < 0)
2041 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){
2042 const uint8_t *buf = avpkt->data;
2043 int buf_size = avpkt->size;
2044 FFV1Context *f = avctx->priv_data;
2045 RangeCoder * const c= &f->slice_context[0]->c;
2046 AVFrame * const p= &f->picture;
2048 uint8_t keystate= 128;
2049 const uint8_t *buf_p;
2051 AVFrame *picture = data;
2053 /* release previously stored data */
2055 avctx->release_buffer(avctx, p);
2057 ff_init_range_decoder(c, buf, buf_size);
2058 ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
2061 p->pict_type= AV_PICTURE_TYPE_I; //FIXME I vs. P
2062 if(get_rac(c, &keystate)){
2064 f->key_frame_ok = 0;
2065 if(read_header(f) < 0)
2067 f->key_frame_ok = 1;
2069 if (!f->key_frame_ok) {
2070 av_log(avctx, AV_LOG_ERROR, "Cant decode non keyframe without valid keyframe\n");
2071 return AVERROR_INVALIDDATA;
2076 p->reference= 3; //for error concealment
2077 if(avctx->get_buffer(avctx, p) < 0){
2078 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
2082 if(avctx->debug&FF_DEBUG_PICT_INFO)
2083 av_log(avctx, AV_LOG_DEBUG, "ver:%d keyframe:%d coder:%d ec:%d slices:%d bps:%d\n",
2084 f->version, p->key_frame, f->ac, f->ec, f->slice_count, f->avctx->bits_per_raw_sample);
2086 buf_p= buf + buf_size;
2087 for(i=f->slice_count-1; i>=0; i--){
2088 FFV1Context *fs= f->slice_context[i];
2089 int trailer = 3 + 5*!!f->ec;
2092 if(i || f->version>2) v = AV_RB24(buf_p-trailer)+trailer;
2093 else v = buf_p - c->bytestream_start;
2094 if(buf_p - c->bytestream_start < v){
2095 av_log(avctx, AV_LOG_ERROR, "Slice pointer chain broken\n");
2101 unsigned crc = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, v);
2103 int64_t ts = avpkt->pts != AV_NOPTS_VALUE ? avpkt->pts : avpkt->dts;
2104 av_log(f->avctx, AV_LOG_ERROR, "CRC mismatch %X!", crc);
2105 if(ts != AV_NOPTS_VALUE && avctx->pkt_timebase.num) {
2106 av_log(f->avctx, AV_LOG_ERROR, "at %f seconds\n",ts*av_q2d(avctx->pkt_timebase));
2107 } else if(ts != AV_NOPTS_VALUE) {
2108 av_log(f->avctx, AV_LOG_ERROR, "at %"PRId64"\n", ts);
2110 av_log(f->avctx, AV_LOG_ERROR, "\n");
2112 fs->slice_damaged = 1;
2117 ff_init_range_decoder(&fs->c, buf_p, v);
2119 fs->c.bytestream_end = (uint8_t *)(buf_p + v);
2122 avctx->execute(avctx, decode_slice, &f->slice_context[0], NULL, f->slice_count, sizeof(void*));
2124 for(i=f->slice_count-1; i>=0; i--){
2125 FFV1Context *fs= f->slice_context[i];
2127 if(fs->slice_damaged && f->last_picture.data[0]){
2128 uint8_t *dst[4], *src[4];
2130 int sh = (j==1 || j==2) ? f->chroma_h_shift : 0;
2131 int sv = (j==1 || j==2) ? f->chroma_v_shift : 0;
2132 dst[j] = f->picture .data[j] + f->picture .linesize[j]*
2133 (fs->slice_y>>sv) + (fs->slice_x>>sh);
2134 src[j] = f->last_picture.data[j] + f->last_picture.linesize[j]*
2135 (fs->slice_y>>sv) + (fs->slice_x>>sh);
2137 av_image_copy(dst, f->picture.linesize, (const uint8_t **)src, f->last_picture.linesize,
2138 avctx->pix_fmt, fs->slice_width, fs->slice_height);
2142 f->picture_number++;
2145 *data_size = sizeof(AVFrame);
2147 FFSWAP(AVFrame, f->picture, f->last_picture);
2152 AVCodec ff_ffv1_decoder = {
2154 .type = AVMEDIA_TYPE_VIDEO,
2155 .id = AV_CODEC_ID_FFV1,
2156 .priv_data_size = sizeof(FFV1Context),
2157 .init = decode_init,
2158 .close = common_end,
2159 .decode = decode_frame,
2160 .capabilities = CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/ |
2161 CODEC_CAP_SLICE_THREADS,
2162 .long_name = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
2165 #if CONFIG_FFV1_ENCODER
2167 #define OFFSET(x) offsetof(FFV1Context, x)
2168 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
2169 static const AVOption options[] = {
2170 { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 1, VE},
2174 static const AVClass class = {
2175 .class_name = "ffv1 encoder",
2176 .item_name = av_default_item_name,
2178 .version = LIBAVUTIL_VERSION_INT,
2181 static const AVCodecDefault ffv1_defaults[] = {
2186 AVCodec ff_ffv1_encoder = {
2188 .type = AVMEDIA_TYPE_VIDEO,
2189 .id = AV_CODEC_ID_FFV1,
2190 .priv_data_size = sizeof(FFV1Context),
2191 .init = encode_init,
2192 .encode2 = encode_frame,
2193 .close = common_end,
2194 .capabilities = CODEC_CAP_SLICE_THREADS,
2195 .defaults = ffv1_defaults,
2196 .pix_fmts = (const enum AVPixelFormat[]){
2197 AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV444P,
2198 AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV411P,
2199 AV_PIX_FMT_YUV410P, AV_PIX_FMT_0RGB32, AV_PIX_FMT_RGB32, AV_PIX_FMT_YUV420P16,
2200 AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9,
2201 AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
2202 AV_PIX_FMT_GRAY16, AV_PIX_FMT_GRAY8, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
2203 AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14,
2206 .long_name = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
2207 .priv_class = &class,