2 * FFV1 codec for libavcodec
4 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
6 * This file is part of Libav.
8 * Libav 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 * Libav 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 Libav; 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;
184 int quant_table_count;
188 struct FFV1Context *slice_context[MAX_SLICES];
198 static av_always_inline int fold(int diff, int bits){
210 static inline int predict(int16_t *src, int16_t *last)
212 const int LT= last[-1];
213 const int T= last[ 0];
214 const int L = src[-1];
216 return mid_pred(L, L + T - LT, T);
219 static inline int get_context(PlaneContext *p, int16_t *src,
220 int16_t *last, int16_t *last2)
222 const int LT= last[-1];
223 const int T= last[ 0];
224 const int RT= last[ 1];
225 const int L = src[-1];
227 if(p->quant_table[3][127]){
228 const int TT= last2[0];
229 const int LL= src[-2];
230 return p->quant_table[0][(L-LT) & 0xFF] + p->quant_table[1][(LT-T) & 0xFF] + p->quant_table[2][(T-RT) & 0xFF]
231 +p->quant_table[3][(LL-L) & 0xFF] + p->quant_table[4][(TT-T) & 0xFF];
233 return p->quant_table[0][(L-LT) & 0xFF] + p->quant_table[1][(LT-T) & 0xFF] + p->quant_table[2][(T-RT) & 0xFF];
236 static void find_best_state(uint8_t best_state[256][256], const uint8_t one_state[256]){
241 l2tab[i]= log2(i/256.0);
243 for(i=0; i<256; i++){
244 double best_len[256];
250 for(j=FFMAX(i-10,1); j<FFMIN(i+11,256); j++){
254 for(k=0; k<256; k++){
255 double newocc[256]={0};
256 for(m=0; m<256; m++){
258 len -=occ[m]*( p *l2tab[ m]
259 + (1-p)*l2tab[256-m]);
262 if(len < best_len[k]){
266 for(m=0; m<256; m++){
268 newocc[ one_state[ m]] += occ[m]* p ;
269 newocc[256-one_state[256-m]] += occ[m]*(1-p);
272 memcpy(occ, newocc, sizeof(occ));
278 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]){
281 #define put_rac(C,S,B) \
285 rc_stat2[(S)-state][B]++;\
291 const int a= FFABS(v);
292 const int e= av_log2(a);
293 put_rac(c, state+0, 0);
296 put_rac(c, state+1+i, 1); //1..10
298 put_rac(c, state+1+i, 0);
300 for(i=e-1; i>=0; i--){
301 put_rac(c, state+22+i, (a>>i)&1); //22..31
305 put_rac(c, state+11 + e, v < 0); //11..21
308 put_rac(c, state+1+FFMIN(i,9), 1); //1..10
310 put_rac(c, state+1+9, 0);
312 for(i=e-1; i>=0; i--){
313 put_rac(c, state+22+FFMIN(i,9), (a>>i)&1); //22..31
317 put_rac(c, state+11 + 10, v < 0); //11..21
320 put_rac(c, state+0, 1);
325 static void av_noinline put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed){
326 put_symbol_inline(c, state, v, is_signed, NULL, NULL);
329 static inline av_flatten int get_symbol_inline(RangeCoder *c, uint8_t *state, int is_signed){
330 if(get_rac(c, state+0))
335 while(get_rac(c, state+1 + FFMIN(e,9))){ //1..10
340 for(i=e-1; i>=0; i--){
341 a += a + get_rac(c, state+22 + FFMIN(i,9)); //22..31
344 e= -(is_signed && get_rac(c, state+11 + FFMIN(e, 10))); //11..21
349 static int av_noinline get_symbol(RangeCoder *c, uint8_t *state, int is_signed){
350 return get_symbol_inline(c, state, is_signed);
353 static inline void update_vlc_state(VlcState * const state, const int v){
354 int drift= state->drift;
355 int count= state->count;
356 state->error_sum += FFABS(v);
359 if(count == 128){ //FIXME variable
362 state->error_sum >>= 1;
367 if(state->bias > -128) state->bias--;
373 if(state->bias < 127) state->bias++;
384 static inline void put_vlc_symbol(PutBitContext *pb, VlcState * const state, int v, int bits){
386 //printf("final: %d ", v);
387 v = fold(v - state->bias, bits);
391 while(i < state->error_sum){ //FIXME optimize
399 if(k==0 && 2*state->drift <= - state->count) code= v ^ (-1);
402 code= v ^ ((2*state->drift + state->count)>>31);
405 //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);
406 set_sr_golomb(pb, code, k, 12, bits);
408 update_vlc_state(state, v);
411 static inline int get_vlc_symbol(GetBitContext *gb, VlcState * const state, int bits){
416 while(i < state->error_sum){ //FIXME optimize
423 v= get_sr_golomb(gb, k, 12, bits);
424 //printf("v:%d bias:%d error:%d drift:%d count:%d k:%d", v, state->bias, state->error_sum, state->drift, state->count, k);
427 if(k==0 && 2*state->drift <= - state->count) v ^= (-1);
429 v ^= ((2*state->drift + state->count)>>31);
432 ret= fold(v + state->bias, bits);
434 update_vlc_state(state, v);
435 //printf("final: %d\n", ret);
439 #if CONFIG_FFV1_ENCODER
440 static av_always_inline int encode_line(FFV1Context *s, int w,
442 int plane_index, int bits)
444 PlaneContext * const p= &s->plane[plane_index];
445 RangeCoder * const c= &s->c;
447 int run_index= s->run_index;
452 if(c->bytestream_end - c->bytestream < w*20){
453 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
457 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < w*4){
458 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
466 context= get_context(p, sample[0]+x, sample[1]+x, sample[2]+x);
467 diff= sample[0][x] - predict(sample[0]+x, sample[1]+x);
474 diff= fold(diff, bits);
477 if(s->flags & CODEC_FLAG_PASS1){
478 put_symbol_inline(c, p->state[context], diff, 1, s->rc_stat, s->rc_stat2[p->quant_table_index][context]);
480 put_symbol_inline(c, p->state[context], diff, 1, NULL, NULL);
483 if(context == 0) run_mode=1;
488 while(run_count >= 1<<ff_log2_run[run_index]){
489 run_count -= 1<<ff_log2_run[run_index];
491 put_bits(&s->pb, 1, 1);
494 put_bits(&s->pb, 1 + ff_log2_run[run_index], run_count);
495 if(run_index) run_index--;
504 // 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));
507 put_vlc_symbol(&s->pb, &p->vlc_state[context], diff, bits);
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);
518 put_bits(&s->pb, 1, 1);
520 s->run_index= run_index;
525 static void encode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
527 const int ring_size= s->avctx->context_model ? 3 : 2;
531 memset(s->sample_buffer, 0, ring_size*(w+6)*sizeof(*s->sample_buffer));
534 for(i=0; i<ring_size; i++)
535 sample[i]= s->sample_buffer + (w+6)*((h+i-y)%ring_size) + 3;
537 sample[0][-1]= sample[1][0 ];
538 sample[1][ w]= sample[1][w-1];
540 if(s->avctx->bits_per_raw_sample<=8){
542 sample[0][x]= src[x + stride*y];
544 encode_line(s, w, sample, plane_index, 8);
547 sample[0][x]= ((uint16_t*)(src + stride*y))[x] >> (16 - s->avctx->bits_per_raw_sample);
549 encode_line(s, w, sample, plane_index, s->avctx->bits_per_raw_sample);
551 //STOP_TIMER("encode line")}
555 static void encode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
557 const int ring_size= s->avctx->context_model ? 3 : 2;
558 int16_t *sample[3][3];
561 memset(s->sample_buffer, 0, ring_size*3*(w+6)*sizeof(*s->sample_buffer));
564 for(i=0; i<ring_size; i++)
566 sample[p][i]= s->sample_buffer + p*ring_size*(w+6) + ((h+i-y)%ring_size)*(w+6) + 3;
569 int v= src[x + stride*y];
580 // assert(g>=0 && b>=0 && r>=0);
581 // assert(g<256 && b<512 && r<512);
587 sample[p][0][-1]= sample[p][1][0 ];
588 sample[p][1][ w]= sample[p][1][w-1];
589 encode_line(s, w, sample[p], FFMIN(p, 1), 9);
594 static void write_quant_table(RangeCoder *c, int16_t *quant_table){
597 uint8_t state[CONTEXT_SIZE];
598 memset(state, 128, sizeof(state));
600 for(i=1; i<128 ; i++){
601 if(quant_table[i] != quant_table[i-1]){
602 put_symbol(c, state, i-last-1, 0);
606 put_symbol(c, state, i-last-1, 0);
609 static void write_quant_tables(RangeCoder *c, int16_t quant_table[MAX_CONTEXT_INPUTS][256]){
612 write_quant_table(c, quant_table[i]);
615 static void write_header(FFV1Context *f){
616 uint8_t state[CONTEXT_SIZE];
618 RangeCoder * const c= &f->slice_context[0]->c;
620 memset(state, 128, sizeof(state));
623 put_symbol(c, state, f->version, 0);
624 put_symbol(c, state, f->ac, 0);
626 for(i=1; i<256; i++){
627 put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
630 put_symbol(c, state, f->colorspace, 0); //YUV cs type
632 put_symbol(c, state, f->avctx->bits_per_raw_sample, 0);
633 put_rac(c, state, 1); //chroma planes
634 put_symbol(c, state, f->chroma_h_shift, 0);
635 put_symbol(c, state, f->chroma_v_shift, 0);
636 put_rac(c, state, 0); //no transparency plane
638 write_quant_tables(c, f->quant_table);
640 put_symbol(c, state, f->slice_count, 0);
641 for(i=0; i<f->slice_count; i++){
642 FFV1Context *fs= f->slice_context[i];
643 put_symbol(c, state, (fs->slice_x +1)*f->num_h_slices / f->width , 0);
644 put_symbol(c, state, (fs->slice_y +1)*f->num_v_slices / f->height , 0);
645 put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
646 put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
647 for(j=0; j<f->plane_count; j++){
648 put_symbol(c, state, f->plane[j].quant_table_index, 0);
649 av_assert0(f->plane[j].quant_table_index == f->avctx->context_model);
654 #endif /* CONFIG_FFV1_ENCODER */
656 static av_cold int common_init(AVCodecContext *avctx){
657 FFV1Context *s = avctx->priv_data;
660 s->flags= avctx->flags;
662 dsputil_init(&s->dsp, avctx);
664 s->width = avctx->width;
665 s->height= avctx->height;
667 assert(s->width && s->height);
676 static int init_slice_state(FFV1Context *f){
679 for(i=0; i<f->slice_count; i++){
680 FFV1Context *fs= f->slice_context[i];
681 for(j=0; j<f->plane_count; j++){
682 PlaneContext * const p= &fs->plane[j];
685 if(!p-> state) p-> state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
687 return AVERROR(ENOMEM);
689 if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
691 return AVERROR(ENOMEM);
696 //FIXME only redo if state_transition changed
697 for(j=1; j<256; j++){
698 fs->c.one_state [ j]= fs->state_transition[j];
699 fs->c.zero_state[256-j]= 256-fs->c.one_state [j];
707 static av_cold int init_slice_contexts(FFV1Context *f){
710 f->slice_count= f->num_h_slices * f->num_v_slices;
712 for(i=0; i<f->slice_count; i++){
713 FFV1Context *fs= av_mallocz(sizeof(*fs));
714 int sx= i % f->num_h_slices;
715 int sy= i / f->num_h_slices;
716 int sxs= f->avctx->width * sx / f->num_h_slices;
717 int sxe= f->avctx->width *(sx+1) / f->num_h_slices;
718 int sys= f->avctx->height* sy / f->num_v_slices;
719 int sye= f->avctx->height*(sy+1) / f->num_v_slices;
720 f->slice_context[i]= fs;
721 memcpy(fs, f, sizeof(*fs));
722 memset(fs->rc_stat2, 0, sizeof(fs->rc_stat2));
724 fs->slice_width = sxe - sxs;
725 fs->slice_height= sye - sys;
729 fs->sample_buffer = av_malloc(9 * (fs->width+6) * sizeof(*fs->sample_buffer));
730 if (!fs->sample_buffer)
731 return AVERROR(ENOMEM);
736 static int allocate_initial_states(FFV1Context *f){
739 for(i=0; i<f->quant_table_count; i++){
740 f->initial_states[i]= av_malloc(f->context_count[i]*sizeof(*f->initial_states[i]));
741 if(!f->initial_states[i])
742 return AVERROR(ENOMEM);
743 memset(f->initial_states[i], 128, f->context_count[i]*sizeof(*f->initial_states[i]));
748 #if CONFIG_FFV1_ENCODER
749 static int write_extra_header(FFV1Context *f){
750 RangeCoder * const c= &f->c;
751 uint8_t state[CONTEXT_SIZE];
753 uint8_t state2[32][CONTEXT_SIZE];
755 memset(state2, 128, sizeof(state2));
756 memset(state, 128, sizeof(state));
758 f->avctx->extradata= av_malloc(f->avctx->extradata_size= 10000 + (11*11*5*5*5+11*11*11)*32);
759 ff_init_range_encoder(c, f->avctx->extradata, f->avctx->extradata_size);
760 ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
762 put_symbol(c, state, f->version, 0);
763 put_symbol(c, state, f->ac, 0);
765 for(i=1; i<256; i++){
766 put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
769 put_symbol(c, state, f->colorspace, 0); //YUV cs type
770 put_symbol(c, state, f->avctx->bits_per_raw_sample, 0);
771 put_rac(c, state, 1); //chroma planes
772 put_symbol(c, state, f->chroma_h_shift, 0);
773 put_symbol(c, state, f->chroma_v_shift, 0);
774 put_rac(c, state, 0); //no transparency plane
775 put_symbol(c, state, f->num_h_slices-1, 0);
776 put_symbol(c, state, f->num_v_slices-1, 0);
778 put_symbol(c, state, f->quant_table_count, 0);
779 for(i=0; i<f->quant_table_count; i++)
780 write_quant_tables(c, f->quant_tables[i]);
782 for(i=0; i<f->quant_table_count; i++){
783 for(j=0; j<f->context_count[i]*CONTEXT_SIZE; j++)
784 if(f->initial_states[i] && f->initial_states[i][0][j] != 128)
786 if(j<f->context_count[i]*CONTEXT_SIZE){
787 put_rac(c, state, 1);
788 for(j=0; j<f->context_count[i]; j++){
789 for(k=0; k<CONTEXT_SIZE; k++){
790 int pred= j ? f->initial_states[i][j-1][k] : 128;
791 put_symbol(c, state2[k], (int8_t)(f->initial_states[i][j][k]-pred), 1);
795 put_rac(c, state, 0);
799 f->avctx->extradata_size= ff_rac_terminate(c);
804 static int sort_stt(FFV1Context *s, uint8_t stt[256]){
805 int i,i2,changed,print=0;
809 for(i=12; i<244; i++){
810 for(i2=i+1; i2<245 && i2<i+4; i2++){
811 #define COST(old, new) \
812 s->rc_stat[old][0]*-log2((256-(new))/256.0)\
813 +s->rc_stat[old][1]*-log2( (new) /256.0)
815 #define COST2(old, new) \
817 +COST(256-(old), 256-(new))
819 double size0= COST2(i, i ) + COST2(i2, i2);
820 double sizeX= COST2(i, i2) + COST2(i2, i );
821 if(sizeX < size0 && i!=128 && i2!=128){
823 FFSWAP(int, stt[ i], stt[ i2]);
824 FFSWAP(int, s->rc_stat[i ][0],s->rc_stat[ i2][0]);
825 FFSWAP(int, s->rc_stat[i ][1],s->rc_stat[ i2][1]);
827 FFSWAP(int, stt[256-i], stt[256-i2]);
828 FFSWAP(int, s->rc_stat[256-i][0],s->rc_stat[256-i2][0]);
829 FFSWAP(int, s->rc_stat[256-i][1],s->rc_stat[256-i2][1]);
831 for(j=1; j<256; j++){
832 if (stt[j] == i ) stt[j] = i2;
833 else if(stt[j] == i2) stt[j] = i ;
835 if (stt[256-j] == 256-i ) stt[256-j] = 256-i2;
836 else if(stt[256-j] == 256-i2) stt[256-j] = 256-i ;
847 static av_cold int encode_init(AVCodecContext *avctx)
849 FFV1Context *s = avctx->priv_data;
855 s->ac= avctx->coder_type ? 2:0;
859 s->state_transition[i]=ver2_state[i];
862 for(i=0; i<256; i++){
863 s->quant_table_count=2;
864 if(avctx->bits_per_raw_sample <=8){
865 s->quant_tables[0][0][i]= quant11[i];
866 s->quant_tables[0][1][i]= 11*quant11[i];
867 s->quant_tables[0][2][i]= 11*11*quant11[i];
868 s->quant_tables[1][0][i]= quant11[i];
869 s->quant_tables[1][1][i]= 11*quant11[i];
870 s->quant_tables[1][2][i]= 11*11*quant5 [i];
871 s->quant_tables[1][3][i]= 5*11*11*quant5 [i];
872 s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
874 s->quant_tables[0][0][i]= quant9_10bit[i];
875 s->quant_tables[0][1][i]= 11*quant9_10bit[i];
876 s->quant_tables[0][2][i]= 11*11*quant9_10bit[i];
877 s->quant_tables[1][0][i]= quant9_10bit[i];
878 s->quant_tables[1][1][i]= 11*quant9_10bit[i];
879 s->quant_tables[1][2][i]= 11*11*quant5_10bit[i];
880 s->quant_tables[1][3][i]= 5*11*11*quant5_10bit[i];
881 s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
884 s->context_count[0]= (11*11*11+1)/2;
885 s->context_count[1]= (11*11*5*5*5+1)/2;
886 memcpy(s->quant_table, s->quant_tables[avctx->context_model], sizeof(s->quant_table));
888 for(i=0; i<s->plane_count; i++){
889 PlaneContext * const p= &s->plane[i];
891 memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
892 p->quant_table_index= avctx->context_model;
893 p->context_count= s->context_count[p->quant_table_index];
896 if(allocate_initial_states(s) < 0)
897 return AVERROR(ENOMEM);
899 avctx->coded_frame= &s->picture;
900 switch(avctx->pix_fmt){
901 case PIX_FMT_YUV444P16:
902 case PIX_FMT_YUV422P16:
903 case PIX_FMT_YUV420P16:
904 if(avctx->bits_per_raw_sample <=8){
905 av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
909 av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample of more than 8 needs -coder 1 currently\n");
912 s->version= FFMAX(s->version, 1);
913 case PIX_FMT_YUV444P:
914 case PIX_FMT_YUV422P:
915 case PIX_FMT_YUV420P:
916 case PIX_FMT_YUV411P:
917 case PIX_FMT_YUV410P:
924 av_log(avctx, AV_LOG_ERROR, "format not supported\n");
927 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
931 if(avctx->flags & (CODEC_FLAG_PASS1|CODEC_FLAG_PASS2)){
932 for(i=0; i<s->quant_table_count; i++){
933 s->rc_stat2[i]= av_mallocz(s->context_count[i]*sizeof(*s->rc_stat2[i]));
935 return AVERROR(ENOMEM);
939 char *p= avctx->stats_in;
940 uint8_t best_state[256][256];
944 av_assert0(s->version>=2);
947 for(j=0; j<256; j++){
949 s->rc_stat[j][i]= strtol(p, &next, 0);
951 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid at %d %d [%s]\n", j,i,p);
957 for(i=0; i<s->quant_table_count; i++){
958 for(j=0; j<s->context_count[i]; j++){
961 s->rc_stat2[i][j][k][m]= strtol(p, &next, 0);
963 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid at %d %d %d %d [%s]\n", i,j,k,m,p);
971 gob_count= strtol(p, &next, 0);
972 if(next==p || gob_count <0){
973 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
977 while(*p=='\n' || *p==' ') p++;
980 sort_stt(s, s->state_transition);
982 find_best_state(best_state, s->state_transition);
984 for(i=0; i<s->quant_table_count; i++){
985 for(j=0; j<s->context_count[i]; j++){
988 if(s->rc_stat2[i][j][k][0]+s->rc_stat2[i][j][k][1]){
989 p=256.0*s->rc_stat2[i][j][k][1] / (s->rc_stat2[i][j][k][0]+s->rc_stat2[i][j][k][1]);
991 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)];
1000 write_extra_header(s);
1003 if(init_slice_contexts(s) < 0)
1005 if(init_slice_state(s) < 0)
1008 #define STATS_OUT_SIZE 1024*1024*6
1009 if(avctx->flags & CODEC_FLAG_PASS1){
1010 avctx->stats_out= av_mallocz(STATS_OUT_SIZE);
1011 for(i=0; i<s->quant_table_count; i++){
1012 for(j=0; j<s->slice_count; j++){
1013 FFV1Context *sf= s->slice_context[j];
1014 av_assert0(!sf->rc_stat2[i]);
1015 sf->rc_stat2[i]= av_mallocz(s->context_count[i]*sizeof(*sf->rc_stat2[i]));
1016 if(!sf->rc_stat2[i])
1017 return AVERROR(ENOMEM);
1024 #endif /* CONFIG_FFV1_ENCODER */
1027 static void clear_state(FFV1Context *f){
1030 for(si=0; si<f->slice_count; si++){
1031 FFV1Context *fs= f->slice_context[si];
1032 for(i=0; i<f->plane_count; i++){
1033 PlaneContext *p= &fs->plane[i];
1035 p->interlace_bit_state[0]= 128;
1036 p->interlace_bit_state[1]= 128;
1039 if(f->initial_states[p->quant_table_index]){
1040 memcpy(p->state, f->initial_states[p->quant_table_index], CONTEXT_SIZE*p->context_count);
1042 memset(p->state, 128, CONTEXT_SIZE*p->context_count);
1044 for(j=0; j<p->context_count; j++){
1045 p->vlc_state[j].drift= 0;
1046 p->vlc_state[j].error_sum= 4; //FFMAX((RANGE + 32)/64, 2);
1047 p->vlc_state[j].bias= 0;
1048 p->vlc_state[j].count= 1;
1055 #if CONFIG_FFV1_ENCODER
1056 static int encode_slice(AVCodecContext *c, void *arg){
1057 FFV1Context *fs= *(void**)arg;
1058 FFV1Context *f= fs->avctx->priv_data;
1059 int width = fs->slice_width;
1060 int height= fs->slice_height;
1063 AVFrame * const p= &f->picture;
1065 if(f->colorspace==0){
1066 const int chroma_width = -((-width )>>f->chroma_h_shift);
1067 const int chroma_height= -((-height)>>f->chroma_v_shift);
1068 const int cx= x>>f->chroma_h_shift;
1069 const int cy= y>>f->chroma_v_shift;
1071 encode_plane(fs, p->data[0] + x + y*p->linesize[0], width, height, p->linesize[0], 0);
1073 encode_plane(fs, p->data[1] + cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
1074 encode_plane(fs, p->data[2] + cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1);
1076 encode_rgb_frame(fs, (uint32_t*)(p->data[0]) + x + y*(p->linesize[0]/4), width, height, p->linesize[0]/4);
1083 static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
1084 FFV1Context *f = avctx->priv_data;
1085 RangeCoder * const c= &f->slice_context[0]->c;
1086 AVFrame *pict = data;
1087 AVFrame * const p= &f->picture;
1089 uint8_t keystate=128;
1093 ff_init_range_encoder(c, buf, buf_size);
1094 ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1097 p->pict_type= AV_PICTURE_TYPE_I;
1099 if(avctx->gop_size==0 || f->picture_number % avctx->gop_size == 0){
1100 put_rac(c, &keystate, 1);
1106 put_rac(c, &keystate, 0);
1111 used_count += ff_rac_terminate(c);
1112 //printf("pos=%d\n", used_count);
1113 init_put_bits(&f->slice_context[0]->pb, buf + used_count, buf_size - used_count);
1116 for(i=1; i<256; i++){
1117 c->one_state[i]= f->state_transition[i];
1118 c->zero_state[256-i]= 256-c->one_state[i];
1122 for(i=1; i<f->slice_count; i++){
1123 FFV1Context *fs= f->slice_context[i];
1124 uint8_t *start= buf + (buf_size-used_count)*i/f->slice_count;
1125 int len= buf_size/f->slice_count;
1128 ff_init_range_encoder(&fs->c, start, len);
1130 init_put_bits(&fs->pb, start, len);
1133 avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL, f->slice_count, sizeof(void*));
1136 for(i=0; i<f->slice_count; i++){
1137 FFV1Context *fs= f->slice_context[i];
1142 put_rac(&fs->c, &state, 0);
1143 bytes= ff_rac_terminate(&fs->c);
1145 flush_put_bits(&fs->pb); //nicer padding FIXME
1146 bytes= used_count + (put_bits_count(&fs->pb)+7)/8;
1150 av_assert0(bytes < buf_size/f->slice_count);
1151 memmove(buf_p, fs->ac ? fs->c.bytestream_start : fs->pb.buf, bytes);
1152 av_assert0(bytes < (1<<24));
1153 AV_WB24(buf_p+bytes, bytes);
1159 if((avctx->flags&CODEC_FLAG_PASS1) && (f->picture_number&31)==0){
1161 char *p= avctx->stats_out;
1162 char *end= p + STATS_OUT_SIZE;
1164 memset(f->rc_stat, 0, sizeof(f->rc_stat));
1165 for(i=0; i<f->quant_table_count; i++)
1166 memset(f->rc_stat2[i], 0, f->context_count[i]*sizeof(*f->rc_stat2[i]));
1168 for(j=0; j<f->slice_count; j++){
1169 FFV1Context *fs= f->slice_context[j];
1170 for(i=0; i<256; i++){
1171 f->rc_stat[i][0] += fs->rc_stat[i][0];
1172 f->rc_stat[i][1] += fs->rc_stat[i][1];
1174 for(i=0; i<f->quant_table_count; i++){
1175 for(k=0; k<f->context_count[i]; k++){
1176 for(m=0; m<32; m++){
1177 f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1178 f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1184 for(j=0; j<256; j++){
1185 snprintf(p, end-p, "%"PRIu64" %"PRIu64" ", f->rc_stat[j][0], f->rc_stat[j][1]);
1188 snprintf(p, end-p, "\n");
1190 for(i=0; i<f->quant_table_count; i++){
1191 for(j=0; j<f->context_count[i]; j++){
1192 for(m=0; m<32; m++){
1193 snprintf(p, end-p, "%"PRIu64" %"PRIu64" ", f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1198 snprintf(p, end-p, "%d\n", f->gob_count);
1199 } else if(avctx->flags&CODEC_FLAG_PASS1)
1200 avctx->stats_out[0] = '\0';
1202 f->picture_number++;
1205 #endif /* CONFIG_FFV1_ENCODER */
1207 static av_cold int common_end(AVCodecContext *avctx){
1208 FFV1Context *s = avctx->priv_data;
1211 if (avctx->codec->decode && s->picture.data[0])
1212 avctx->release_buffer(avctx, &s->picture);
1214 for(j=0; j<s->slice_count; j++){
1215 FFV1Context *fs= s->slice_context[j];
1216 for(i=0; i<s->plane_count; i++){
1217 PlaneContext *p= &fs->plane[i];
1219 av_freep(&p->state);
1220 av_freep(&p->vlc_state);
1222 av_freep(&fs->sample_buffer);
1225 av_freep(&avctx->stats_out);
1226 for(j=0; j<s->quant_table_count; j++){
1227 av_freep(&s->initial_states[j]);
1228 for(i=0; i<s->slice_count; i++){
1229 FFV1Context *sf= s->slice_context[i];
1230 av_freep(&sf->rc_stat2[j]);
1232 av_freep(&s->rc_stat2[j]);
1235 for(i=0; i<s->slice_count; i++){
1236 av_freep(&s->slice_context[i]);
1242 static av_always_inline void decode_line(FFV1Context *s, int w,
1244 int plane_index, int bits)
1246 PlaneContext * const p= &s->plane[plane_index];
1247 RangeCoder * const c= &s->c;
1251 int run_index= s->run_index;
1254 int diff, context, sign;
1256 context= get_context(p, sample[1] + x, sample[0] + x, sample[1] + x);
1263 av_assert2(context < p->context_count);
1266 diff= get_symbol_inline(c, p->state[context], 1);
1268 if(context == 0 && run_mode==0) run_mode=1;
1271 if(run_count==0 && run_mode==1){
1272 if(get_bits1(&s->gb)){
1273 run_count = 1<<ff_log2_run[run_index];
1274 if(x + run_count <= w) run_index++;
1276 if(ff_log2_run[run_index]) run_count = get_bits(&s->gb, ff_log2_run[run_index]);
1278 if(run_index) run_index--;
1286 diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
1291 diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
1293 // 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));
1296 if(sign) diff= -diff;
1298 sample[1][x]= (predict(sample[1] + x, sample[0] + x) + diff) & ((1<<bits)-1);
1300 s->run_index= run_index;
1303 static void decode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
1306 sample[0]=s->sample_buffer +3;
1307 sample[1]=s->sample_buffer+w+6+3;
1311 memset(s->sample_buffer, 0, 2*(w+6)*sizeof(*s->sample_buffer));
1314 int16_t *temp = sample[0]; //FIXME try a normal buffer
1316 sample[0]= sample[1];
1319 sample[1][-1]= sample[0][0 ];
1320 sample[0][ w]= sample[0][w-1];
1323 if(s->avctx->bits_per_raw_sample <= 8){
1324 decode_line(s, w, sample, plane_index, 8);
1326 src[x + stride*y]= sample[1][x];
1329 decode_line(s, w, sample, plane_index, s->avctx->bits_per_raw_sample);
1331 ((uint16_t*)(src + stride*y))[x]= sample[1][x] << (16 - s->avctx->bits_per_raw_sample);
1334 //STOP_TIMER("decode-line")}
1338 static void decode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
1340 int16_t *sample[3][2];
1342 sample[x][0] = s->sample_buffer + x*2 *(w+6) + 3;
1343 sample[x][1] = s->sample_buffer + (x*2+1)*(w+6) + 3;
1348 memset(s->sample_buffer, 0, 6*(w+6)*sizeof(*s->sample_buffer));
1352 int16_t *temp = sample[p][0]; //FIXME try a normal buffer
1354 sample[p][0]= sample[p][1];
1357 sample[p][1][-1]= sample[p][0][0 ];
1358 sample[p][0][ w]= sample[p][0][w-1];
1359 decode_line(s, w, sample[p], FFMIN(p, 1), 9);
1362 int g= sample[0][1][x];
1363 int b= sample[1][1][x];
1364 int r= sample[2][1][x];
1366 // assert(g>=0 && b>=0 && r>=0);
1367 // assert(g<256 && b<512 && r<512);
1375 src[x + stride*y]= b + (g<<8) + (r<<16) + (0xFF<<24);
1380 static int decode_slice(AVCodecContext *c, void *arg){
1381 FFV1Context *fs= *(void**)arg;
1382 FFV1Context *f= fs->avctx->priv_data;
1383 int width = fs->slice_width;
1384 int height= fs->slice_height;
1387 AVFrame * const p= &f->picture;
1389 av_assert1(width && height);
1390 if(f->colorspace==0){
1391 const int chroma_width = -((-width )>>f->chroma_h_shift);
1392 const int chroma_height= -((-height)>>f->chroma_v_shift);
1393 const int cx= x>>f->chroma_h_shift;
1394 const int cy= y>>f->chroma_v_shift;
1395 decode_plane(fs, p->data[0] + x + y*p->linesize[0], width, height, p->linesize[0], 0);
1397 decode_plane(fs, p->data[1] + cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
1398 decode_plane(fs, p->data[2] + cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[2], 1);
1400 decode_rgb_frame(fs, (uint32_t*)p->data[0] + x + y*(p->linesize[0]/4), width, height, p->linesize[0]/4);
1408 static int read_quant_table(RangeCoder *c, int16_t *quant_table, int scale){
1411 uint8_t state[CONTEXT_SIZE];
1413 memset(state, 128, sizeof(state));
1415 for(v=0; i<128 ; v++){
1416 int len= get_symbol(c, state, 0) + 1;
1418 if(len + i > 128) return -1;
1421 quant_table[i] = scale*v;
1424 //if(i%16==0) printf("\n");
1428 for(i=1; i<128; i++){
1429 quant_table[256-i]= -quant_table[i];
1431 quant_table[128]= -quant_table[127];
1436 static int read_quant_tables(RangeCoder *c, int16_t quant_table[MAX_CONTEXT_INPUTS][256]){
1438 int context_count=1;
1441 context_count*= read_quant_table(c, quant_table[i], context_count);
1442 if(context_count > 32768U){
1446 return (context_count+1)/2;
1449 static int read_extra_header(FFV1Context *f){
1450 RangeCoder * const c= &f->c;
1451 uint8_t state[CONTEXT_SIZE];
1453 uint8_t state2[32][CONTEXT_SIZE];
1455 memset(state2, 128, sizeof(state2));
1456 memset(state, 128, sizeof(state));
1458 ff_init_range_decoder(c, f->avctx->extradata, f->avctx->extradata_size);
1459 ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1461 f->version= get_symbol(c, state, 0);
1462 f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
1464 for(i=1; i<256; i++){
1465 f->state_transition[i]= get_symbol(c, state, 1) + c->one_state[i];
1468 f->colorspace= get_symbol(c, state, 0); //YUV cs type
1469 f->avctx->bits_per_raw_sample= get_symbol(c, state, 0);
1470 get_rac(c, state); //no chroma = false
1471 f->chroma_h_shift= get_symbol(c, state, 0);
1472 f->chroma_v_shift= get_symbol(c, state, 0);
1473 get_rac(c, state); //transparency plane
1475 f->num_h_slices= 1 + get_symbol(c, state, 0);
1476 f->num_v_slices= 1 + get_symbol(c, state, 0);
1477 if(f->num_h_slices > (unsigned)f->width || f->num_v_slices > (unsigned)f->height){
1478 av_log(f->avctx, AV_LOG_ERROR, "too many slices\n");
1482 f->quant_table_count= get_symbol(c, state, 0);
1483 if(f->quant_table_count > (unsigned)MAX_QUANT_TABLES)
1485 for(i=0; i<f->quant_table_count; i++){
1486 if((f->context_count[i]= read_quant_tables(c, f->quant_tables[i])) < 0){
1487 av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
1492 if(allocate_initial_states(f) < 0)
1493 return AVERROR(ENOMEM);
1495 for(i=0; i<f->quant_table_count; i++){
1496 if(get_rac(c, state)){
1497 for(j=0; j<f->context_count[i]; j++){
1498 for(k=0; k<CONTEXT_SIZE; k++){
1499 int pred= j ? f->initial_states[i][j-1][k] : 128;
1500 f->initial_states[i][j][k]= (pred+get_symbol(c, state2[k], 1))&0xFF;
1509 static int read_header(FFV1Context *f){
1510 uint8_t state[CONTEXT_SIZE];
1511 int i, j, context_count;
1512 RangeCoder * const c= &f->slice_context[0]->c;
1514 memset(state, 128, sizeof(state));
1517 f->version= get_symbol(c, state, 0);
1518 f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
1520 for(i=1; i<256; i++){
1521 f->state_transition[i]= get_symbol(c, state, 1) + c->one_state[i];
1524 f->colorspace= get_symbol(c, state, 0); //YUV cs type
1526 f->avctx->bits_per_raw_sample= get_symbol(c, state, 0);
1527 get_rac(c, state); //no chroma = false
1528 f->chroma_h_shift= get_symbol(c, state, 0);
1529 f->chroma_v_shift= get_symbol(c, state, 0);
1530 get_rac(c, state); //transparency plane
1534 if(f->colorspace==0){
1535 if(f->avctx->bits_per_raw_sample<=8){
1536 switch(16*f->chroma_h_shift + f->chroma_v_shift){
1537 case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P; break;
1538 case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P; break;
1539 case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P; break;
1540 case 0x20: f->avctx->pix_fmt= PIX_FMT_YUV411P; break;
1541 case 0x22: f->avctx->pix_fmt= PIX_FMT_YUV410P; break;
1543 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1547 switch(16*f->chroma_h_shift + f->chroma_v_shift){
1548 case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P16; break;
1549 case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P16; break;
1550 case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P16; break;
1552 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1556 }else if(f->colorspace==1){
1557 if(f->chroma_h_shift || f->chroma_v_shift){
1558 av_log(f->avctx, AV_LOG_ERROR, "chroma subsampling not supported in this colorspace\n");
1561 f->avctx->pix_fmt= PIX_FMT_RGB32;
1563 av_log(f->avctx, AV_LOG_ERROR, "colorspace not supported\n");
1567 //printf("%d %d %d\n", f->chroma_h_shift, f->chroma_v_shift,f->avctx->pix_fmt);
1569 context_count= read_quant_tables(c, f->quant_table);
1570 if(context_count < 0){
1571 av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
1575 f->slice_count= get_symbol(c, state, 0);
1576 if(f->slice_count > (unsigned)MAX_SLICES)
1580 for(j=0; j<f->slice_count; j++){
1581 FFV1Context *fs= f->slice_context[j];
1584 if(f->version >= 2){
1585 fs->slice_x = get_symbol(c, state, 0) *f->width ;
1586 fs->slice_y = get_symbol(c, state, 0) *f->height;
1587 fs->slice_width =(get_symbol(c, state, 0)+1)*f->width + fs->slice_x;
1588 fs->slice_height=(get_symbol(c, state, 0)+1)*f->height + fs->slice_y;
1590 fs->slice_x /= f->num_h_slices;
1591 fs->slice_y /= f->num_v_slices;
1592 fs->slice_width = fs->slice_width /f->num_h_slices - fs->slice_x;
1593 fs->slice_height = fs->slice_height/f->num_v_slices - fs->slice_y;
1594 if((unsigned)fs->slice_width > f->width || (unsigned)fs->slice_height > f->height)
1596 if( (unsigned)fs->slice_x + (uint64_t)fs->slice_width > f->width
1597 || (unsigned)fs->slice_y + (uint64_t)fs->slice_height > f->height)
1601 for(i=0; i<f->plane_count; i++){
1602 PlaneContext * const p= &fs->plane[i];
1604 if(f->version >= 2){
1605 int idx=get_symbol(c, state, 0);
1606 if(idx > (unsigned)f->quant_table_count){
1607 av_log(f->avctx, AV_LOG_ERROR, "quant_table_index out of range\n");
1610 p->quant_table_index= idx;
1611 memcpy(p->quant_table, f->quant_tables[idx], sizeof(p->quant_table));
1612 context_count= f->context_count[idx];
1614 memcpy(p->quant_table, f->quant_table, sizeof(p->quant_table));
1617 if(p->context_count < context_count){
1618 av_freep(&p->state);
1619 av_freep(&p->vlc_state);
1621 p->context_count= context_count;
1628 static av_cold int decode_init(AVCodecContext *avctx)
1630 FFV1Context *f = avctx->priv_data;
1634 if(avctx->extradata && read_extra_header(f) < 0)
1637 if(init_slice_contexts(f) < 0)
1643 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){
1644 const uint8_t *buf = avpkt->data;
1645 int buf_size = avpkt->size;
1646 FFV1Context *f = avctx->priv_data;
1647 RangeCoder * const c= &f->slice_context[0]->c;
1648 AVFrame * const p= &f->picture;
1650 uint8_t keystate= 128;
1651 const uint8_t *buf_p;
1653 AVFrame *picture = data;
1655 /* release previously stored data */
1657 avctx->release_buffer(avctx, p);
1659 ff_init_range_decoder(c, buf, buf_size);
1660 ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1663 p->pict_type= AV_PICTURE_TYPE_I; //FIXME I vs. P
1664 if(get_rac(c, &keystate)){
1666 if(read_header(f) < 0)
1668 if(init_slice_state(f) < 0)
1677 for(i=1; i<256; i++){
1678 c->one_state[i]= f->state_transition[i];
1679 c->zero_state[256-i]= 256-c->one_state[i];
1684 if(avctx->get_buffer(avctx, p) < 0){
1685 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1689 if(avctx->debug&FF_DEBUG_PICT_INFO)
1690 av_log(avctx, AV_LOG_ERROR, "keyframe:%d coder:%d\n", p->key_frame, f->ac);
1693 bytes_read = c->bytestream - c->bytestream_start - 1;
1694 if(bytes_read ==0) av_log(avctx, AV_LOG_ERROR, "error at end of AC stream\n"); //FIXME
1695 //printf("pos=%d\n", bytes_read);
1696 init_get_bits(&f->slice_context[0]->gb, buf + bytes_read, (buf_size - bytes_read) * 8);
1698 bytes_read = 0; /* avoid warning */
1701 buf_p= buf + buf_size;
1702 for(i=f->slice_count-1; i>0; i--){
1703 FFV1Context *fs= f->slice_context[i];
1704 int v= AV_RB24(buf_p-3)+3;
1705 if(buf_p - buf <= v){
1706 av_log(avctx, AV_LOG_ERROR, "Slice pointer chain broken\n");
1711 ff_init_range_decoder(&fs->c, buf_p, v);
1713 init_get_bits(&fs->gb, buf_p, v * 8);
1717 avctx->execute(avctx, decode_slice, &f->slice_context[0], NULL, f->slice_count, sizeof(void*));
1718 f->picture_number++;
1721 *data_size = sizeof(AVFrame);
1726 AVCodec ff_ffv1_decoder = {
1728 .type = AVMEDIA_TYPE_VIDEO,
1729 .id = CODEC_ID_FFV1,
1730 .priv_data_size = sizeof(FFV1Context),
1731 .init = decode_init,
1732 .close = common_end,
1733 .decode = decode_frame,
1734 .capabilities = CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/ | CODEC_CAP_SLICE_THREADS,
1735 .long_name= NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1738 #if CONFIG_FFV1_ENCODER
1739 AVCodec ff_ffv1_encoder = {
1741 .type = AVMEDIA_TYPE_VIDEO,
1742 .id = CODEC_ID_FFV1,
1743 .priv_data_size = sizeof(FFV1Context),
1744 .init = encode_init,
1745 .encode = encode_frame,
1746 .close = common_end,
1747 .capabilities = CODEC_CAP_SLICE_THREADS,
1748 .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_NONE},
1749 .long_name= NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),