2 * FFV1 codec for libavcodec
4 * Copyright (c) 2003 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)
32 #include "rangecoder.h"
35 #include "libavutil/avassert.h"
38 #define CONTEXT_SIZE 32
40 #define MAX_QUANT_TABLES 8
41 #define MAX_CONTEXT_INPUTS 5
43 extern const uint8_t ff_log2_run[41];
45 static const int8_t quant5_10bit[256]={
46 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
47 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
48 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
49 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
50 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
51 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
52 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
53 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
54 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
55 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
56 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
57 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
58 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-1,
59 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
60 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
61 -1,-1,-1,-1,-1,-1,-0,-0,-0,-0,-0,-0,-0,-0,-0,-0,
64 static const int8_t quant5[256]={
65 0, 1, 1, 1, 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, 2,
70 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
71 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
72 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
73 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
74 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
75 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
76 -2,-2,-2,-2,-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,-1,-1,-1,
83 static const int8_t quant9_10bit[256]={
84 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2,
85 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3,
86 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
87 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
88 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
89 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
90 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
91 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
92 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
93 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
94 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
95 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
96 -4,-4,-4,-4,-4,-4,-4,-4,-4,-3,-3,-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,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
99 -2,-2,-2,-2,-1,-1,-1,-1,-1,-1,-1,-1,-0,-0,-0,-0,
102 static const int8_t quant11[256]={
103 0, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 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, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
106 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
107 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
108 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
109 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
110 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
111 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
112 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
113 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
114 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
115 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
116 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-4,-4,
117 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
118 -4,-4,-4,-4,-4,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-1,
121 static const uint8_t ver2_state[256]= {
122 0, 10, 10, 10, 10, 16, 16, 16, 28, 16, 16, 29, 42, 49, 20, 49,
123 59, 25, 26, 26, 27, 31, 33, 33, 33, 34, 34, 37, 67, 38, 39, 39,
124 40, 40, 41, 79, 43, 44, 45, 45, 48, 48, 64, 50, 51, 52, 88, 52,
125 53, 74, 55, 57, 58, 58, 74, 60, 101, 61, 62, 84, 66, 66, 68, 69,
126 87, 82, 71, 97, 73, 73, 82, 75, 111, 77, 94, 78, 87, 81, 83, 97,
127 85, 83, 94, 86, 99, 89, 90, 99, 111, 92, 93, 134, 95, 98, 105, 98,
128 105, 110, 102, 108, 102, 118, 103, 106, 106, 113, 109, 112, 114, 112, 116, 125,
129 115, 116, 117, 117, 126, 119, 125, 121, 121, 123, 145, 124, 126, 131, 127, 129,
130 165, 130, 132, 138, 133, 135, 145, 136, 137, 139, 146, 141, 143, 142, 144, 148,
131 147, 155, 151, 149, 151, 150, 152, 157, 153, 154, 156, 168, 158, 162, 161, 160,
132 172, 163, 169, 164, 166, 184, 167, 170, 177, 174, 171, 173, 182, 176, 180, 178,
133 175, 189, 179, 181, 186, 183, 192, 185, 200, 187, 191, 188, 190, 197, 193, 196,
134 197, 194, 195, 196, 198, 202, 199, 201, 210, 203, 207, 204, 205, 206, 208, 214,
135 209, 211, 221, 212, 213, 215, 224, 216, 217, 218, 219, 220, 222, 228, 223, 225,
136 226, 224, 227, 229, 240, 230, 231, 232, 233, 234, 235, 236, 238, 239, 237, 242,
137 241, 243, 242, 244, 245, 246, 247, 248, 249, 250, 251, 252, 252, 253, 254, 255,
140 typedef struct VlcState{
147 typedef struct PlaneContext{
148 int16_t quant_table[MAX_CONTEXT_INPUTS][256];
149 int quant_table_index;
151 uint8_t (*state)[CONTEXT_SIZE];
153 uint8_t interlace_bit_state[2];
156 #define MAX_SLICES 256
158 typedef struct FFV1Context{
159 AVCodecContext *avctx;
163 uint64_t rc_stat[256][2];
164 uint64_t (*rc_stat2[MAX_QUANT_TABLES])[32][2];
167 int chroma_h_shift, chroma_v_shift;
172 int ac; ///< 1=range coder <-> 0=golomb rice
173 PlaneContext plane[MAX_PLANES];
174 int16_t quant_table[MAX_CONTEXT_INPUTS][256];
175 int16_t quant_tables[MAX_QUANT_TABLES][MAX_CONTEXT_INPUTS][256];
176 int context_count[MAX_QUANT_TABLES];
177 uint8_t state_transition[256];
178 uint8_t (*initial_states[MAX_QUANT_TABLES])[32];
181 int16_t *sample_buffer;
185 int quant_table_count;
189 struct FFV1Context *slice_context[MAX_SLICES];
199 static av_always_inline int fold(int diff, int bits){
211 static inline int predict(int16_t *src, int16_t *last)
213 const int LT= last[-1];
214 const int T= last[ 0];
215 const int L = src[-1];
217 return mid_pred(L, L + T - LT, T);
220 static inline int get_context(PlaneContext *p, int16_t *src,
221 int16_t *last, int16_t *last2)
223 const int LT= last[-1];
224 const int T= last[ 0];
225 const int RT= last[ 1];
226 const int L = src[-1];
228 if(p->quant_table[3][127]){
229 const int TT= last2[0];
230 const int LL= src[-2];
231 return p->quant_table[0][(L-LT) & 0xFF] + p->quant_table[1][(LT-T) & 0xFF] + p->quant_table[2][(T-RT) & 0xFF]
232 +p->quant_table[3][(LL-L) & 0xFF] + p->quant_table[4][(TT-T) & 0xFF];
234 return p->quant_table[0][(L-LT) & 0xFF] + p->quant_table[1][(LT-T) & 0xFF] + p->quant_table[2][(T-RT) & 0xFF];
237 static void find_best_state(uint8_t best_state[256][256], const uint8_t one_state[256]){
242 l2tab[i]= log2(i/256.0);
244 for(i=0; i<256; i++){
245 double best_len[256];
251 for(j=FFMAX(i-10,1); j<FFMIN(i+11,256); j++){
255 for(k=0; k<256; k++){
256 double newocc[256]={0};
257 for(m=0; m<256; m++){
259 len -=occ[m]*( p *l2tab[ m]
260 + (1-p)*l2tab[256-m]);
263 if(len < best_len[k]){
267 for(m=0; m<256; m++){
269 newocc[ one_state[ m]] += occ[m]* p ;
270 newocc[256-one_state[256-m]] += occ[m]*(1-p);
273 memcpy(occ, newocc, sizeof(occ));
279 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]){
282 #define put_rac(C,S,B) \
286 rc_stat2[(S)-state][B]++;\
292 const int a= FFABS(v);
293 const int e= av_log2(a);
294 put_rac(c, state+0, 0);
297 put_rac(c, state+1+i, 1); //1..10
299 put_rac(c, state+1+i, 0);
301 for(i=e-1; i>=0; i--){
302 put_rac(c, state+22+i, (a>>i)&1); //22..31
306 put_rac(c, state+11 + e, v < 0); //11..21
309 put_rac(c, state+1+FFMIN(i,9), 1); //1..10
311 put_rac(c, state+1+9, 0);
313 for(i=e-1; i>=0; i--){
314 put_rac(c, state+22+FFMIN(i,9), (a>>i)&1); //22..31
318 put_rac(c, state+11 + 10, v < 0); //11..21
321 put_rac(c, state+0, 1);
326 static void av_noinline put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed){
327 put_symbol_inline(c, state, v, is_signed, NULL, NULL);
330 static inline av_flatten int get_symbol_inline(RangeCoder *c, uint8_t *state, int is_signed){
331 if(get_rac(c, state+0))
336 while(get_rac(c, state+1 + FFMIN(e,9))){ //1..10
341 for(i=e-1; i>=0; i--){
342 a += a + get_rac(c, state+22 + FFMIN(i,9)); //22..31
345 e= -(is_signed && get_rac(c, state+11 + FFMIN(e, 10))); //11..21
350 static int av_noinline get_symbol(RangeCoder *c, uint8_t *state, int is_signed){
351 return get_symbol_inline(c, state, is_signed);
354 static inline void update_vlc_state(VlcState * const state, const int v){
355 int drift= state->drift;
356 int count= state->count;
357 state->error_sum += FFABS(v);
360 if(count == 128){ //FIXME variable
363 state->error_sum >>= 1;
368 if(state->bias > -128) state->bias--;
374 if(state->bias < 127) state->bias++;
385 static inline void put_vlc_symbol(PutBitContext *pb, VlcState * const state, int v, int bits){
387 //printf("final: %d ", v);
388 v = fold(v - state->bias, bits);
392 while(i < state->error_sum){ //FIXME optimize
400 if(k==0 && 2*state->drift <= - state->count) code= v ^ (-1);
403 code= v ^ ((2*state->drift + state->count)>>31);
406 //printf("v:%d/%d bias:%d error:%d drift:%d count:%d k:%d\n", v, code, state->bias, state->error_sum, state->drift, state->count, k);
407 set_sr_golomb(pb, code, k, 12, bits);
409 update_vlc_state(state, v);
412 static inline int get_vlc_symbol(GetBitContext *gb, VlcState * const state, int bits){
417 while(i < state->error_sum){ //FIXME optimize
424 v= get_sr_golomb(gb, k, 12, bits);
425 //printf("v:%d bias:%d error:%d drift:%d count:%d k:%d", v, state->bias, state->error_sum, state->drift, state->count, k);
428 if(k==0 && 2*state->drift <= - state->count) v ^= (-1);
430 v ^= ((2*state->drift + state->count)>>31);
433 ret= fold(v + state->bias, bits);
435 update_vlc_state(state, v);
436 //printf("final: %d\n", ret);
440 #if CONFIG_FFV1_ENCODER
441 static av_always_inline int encode_line(FFV1Context *s, int w,
443 int plane_index, int bits)
445 PlaneContext * const p= &s->plane[plane_index];
446 RangeCoder * const c= &s->c;
448 int run_index= s->run_index;
453 if(c->bytestream_end - c->bytestream < w*20){
454 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
458 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < w*4){
459 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
467 context= get_context(p, sample[0]+x, sample[1]+x, sample[2]+x);
468 diff= sample[0][x] - predict(sample[0]+x, sample[1]+x);
475 diff= fold(diff, bits);
478 if(s->flags & CODEC_FLAG_PASS1){
479 put_symbol_inline(c, p->state[context], diff, 1, s->rc_stat, s->rc_stat2[p->quant_table_index][context]);
481 put_symbol_inline(c, p->state[context], diff, 1, NULL, NULL);
484 if(context == 0) run_mode=1;
489 while(run_count >= 1<<ff_log2_run[run_index]){
490 run_count -= 1<<ff_log2_run[run_index];
492 put_bits(&s->pb, 1, 1);
495 put_bits(&s->pb, 1 + ff_log2_run[run_index], run_count);
496 if(run_index) run_index--;
505 // printf("count:%d index:%d, mode:%d, x:%d y:%d pos:%d\n", run_count, run_index, run_mode, x, y, (int)put_bits_count(&s->pb));
508 put_vlc_symbol(&s->pb, &p->vlc_state[context], diff, bits);
512 while(run_count >= 1<<ff_log2_run[run_index]){
513 run_count -= 1<<ff_log2_run[run_index];
515 put_bits(&s->pb, 1, 1);
519 put_bits(&s->pb, 1, 1);
521 s->run_index= run_index;
526 static void encode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
528 const int ring_size= s->avctx->context_model ? 3 : 2;
532 memset(s->sample_buffer, 0, ring_size*(w+6)*sizeof(*s->sample_buffer));
535 for(i=0; i<ring_size; i++)
536 sample[i]= s->sample_buffer + (w+6)*((h+i-y)%ring_size) + 3;
538 sample[0][-1]= sample[1][0 ];
539 sample[1][ w]= sample[1][w-1];
541 if(s->avctx->bits_per_raw_sample<=8){
543 sample[0][x]= src[x + stride*y];
545 encode_line(s, w, sample, plane_index, 8);
547 if(s->packed_at_lsb){
549 sample[0][x]= ((uint16_t*)(src + stride*y))[x];
553 sample[0][x]= ((uint16_t*)(src + stride*y))[x] >> (16 - s->avctx->bits_per_raw_sample);
556 encode_line(s, w, sample, plane_index, s->avctx->bits_per_raw_sample);
558 //STOP_TIMER("encode line")}
562 static void encode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
564 const int ring_size= s->avctx->context_model ? 3 : 2;
565 int16_t *sample[3][3];
568 memset(s->sample_buffer, 0, ring_size*3*(w+6)*sizeof(*s->sample_buffer));
571 for(i=0; i<ring_size; i++)
573 sample[p][i]= s->sample_buffer + p*ring_size*(w+6) + ((h+i-y)%ring_size)*(w+6) + 3;
576 int v= src[x + stride*y];
587 // assert(g>=0 && b>=0 && r>=0);
588 // assert(g<256 && b<512 && r<512);
594 sample[p][0][-1]= sample[p][1][0 ];
595 sample[p][1][ w]= sample[p][1][w-1];
596 encode_line(s, w, sample[p], FFMIN(p, 1), 9);
601 static void write_quant_table(RangeCoder *c, int16_t *quant_table){
604 uint8_t state[CONTEXT_SIZE];
605 memset(state, 128, sizeof(state));
607 for(i=1; i<128 ; i++){
608 if(quant_table[i] != quant_table[i-1]){
609 put_symbol(c, state, i-last-1, 0);
613 put_symbol(c, state, i-last-1, 0);
616 static void write_quant_tables(RangeCoder *c, int16_t quant_table[MAX_CONTEXT_INPUTS][256]){
619 write_quant_table(c, quant_table[i]);
622 static void write_header(FFV1Context *f){
623 uint8_t state[CONTEXT_SIZE];
625 RangeCoder * const c= &f->slice_context[0]->c;
627 memset(state, 128, sizeof(state));
630 put_symbol(c, state, f->version, 0);
631 put_symbol(c, state, f->ac, 0);
633 for(i=1; i<256; i++){
634 put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
637 put_symbol(c, state, f->colorspace, 0); //YUV cs type
639 put_symbol(c, state, f->avctx->bits_per_raw_sample, 0);
640 put_rac(c, state, 1); //chroma planes
641 put_symbol(c, state, f->chroma_h_shift, 0);
642 put_symbol(c, state, f->chroma_v_shift, 0);
643 put_rac(c, state, 0); //no transparency plane
645 write_quant_tables(c, f->quant_table);
647 put_symbol(c, state, f->slice_count, 0);
648 for(i=0; i<f->slice_count; i++){
649 FFV1Context *fs= f->slice_context[i];
650 put_symbol(c, state, (fs->slice_x +1)*f->num_h_slices / f->width , 0);
651 put_symbol(c, state, (fs->slice_y +1)*f->num_v_slices / f->height , 0);
652 put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
653 put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
654 for(j=0; j<f->plane_count; j++){
655 put_symbol(c, state, f->plane[j].quant_table_index, 0);
656 av_assert0(f->plane[j].quant_table_index == f->avctx->context_model);
661 #endif /* CONFIG_FFV1_ENCODER */
663 static av_cold int common_init(AVCodecContext *avctx){
664 FFV1Context *s = avctx->priv_data;
667 s->flags= avctx->flags;
669 avcodec_get_frame_defaults(&s->picture);
671 dsputil_init(&s->dsp, avctx);
673 s->width = avctx->width;
674 s->height= avctx->height;
676 assert(s->width && s->height);
685 static int init_slice_state(FFV1Context *f){
688 for(i=0; i<f->slice_count; i++){
689 FFV1Context *fs= f->slice_context[i];
690 for(j=0; j<f->plane_count; j++){
691 PlaneContext * const p= &fs->plane[j];
694 if(!p-> state) p-> state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
696 return AVERROR(ENOMEM);
698 if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
700 return AVERROR(ENOMEM);
705 //FIXME only redo if state_transition changed
706 for(j=1; j<256; j++){
707 fs->c.one_state [ j]= fs->state_transition[j];
708 fs->c.zero_state[256-j]= 256-fs->c.one_state [j];
716 static av_cold int init_slice_contexts(FFV1Context *f){
719 f->slice_count= f->num_h_slices * f->num_v_slices;
721 for(i=0; i<f->slice_count; i++){
722 FFV1Context *fs= av_mallocz(sizeof(*fs));
723 int sx= i % f->num_h_slices;
724 int sy= i / f->num_h_slices;
725 int sxs= f->avctx->width * sx / f->num_h_slices;
726 int sxe= f->avctx->width *(sx+1) / f->num_h_slices;
727 int sys= f->avctx->height* sy / f->num_v_slices;
728 int sye= f->avctx->height*(sy+1) / f->num_v_slices;
729 f->slice_context[i]= fs;
730 memcpy(fs, f, sizeof(*fs));
731 memset(fs->rc_stat2, 0, sizeof(fs->rc_stat2));
733 fs->slice_width = sxe - sxs;
734 fs->slice_height= sye - sys;
738 fs->sample_buffer = av_malloc(9 * (fs->width+6) * sizeof(*fs->sample_buffer));
739 if (!fs->sample_buffer)
740 return AVERROR(ENOMEM);
745 static int allocate_initial_states(FFV1Context *f){
748 for(i=0; i<f->quant_table_count; i++){
749 f->initial_states[i]= av_malloc(f->context_count[i]*sizeof(*f->initial_states[i]));
750 if(!f->initial_states[i])
751 return AVERROR(ENOMEM);
752 memset(f->initial_states[i], 128, f->context_count[i]*sizeof(*f->initial_states[i]));
757 #if CONFIG_FFV1_ENCODER
758 static int write_extra_header(FFV1Context *f){
759 RangeCoder * const c= &f->c;
760 uint8_t state[CONTEXT_SIZE];
762 uint8_t state2[32][CONTEXT_SIZE];
764 memset(state2, 128, sizeof(state2));
765 memset(state, 128, sizeof(state));
767 f->avctx->extradata= av_malloc(f->avctx->extradata_size= 10000 + (11*11*5*5*5+11*11*11)*32);
768 ff_init_range_encoder(c, f->avctx->extradata, f->avctx->extradata_size);
769 ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
771 put_symbol(c, state, f->version, 0);
772 put_symbol(c, state, f->ac, 0);
774 for(i=1; i<256; i++){
775 put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
778 put_symbol(c, state, f->colorspace, 0); //YUV cs type
779 put_symbol(c, state, f->avctx->bits_per_raw_sample, 0);
780 put_rac(c, state, 1); //chroma planes
781 put_symbol(c, state, f->chroma_h_shift, 0);
782 put_symbol(c, state, f->chroma_v_shift, 0);
783 put_rac(c, state, 0); //no transparency plane
784 put_symbol(c, state, f->num_h_slices-1, 0);
785 put_symbol(c, state, f->num_v_slices-1, 0);
787 put_symbol(c, state, f->quant_table_count, 0);
788 for(i=0; i<f->quant_table_count; i++)
789 write_quant_tables(c, f->quant_tables[i]);
791 for(i=0; i<f->quant_table_count; i++){
792 for(j=0; j<f->context_count[i]*CONTEXT_SIZE; j++)
793 if(f->initial_states[i] && f->initial_states[i][0][j] != 128)
795 if(j<f->context_count[i]*CONTEXT_SIZE){
796 put_rac(c, state, 1);
797 for(j=0; j<f->context_count[i]; j++){
798 for(k=0; k<CONTEXT_SIZE; k++){
799 int pred= j ? f->initial_states[i][j-1][k] : 128;
800 put_symbol(c, state2[k], (int8_t)(f->initial_states[i][j][k]-pred), 1);
804 put_rac(c, state, 0);
808 f->avctx->extradata_size= ff_rac_terminate(c);
813 static int sort_stt(FFV1Context *s, uint8_t stt[256]){
814 int i,i2,changed,print=0;
818 for(i=12; i<244; i++){
819 for(i2=i+1; i2<245 && i2<i+4; i2++){
820 #define COST(old, new) \
821 s->rc_stat[old][0]*-log2((256-(new))/256.0)\
822 +s->rc_stat[old][1]*-log2( (new) /256.0)
824 #define COST2(old, new) \
826 +COST(256-(old), 256-(new))
828 double size0= COST2(i, i ) + COST2(i2, i2);
829 double sizeX= COST2(i, i2) + COST2(i2, i );
830 if(sizeX < size0 && i!=128 && i2!=128){
832 FFSWAP(int, stt[ i], stt[ i2]);
833 FFSWAP(int, s->rc_stat[i ][0],s->rc_stat[ i2][0]);
834 FFSWAP(int, s->rc_stat[i ][1],s->rc_stat[ i2][1]);
836 FFSWAP(int, stt[256-i], stt[256-i2]);
837 FFSWAP(int, s->rc_stat[256-i][0],s->rc_stat[256-i2][0]);
838 FFSWAP(int, s->rc_stat[256-i][1],s->rc_stat[256-i2][1]);
840 for(j=1; j<256; j++){
841 if (stt[j] == i ) stt[j] = i2;
842 else if(stt[j] == i2) stt[j] = i ;
844 if (stt[256-j] == 256-i ) stt[256-j] = 256-i2;
845 else if(stt[256-j] == 256-i2) stt[256-j] = 256-i ;
856 static av_cold int encode_init(AVCodecContext *avctx)
858 FFV1Context *s = avctx->priv_data;
864 s->ac= avctx->coder_type ? 2:0;
868 s->state_transition[i]=ver2_state[i];
871 for(i=0; i<256; i++){
872 s->quant_table_count=2;
873 if(avctx->bits_per_raw_sample <=8){
874 s->quant_tables[0][0][i]= quant11[i];
875 s->quant_tables[0][1][i]= 11*quant11[i];
876 s->quant_tables[0][2][i]= 11*11*quant11[i];
877 s->quant_tables[1][0][i]= quant11[i];
878 s->quant_tables[1][1][i]= 11*quant11[i];
879 s->quant_tables[1][2][i]= 11*11*quant5 [i];
880 s->quant_tables[1][3][i]= 5*11*11*quant5 [i];
881 s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
883 s->quant_tables[0][0][i]= quant9_10bit[i];
884 s->quant_tables[0][1][i]= 11*quant9_10bit[i];
885 s->quant_tables[0][2][i]= 11*11*quant9_10bit[i];
886 s->quant_tables[1][0][i]= quant9_10bit[i];
887 s->quant_tables[1][1][i]= 11*quant9_10bit[i];
888 s->quant_tables[1][2][i]= 11*11*quant5_10bit[i];
889 s->quant_tables[1][3][i]= 5*11*11*quant5_10bit[i];
890 s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
893 s->context_count[0]= (11*11*11+1)/2;
894 s->context_count[1]= (11*11*5*5*5+1)/2;
895 memcpy(s->quant_table, s->quant_tables[avctx->context_model], sizeof(s->quant_table));
897 for(i=0; i<s->plane_count; i++){
898 PlaneContext * const p= &s->plane[i];
900 memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
901 p->quant_table_index= avctx->context_model;
902 p->context_count= s->context_count[p->quant_table_index];
905 if(allocate_initial_states(s) < 0)
906 return AVERROR(ENOMEM);
908 avctx->coded_frame= &s->picture;
909 switch(avctx->pix_fmt){
910 case PIX_FMT_YUV420P9:
911 case PIX_FMT_YUV420P10:
912 case PIX_FMT_YUV422P10:
913 s->packed_at_lsb = 1;
914 case PIX_FMT_YUV444P16:
915 case PIX_FMT_YUV422P16:
916 case PIX_FMT_YUV420P16:
917 if(avctx->bits_per_raw_sample <=8){
918 av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
922 av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample of more than 8 needs -coder 1 currently\n");
925 s->version= FFMAX(s->version, 1);
926 case PIX_FMT_YUV444P:
927 case PIX_FMT_YUV422P:
928 case PIX_FMT_YUV420P:
929 case PIX_FMT_YUV411P:
930 case PIX_FMT_YUV410P:
937 av_log(avctx, AV_LOG_ERROR, "format not supported\n");
940 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
944 if(avctx->flags & (CODEC_FLAG_PASS1|CODEC_FLAG_PASS2)){
945 for(i=0; i<s->quant_table_count; i++){
946 s->rc_stat2[i]= av_mallocz(s->context_count[i]*sizeof(*s->rc_stat2[i]));
948 return AVERROR(ENOMEM);
952 char *p= avctx->stats_in;
953 uint8_t best_state[256][256];
957 av_assert0(s->version>=2);
960 for(j=0; j<256; j++){
962 s->rc_stat[j][i]= strtol(p, &next, 0);
964 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid at %d %d [%s]\n", j,i,p);
970 for(i=0; i<s->quant_table_count; i++){
971 for(j=0; j<s->context_count[i]; j++){
974 s->rc_stat2[i][j][k][m]= strtol(p, &next, 0);
976 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid at %d %d %d %d [%s]\n", i,j,k,m,p);
984 gob_count= strtol(p, &next, 0);
985 if(next==p || gob_count <0){
986 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
990 while(*p=='\n' || *p==' ') p++;
993 sort_stt(s, s->state_transition);
995 find_best_state(best_state, s->state_transition);
997 for(i=0; i<s->quant_table_count; i++){
998 for(j=0; j<s->context_count[i]; j++){
1001 if(s->rc_stat2[i][j][k][0]+s->rc_stat2[i][j][k][1]){
1002 p=256.0*s->rc_stat2[i][j][k][1] / (s->rc_stat2[i][j][k][0]+s->rc_stat2[i][j][k][1]);
1004 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)];
1013 write_extra_header(s);
1016 if(init_slice_contexts(s) < 0)
1018 if(init_slice_state(s) < 0)
1021 #define STATS_OUT_SIZE 1024*1024*6
1022 if(avctx->flags & CODEC_FLAG_PASS1){
1023 avctx->stats_out= av_mallocz(STATS_OUT_SIZE);
1024 for(i=0; i<s->quant_table_count; i++){
1025 for(j=0; j<s->slice_count; j++){
1026 FFV1Context *sf= s->slice_context[j];
1027 av_assert0(!sf->rc_stat2[i]);
1028 sf->rc_stat2[i]= av_mallocz(s->context_count[i]*sizeof(*sf->rc_stat2[i]));
1029 if(!sf->rc_stat2[i])
1030 return AVERROR(ENOMEM);
1037 #endif /* CONFIG_FFV1_ENCODER */
1040 static void clear_state(FFV1Context *f){
1043 for(si=0; si<f->slice_count; si++){
1044 FFV1Context *fs= f->slice_context[si];
1045 for(i=0; i<f->plane_count; i++){
1046 PlaneContext *p= &fs->plane[i];
1048 p->interlace_bit_state[0]= 128;
1049 p->interlace_bit_state[1]= 128;
1052 if(f->initial_states[p->quant_table_index]){
1053 memcpy(p->state, f->initial_states[p->quant_table_index], CONTEXT_SIZE*p->context_count);
1055 memset(p->state, 128, CONTEXT_SIZE*p->context_count);
1057 for(j=0; j<p->context_count; j++){
1058 p->vlc_state[j].drift= 0;
1059 p->vlc_state[j].error_sum= 4; //FFMAX((RANGE + 32)/64, 2);
1060 p->vlc_state[j].bias= 0;
1061 p->vlc_state[j].count= 1;
1068 #if CONFIG_FFV1_ENCODER
1069 static int encode_slice(AVCodecContext *c, void *arg){
1070 FFV1Context *fs= *(void**)arg;
1071 FFV1Context *f= fs->avctx->priv_data;
1072 int width = fs->slice_width;
1073 int height= fs->slice_height;
1076 AVFrame * const p= &f->picture;
1077 const int ps= (c->bits_per_raw_sample>8)+1;
1079 if(f->colorspace==0){
1080 const int chroma_width = -((-width )>>f->chroma_h_shift);
1081 const int chroma_height= -((-height)>>f->chroma_v_shift);
1082 const int cx= x>>f->chroma_h_shift;
1083 const int cy= y>>f->chroma_v_shift;
1085 encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0);
1087 encode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
1088 encode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1);
1090 encode_rgb_frame(fs, (uint32_t*)(p->data[0]) + ps*x + y*(p->linesize[0]/4), width, height, p->linesize[0]/4);
1097 static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
1098 FFV1Context *f = avctx->priv_data;
1099 RangeCoder * const c= &f->slice_context[0]->c;
1100 AVFrame *pict = data;
1101 AVFrame * const p= &f->picture;
1103 uint8_t keystate=128;
1107 ff_init_range_encoder(c, buf, buf_size);
1108 ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1111 p->pict_type= AV_PICTURE_TYPE_I;
1113 if(avctx->gop_size==0 || f->picture_number % avctx->gop_size == 0){
1114 put_rac(c, &keystate, 1);
1120 put_rac(c, &keystate, 0);
1125 used_count += ff_rac_terminate(c);
1126 //printf("pos=%d\n", used_count);
1127 init_put_bits(&f->slice_context[0]->pb, buf + used_count, buf_size - used_count);
1130 for(i=1; i<256; i++){
1131 c->one_state[i]= f->state_transition[i];
1132 c->zero_state[256-i]= 256-c->one_state[i];
1136 for(i=1; i<f->slice_count; i++){
1137 FFV1Context *fs= f->slice_context[i];
1138 uint8_t *start= buf + (buf_size-used_count)*i/f->slice_count;
1139 int len= buf_size/f->slice_count;
1142 ff_init_range_encoder(&fs->c, start, len);
1144 init_put_bits(&fs->pb, start, len);
1147 avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL, f->slice_count, sizeof(void*));
1150 for(i=0; i<f->slice_count; i++){
1151 FFV1Context *fs= f->slice_context[i];
1156 put_rac(&fs->c, &state, 0);
1157 bytes= ff_rac_terminate(&fs->c);
1159 flush_put_bits(&fs->pb); //nicer padding FIXME
1160 bytes= used_count + (put_bits_count(&fs->pb)+7)/8;
1164 av_assert0(bytes < buf_size/f->slice_count);
1165 memmove(buf_p, fs->ac ? fs->c.bytestream_start : fs->pb.buf, bytes);
1166 av_assert0(bytes < (1<<24));
1167 AV_WB24(buf_p+bytes, bytes);
1173 if((avctx->flags&CODEC_FLAG_PASS1) && (f->picture_number&31)==0){
1175 char *p= avctx->stats_out;
1176 char *end= p + STATS_OUT_SIZE;
1178 memset(f->rc_stat, 0, sizeof(f->rc_stat));
1179 for(i=0; i<f->quant_table_count; i++)
1180 memset(f->rc_stat2[i], 0, f->context_count[i]*sizeof(*f->rc_stat2[i]));
1182 for(j=0; j<f->slice_count; j++){
1183 FFV1Context *fs= f->slice_context[j];
1184 for(i=0; i<256; i++){
1185 f->rc_stat[i][0] += fs->rc_stat[i][0];
1186 f->rc_stat[i][1] += fs->rc_stat[i][1];
1188 for(i=0; i<f->quant_table_count; i++){
1189 for(k=0; k<f->context_count[i]; k++){
1190 for(m=0; m<32; m++){
1191 f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1192 f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1198 for(j=0; j<256; j++){
1199 snprintf(p, end-p, "%"PRIu64" %"PRIu64" ", f->rc_stat[j][0], f->rc_stat[j][1]);
1202 snprintf(p, end-p, "\n");
1204 for(i=0; i<f->quant_table_count; i++){
1205 for(j=0; j<f->context_count[i]; j++){
1206 for(m=0; m<32; m++){
1207 snprintf(p, end-p, "%"PRIu64" %"PRIu64" ", f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1212 snprintf(p, end-p, "%d\n", f->gob_count);
1213 } else if(avctx->flags&CODEC_FLAG_PASS1)
1214 avctx->stats_out[0] = '\0';
1216 f->picture_number++;
1219 #endif /* CONFIG_FFV1_ENCODER */
1221 static av_cold int common_end(AVCodecContext *avctx){
1222 FFV1Context *s = avctx->priv_data;
1225 if (avctx->codec->decode && s->picture.data[0])
1226 avctx->release_buffer(avctx, &s->picture);
1228 for(j=0; j<s->slice_count; j++){
1229 FFV1Context *fs= s->slice_context[j];
1230 for(i=0; i<s->plane_count; i++){
1231 PlaneContext *p= &fs->plane[i];
1233 av_freep(&p->state);
1234 av_freep(&p->vlc_state);
1236 av_freep(&fs->sample_buffer);
1239 av_freep(&avctx->stats_out);
1240 for(j=0; j<s->quant_table_count; j++){
1241 av_freep(&s->initial_states[j]);
1242 for(i=0; i<s->slice_count; i++){
1243 FFV1Context *sf= s->slice_context[i];
1244 av_freep(&sf->rc_stat2[j]);
1246 av_freep(&s->rc_stat2[j]);
1249 for(i=0; i<s->slice_count; i++){
1250 av_freep(&s->slice_context[i]);
1256 static av_always_inline void decode_line(FFV1Context *s, int w,
1258 int plane_index, int bits)
1260 PlaneContext * const p= &s->plane[plane_index];
1261 RangeCoder * const c= &s->c;
1265 int run_index= s->run_index;
1268 int diff, context, sign;
1270 context= get_context(p, sample[1] + x, sample[0] + x, sample[1] + x);
1277 av_assert2(context < p->context_count);
1280 diff= get_symbol_inline(c, p->state[context], 1);
1282 if(context == 0 && run_mode==0) run_mode=1;
1285 if(run_count==0 && run_mode==1){
1286 if(get_bits1(&s->gb)){
1287 run_count = 1<<ff_log2_run[run_index];
1288 if(x + run_count <= w) run_index++;
1290 if(ff_log2_run[run_index]) run_count = get_bits(&s->gb, ff_log2_run[run_index]);
1292 if(run_index) run_index--;
1300 diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
1305 diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
1307 // printf("count:%d index:%d, mode:%d, x:%d y:%d pos:%d\n", run_count, run_index, run_mode, x, y, get_bits_count(&s->gb));
1310 if(sign) diff= -diff;
1312 sample[1][x]= (predict(sample[1] + x, sample[0] + x) + diff) & ((1<<bits)-1);
1314 s->run_index= run_index;
1317 static void decode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
1320 sample[0]=s->sample_buffer +3;
1321 sample[1]=s->sample_buffer+w+6+3;
1325 memset(s->sample_buffer, 0, 2*(w+6)*sizeof(*s->sample_buffer));
1328 int16_t *temp = sample[0]; //FIXME try a normal buffer
1330 sample[0]= sample[1];
1333 sample[1][-1]= sample[0][0 ];
1334 sample[0][ w]= sample[0][w-1];
1337 if(s->avctx->bits_per_raw_sample <= 8){
1338 decode_line(s, w, sample, plane_index, 8);
1340 src[x + stride*y]= sample[1][x];
1343 decode_line(s, w, sample, plane_index, s->avctx->bits_per_raw_sample);
1344 if(s->packed_at_lsb){
1346 ((uint16_t*)(src + stride*y))[x]= sample[1][x];
1350 ((uint16_t*)(src + stride*y))[x]= sample[1][x] << (16 - s->avctx->bits_per_raw_sample);
1354 //STOP_TIMER("decode-line")}
1358 static void decode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
1360 int16_t *sample[3][2];
1362 sample[x][0] = s->sample_buffer + x*2 *(w+6) + 3;
1363 sample[x][1] = s->sample_buffer + (x*2+1)*(w+6) + 3;
1368 memset(s->sample_buffer, 0, 6*(w+6)*sizeof(*s->sample_buffer));
1372 int16_t *temp = sample[p][0]; //FIXME try a normal buffer
1374 sample[p][0]= sample[p][1];
1377 sample[p][1][-1]= sample[p][0][0 ];
1378 sample[p][0][ w]= sample[p][0][w-1];
1379 decode_line(s, w, sample[p], FFMIN(p, 1), 9);
1382 int g= sample[0][1][x];
1383 int b= sample[1][1][x];
1384 int r= sample[2][1][x];
1386 // assert(g>=0 && b>=0 && r>=0);
1387 // assert(g<256 && b<512 && r<512);
1395 src[x + stride*y]= b + (g<<8) + (r<<16) + (0xFF<<24);
1400 static int decode_slice(AVCodecContext *c, void *arg){
1401 FFV1Context *fs= *(void**)arg;
1402 FFV1Context *f= fs->avctx->priv_data;
1403 int width = fs->slice_width;
1404 int height= fs->slice_height;
1407 const int ps= (c->bits_per_raw_sample>8)+1;
1408 AVFrame * const p= &f->picture;
1410 av_assert1(width && height);
1411 if(f->colorspace==0){
1412 const int chroma_width = -((-width )>>f->chroma_h_shift);
1413 const int chroma_height= -((-height)>>f->chroma_v_shift);
1414 const int cx= x>>f->chroma_h_shift;
1415 const int cy= y>>f->chroma_v_shift;
1416 decode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0);
1418 decode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
1419 decode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[2], 1);
1421 decode_rgb_frame(fs, (uint32_t*)p->data[0] + ps*x + y*(p->linesize[0]/4), width, height, p->linesize[0]/4);
1429 static int read_quant_table(RangeCoder *c, int16_t *quant_table, int scale){
1432 uint8_t state[CONTEXT_SIZE];
1434 memset(state, 128, sizeof(state));
1436 for(v=0; i<128 ; v++){
1437 int len= get_symbol(c, state, 0) + 1;
1439 if(len + i > 128) return -1;
1442 quant_table[i] = scale*v;
1445 //if(i%16==0) printf("\n");
1449 for(i=1; i<128; i++){
1450 quant_table[256-i]= -quant_table[i];
1452 quant_table[128]= -quant_table[127];
1457 static int read_quant_tables(RangeCoder *c, int16_t quant_table[MAX_CONTEXT_INPUTS][256]){
1459 int context_count=1;
1462 context_count*= read_quant_table(c, quant_table[i], context_count);
1463 if(context_count > 32768U){
1467 return (context_count+1)/2;
1470 static int read_extra_header(FFV1Context *f){
1471 RangeCoder * const c= &f->c;
1472 uint8_t state[CONTEXT_SIZE];
1474 uint8_t state2[32][CONTEXT_SIZE];
1476 memset(state2, 128, sizeof(state2));
1477 memset(state, 128, sizeof(state));
1479 ff_init_range_decoder(c, f->avctx->extradata, f->avctx->extradata_size);
1480 ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1482 f->version= get_symbol(c, state, 0);
1483 f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
1485 for(i=1; i<256; i++){
1486 f->state_transition[i]= get_symbol(c, state, 1) + c->one_state[i];
1489 f->colorspace= get_symbol(c, state, 0); //YUV cs type
1490 f->avctx->bits_per_raw_sample= get_symbol(c, state, 0);
1491 get_rac(c, state); //no chroma = false
1492 f->chroma_h_shift= get_symbol(c, state, 0);
1493 f->chroma_v_shift= get_symbol(c, state, 0);
1494 get_rac(c, state); //transparency plane
1496 f->num_h_slices= 1 + get_symbol(c, state, 0);
1497 f->num_v_slices= 1 + get_symbol(c, state, 0);
1498 if(f->num_h_slices > (unsigned)f->width || f->num_v_slices > (unsigned)f->height){
1499 av_log(f->avctx, AV_LOG_ERROR, "too many slices\n");
1503 f->quant_table_count= get_symbol(c, state, 0);
1504 if(f->quant_table_count > (unsigned)MAX_QUANT_TABLES)
1506 for(i=0; i<f->quant_table_count; i++){
1507 if((f->context_count[i]= read_quant_tables(c, f->quant_tables[i])) < 0){
1508 av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
1513 if(allocate_initial_states(f) < 0)
1514 return AVERROR(ENOMEM);
1516 for(i=0; i<f->quant_table_count; i++){
1517 if(get_rac(c, state)){
1518 for(j=0; j<f->context_count[i]; j++){
1519 for(k=0; k<CONTEXT_SIZE; k++){
1520 int pred= j ? f->initial_states[i][j-1][k] : 128;
1521 f->initial_states[i][j][k]= (pred+get_symbol(c, state2[k], 1))&0xFF;
1530 static int read_header(FFV1Context *f){
1531 uint8_t state[CONTEXT_SIZE];
1532 int i, j, context_count;
1533 RangeCoder * const c= &f->slice_context[0]->c;
1535 memset(state, 128, sizeof(state));
1538 f->version= get_symbol(c, state, 0);
1539 f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
1541 for(i=1; i<256; i++){
1542 f->state_transition[i]= get_symbol(c, state, 1) + c->one_state[i];
1545 f->colorspace= get_symbol(c, state, 0); //YUV cs type
1547 f->avctx->bits_per_raw_sample= get_symbol(c, state, 0);
1548 get_rac(c, state); //no chroma = false
1549 f->chroma_h_shift= get_symbol(c, state, 0);
1550 f->chroma_v_shift= get_symbol(c, state, 0);
1551 get_rac(c, state); //transparency plane
1555 if(f->colorspace==0){
1556 if(f->avctx->bits_per_raw_sample<=8){
1557 switch(16*f->chroma_h_shift + f->chroma_v_shift){
1558 case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P; break;
1559 case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P; break;
1560 case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P; break;
1561 case 0x20: f->avctx->pix_fmt= PIX_FMT_YUV411P; break;
1562 case 0x22: f->avctx->pix_fmt= PIX_FMT_YUV410P; break;
1564 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1567 }else if(f->avctx->bits_per_raw_sample==9) {
1568 switch(16*f->chroma_h_shift + f->chroma_v_shift){
1569 case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P16; break;
1570 case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P16; break;
1571 case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P9 ; f->packed_at_lsb=1; break;
1573 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1576 }else if(f->avctx->bits_per_raw_sample==10) {
1577 switch(16*f->chroma_h_shift + f->chroma_v_shift){
1578 case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P16; break;
1579 case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P10; f->packed_at_lsb=1; break;
1580 case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P10; f->packed_at_lsb=1; break;
1582 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1586 switch(16*f->chroma_h_shift + f->chroma_v_shift){
1587 case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P16; break;
1588 case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P16; break;
1589 case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P16; break;
1591 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1595 }else if(f->colorspace==1){
1596 if(f->chroma_h_shift || f->chroma_v_shift){
1597 av_log(f->avctx, AV_LOG_ERROR, "chroma subsampling not supported in this colorspace\n");
1600 f->avctx->pix_fmt= PIX_FMT_RGB32;
1602 av_log(f->avctx, AV_LOG_ERROR, "colorspace not supported\n");
1606 //printf("%d %d %d\n", f->chroma_h_shift, f->chroma_v_shift,f->avctx->pix_fmt);
1608 context_count= read_quant_tables(c, f->quant_table);
1609 if(context_count < 0){
1610 av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
1614 f->slice_count= get_symbol(c, state, 0);
1615 if(f->slice_count > (unsigned)MAX_SLICES)
1619 for(j=0; j<f->slice_count; j++){
1620 FFV1Context *fs= f->slice_context[j];
1622 fs->packed_at_lsb= f->packed_at_lsb;
1624 if(f->version >= 2){
1625 fs->slice_x = get_symbol(c, state, 0) *f->width ;
1626 fs->slice_y = get_symbol(c, state, 0) *f->height;
1627 fs->slice_width =(get_symbol(c, state, 0)+1)*f->width + fs->slice_x;
1628 fs->slice_height=(get_symbol(c, state, 0)+1)*f->height + fs->slice_y;
1630 fs->slice_x /= f->num_h_slices;
1631 fs->slice_y /= f->num_v_slices;
1632 fs->slice_width = fs->slice_width /f->num_h_slices - fs->slice_x;
1633 fs->slice_height = fs->slice_height/f->num_v_slices - fs->slice_y;
1634 if((unsigned)fs->slice_width > f->width || (unsigned)fs->slice_height > f->height)
1636 if( (unsigned)fs->slice_x + (uint64_t)fs->slice_width > f->width
1637 || (unsigned)fs->slice_y + (uint64_t)fs->slice_height > f->height)
1641 for(i=0; i<f->plane_count; i++){
1642 PlaneContext * const p= &fs->plane[i];
1644 if(f->version >= 2){
1645 int idx=get_symbol(c, state, 0);
1646 if(idx > (unsigned)f->quant_table_count){
1647 av_log(f->avctx, AV_LOG_ERROR, "quant_table_index out of range\n");
1650 p->quant_table_index= idx;
1651 memcpy(p->quant_table, f->quant_tables[idx], sizeof(p->quant_table));
1652 context_count= f->context_count[idx];
1654 memcpy(p->quant_table, f->quant_table, sizeof(p->quant_table));
1657 if(p->context_count < context_count){
1658 av_freep(&p->state);
1659 av_freep(&p->vlc_state);
1661 p->context_count= context_count;
1668 static av_cold int decode_init(AVCodecContext *avctx)
1670 FFV1Context *f = avctx->priv_data;
1674 if(avctx->extradata && read_extra_header(f) < 0)
1677 if(init_slice_contexts(f) < 0)
1683 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){
1684 const uint8_t *buf = avpkt->data;
1685 int buf_size = avpkt->size;
1686 FFV1Context *f = avctx->priv_data;
1687 RangeCoder * const c= &f->slice_context[0]->c;
1688 AVFrame * const p= &f->picture;
1690 uint8_t keystate= 128;
1691 const uint8_t *buf_p;
1693 AVFrame *picture = data;
1695 /* release previously stored data */
1697 avctx->release_buffer(avctx, p);
1699 ff_init_range_decoder(c, buf, buf_size);
1700 ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1703 p->pict_type= AV_PICTURE_TYPE_I; //FIXME I vs. P
1704 if(get_rac(c, &keystate)){
1706 if(read_header(f) < 0)
1708 if(init_slice_state(f) < 0)
1717 for(i=1; i<256; i++){
1718 c->one_state[i]= f->state_transition[i];
1719 c->zero_state[256-i]= 256-c->one_state[i];
1724 if(avctx->get_buffer(avctx, p) < 0){
1725 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1729 if(avctx->debug&FF_DEBUG_PICT_INFO)
1730 av_log(avctx, AV_LOG_ERROR, "keyframe:%d coder:%d\n", p->key_frame, f->ac);
1733 bytes_read = c->bytestream - c->bytestream_start - 1;
1734 if(bytes_read ==0) av_log(avctx, AV_LOG_ERROR, "error at end of AC stream\n"); //FIXME
1735 //printf("pos=%d\n", bytes_read);
1736 init_get_bits(&f->slice_context[0]->gb, buf + bytes_read, (buf_size - bytes_read) * 8);
1738 bytes_read = 0; /* avoid warning */
1741 buf_p= buf + buf_size;
1742 for(i=f->slice_count-1; i>0; i--){
1743 FFV1Context *fs= f->slice_context[i];
1744 int v= AV_RB24(buf_p-3)+3;
1745 if(buf_p - buf <= v){
1746 av_log(avctx, AV_LOG_ERROR, "Slice pointer chain broken\n");
1751 ff_init_range_decoder(&fs->c, buf_p, v);
1753 init_get_bits(&fs->gb, buf_p, v * 8);
1757 avctx->execute(avctx, decode_slice, &f->slice_context[0], NULL, f->slice_count, sizeof(void*));
1758 f->picture_number++;
1761 *data_size = sizeof(AVFrame);
1766 AVCodec ff_ffv1_decoder = {
1768 .type = AVMEDIA_TYPE_VIDEO,
1769 .id = CODEC_ID_FFV1,
1770 .priv_data_size = sizeof(FFV1Context),
1771 .init = decode_init,
1772 .close = common_end,
1773 .decode = decode_frame,
1774 .capabilities = CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/ | CODEC_CAP_SLICE_THREADS,
1775 .long_name= NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1778 #if CONFIG_FFV1_ENCODER
1779 AVCodec ff_ffv1_encoder = {
1781 .type = AVMEDIA_TYPE_VIDEO,
1782 .id = CODEC_ID_FFV1,
1783 .priv_data_size = sizeof(FFV1Context),
1784 .init = encode_init,
1785 .encode = encode_frame,
1786 .close = common_end,
1787 .capabilities = CODEC_CAP_SLICE_THREADS,
1788 .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_YUV444P, PIX_FMT_YUV422P, PIX_FMT_YUV411P, PIX_FMT_YUV410P, PIX_FMT_RGB32, PIX_FMT_YUV420P16, PIX_FMT_YUV422P16, PIX_FMT_YUV444P16, PIX_FMT_YUV420P9, PIX_FMT_YUV420P10, PIX_FMT_YUV422P10, PIX_FMT_NONE},
1789 .long_name= NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),