git.sesse.net Git - ffmpeg/blob - libavcodec/ffv1.c

   1 /*
   2  * FFV1 codec for libavcodec
   3  *
   4  * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
   5  *
   6  * This file is part of FFmpeg.
   7  *
   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.
  12  *
  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.
  17  *
  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
  21  */
  22
  23 /**
  24  * @file
  25  * FF Video Codec 1 (a lossless codec)
  26  */
  27
  28 #include "avcodec.h"
  29 #include "get_bits.h"
  30 #include "put_bits.h"
  31 #include "dsputil.h"
  32 #include "rangecoder.h"
  33 #include "golomb.h"
  34 #include "mathops.h"
  35 #include "libavutil/pixdesc.h"
  36 #include "libavutil/avassert.h"
  37
  38 #define MAX_PLANES 4
  39 #define CONTEXT_SIZE 32
  40
  41 #define MAX_QUANT_TABLES 8
  42 #define MAX_CONTEXT_INPUTS 5
  43
  44 extern const uint8_t ff_log2_run[41];
  45
  46 static const int8_t quant5_10bit[256]={
  47  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  50  1, 1, 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,-2,
  59 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-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,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
  62 -1,-1,-1,-1,-1,-1,-0,-0,-0,-0,-0,-0,-0,-0,-0,-0,
  63 };
  64
  65 static const int8_t quant5[256]={
  66  0, 1, 1, 1, 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,-2,-2,-2,
  81 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-1,-1,-1,
  82 };
  83
  84 static const int8_t quant9_10bit[256]={
  85  0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2,
  86  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3,
  87  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
  88  3, 3, 3, 3, 3, 3, 3, 3, 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,-4,-4,-4,-4,-4,-4,-4,
  97 -4,-4,-4,-4,-4,-4,-4,-4,-4,-3,-3,-3,-3,-3,-3,-3,
  98 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
  99 -3,-3,-3,-3,-3,-3,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
 100 -2,-2,-2,-2,-1,-1,-1,-1,-1,-1,-1,-1,-0,-0,-0,-0,
 101 };
 102
 103 static const int8_t quant11[256]={
 104  0, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 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, 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,-5,-5,
 117 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-4,-4,
 118 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
 119 -4,-4,-4,-4,-4,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-1,
 120 };
 121
 122 static const uint8_t ver2_state[256]= {
 123    0,  10,  10,  10,  10,  16,  16,  16,  28,  16,  16,  29,  42,  49,  20,  49,
 124   59,  25,  26,  26,  27,  31,  33,  33,  33,  34,  34,  37,  67,  38,  39,  39,
 125   40,  40,  41,  79,  43,  44,  45,  45,  48,  48,  64,  50,  51,  52,  88,  52,
 126   53,  74,  55,  57,  58,  58,  74,  60, 101,  61,  62,  84,  66,  66,  68,  69,
 127   87,  82,  71,  97,  73,  73,  82,  75, 111,  77,  94,  78,  87,  81,  83,  97,
 128   85,  83,  94,  86,  99,  89,  90,  99, 111,  92,  93, 134,  95,  98, 105,  98,
 129  105, 110, 102, 108, 102, 118, 103, 106, 106, 113, 109, 112, 114, 112, 116, 125,
 130  115, 116, 117, 117, 126, 119, 125, 121, 121, 123, 145, 124, 126, 131, 127, 129,
 131  165, 130, 132, 138, 133, 135, 145, 136, 137, 139, 146, 141, 143, 142, 144, 148,
 132  147, 155, 151, 149, 151, 150, 152, 157, 153, 154, 156, 168, 158, 162, 161, 160,
 133  172, 163, 169, 164, 166, 184, 167, 170, 177, 174, 171, 173, 182, 176, 180, 178,
 134  175, 189, 179, 181, 186, 183, 192, 185, 200, 187, 191, 188, 190, 197, 193, 196,
 135  197, 194, 195, 196, 198, 202, 199, 201, 210, 203, 207, 204, 205, 206, 208, 214,
 136  209, 211, 221, 212, 213, 215, 224, 216, 217, 218, 219, 220, 222, 228, 223, 225,
 137  226, 224, 227, 229, 240, 230, 231, 232, 233, 234, 235, 236, 238, 239, 237, 242,
 138  241, 243, 242, 244, 245, 246, 247, 248, 249, 250, 251, 252, 252, 253, 254, 255,
 139 };
 140
 141 typedef struct VlcState{
 142     int16_t drift;
 143     uint16_t error_sum;
 144     int8_t bias;
 145     uint8_t count;
 146 } VlcState;
 147
 148 typedef struct PlaneContext{
 149     int16_t quant_table[MAX_CONTEXT_INPUTS][256];
 150     int quant_table_index;
 151     int context_count;
 152     uint8_t (*state)[CONTEXT_SIZE];
 153     VlcState *vlc_state;
 154     uint8_t interlace_bit_state[2];
 155 } PlaneContext;
 156
 157 #define MAX_SLICES 256
 158
 159 typedef struct FFV1Context{
 160     AVCodecContext *avctx;
 161     RangeCoder c;
 162     GetBitContext gb;
 163     PutBitContext pb;
 164     uint64_t rc_stat[256][2];
 165     uint64_t (*rc_stat2[MAX_QUANT_TABLES])[32][2];
 166     int version;
 167     int width, height;
 168     int chroma_h_shift, chroma_v_shift;
 169     int chroma_planes;
 170     int transparency;
 171     int flags;
 172     int picture_number;
 173     AVFrame picture;
 174     int plane_count;
 175     int ac;                              ///< 1=range coder <-> 0=golomb rice
 176     PlaneContext plane[MAX_PLANES];
 177     int16_t quant_table[MAX_CONTEXT_INPUTS][256];
 178     int16_t quant_tables[MAX_QUANT_TABLES][MAX_CONTEXT_INPUTS][256];
 179     int context_count[MAX_QUANT_TABLES];
 180     uint8_t state_transition[256];
 181     uint8_t (*initial_states[MAX_QUANT_TABLES])[32];
 182     int run_index;
 183     int colorspace;
 184     int16_t *sample_buffer;
 185     int gob_count;
 186     int packed_at_lsb;
 187
 188     int quant_table_count;
 189
 190     DSPContext dsp;
 191
 192     struct FFV1Context *slice_context[MAX_SLICES];
 193     int slice_count;
 194     int num_v_slices;
 195     int num_h_slices;
 196     int slice_width;
 197     int slice_height;
 198     int slice_x;
 199     int slice_y;
 200     int bits_per_raw_sample;
 201 }FFV1Context;
 202
 203 static av_always_inline int fold(int diff, int bits){
 204     if(bits==8)
 205         diff= (int8_t)diff;
 206     else{
 207         diff+= 1<<(bits-1);
 208         diff&=(1<<bits)-1;
 209         diff-= 1<<(bits-1);
 210     }
 211
 212     return diff;
 213 }
 214
 215 static inline int predict(int16_t *src, int16_t *last)
 216 {
 217     const int LT= last[-1];
 218     const int  T= last[ 0];
 219     const int L =  src[-1];
 220
 221     return mid_pred(L, L + T - LT, T);
 222 }
 223
 224 static inline int get_context(PlaneContext *p, int16_t *src,
 225                               int16_t *last, int16_t *last2)
 226 {
 227     const int LT= last[-1];
 228     const int  T= last[ 0];
 229     const int RT= last[ 1];
 230     const int L =  src[-1];
 231
 232     if(p->quant_table[3][127]){
 233         const int TT= last2[0];
 234         const int LL=  src[-2];
 235         return p->quant_table[0][(L-LT) & 0xFF] + p->quant_table[1][(LT-T) & 0xFF] + p->quant_table[2][(T-RT) & 0xFF]
 236               +p->quant_table[3][(LL-L) & 0xFF] + p->quant_table[4][(TT-T) & 0xFF];
 237     }else
 238         return p->quant_table[0][(L-LT) & 0xFF] + p->quant_table[1][(LT-T) & 0xFF] + p->quant_table[2][(T-RT) & 0xFF];
 239 }
 240
 241 static void find_best_state(uint8_t best_state[256][256], const uint8_t one_state[256]){
 242     int i,j,k,m;
 243     double l2tab[256];
 244
 245     for(i=1; i<256; i++)
 246         l2tab[i]= log2(i/256.0);
 247
 248     for(i=0; i<256; i++){
 249         double best_len[256];
 250         double p= i/256.0;
 251
 252         for(j=0; j<256; j++)
 253             best_len[j]= 1<<30;
 254
 255         for(j=FFMAX(i-10,1); j<FFMIN(i+11,256); j++){
 256             double occ[256]={0};
 257             double len=0;
 258             occ[j]=1.0;
 259             for(k=0; k<256; k++){
 260                 double newocc[256]={0};
 261                 for(m=0; m<256; m++){
 262                     if(occ[m]){
 263                         len -=occ[m]*(     p *l2tab[    m]
 264                                       + (1-p)*l2tab[256-m]);
 265                     }
 266                 }
 267                 if(len < best_len[k]){
 268                     best_len[k]= len;
 269                     best_state[i][k]= j;
 270                 }
 271                 for(m=0; m<256; m++){
 272                     if(occ[m]){
 273                         newocc[    one_state[    m]] += occ[m]*   p ;
 274                         newocc[256-one_state[256-m]] += occ[m]*(1-p);
 275                     }
 276                 }
 277                 memcpy(occ, newocc, sizeof(occ));
 278             }
 279         }
 280     }
 281 }
 282
 283 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]){
 284     int i;
 285
 286 #define put_rac(C,S,B) \
 287 do{\
 288     if(rc_stat){\
 289     rc_stat[*(S)][B]++;\
 290         rc_stat2[(S)-state][B]++;\
 291     }\
 292     put_rac(C,S,B);\
 293 }while(0)
 294
 295     if(v){
 296         const int a= FFABS(v);
 297         const int e= av_log2(a);
 298         put_rac(c, state+0, 0);
 299         if(e<=9){
 300             for(i=0; i<e; i++){
 301                 put_rac(c, state+1+i, 1);  //1..10
 302             }
 303             put_rac(c, state+1+i, 0);
 304
 305             for(i=e-1; i>=0; i--){
 306                 put_rac(c, state+22+i, (a>>i)&1); //22..31
 307             }
 308
 309             if(is_signed)
 310                 put_rac(c, state+11 + e, v < 0); //11..21
 311         }else{
 312             for(i=0; i<e; i++){
 313                 put_rac(c, state+1+FFMIN(i,9), 1);  //1..10
 314             }
 315             put_rac(c, state+1+9, 0);
 316
 317             for(i=e-1; i>=0; i--){
 318                 put_rac(c, state+22+FFMIN(i,9), (a>>i)&1); //22..31
 319             }
 320
 321             if(is_signed)
 322                 put_rac(c, state+11 + 10, v < 0); //11..21
 323         }
 324     }else{
 325         put_rac(c, state+0, 1);
 326     }
 327 #undef put_rac
 328 }
 329
 330 static void av_noinline put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed){
 331     put_symbol_inline(c, state, v, is_signed, NULL, NULL);
 332 }
 333
 334 static inline av_flatten int get_symbol_inline(RangeCoder *c, uint8_t *state, int is_signed){
 335     if(get_rac(c, state+0))
 336         return 0;
 337     else{
 338         int i, e, a;
 339         e= 0;
 340         while(get_rac(c, state+1 + FFMIN(e,9))){ //1..10
 341             e++;
 342         }
 343
 344         a= 1;
 345         for(i=e-1; i>=0; i--){
 346             a += a + get_rac(c, state+22 + FFMIN(i,9)); //22..31
 347         }
 348
 349         e= -(is_signed && get_rac(c, state+11 + FFMIN(e, 10))); //11..21
 350         return (a^e)-e;
 351     }
 352 }
 353
 354 static int av_noinline get_symbol(RangeCoder *c, uint8_t *state, int is_signed){
 355     return get_symbol_inline(c, state, is_signed);
 356 }
 357
 358 static inline void update_vlc_state(VlcState * const state, const int v){
 359     int drift= state->drift;
 360     int count= state->count;
 361     state->error_sum += FFABS(v);
 362     drift += v;
 363
 364     if(count == 128){ //FIXME variable
 365         count >>= 1;
 366         drift >>= 1;
 367         state->error_sum >>= 1;
 368     }
 369     count++;
 370
 371     if(drift <= -count){
 372         if(state->bias > -128) state->bias--;
 373
 374         drift += count;
 375         if(drift <= -count)
 376             drift= -count + 1;
 377     }else if(drift > 0){
 378         if(state->bias <  127) state->bias++;
 379
 380         drift -= count;
 381         if(drift > 0)
 382             drift= 0;
 383     }
 384
 385     state->drift= drift;
 386     state->count= count;
 387 }
 388
 389 static inline void put_vlc_symbol(PutBitContext *pb, VlcState * const state, int v, int bits){
 390     int i, k, code;
 391 //printf("final: %d ", v);
 392     v = fold(v - state->bias, bits);
 393
 394     i= state->count;
 395     k=0;
 396     while(i < state->error_sum){ //FIXME optimize
 397         k++;
 398         i += i;
 399     }
 400
 401     assert(k<=8);
 402
 403 #if 0 // JPEG LS
 404     if(k==0 && 2*state->drift <= - state->count) code= v ^ (-1);
 405     else                                         code= v;
 406 #else
 407      code= v ^ ((2*state->drift + state->count)>>31);
 408 #endif
 409
 410 //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);
 411     set_sr_golomb(pb, code, k, 12, bits);
 412
 413     update_vlc_state(state, v);
 414 }
 415
 416 static inline int get_vlc_symbol(GetBitContext *gb, VlcState * const state, int bits){
 417     int k, i, v, ret;
 418
 419     i= state->count;
 420     k=0;
 421     while(i < state->error_sum){ //FIXME optimize
 422         k++;
 423         i += i;
 424     }
 425
 426     assert(k<=8);
 427
 428     v= get_sr_golomb(gb, k, 12, bits);
 429 //printf("v:%d bias:%d error:%d drift:%d count:%d k:%d", v, state->bias, state->error_sum, state->drift, state->count, k);
 430
 431 #if 0 // JPEG LS
 432     if(k==0 && 2*state->drift <= - state->count) v ^= (-1);
 433 #else
 434      v ^= ((2*state->drift + state->count)>>31);
 435 #endif
 436
 437     ret= fold(v + state->bias, bits);
 438
 439     update_vlc_state(state, v);
 440 //printf("final: %d\n", ret);
 441     return ret;
 442 }
 443
 444 #if CONFIG_FFV1_ENCODER
 445 static av_always_inline int encode_line(FFV1Context *s, int w,
 446                                         int16_t *sample[2],
 447                                         int plane_index, int bits)
 448 {
 449     PlaneContext * const p= &s->plane[plane_index];
 450     RangeCoder * const c= &s->c;
 451     int x;
 452     int run_index= s->run_index;
 453     int run_count=0;
 454     int run_mode=0;
 455
 456     if(s->ac){
 457         if(c->bytestream_end - c->bytestream < w*20){
 458             av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
 459             return -1;
 460         }
 461     }else{
 462         if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < w*4){
 463             av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
 464             return -1;
 465         }
 466     }
 467
 468     for(x=0; x<w; x++){
 469         int diff, context;
 470
 471         context= get_context(p, sample[0]+x, sample[1]+x, sample[2]+x);
 472         diff= sample[0][x] - predict(sample[0]+x, sample[1]+x);
 473
 474         if(context < 0){
 475             context = -context;
 476             diff= -diff;
 477         }
 478
 479         diff= fold(diff, bits);
 480
 481         if(s->ac){
 482             if(s->flags & CODEC_FLAG_PASS1){
 483                 put_symbol_inline(c, p->state[context], diff, 1, s->rc_stat, s->rc_stat2[p->quant_table_index][context]);
 484             }else{
 485                 put_symbol_inline(c, p->state[context], diff, 1, NULL, NULL);
 486             }
 487         }else{
 488             if(context == 0) run_mode=1;
 489
 490             if(run_mode){
 491
 492                 if(diff){
 493                     while(run_count >= 1<<ff_log2_run[run_index]){
 494                         run_count -= 1<<ff_log2_run[run_index];
 495                         run_index++;
 496                         put_bits(&s->pb, 1, 1);
 497                     }
 498
 499                     put_bits(&s->pb, 1 + ff_log2_run[run_index], run_count);
 500                     if(run_index) run_index--;
 501                     run_count=0;
 502                     run_mode=0;
 503                     if(diff>0) diff--;
 504                 }else{
 505                     run_count++;
 506                 }
 507             }
 508
 509 //            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));
 510
 511             if(run_mode == 0)
 512                 put_vlc_symbol(&s->pb, &p->vlc_state[context], diff, bits);
 513         }
 514     }
 515     if(run_mode){
 516         while(run_count >= 1<<ff_log2_run[run_index]){
 517             run_count -= 1<<ff_log2_run[run_index];
 518             run_index++;
 519             put_bits(&s->pb, 1, 1);
 520         }
 521
 522         if(run_count)
 523             put_bits(&s->pb, 1, 1);
 524     }
 525     s->run_index= run_index;
 526
 527     return 0;
 528 }
 529
 530 static void encode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
 531     int x,y,i;
 532     const int ring_size= s->avctx->context_model ? 3 : 2;
 533     int16_t *sample[3];
 534     s->run_index=0;
 535
 536     memset(s->sample_buffer, 0, ring_size*(w+6)*sizeof(*s->sample_buffer));
 537
 538     for(y=0; y<h; y++){
 539         for(i=0; i<ring_size; i++)
 540             sample[i]= s->sample_buffer + (w+6)*((h+i-y)%ring_size) + 3;
 541
 542         sample[0][-1]= sample[1][0  ];
 543         sample[1][ w]= sample[1][w-1];
 544 //{START_TIMER
 545         if(s->bits_per_raw_sample<=8){
 546             for(x=0; x<w; x++){
 547                 sample[0][x]= src[x + stride*y];
 548             }
 549             encode_line(s, w, sample, plane_index, 8);
 550         }else{
 551             if(s->packed_at_lsb){
 552                 for(x=0; x<w; x++){
 553                     sample[0][x]= ((uint16_t*)(src + stride*y))[x];
 554                 }
 555             }else{
 556                 for(x=0; x<w; x++){
 557                     sample[0][x]= ((uint16_t*)(src + stride*y))[x] >> (16 - s->bits_per_raw_sample);
 558                 }
 559             }
 560             encode_line(s, w, sample, plane_index, s->bits_per_raw_sample);
 561         }
 562 //STOP_TIMER("encode line")}
 563     }
 564 }
 565
 566 static void encode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
 567     int x, y, p, i;
 568     const int ring_size= s->avctx->context_model ? 3 : 2;
 569     int16_t *sample[4][3];
 570     s->run_index=0;
 571
 572     memset(s->sample_buffer, 0, ring_size*4*(w+6)*sizeof(*s->sample_buffer));
 573
 574     for(y=0; y<h; y++){
 575         for(i=0; i<ring_size; i++)
 576             for(p=0; p<4; p++)
 577                 sample[p][i]= s->sample_buffer + p*ring_size*(w+6) + ((h+i-y)%ring_size)*(w+6) + 3;
 578
 579         for(x=0; x<w; x++){
 580             unsigned v= src[x + stride*y];
 581             int b= v&0xFF;
 582             int g= (v>>8)&0xFF;
 583             int r= (v>>16)&0xFF;
 584             int a=  v>>24;
 585
 586             b -= g;
 587             r -= g;
 588             g += (b + r)>>2;
 589             b += 0x100;
 590             r += 0x100;
 591
 592 //            assert(g>=0 && b>=0 && r>=0);
 593 //            assert(g<256 && b<512 && r<512);
 594             sample[0][0][x]= g;
 595             sample[1][0][x]= b;
 596             sample[2][0][x]= r;
 597             sample[3][0][x]= a;
 598         }
 599         for(p=0; p<3 + s->transparency; p++){
 600             sample[p][0][-1]= sample[p][1][0  ];
 601             sample[p][1][ w]= sample[p][1][w-1];
 602             encode_line(s, w, sample[p], (p+1)/2, 9);
 603         }
 604     }
 605 }
 606
 607 static void write_quant_table(RangeCoder *c, int16_t *quant_table){
 608     int last=0;
 609     int i;
 610     uint8_t state[CONTEXT_SIZE];
 611     memset(state, 128, sizeof(state));
 612
 613     for(i=1; i<128 ; i++){
 614         if(quant_table[i] != quant_table[i-1]){
 615             put_symbol(c, state, i-last-1, 0);
 616             last= i;
 617         }
 618     }
 619     put_symbol(c, state, i-last-1, 0);
 620 }
 621
 622 static void write_quant_tables(RangeCoder *c, int16_t quant_table[MAX_CONTEXT_INPUTS][256]){
 623     int i;
 624     for(i=0; i<5; i++)
 625         write_quant_table(c, quant_table[i]);
 626 }
 627
 628 static void write_header(FFV1Context *f){
 629     uint8_t state[CONTEXT_SIZE];
 630     int i, j;
 631     RangeCoder * const c= &f->slice_context[0]->c;
 632
 633     memset(state, 128, sizeof(state));
 634
 635     if(f->version < 2){
 636         put_symbol(c, state, f->version, 0);
 637         put_symbol(c, state, f->ac, 0);
 638         if(f->ac>1){
 639             for(i=1; i<256; i++){
 640                 put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
 641             }
 642         }
 643         put_symbol(c, state, f->colorspace, 0); //YUV cs type
 644         if(f->version>0)
 645             put_symbol(c, state, f->bits_per_raw_sample, 0);
 646         put_rac(c, state, f->chroma_planes);
 647         put_symbol(c, state, f->chroma_h_shift, 0);
 648         put_symbol(c, state, f->chroma_v_shift, 0);
 649         put_rac(c, state, f->transparency);
 650
 651         write_quant_tables(c, f->quant_table);
 652     }else{
 653         put_symbol(c, state, f->slice_count, 0);
 654         for(i=0; i<f->slice_count; i++){
 655             FFV1Context *fs= f->slice_context[i];
 656             put_symbol(c, state, (fs->slice_x     +1)*f->num_h_slices / f->width   , 0);
 657             put_symbol(c, state, (fs->slice_y     +1)*f->num_v_slices / f->height  , 0);
 658             put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
 659             put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
 660             for(j=0; j<f->plane_count; j++){
 661                 put_symbol(c, state, f->plane[j].quant_table_index, 0);
 662                 av_assert0(f->plane[j].quant_table_index == f->avctx->context_model);
 663             }
 664         }
 665     }
 666 }
 667 #endif /* CONFIG_FFV1_ENCODER */
 668
 669 static av_cold int common_init(AVCodecContext *avctx){
 670     FFV1Context *s = avctx->priv_data;
 671
 672     s->avctx= avctx;
 673     s->flags= avctx->flags;
 674
 675     avcodec_get_frame_defaults(&s->picture);
 676
 677     dsputil_init(&s->dsp, avctx);
 678
 679     s->width = avctx->width;
 680     s->height= avctx->height;
 681
 682     assert(s->width && s->height);
 683     //defaults
 684     s->num_h_slices=1;
 685     s->num_v_slices=1;
 686
 687
 688     return 0;
 689 }
 690
 691 static int init_slice_state(FFV1Context *f){
 692     int i, j;
 693
 694     for(i=0; i<f->slice_count; i++){
 695         FFV1Context *fs= f->slice_context[i];
 696         fs->plane_count= f->plane_count;
 697         fs->transparency= f->transparency;
 698         for(j=0; j<f->plane_count; j++){
 699             PlaneContext * const p= &fs->plane[j];
 700
 701             if(fs->ac){
 702                 if(!p->    state) p->    state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
 703                 if(!p->    state)
 704                     return AVERROR(ENOMEM);
 705             }else{
 706                 if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
 707                 if(!p->vlc_state)
 708                     return AVERROR(ENOMEM);
 709             }
 710         }
 711
 712         if (fs->ac>1){
 713             //FIXME only redo if state_transition changed
 714             for(j=1; j<256; j++){
 715                 fs->c.one_state [    j]= fs->state_transition[j];
 716                 fs->c.zero_state[256-j]= 256-fs->c.one_state [j];
 717             }
 718         }
 719     }
 720
 721     return 0;
 722 }
 723
 724 static av_cold int init_slice_contexts(FFV1Context *f){
 725     int i;
 726
 727     f->slice_count= f->num_h_slices * f->num_v_slices;
 728
 729     for(i=0; i<f->slice_count; i++){
 730         FFV1Context *fs= av_mallocz(sizeof(*fs));
 731         int sx= i % f->num_h_slices;
 732         int sy= i / f->num_h_slices;
 733         int sxs= f->avctx->width * sx    / f->num_h_slices;
 734         int sxe= f->avctx->width *(sx+1) / f->num_h_slices;
 735         int sys= f->avctx->height* sy    / f->num_v_slices;
 736         int sye= f->avctx->height*(sy+1) / f->num_v_slices;
 737         f->slice_context[i]= fs;
 738         memcpy(fs, f, sizeof(*fs));
 739         memset(fs->rc_stat2, 0, sizeof(fs->rc_stat2));
 740
 741         fs->slice_width = sxe - sxs;
 742         fs->slice_height= sye - sys;
 743         fs->slice_x     = sxs;
 744         fs->slice_y     = sys;
 745
 746         fs->sample_buffer = av_malloc(3*4 * (fs->width+6) * sizeof(*fs->sample_buffer));
 747         if (!fs->sample_buffer)
 748             return AVERROR(ENOMEM);
 749     }
 750     return 0;
 751 }
 752
 753 static int allocate_initial_states(FFV1Context *f){
 754     int i;
 755
 756     for(i=0; i<f->quant_table_count; i++){
 757         f->initial_states[i]= av_malloc(f->context_count[i]*sizeof(*f->initial_states[i]));
 758         if(!f->initial_states[i])
 759             return AVERROR(ENOMEM);
 760         memset(f->initial_states[i], 128, f->context_count[i]*sizeof(*f->initial_states[i]));
 761     }
 762     return 0;
 763 }
 764
 765 #if CONFIG_FFV1_ENCODER
 766 static int write_extra_header(FFV1Context *f){
 767     RangeCoder * const c= &f->c;
 768     uint8_t state[CONTEXT_SIZE];
 769     int i, j, k;
 770     uint8_t state2[32][CONTEXT_SIZE];
 771
 772     memset(state2, 128, sizeof(state2));
 773     memset(state, 128, sizeof(state));
 774
 775     f->avctx->extradata= av_malloc(f->avctx->extradata_size= 10000 + (11*11*5*5*5+11*11*11)*32);
 776     ff_init_range_encoder(c, f->avctx->extradata, f->avctx->extradata_size);
 777     ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
 778
 779     put_symbol(c, state, f->version, 0);
 780     put_symbol(c, state, f->ac, 0);
 781     if(f->ac>1){
 782         for(i=1; i<256; i++){
 783             put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
 784         }
 785     }
 786     put_symbol(c, state, f->colorspace, 0); //YUV cs type
 787     put_symbol(c, state, f->bits_per_raw_sample, 0);
 788     put_rac(c, state, f->chroma_planes);
 789     put_symbol(c, state, f->chroma_h_shift, 0);
 790     put_symbol(c, state, f->chroma_v_shift, 0);
 791     put_rac(c, state, f->transparency);
 792     put_symbol(c, state, f->num_h_slices-1, 0);
 793     put_symbol(c, state, f->num_v_slices-1, 0);
 794
 795     put_symbol(c, state, f->quant_table_count, 0);
 796     for(i=0; i<f->quant_table_count; i++)
 797         write_quant_tables(c, f->quant_tables[i]);
 798
 799     for(i=0; i<f->quant_table_count; i++){
 800         for(j=0; j<f->context_count[i]*CONTEXT_SIZE; j++)
 801             if(f->initial_states[i] && f->initial_states[i][0][j] != 128)
 802                 break;
 803         if(j<f->context_count[i]*CONTEXT_SIZE){
 804             put_rac(c, state, 1);
 805             for(j=0; j<f->context_count[i]; j++){
 806                 for(k=0; k<CONTEXT_SIZE; k++){
 807                     int pred= j ? f->initial_states[i][j-1][k] : 128;
 808                     put_symbol(c, state2[k], (int8_t)(f->initial_states[i][j][k]-pred), 1);
 809                 }
 810             }
 811         }else{
 812             put_rac(c, state, 0);
 813         }
 814     }
 815
 816     f->avctx->extradata_size= ff_rac_terminate(c);
 817
 818     return 0;
 819 }
 820
 821 static int sort_stt(FFV1Context *s, uint8_t stt[256]){
 822     int i,i2,changed,print=0;
 823
 824     do{
 825         changed=0;
 826         for(i=12; i<244; i++){
 827             for(i2=i+1; i2<245 && i2<i+4; i2++){
 828 #define COST(old, new) \
 829     s->rc_stat[old][0]*-log2((256-(new))/256.0)\
 830    +s->rc_stat[old][1]*-log2(     (new) /256.0)
 831
 832 #define COST2(old, new) \
 833     COST(old, new)\
 834    +COST(256-(old), 256-(new))
 835
 836                 double size0= COST2(i, i ) + COST2(i2, i2);
 837                 double sizeX= COST2(i, i2) + COST2(i2, i );
 838                 if(sizeX < size0 && i!=128 && i2!=128){
 839                     int j;
 840                     FFSWAP(int, stt[    i], stt[    i2]);
 841                     FFSWAP(int, s->rc_stat[i    ][0],s->rc_stat[    i2][0]);
 842                     FFSWAP(int, s->rc_stat[i    ][1],s->rc_stat[    i2][1]);
 843                     if(i != 256-i2){
 844                         FFSWAP(int, stt[256-i], stt[256-i2]);
 845                         FFSWAP(int, s->rc_stat[256-i][0],s->rc_stat[256-i2][0]);
 846                         FFSWAP(int, s->rc_stat[256-i][1],s->rc_stat[256-i2][1]);
 847                     }
 848                     for(j=1; j<256; j++){
 849                         if     (stt[j] == i ) stt[j] = i2;
 850                         else if(stt[j] == i2) stt[j] = i ;
 851                         if(i != 256-i2){
 852                             if     (stt[256-j] == 256-i ) stt[256-j] = 256-i2;
 853                             else if(stt[256-j] == 256-i2) stt[256-j] = 256-i ;
 854                         }
 855                     }
 856                     print=changed=1;
 857                 }
 858             }
 859         }
 860     }while(changed);
 861     return print;
 862 }
 863
 864 static av_cold int encode_init(AVCodecContext *avctx)
 865 {
 866     FFV1Context *s = avctx->priv_data;
 867     int i, j, k, m;
 868
 869     common_init(avctx);
 870
 871     s->version=0;
 872     s->ac= avctx->coder_type ? 2:0;
 873
 874     if(s->ac>1)
 875         for(i=1; i<256; i++)
 876             s->state_transition[i]=ver2_state[i];
 877
 878     s->plane_count=3;
 879     switch(avctx->pix_fmt){
 880     case PIX_FMT_YUV420P9:
 881         if (!avctx->bits_per_raw_sample)
 882             s->bits_per_raw_sample = 9;
 883     case PIX_FMT_YUV420P10:
 884     case PIX_FMT_YUV422P10:
 885         s->packed_at_lsb = 1;
 886         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
 887             s->bits_per_raw_sample = 10;
 888     case PIX_FMT_GRAY16:
 889     case PIX_FMT_YUV444P16:
 890     case PIX_FMT_YUV422P16:
 891     case PIX_FMT_YUV420P16:
 892         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {
 893             s->bits_per_raw_sample = 16;
 894         } else if (!s->bits_per_raw_sample){
 895             s->bits_per_raw_sample = avctx->bits_per_raw_sample;
 896         }
 897         if(s->bits_per_raw_sample <=8){
 898             av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
 899             return -1;
 900         }
 901         if(!s->ac){
 902             av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample of more than 8 needs -coder 1 currently\n");
 903             return -1;
 904         }
 905         s->version= FFMAX(s->version, 1);
 906     case PIX_FMT_GRAY8:
 907     case PIX_FMT_YUV444P:
 908     case PIX_FMT_YUV440P:
 909     case PIX_FMT_YUV422P:
 910     case PIX_FMT_YUV420P:
 911     case PIX_FMT_YUV411P:
 912     case PIX_FMT_YUV410P:
 913         s->chroma_planes= av_pix_fmt_descriptors[avctx->pix_fmt].nb_components < 3 ? 0 : 1;
 914         s->colorspace= 0;
 915         break;
 916     case PIX_FMT_YUVA444P:
 917     case PIX_FMT_YUVA420P:
 918         s->chroma_planes= 1;
 919         s->colorspace= 0;
 920         s->transparency= 1;
 921         break;
 922     case PIX_FMT_RGB32:
 923         s->colorspace= 1;
 924         s->transparency= 1;
 925         break;
 926     case PIX_FMT_0RGB32:
 927         s->colorspace= 1;
 928         break;
 929     default:
 930         av_log(avctx, AV_LOG_ERROR, "format not supported\n");
 931         return -1;
 932     }
 933     for(i=0; i<256; i++){
 934         s->quant_table_count=2;
 935         if(s->bits_per_raw_sample <=8){
 936             s->quant_tables[0][0][i]=           quant11[i];
 937             s->quant_tables[0][1][i]=        11*quant11[i];
 938             s->quant_tables[0][2][i]=     11*11*quant11[i];
 939             s->quant_tables[1][0][i]=           quant11[i];
 940             s->quant_tables[1][1][i]=        11*quant11[i];
 941             s->quant_tables[1][2][i]=     11*11*quant5 [i];
 942             s->quant_tables[1][3][i]=   5*11*11*quant5 [i];
 943             s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
 944         }else{
 945             s->quant_tables[0][0][i]=           quant9_10bit[i];
 946             s->quant_tables[0][1][i]=        11*quant9_10bit[i];
 947             s->quant_tables[0][2][i]=     11*11*quant9_10bit[i];
 948             s->quant_tables[1][0][i]=           quant9_10bit[i];
 949             s->quant_tables[1][1][i]=        11*quant9_10bit[i];
 950             s->quant_tables[1][2][i]=     11*11*quant5_10bit[i];
 951             s->quant_tables[1][3][i]=   5*11*11*quant5_10bit[i];
 952             s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
 953         }
 954     }
 955     s->context_count[0]= (11*11*11+1)/2;
 956     s->context_count[1]= (11*11*5*5*5+1)/2;
 957     memcpy(s->quant_table, s->quant_tables[avctx->context_model], sizeof(s->quant_table));
 958
 959     for(i=0; i<s->plane_count; i++){
 960         PlaneContext * const p= &s->plane[i];
 961
 962         memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
 963         p->quant_table_index= avctx->context_model;
 964         p->context_count= s->context_count[p->quant_table_index];
 965     }
 966
 967     if(allocate_initial_states(s) < 0)
 968         return AVERROR(ENOMEM);
 969
 970     avctx->coded_frame= &s->picture;
 971     if(!s->transparency)
 972         s->plane_count= 2;
 973     avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
 974
 975     s->picture_number=0;
 976
 977     if(avctx->flags & (CODEC_FLAG_PASS1|CODEC_FLAG_PASS2)){
 978         for(i=0; i<s->quant_table_count; i++){
 979             s->rc_stat2[i]= av_mallocz(s->context_count[i]*sizeof(*s->rc_stat2[i]));
 980             if(!s->rc_stat2[i])
 981                 return AVERROR(ENOMEM);
 982         }
 983     }
 984     if(avctx->stats_in){
 985         char *p= avctx->stats_in;
 986         uint8_t best_state[256][256];
 987         int gob_count=0;
 988         char *next;
 989
 990         av_assert0(s->version>=2);
 991
 992         for(;;){
 993             for(j=0; j<256; j++){
 994                 for(i=0; i<2; i++){
 995                     s->rc_stat[j][i]= strtol(p, &next, 0);
 996                     if(next==p){
 997                         av_log(avctx, AV_LOG_ERROR, "2Pass file invalid at %d %d [%s]\n", j,i,p);
 998                         return -1;
 999                     }
1000                     p=next;
1001                 }
1002             }
1003             for(i=0; i<s->quant_table_count; i++){
1004                 for(j=0; j<s->context_count[i]; j++){
1005                     for(k=0; k<32; k++){
1006                         for(m=0; m<2; m++){
1007                             s->rc_stat2[i][j][k][m]= strtol(p, &next, 0);
1008                             if(next==p){
1009                                 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid at %d %d %d %d [%s]\n", i,j,k,m,p);
1010                                 return -1;
1011                             }
1012                             p=next;
1013                         }
1014                     }
1015                 }
1016             }
1017             gob_count= strtol(p, &next, 0);
1018             if(next==p || gob_count <0){
1019                 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
1020                 return -1;
1021             }
1022             p=next;
1023             while(*p=='\n' || *p==' ') p++;
1024             if(p[0]==0) break;
1025         }
1026         sort_stt(s, s->state_transition);
1027
1028         find_best_state(best_state, s->state_transition);
1029
1030         for(i=0; i<s->quant_table_count; i++){
1031             for(j=0; j<s->context_count[i]; j++){
1032                 for(k=0; k<32; k++){
1033                     double p= 128;
1034                     if(s->rc_stat2[i][j][k][0]+s->rc_stat2[i][j][k][1]){
1035                         p=256.0*s->rc_stat2[i][j][k][1] / (s->rc_stat2[i][j][k][0]+s->rc_stat2[i][j][k][1]);
1036                     }
1037                     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)];
1038                 }
1039             }
1040         }
1041     }
1042
1043     if(s->version>1){
1044         s->num_h_slices=2;
1045         s->num_v_slices=2;
1046         write_extra_header(s);
1047     }
1048
1049     if(init_slice_contexts(s) < 0)
1050         return -1;
1051     if(init_slice_state(s) < 0)
1052         return -1;
1053
1054 #define STATS_OUT_SIZE 1024*1024*6
1055     if(avctx->flags & CODEC_FLAG_PASS1){
1056         avctx->stats_out= av_mallocz(STATS_OUT_SIZE);
1057         for(i=0; i<s->quant_table_count; i++){
1058             for(j=0; j<s->slice_count; j++){
1059                 FFV1Context *sf= s->slice_context[j];
1060                 av_assert0(!sf->rc_stat2[i]);
1061                 sf->rc_stat2[i]= av_mallocz(s->context_count[i]*sizeof(*sf->rc_stat2[i]));
1062                 if(!sf->rc_stat2[i])
1063                     return AVERROR(ENOMEM);
1064             }
1065         }
1066     }
1067
1068     return 0;
1069 }
1070 #endif /* CONFIG_FFV1_ENCODER */
1071
1072
1073 static void clear_state(FFV1Context *f){
1074     int i, si, j;
1075
1076     for(si=0; si<f->slice_count; si++){
1077         FFV1Context *fs= f->slice_context[si];
1078         for(i=0; i<f->plane_count; i++){
1079             PlaneContext *p= &fs->plane[i];
1080
1081             p->interlace_bit_state[0]= 128;
1082             p->interlace_bit_state[1]= 128;
1083
1084             if(fs->ac){
1085                 if(f->initial_states[p->quant_table_index]){
1086                     memcpy(p->state, f->initial_states[p->quant_table_index], CONTEXT_SIZE*p->context_count);
1087                 }else
1088                 memset(p->state, 128, CONTEXT_SIZE*p->context_count);
1089             }else{
1090                 for(j=0; j<p->context_count; j++){
1091                     p->vlc_state[j].drift= 0;
1092                     p->vlc_state[j].error_sum= 4; //FFMAX((RANGE + 32)/64, 2);
1093                     p->vlc_state[j].bias= 0;
1094                     p->vlc_state[j].count= 1;
1095                 }
1096             }
1097         }
1098     }
1099 }
1100
1101 #if CONFIG_FFV1_ENCODER
1102 static int encode_slice(AVCodecContext *c, void *arg){
1103     FFV1Context *fs= *(void**)arg;
1104     FFV1Context *f= fs->avctx->priv_data;
1105     int width = fs->slice_width;
1106     int height= fs->slice_height;
1107     int x= fs->slice_x;
1108     int y= fs->slice_y;
1109     AVFrame * const p= &f->picture;
1110     const int ps= (f->bits_per_raw_sample>8)+1;
1111
1112     if(f->colorspace==0){
1113         const int chroma_width = -((-width )>>f->chroma_h_shift);
1114         const int chroma_height= -((-height)>>f->chroma_v_shift);
1115         const int cx= x>>f->chroma_h_shift;
1116         const int cy= y>>f->chroma_v_shift;
1117
1118         encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0);
1119
1120         if (f->chroma_planes){
1121             encode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
1122             encode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1);
1123         }
1124         if (fs->transparency)
1125             encode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2);
1126     }else{
1127         encode_rgb_frame(fs, (uint32_t*)(p->data[0]) + ps*x + y*(p->linesize[0]/4), width, height, p->linesize[0]/4);
1128     }
1129     emms_c();
1130
1131     return 0;
1132 }
1133
1134 static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
1135     FFV1Context *f = avctx->priv_data;
1136     RangeCoder * const c= &f->slice_context[0]->c;
1137     AVFrame *pict = data;
1138     AVFrame * const p= &f->picture;
1139     int used_count= 0;
1140     uint8_t keystate=128;
1141     uint8_t *buf_p;
1142     int i;
1143
1144     ff_init_range_encoder(c, buf, buf_size);
1145     ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1146
1147     *p = *pict;
1148     p->pict_type= AV_PICTURE_TYPE_I;
1149
1150     if(avctx->gop_size==0 || f->picture_number % avctx->gop_size == 0){
1151         put_rac(c, &keystate, 1);
1152         p->key_frame= 1;
1153         f->gob_count++;
1154         write_header(f);
1155         clear_state(f);
1156     }else{
1157         put_rac(c, &keystate, 0);
1158         p->key_frame= 0;
1159     }
1160
1161     if(!f->ac){
1162         used_count += ff_rac_terminate(c);
1163 //printf("pos=%d\n", used_count);
1164         init_put_bits(&f->slice_context[0]->pb, buf + used_count, buf_size - used_count);
1165     }else if (f->ac>1){
1166         int i;
1167         for(i=1; i<256; i++){
1168             c->one_state[i]= f->state_transition[i];
1169             c->zero_state[256-i]= 256-c->one_state[i];
1170         }
1171     }
1172
1173     for(i=1; i<f->slice_count; i++){
1174         FFV1Context *fs= f->slice_context[i];
1175         uint8_t *start= buf + (buf_size-used_count)*i/f->slice_count;
1176         int len= buf_size/f->slice_count;
1177
1178         if(fs->ac){
1179             ff_init_range_encoder(&fs->c, start, len);
1180         }else{
1181             init_put_bits(&fs->pb, start, len);
1182         }
1183     }
1184     avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL, f->slice_count, sizeof(void*));
1185
1186     buf_p=buf;
1187     for(i=0; i<f->slice_count; i++){
1188         FFV1Context *fs= f->slice_context[i];
1189         int bytes;
1190
1191         if(fs->ac){
1192             uint8_t state=128;
1193             put_rac(&fs->c, &state, 0);
1194             bytes= ff_rac_terminate(&fs->c);
1195         }else{
1196             flush_put_bits(&fs->pb); //nicer padding FIXME
1197             bytes= used_count + (put_bits_count(&fs->pb)+7)/8;
1198             used_count= 0;
1199         }
1200         if(i>0){
1201             av_assert0(bytes < buf_size/f->slice_count);
1202             memmove(buf_p, fs->ac ? fs->c.bytestream_start : fs->pb.buf, bytes);
1203             av_assert0(bytes < (1<<24));
1204             AV_WB24(buf_p+bytes, bytes);
1205             bytes+=3;
1206         }
1207         buf_p += bytes;
1208     }
1209
1210     if((avctx->flags&CODEC_FLAG_PASS1) && (f->picture_number&31)==0){
1211         int j, k, m;
1212         char *p= avctx->stats_out;
1213         char *end= p + STATS_OUT_SIZE;
1214
1215         memset(f->rc_stat, 0, sizeof(f->rc_stat));
1216         for(i=0; i<f->quant_table_count; i++)
1217             memset(f->rc_stat2[i], 0, f->context_count[i]*sizeof(*f->rc_stat2[i]));
1218
1219         for(j=0; j<f->slice_count; j++){
1220             FFV1Context *fs= f->slice_context[j];
1221             for(i=0; i<256; i++){
1222                 f->rc_stat[i][0] += fs->rc_stat[i][0];
1223                 f->rc_stat[i][1] += fs->rc_stat[i][1];
1224             }
1225             for(i=0; i<f->quant_table_count; i++){
1226                 for(k=0; k<f->context_count[i]; k++){
1227                     for(m=0; m<32; m++){
1228                         f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1229                         f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1230                     }
1231                 }
1232             }
1233         }
1234
1235         for(j=0; j<256; j++){
1236             snprintf(p, end-p, "%"PRIu64" %"PRIu64" ", f->rc_stat[j][0], f->rc_stat[j][1]);
1237             p+= strlen(p);
1238         }
1239         snprintf(p, end-p, "\n");
1240
1241         for(i=0; i<f->quant_table_count; i++){
1242             for(j=0; j<f->context_count[i]; j++){
1243                 for(m=0; m<32; m++){
1244                     snprintf(p, end-p, "%"PRIu64" %"PRIu64" ", f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1245                     p+= strlen(p);
1246                 }
1247             }
1248         }
1249         snprintf(p, end-p, "%d\n", f->gob_count);
1250     } else if(avctx->flags&CODEC_FLAG_PASS1)
1251         avctx->stats_out[0] = '\0';
1252
1253     f->picture_number++;
1254     return buf_p-buf;
1255 }
1256 #endif /* CONFIG_FFV1_ENCODER */
1257
1258 static av_cold int common_end(AVCodecContext *avctx){
1259     FFV1Context *s = avctx->priv_data;
1260     int i, j;
1261
1262     if (avctx->codec->decode && s->picture.data[0])
1263         avctx->release_buffer(avctx, &s->picture);
1264
1265     for(j=0; j<s->slice_count; j++){
1266         FFV1Context *fs= s->slice_context[j];
1267         for(i=0; i<s->plane_count; i++){
1268             PlaneContext *p= &fs->plane[i];
1269
1270             av_freep(&p->state);
1271             av_freep(&p->vlc_state);
1272         }
1273         av_freep(&fs->sample_buffer);
1274     }
1275
1276     av_freep(&avctx->stats_out);
1277     for(j=0; j<s->quant_table_count; j++){
1278         av_freep(&s->initial_states[j]);
1279         for(i=0; i<s->slice_count; i++){
1280             FFV1Context *sf= s->slice_context[i];
1281             av_freep(&sf->rc_stat2[j]);
1282         }
1283         av_freep(&s->rc_stat2[j]);
1284     }
1285
1286     for(i=0; i<s->slice_count; i++){
1287         av_freep(&s->slice_context[i]);
1288     }
1289
1290     return 0;
1291 }
1292
1293 static av_always_inline void decode_line(FFV1Context *s, int w,
1294                                          int16_t *sample[2],
1295                                          int plane_index, int bits)
1296 {
1297     PlaneContext * const p= &s->plane[plane_index];
1298     RangeCoder * const c= &s->c;
1299     int x;
1300     int run_count=0;
1301     int run_mode=0;
1302     int run_index= s->run_index;
1303
1304     for(x=0; x<w; x++){
1305         int diff, context, sign;
1306
1307         context= get_context(p, sample[1] + x, sample[0] + x, sample[1] + x);
1308         if(context < 0){
1309             context= -context;
1310             sign=1;
1311         }else
1312             sign=0;
1313
1314         av_assert2(context < p->context_count);
1315
1316         if(s->ac){
1317             diff= get_symbol_inline(c, p->state[context], 1);
1318         }else{
1319             if(context == 0 && run_mode==0) run_mode=1;
1320
1321             if(run_mode){
1322                 if(run_count==0 && run_mode==1){
1323                     if(get_bits1(&s->gb)){
1324                         run_count = 1<<ff_log2_run[run_index];
1325                         if(x + run_count <= w) run_index++;
1326                     }else{
1327                         if(ff_log2_run[run_index]) run_count = get_bits(&s->gb, ff_log2_run[run_index]);
1328                         else run_count=0;
1329                         if(run_index) run_index--;
1330                         run_mode=2;
1331                     }
1332                 }
1333                 run_count--;
1334                 if(run_count < 0){
1335                     run_mode=0;
1336                     run_count=0;
1337                     diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
1338                     if(diff>=0) diff++;
1339                 }else
1340                     diff=0;
1341             }else
1342                 diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
1343
1344 //            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));
1345         }
1346
1347         if(sign) diff= -diff;
1348
1349         sample[1][x]= (predict(sample[1] + x, sample[0] + x) + diff) & ((1<<bits)-1);
1350     }
1351     s->run_index= run_index;
1352 }
1353
1354 static void decode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
1355     int x, y;
1356     int16_t *sample[2];
1357     sample[0]=s->sample_buffer    +3;
1358     sample[1]=s->sample_buffer+w+6+3;
1359
1360     s->run_index=0;
1361
1362     memset(s->sample_buffer, 0, 2*(w+6)*sizeof(*s->sample_buffer));
1363
1364     for(y=0; y<h; y++){
1365         int16_t *temp = sample[0]; //FIXME try a normal buffer
1366
1367         sample[0]= sample[1];
1368         sample[1]= temp;
1369
1370         sample[1][-1]= sample[0][0  ];
1371         sample[0][ w]= sample[0][w-1];
1372
1373 //{START_TIMER
1374         if(s->avctx->bits_per_raw_sample <= 8){
1375             decode_line(s, w, sample, plane_index, 8);
1376             for(x=0; x<w; x++){
1377                 src[x + stride*y]= sample[1][x];
1378             }
1379         }else{
1380             decode_line(s, w, sample, plane_index, s->avctx->bits_per_raw_sample);
1381             if(s->packed_at_lsb){
1382                 for(x=0; x<w; x++){
1383                     ((uint16_t*)(src + stride*y))[x]= sample[1][x];
1384                 }
1385             }else{
1386                 for(x=0; x<w; x++){
1387                     ((uint16_t*)(src + stride*y))[x]= sample[1][x] << (16 - s->avctx->bits_per_raw_sample);
1388                 }
1389             }
1390         }
1391 //STOP_TIMER("decode-line")}
1392     }
1393 }
1394
1395 static void decode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
1396     int x, y, p;
1397     int16_t *sample[4][2];
1398     for(x=0; x<4; x++){
1399         sample[x][0] = s->sample_buffer +  x*2   *(w+6) + 3;
1400         sample[x][1] = s->sample_buffer + (x*2+1)*(w+6) + 3;
1401     }
1402
1403     s->run_index=0;
1404
1405     memset(s->sample_buffer, 0, 8*(w+6)*sizeof(*s->sample_buffer));
1406
1407     for(y=0; y<h; y++){
1408         for(p=0; p<3 + s->transparency; p++){
1409             int16_t *temp = sample[p][0]; //FIXME try a normal buffer
1410
1411             sample[p][0]= sample[p][1];
1412             sample[p][1]= temp;
1413
1414             sample[p][1][-1]= sample[p][0][0  ];
1415             sample[p][0][ w]= sample[p][0][w-1];
1416             decode_line(s, w, sample[p], (p+1)/2, 9);
1417         }
1418         for(x=0; x<w; x++){
1419             int g= sample[0][1][x];
1420             int b= sample[1][1][x];
1421             int r= sample[2][1][x];
1422             int a= sample[3][1][x];
1423
1424 //            assert(g>=0 && b>=0 && r>=0);
1425 //            assert(g<256 && b<512 && r<512);
1426
1427             b -= 0x100;
1428             r -= 0x100;
1429             g -= (b + r)>>2;
1430             b += g;
1431             r += g;
1432
1433             src[x + stride*y]= b + (g<<8) + (r<<16) + (a<<24);
1434         }
1435     }
1436 }
1437
1438 static int decode_slice(AVCodecContext *c, void *arg){
1439     FFV1Context *fs= *(void**)arg;
1440     FFV1Context *f= fs->avctx->priv_data;
1441     int width = fs->slice_width;
1442     int height= fs->slice_height;
1443     int x= fs->slice_x;
1444     int y= fs->slice_y;
1445     const int ps= (c->bits_per_raw_sample>8)+1;
1446     AVFrame * const p= &f->picture;
1447
1448     av_assert1(width && height);
1449     if(f->colorspace==0){
1450         const int chroma_width = -((-width )>>f->chroma_h_shift);
1451         const int chroma_height= -((-height)>>f->chroma_v_shift);
1452         const int cx= x>>f->chroma_h_shift;
1453         const int cy= y>>f->chroma_v_shift;
1454         decode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0);
1455
1456         if (f->chroma_planes){
1457             decode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
1458             decode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1);
1459         }
1460         if (fs->transparency)
1461             decode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2);
1462     }else{
1463         decode_rgb_frame(fs, (uint32_t*)p->data[0] + ps*x + y*(p->linesize[0]/4), width, height, p->linesize[0]/4);
1464     }
1465
1466     emms_c();
1467
1468     return 0;
1469 }
1470
1471 static int read_quant_table(RangeCoder *c, int16_t *quant_table, int scale){
1472     int v;
1473     int i=0;
1474     uint8_t state[CONTEXT_SIZE];
1475
1476     memset(state, 128, sizeof(state));
1477
1478     for(v=0; i<128 ; v++){
1479         int len= get_symbol(c, state, 0) + 1;
1480
1481         if(len + i > 128) return -1;
1482
1483         while(len--){
1484             quant_table[i] = scale*v;
1485             i++;
1486 //printf("%2d ",v);
1487 //if(i%16==0) printf("\n");
1488         }
1489     }
1490
1491     for(i=1; i<128; i++){
1492         quant_table[256-i]= -quant_table[i];
1493     }
1494     quant_table[128]= -quant_table[127];
1495
1496     return 2*v - 1;
1497 }
1498
1499 static int read_quant_tables(RangeCoder *c, int16_t quant_table[MAX_CONTEXT_INPUTS][256]){
1500     int i;
1501     int context_count=1;
1502
1503     for(i=0; i<5; i++){
1504         context_count*= read_quant_table(c, quant_table[i], context_count);
1505         if(context_count > 32768U){
1506             return -1;
1507         }
1508     }
1509     return (context_count+1)/2;
1510 }
1511
1512 static int read_extra_header(FFV1Context *f){
1513     RangeCoder * const c= &f->c;
1514     uint8_t state[CONTEXT_SIZE];
1515     int i, j, k;
1516     uint8_t state2[32][CONTEXT_SIZE];
1517
1518     memset(state2, 128, sizeof(state2));
1519     memset(state, 128, sizeof(state));
1520
1521     ff_init_range_decoder(c, f->avctx->extradata, f->avctx->extradata_size);
1522     ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1523
1524     f->version= get_symbol(c, state, 0);
1525     f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
1526     if(f->ac>1){
1527         for(i=1; i<256; i++){
1528             f->state_transition[i]= get_symbol(c, state, 1) + c->one_state[i];
1529         }
1530     }
1531     f->colorspace= get_symbol(c, state, 0); //YUV cs type
1532     f->avctx->bits_per_raw_sample= get_symbol(c, state, 0);
1533     get_rac(c, state); //no chroma = false
1534     f->chroma_h_shift= get_symbol(c, state, 0);
1535     f->chroma_v_shift= get_symbol(c, state, 0);
1536     f->transparency= get_rac(c, state);
1537     f->plane_count= 2 + f->transparency;
1538     f->num_h_slices= 1 + get_symbol(c, state, 0);
1539     f->num_v_slices= 1 + get_symbol(c, state, 0);
1540     if(f->num_h_slices > (unsigned)f->width || f->num_v_slices > (unsigned)f->height){
1541         av_log(f->avctx, AV_LOG_ERROR, "too many slices\n");
1542         return -1;
1543     }
1544
1545     f->quant_table_count= get_symbol(c, state, 0);
1546     if(f->quant_table_count > (unsigned)MAX_QUANT_TABLES)
1547         return -1;
1548     for(i=0; i<f->quant_table_count; i++){
1549         if((f->context_count[i]= read_quant_tables(c, f->quant_tables[i])) < 0){
1550             av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
1551             return -1;
1552         }
1553     }
1554
1555     if(allocate_initial_states(f) < 0)
1556         return AVERROR(ENOMEM);
1557
1558     for(i=0; i<f->quant_table_count; i++){
1559         if(get_rac(c, state)){
1560             for(j=0; j<f->context_count[i]; j++){
1561                 for(k=0; k<CONTEXT_SIZE; k++){
1562                     int pred= j ? f->initial_states[i][j-1][k] : 128;
1563                     f->initial_states[i][j][k]= (pred+get_symbol(c, state2[k], 1))&0xFF;
1564                 }
1565             }
1566         }
1567     }
1568
1569     return 0;
1570 }
1571
1572 static int read_header(FFV1Context *f){
1573     uint8_t state[CONTEXT_SIZE];
1574     int i, j, context_count;
1575     RangeCoder * const c= &f->slice_context[0]->c;
1576
1577     memset(state, 128, sizeof(state));
1578
1579     if(f->version < 2){
1580         f->version= get_symbol(c, state, 0);
1581         f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
1582         if(f->ac>1){
1583             for(i=1; i<256; i++){
1584                 f->state_transition[i]= get_symbol(c, state, 1) + c->one_state[i];
1585             }
1586         }
1587         f->colorspace= get_symbol(c, state, 0); //YUV cs type
1588         if(f->version>0)
1589             f->avctx->bits_per_raw_sample= get_symbol(c, state, 0);
1590         f->chroma_planes= get_rac(c, state);
1591         f->chroma_h_shift= get_symbol(c, state, 0);
1592         f->chroma_v_shift= get_symbol(c, state, 0);
1593         f->transparency= get_rac(c, state);
1594         f->plane_count= 2 + f->transparency;
1595     }
1596
1597     if(f->colorspace==0){
1598         if(!f->transparency && !f->chroma_planes){
1599             if (f->avctx->bits_per_raw_sample<=8)
1600                 f->avctx->pix_fmt= PIX_FMT_GRAY8;
1601             else
1602                 f->avctx->pix_fmt= PIX_FMT_GRAY16;
1603         }else if(f->avctx->bits_per_raw_sample<=8 && !f->transparency){
1604             switch(16*f->chroma_h_shift + f->chroma_v_shift){
1605             case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P; break;
1606             case 0x01: f->avctx->pix_fmt= PIX_FMT_YUV440P; break;
1607             case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P; break;
1608             case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P; break;
1609             case 0x20: f->avctx->pix_fmt= PIX_FMT_YUV411P; break;
1610             case 0x22: f->avctx->pix_fmt= PIX_FMT_YUV410P; break;
1611             default:
1612                 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1613                 return -1;
1614             }
1615         }else if(f->avctx->bits_per_raw_sample<=8 && f->transparency){
1616             switch(16*f->chroma_h_shift + f->chroma_v_shift){
1617             case 0x00: f->avctx->pix_fmt= PIX_FMT_YUVA444P; break;
1618             case 0x11: f->avctx->pix_fmt= PIX_FMT_YUVA420P; break;
1619             default:
1620                 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1621                 return -1;
1622             }
1623         }else if(f->avctx->bits_per_raw_sample==9) {
1624             switch(16*f->chroma_h_shift + f->chroma_v_shift){
1625             case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P16; break;
1626             case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P16; break;
1627             case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P9 ; f->packed_at_lsb=1; break;
1628             default:
1629                 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1630                 return -1;
1631             }
1632         }else if(f->avctx->bits_per_raw_sample==10) {
1633             switch(16*f->chroma_h_shift + f->chroma_v_shift){
1634             case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P16; break;
1635             case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P10; f->packed_at_lsb=1; break;
1636             case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P10; f->packed_at_lsb=1; break;
1637             default:
1638                 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1639                 return -1;
1640             }
1641         }else {
1642             switch(16*f->chroma_h_shift + f->chroma_v_shift){
1643             case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P16; break;
1644             case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P16; break;
1645             case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P16; break;
1646             default:
1647                 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1648                 return -1;
1649             }
1650         }
1651     }else if(f->colorspace==1){
1652         if(f->chroma_h_shift || f->chroma_v_shift){
1653             av_log(f->avctx, AV_LOG_ERROR, "chroma subsampling not supported in this colorspace\n");
1654             return -1;
1655         }
1656         if(f->transparency) f->avctx->pix_fmt= PIX_FMT_RGB32;
1657         else                f->avctx->pix_fmt= PIX_FMT_0RGB32;
1658     }else{
1659         av_log(f->avctx, AV_LOG_ERROR, "colorspace not supported\n");
1660         return -1;
1661     }
1662
1663 //printf("%d %d %d\n", f->chroma_h_shift, f->chroma_v_shift,f->avctx->pix_fmt);
1664     if(f->version < 2){
1665         context_count= read_quant_tables(c, f->quant_table);
1666         if(context_count < 0){
1667                 av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
1668                 return -1;
1669         }
1670     }else{
1671         f->slice_count= get_symbol(c, state, 0);
1672         if(f->slice_count > (unsigned)MAX_SLICES)
1673             return -1;
1674     }
1675
1676     for(j=0; j<f->slice_count; j++){
1677         FFV1Context *fs= f->slice_context[j];
1678         fs->ac= f->ac;
1679         fs->packed_at_lsb= f->packed_at_lsb;
1680
1681         if(f->version >= 2){
1682             fs->slice_x     = get_symbol(c, state, 0)   *f->width ;
1683             fs->slice_y     = get_symbol(c, state, 0)   *f->height;
1684             fs->slice_width =(get_symbol(c, state, 0)+1)*f->width  + fs->slice_x;
1685             fs->slice_height=(get_symbol(c, state, 0)+1)*f->height + fs->slice_y;
1686
1687             fs->slice_x /= f->num_h_slices;
1688             fs->slice_y /= f->num_v_slices;
1689             fs->slice_width  = fs->slice_width /f->num_h_slices - fs->slice_x;
1690             fs->slice_height = fs->slice_height/f->num_v_slices - fs->slice_y;
1691             if((unsigned)fs->slice_width > f->width || (unsigned)fs->slice_height > f->height)
1692                 return -1;
1693             if(    (unsigned)fs->slice_x + (uint64_t)fs->slice_width  > f->width
1694                 || (unsigned)fs->slice_y + (uint64_t)fs->slice_height > f->height)
1695                 return -1;
1696         }
1697
1698         for(i=0; i<f->plane_count; i++){
1699             PlaneContext * const p= &fs->plane[i];
1700
1701             if(f->version >= 2){
1702                 int idx=get_symbol(c, state, 0);
1703                 if(idx > (unsigned)f->quant_table_count){
1704                     av_log(f->avctx, AV_LOG_ERROR, "quant_table_index out of range\n");
1705                     return -1;
1706                 }
1707                 p->quant_table_index= idx;
1708                 memcpy(p->quant_table, f->quant_tables[idx], sizeof(p->quant_table));
1709                 context_count= f->context_count[idx];
1710             }else{
1711                 memcpy(p->quant_table, f->quant_table, sizeof(p->quant_table));
1712             }
1713
1714             if(p->context_count < context_count){
1715                 av_freep(&p->state);
1716                 av_freep(&p->vlc_state);
1717             }
1718             p->context_count= context_count;
1719         }
1720     }
1721
1722     return 0;
1723 }
1724
1725 static av_cold int decode_init(AVCodecContext *avctx)
1726 {
1727     FFV1Context *f = avctx->priv_data;
1728
1729     common_init(avctx);
1730
1731     if(avctx->extradata && read_extra_header(f) < 0)
1732         return -1;
1733
1734     if(init_slice_contexts(f) < 0)
1735         return -1;
1736
1737     return 0;
1738 }
1739
1740 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){
1741     const uint8_t *buf = avpkt->data;
1742     int buf_size = avpkt->size;
1743     FFV1Context *f = avctx->priv_data;
1744     RangeCoder * const c= &f->slice_context[0]->c;
1745     AVFrame * const p= &f->picture;
1746     int bytes_read, i;
1747     uint8_t keystate= 128;
1748     const uint8_t *buf_p;
1749
1750     AVFrame *picture = data;
1751
1752     /* release previously stored data */
1753     if (p->data[0])
1754         avctx->release_buffer(avctx, p);
1755
1756     ff_init_range_decoder(c, buf, buf_size);
1757     ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1758
1759
1760     p->pict_type= AV_PICTURE_TYPE_I; //FIXME I vs. P
1761     if(get_rac(c, &keystate)){
1762         p->key_frame= 1;
1763         if(read_header(f) < 0)
1764             return -1;
1765         if(init_slice_state(f) < 0)
1766             return -1;
1767
1768         clear_state(f);
1769     }else{
1770         p->key_frame= 0;
1771     }
1772     if(f->ac>1){
1773         int i;
1774         for(i=1; i<256; i++){
1775             c->one_state[i]= f->state_transition[i];
1776             c->zero_state[256-i]= 256-c->one_state[i];
1777         }
1778     }
1779
1780     p->reference= 0;
1781     if(avctx->get_buffer(avctx, p) < 0){
1782         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1783         return -1;
1784     }
1785
1786     if(avctx->debug&FF_DEBUG_PICT_INFO)
1787         av_log(avctx, AV_LOG_ERROR, "keyframe:%d coder:%d\n", p->key_frame, f->ac);
1788
1789     if(!f->ac){
1790         bytes_read = c->bytestream - c->bytestream_start - 1;
1791         if(bytes_read ==0) av_log(avctx, AV_LOG_ERROR, "error at end of AC stream\n"); //FIXME
1792 //printf("pos=%d\n", bytes_read);
1793         init_get_bits(&f->slice_context[0]->gb, buf + bytes_read, (buf_size - bytes_read) * 8);
1794     } else {
1795         bytes_read = 0; /* avoid warning */
1796     }
1797
1798     buf_p= buf + buf_size;
1799     for(i=f->slice_count-1; i>0; i--){
1800         FFV1Context *fs= f->slice_context[i];
1801         int v= AV_RB24(buf_p-3)+3;
1802         if(buf_p - buf <= v){
1803             av_log(avctx, AV_LOG_ERROR, "Slice pointer chain broken\n");
1804             return -1;
1805         }
1806         buf_p -= v;
1807         if(fs->ac){
1808             ff_init_range_decoder(&fs->c, buf_p, v);
1809         }else{
1810             init_get_bits(&fs->gb, buf_p, v * 8);
1811         }
1812     }
1813
1814     avctx->execute(avctx, decode_slice, &f->slice_context[0], NULL, f->slice_count, sizeof(void*));
1815     f->picture_number++;
1816
1817     *picture= *p;
1818     *data_size = sizeof(AVFrame);
1819
1820     return buf_size;
1821 }
1822
1823 AVCodec ff_ffv1_decoder = {
1824     .name           = "ffv1",
1825     .type           = AVMEDIA_TYPE_VIDEO,
1826     .id             = CODEC_ID_FFV1,
1827     .priv_data_size = sizeof(FFV1Context),
1828     .init           = decode_init,
1829     .close          = common_end,
1830     .decode         = decode_frame,
1831     .capabilities   = CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/ | CODEC_CAP_SLICE_THREADS,
1832     .long_name= NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1833 };
1834
1835 #if CONFIG_FFV1_ENCODER
1836 AVCodec ff_ffv1_encoder = {
1837     .name           = "ffv1",
1838     .type           = AVMEDIA_TYPE_VIDEO,
1839     .id             = CODEC_ID_FFV1,
1840     .priv_data_size = sizeof(FFV1Context),
1841     .init           = encode_init,
1842     .encode         = encode_frame,
1843     .close          = common_end,
1844     .capabilities = CODEC_CAP_SLICE_THREADS,
1845     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_YUVA420P, PIX_FMT_YUV444P, PIX_FMT_YUVA444P, PIX_FMT_YUV440P, PIX_FMT_YUV422P, PIX_FMT_YUV411P, PIX_FMT_YUV410P, PIX_FMT_0RGB32, PIX_FMT_RGB32, PIX_FMT_YUV420P16, PIX_FMT_YUV422P16, PIX_FMT_YUV444P16, PIX_FMT_YUV420P9, PIX_FMT_YUV420P10, PIX_FMT_YUV422P10, PIX_FMT_GRAY16, PIX_FMT_GRAY8, PIX_FMT_NONE},
1846     .long_name= NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1847 };
1848 #endif