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     ff_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_YUV444P9:
 881     case PIX_FMT_YUV422P9:
 882     case PIX_FMT_YUV420P9:
 883         if (!avctx->bits_per_raw_sample)
 884             s->bits_per_raw_sample = 9;
 885     case PIX_FMT_YUV444P10:
 886     case PIX_FMT_YUV420P10:
 887     case PIX_FMT_YUV422P10:
 888         s->packed_at_lsb = 1;
 889         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
 890             s->bits_per_raw_sample = 10;
 891     case PIX_FMT_GRAY16:
 892     case PIX_FMT_YUV444P16:
 893     case PIX_FMT_YUV422P16:
 894     case PIX_FMT_YUV420P16:
 895         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {
 896             s->bits_per_raw_sample = 16;
 897         } else if (!s->bits_per_raw_sample){
 898             s->bits_per_raw_sample = avctx->bits_per_raw_sample;
 899         }
 900         if(s->bits_per_raw_sample <=8){
 901             av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
 902             return -1;
 903         }
 904         if(!s->ac){
 905             av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample of more than 8 needs -coder 1 currently\n");
 906             return -1;
 907         }
 908         s->version= FFMAX(s->version, 1);
 909     case PIX_FMT_GRAY8:
 910     case PIX_FMT_YUV444P:
 911     case PIX_FMT_YUV440P:
 912     case PIX_FMT_YUV422P:
 913     case PIX_FMT_YUV420P:
 914     case PIX_FMT_YUV411P:
 915     case PIX_FMT_YUV410P:
 916         s->chroma_planes= av_pix_fmt_descriptors[avctx->pix_fmt].nb_components < 3 ? 0 : 1;
 917         s->colorspace= 0;
 918         break;
 919     case PIX_FMT_YUVA444P:
 920     case PIX_FMT_YUVA420P:
 921         s->chroma_planes= 1;
 922         s->colorspace= 0;
 923         s->transparency= 1;
 924         break;
 925     case PIX_FMT_RGB32:
 926         s->colorspace= 1;
 927         s->transparency= 1;
 928         break;
 929     case PIX_FMT_0RGB32:
 930         s->colorspace= 1;
 931         break;
 932     default:
 933         av_log(avctx, AV_LOG_ERROR, "format not supported\n");
 934         return -1;
 935     }
 936     if (s->transparency) {
 937         av_log(avctx, AV_LOG_WARNING, "Storing alpha plane, this will require a recent FFV1 decoder to playback!\n");
 938     }
 939
 940     for(i=0; i<256; i++){
 941         s->quant_table_count=2;
 942         if(s->bits_per_raw_sample <=8){
 943             s->quant_tables[0][0][i]=           quant11[i];
 944             s->quant_tables[0][1][i]=        11*quant11[i];
 945             s->quant_tables[0][2][i]=     11*11*quant11[i];
 946             s->quant_tables[1][0][i]=           quant11[i];
 947             s->quant_tables[1][1][i]=        11*quant11[i];
 948             s->quant_tables[1][2][i]=     11*11*quant5 [i];
 949             s->quant_tables[1][3][i]=   5*11*11*quant5 [i];
 950             s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
 951         }else{
 952             s->quant_tables[0][0][i]=           quant9_10bit[i];
 953             s->quant_tables[0][1][i]=        11*quant9_10bit[i];
 954             s->quant_tables[0][2][i]=     11*11*quant9_10bit[i];
 955             s->quant_tables[1][0][i]=           quant9_10bit[i];
 956             s->quant_tables[1][1][i]=        11*quant9_10bit[i];
 957             s->quant_tables[1][2][i]=     11*11*quant5_10bit[i];
 958             s->quant_tables[1][3][i]=   5*11*11*quant5_10bit[i];
 959             s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
 960         }
 961     }
 962     s->context_count[0]= (11*11*11+1)/2;
 963     s->context_count[1]= (11*11*5*5*5+1)/2;
 964     memcpy(s->quant_table, s->quant_tables[avctx->context_model], sizeof(s->quant_table));
 965
 966     for(i=0; i<s->plane_count; i++){
 967         PlaneContext * const p= &s->plane[i];
 968
 969         memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
 970         p->quant_table_index= avctx->context_model;
 971         p->context_count= s->context_count[p->quant_table_index];
 972     }
 973
 974     if(allocate_initial_states(s) < 0)
 975         return AVERROR(ENOMEM);
 976
 977     avctx->coded_frame= &s->picture;
 978     if(!s->transparency)
 979         s->plane_count= 2;
 980     avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
 981
 982     s->picture_number=0;
 983
 984     if(avctx->flags & (CODEC_FLAG_PASS1|CODEC_FLAG_PASS2)){
 985         for(i=0; i<s->quant_table_count; i++){
 986             s->rc_stat2[i]= av_mallocz(s->context_count[i]*sizeof(*s->rc_stat2[i]));
 987             if(!s->rc_stat2[i])
 988                 return AVERROR(ENOMEM);
 989         }
 990     }
 991     if(avctx->stats_in){
 992         char *p= avctx->stats_in;
 993         uint8_t best_state[256][256];
 994         int gob_count=0;
 995         char *next;
 996
 997         av_assert0(s->version>=2);
 998
 999         for(;;){
1000             for(j=0; j<256; j++){
1001                 for(i=0; i<2; i++){
1002                     s->rc_stat[j][i]= strtol(p, &next, 0);
1003                     if(next==p){
1004                         av_log(avctx, AV_LOG_ERROR, "2Pass file invalid at %d %d [%s]\n", j,i,p);
1005                         return -1;
1006                     }
1007                     p=next;
1008                 }
1009             }
1010             for(i=0; i<s->quant_table_count; i++){
1011                 for(j=0; j<s->context_count[i]; j++){
1012                     for(k=0; k<32; k++){
1013                         for(m=0; m<2; m++){
1014                             s->rc_stat2[i][j][k][m]= strtol(p, &next, 0);
1015                             if(next==p){
1016                                 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid at %d %d %d %d [%s]\n", i,j,k,m,p);
1017                                 return -1;
1018                             }
1019                             p=next;
1020                         }
1021                     }
1022                 }
1023             }
1024             gob_count= strtol(p, &next, 0);
1025             if(next==p || gob_count <0){
1026                 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
1027                 return -1;
1028             }
1029             p=next;
1030             while(*p=='\n' || *p==' ') p++;
1031             if(p[0]==0) break;
1032         }
1033         sort_stt(s, s->state_transition);
1034
1035         find_best_state(best_state, s->state_transition);
1036
1037         for(i=0; i<s->quant_table_count; i++){
1038             for(j=0; j<s->context_count[i]; j++){
1039                 for(k=0; k<32; k++){
1040                     double p= 128;
1041                     if(s->rc_stat2[i][j][k][0]+s->rc_stat2[i][j][k][1]){
1042                         p=256.0*s->rc_stat2[i][j][k][1] / (s->rc_stat2[i][j][k][0]+s->rc_stat2[i][j][k][1]);
1043                     }
1044                     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)];
1045                 }
1046             }
1047         }
1048     }
1049
1050     if(s->version>1){
1051         s->num_h_slices=2;
1052         s->num_v_slices=2;
1053         write_extra_header(s);
1054     }
1055
1056     if(init_slice_contexts(s) < 0)
1057         return -1;
1058     if(init_slice_state(s) < 0)
1059         return -1;
1060
1061 #define STATS_OUT_SIZE 1024*1024*6
1062     if(avctx->flags & CODEC_FLAG_PASS1){
1063         avctx->stats_out= av_mallocz(STATS_OUT_SIZE);
1064         for(i=0; i<s->quant_table_count; i++){
1065             for(j=0; j<s->slice_count; j++){
1066                 FFV1Context *sf= s->slice_context[j];
1067                 av_assert0(!sf->rc_stat2[i]);
1068                 sf->rc_stat2[i]= av_mallocz(s->context_count[i]*sizeof(*sf->rc_stat2[i]));
1069                 if(!sf->rc_stat2[i])
1070                     return AVERROR(ENOMEM);
1071             }
1072         }
1073     }
1074
1075     return 0;
1076 }
1077 #endif /* CONFIG_FFV1_ENCODER */
1078
1079
1080 static void clear_state(FFV1Context *f){
1081     int i, si, j;
1082
1083     for(si=0; si<f->slice_count; si++){
1084         FFV1Context *fs= f->slice_context[si];
1085         for(i=0; i<f->plane_count; i++){
1086             PlaneContext *p= &fs->plane[i];
1087
1088             p->interlace_bit_state[0]= 128;
1089             p->interlace_bit_state[1]= 128;
1090
1091             if(fs->ac){
1092                 if(f->initial_states[p->quant_table_index]){
1093                     memcpy(p->state, f->initial_states[p->quant_table_index], CONTEXT_SIZE*p->context_count);
1094                 }else
1095                 memset(p->state, 128, CONTEXT_SIZE*p->context_count);
1096             }else{
1097                 for(j=0; j<p->context_count; j++){
1098                     p->vlc_state[j].drift= 0;
1099                     p->vlc_state[j].error_sum= 4; //FFMAX((RANGE + 32)/64, 2);
1100                     p->vlc_state[j].bias= 0;
1101                     p->vlc_state[j].count= 1;
1102                 }
1103             }
1104         }
1105     }
1106 }
1107
1108 #if CONFIG_FFV1_ENCODER
1109 static int encode_slice(AVCodecContext *c, void *arg){
1110     FFV1Context *fs= *(void**)arg;
1111     FFV1Context *f= fs->avctx->priv_data;
1112     int width = fs->slice_width;
1113     int height= fs->slice_height;
1114     int x= fs->slice_x;
1115     int y= fs->slice_y;
1116     AVFrame * const p= &f->picture;
1117     const int ps= (f->bits_per_raw_sample>8)+1;
1118
1119     if(f->colorspace==0){
1120         const int chroma_width = -((-width )>>f->chroma_h_shift);
1121         const int chroma_height= -((-height)>>f->chroma_v_shift);
1122         const int cx= x>>f->chroma_h_shift;
1123         const int cy= y>>f->chroma_v_shift;
1124
1125         encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0);
1126
1127         if (f->chroma_planes){
1128             encode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
1129             encode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1);
1130         }
1131         if (fs->transparency)
1132             encode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2);
1133     }else{
1134         encode_rgb_frame(fs, (uint32_t*)(p->data[0]) + ps*x + y*(p->linesize[0]/4), width, height, p->linesize[0]/4);
1135     }
1136     emms_c();
1137
1138     return 0;
1139 }
1140
1141 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1142                         const AVFrame *pict, int *got_packet)
1143 {
1144     FFV1Context *f = avctx->priv_data;
1145     RangeCoder * const c= &f->slice_context[0]->c;
1146     AVFrame * const p= &f->picture;
1147     int used_count= 0;
1148     uint8_t keystate=128;
1149     uint8_t *buf_p;
1150     int i, ret;
1151
1152     if (!pkt->data &&
1153         (ret = av_new_packet(pkt, avctx->width*avctx->height*((8*2+1+1)*4)/8
1154                                   + FF_MIN_BUFFER_SIZE)) < 0) {
1155         av_log(avctx, AV_LOG_ERROR, "Error getting output packet.\n");
1156         return ret;
1157     }
1158
1159     ff_init_range_encoder(c, pkt->data, pkt->size);
1160     ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1161
1162     *p = *pict;
1163     p->pict_type= AV_PICTURE_TYPE_I;
1164
1165     if(avctx->gop_size==0 || f->picture_number % avctx->gop_size == 0){
1166         put_rac(c, &keystate, 1);
1167         p->key_frame= 1;
1168         f->gob_count++;
1169         write_header(f);
1170         clear_state(f);
1171     }else{
1172         put_rac(c, &keystate, 0);
1173         p->key_frame= 0;
1174     }
1175
1176     if(!f->ac){
1177         used_count += ff_rac_terminate(c);
1178 //printf("pos=%d\n", used_count);
1179         init_put_bits(&f->slice_context[0]->pb, pkt->data + used_count, pkt->size - used_count);
1180     }else if (f->ac>1){
1181         int i;
1182         for(i=1; i<256; i++){
1183             c->one_state[i]= f->state_transition[i];
1184             c->zero_state[256-i]= 256-c->one_state[i];
1185         }
1186     }
1187
1188     for(i=1; i<f->slice_count; i++){
1189         FFV1Context *fs= f->slice_context[i];
1190         uint8_t *start = pkt->data + (pkt->size-used_count)*i/f->slice_count;
1191         int len = pkt->size/f->slice_count;
1192
1193         if(fs->ac){
1194             ff_init_range_encoder(&fs->c, start, len);
1195         }else{
1196             init_put_bits(&fs->pb, start, len);
1197         }
1198     }
1199     avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL, f->slice_count, sizeof(void*));
1200
1201     buf_p = pkt->data;
1202     for(i=0; i<f->slice_count; i++){
1203         FFV1Context *fs= f->slice_context[i];
1204         int bytes;
1205
1206         if(fs->ac){
1207             uint8_t state=128;
1208             put_rac(&fs->c, &state, 0);
1209             bytes= ff_rac_terminate(&fs->c);
1210         }else{
1211             flush_put_bits(&fs->pb); //nicer padding FIXME
1212             bytes= used_count + (put_bits_count(&fs->pb)+7)/8;
1213             used_count= 0;
1214         }
1215         if(i>0){
1216             av_assert0(bytes < pkt->size/f->slice_count);
1217             memmove(buf_p, fs->ac ? fs->c.bytestream_start : fs->pb.buf, bytes);
1218             av_assert0(bytes < (1<<24));
1219             AV_WB24(buf_p+bytes, bytes);
1220             bytes+=3;
1221         }
1222         buf_p += bytes;
1223     }
1224
1225     if((avctx->flags&CODEC_FLAG_PASS1) && (f->picture_number&31)==0){
1226         int j, k, m;
1227         char *p= avctx->stats_out;
1228         char *end= p + STATS_OUT_SIZE;
1229
1230         memset(f->rc_stat, 0, sizeof(f->rc_stat));
1231         for(i=0; i<f->quant_table_count; i++)
1232             memset(f->rc_stat2[i], 0, f->context_count[i]*sizeof(*f->rc_stat2[i]));
1233
1234         for(j=0; j<f->slice_count; j++){
1235             FFV1Context *fs= f->slice_context[j];
1236             for(i=0; i<256; i++){
1237                 f->rc_stat[i][0] += fs->rc_stat[i][0];
1238                 f->rc_stat[i][1] += fs->rc_stat[i][1];
1239             }
1240             for(i=0; i<f->quant_table_count; i++){
1241                 for(k=0; k<f->context_count[i]; k++){
1242                     for(m=0; m<32; m++){
1243                         f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1244                         f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1245                     }
1246                 }
1247             }
1248         }
1249
1250         for(j=0; j<256; j++){
1251             snprintf(p, end-p, "%"PRIu64" %"PRIu64" ", f->rc_stat[j][0], f->rc_stat[j][1]);
1252             p+= strlen(p);
1253         }
1254         snprintf(p, end-p, "\n");
1255
1256         for(i=0; i<f->quant_table_count; i++){
1257             for(j=0; j<f->context_count[i]; j++){
1258                 for(m=0; m<32; m++){
1259                     snprintf(p, end-p, "%"PRIu64" %"PRIu64" ", f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1260                     p+= strlen(p);
1261                 }
1262             }
1263         }
1264         snprintf(p, end-p, "%d\n", f->gob_count);
1265     } else if(avctx->flags&CODEC_FLAG_PASS1)
1266         avctx->stats_out[0] = '\0';
1267
1268     f->picture_number++;
1269     pkt->size   = buf_p - pkt->data;
1270     pkt->flags |= AV_PKT_FLAG_KEY*p->key_frame;
1271     *got_packet = 1;
1272
1273     return 0;
1274 }
1275 #endif /* CONFIG_FFV1_ENCODER */
1276
1277 static av_cold int common_end(AVCodecContext *avctx){
1278     FFV1Context *s = avctx->priv_data;
1279     int i, j;
1280
1281     if (avctx->codec->decode && s->picture.data[0])
1282         avctx->release_buffer(avctx, &s->picture);
1283
1284     for(j=0; j<s->slice_count; j++){
1285         FFV1Context *fs= s->slice_context[j];
1286         for(i=0; i<s->plane_count; i++){
1287             PlaneContext *p= &fs->plane[i];
1288
1289             av_freep(&p->state);
1290             av_freep(&p->vlc_state);
1291         }
1292         av_freep(&fs->sample_buffer);
1293     }
1294
1295     av_freep(&avctx->stats_out);
1296     for(j=0; j<s->quant_table_count; j++){
1297         av_freep(&s->initial_states[j]);
1298         for(i=0; i<s->slice_count; i++){
1299             FFV1Context *sf= s->slice_context[i];
1300             av_freep(&sf->rc_stat2[j]);
1301         }
1302         av_freep(&s->rc_stat2[j]);
1303     }
1304
1305     for(i=0; i<s->slice_count; i++){
1306         av_freep(&s->slice_context[i]);
1307     }
1308
1309     return 0;
1310 }
1311
1312 static av_always_inline void decode_line(FFV1Context *s, int w,
1313                                          int16_t *sample[2],
1314                                          int plane_index, int bits)
1315 {
1316     PlaneContext * const p= &s->plane[plane_index];
1317     RangeCoder * const c= &s->c;
1318     int x;
1319     int run_count=0;
1320     int run_mode=0;
1321     int run_index= s->run_index;
1322
1323     for(x=0; x<w; x++){
1324         int diff, context, sign;
1325
1326         context= get_context(p, sample[1] + x, sample[0] + x, sample[1] + x);
1327         if(context < 0){
1328             context= -context;
1329             sign=1;
1330         }else
1331             sign=0;
1332
1333         av_assert2(context < p->context_count);
1334
1335         if(s->ac){
1336             diff= get_symbol_inline(c, p->state[context], 1);
1337         }else{
1338             if(context == 0 && run_mode==0) run_mode=1;
1339
1340             if(run_mode){
1341                 if(run_count==0 && run_mode==1){
1342                     if(get_bits1(&s->gb)){
1343                         run_count = 1<<ff_log2_run[run_index];
1344                         if(x + run_count <= w) run_index++;
1345                     }else{
1346                         if(ff_log2_run[run_index]) run_count = get_bits(&s->gb, ff_log2_run[run_index]);
1347                         else run_count=0;
1348                         if(run_index) run_index--;
1349                         run_mode=2;
1350                     }
1351                 }
1352                 run_count--;
1353                 if(run_count < 0){
1354                     run_mode=0;
1355                     run_count=0;
1356                     diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
1357                     if(diff>=0) diff++;
1358                 }else
1359                     diff=0;
1360             }else
1361                 diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
1362
1363 //            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));
1364         }
1365
1366         if(sign) diff= -diff;
1367
1368         sample[1][x]= (predict(sample[1] + x, sample[0] + x) + diff) & ((1<<bits)-1);
1369     }
1370     s->run_index= run_index;
1371 }
1372
1373 static void decode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
1374     int x, y;
1375     int16_t *sample[2];
1376     sample[0]=s->sample_buffer    +3;
1377     sample[1]=s->sample_buffer+w+6+3;
1378
1379     s->run_index=0;
1380
1381     memset(s->sample_buffer, 0, 2*(w+6)*sizeof(*s->sample_buffer));
1382
1383     for(y=0; y<h; y++){
1384         int16_t *temp = sample[0]; //FIXME try a normal buffer
1385
1386         sample[0]= sample[1];
1387         sample[1]= temp;
1388
1389         sample[1][-1]= sample[0][0  ];
1390         sample[0][ w]= sample[0][w-1];
1391
1392 //{START_TIMER
1393         if(s->avctx->bits_per_raw_sample <= 8){
1394             decode_line(s, w, sample, plane_index, 8);
1395             for(x=0; x<w; x++){
1396                 src[x + stride*y]= sample[1][x];
1397             }
1398         }else{
1399             decode_line(s, w, sample, plane_index, s->avctx->bits_per_raw_sample);
1400             if(s->packed_at_lsb){
1401                 for(x=0; x<w; x++){
1402                     ((uint16_t*)(src + stride*y))[x]= sample[1][x];
1403                 }
1404             }else{
1405                 for(x=0; x<w; x++){
1406                     ((uint16_t*)(src + stride*y))[x]= sample[1][x] << (16 - s->avctx->bits_per_raw_sample);
1407                 }
1408             }
1409         }
1410 //STOP_TIMER("decode-line")}
1411     }
1412 }
1413
1414 static void decode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
1415     int x, y, p;
1416     int16_t *sample[4][2];
1417     for(x=0; x<4; x++){
1418         sample[x][0] = s->sample_buffer +  x*2   *(w+6) + 3;
1419         sample[x][1] = s->sample_buffer + (x*2+1)*(w+6) + 3;
1420     }
1421
1422     s->run_index=0;
1423
1424     memset(s->sample_buffer, 0, 8*(w+6)*sizeof(*s->sample_buffer));
1425
1426     for(y=0; y<h; y++){
1427         for(p=0; p<3 + s->transparency; p++){
1428             int16_t *temp = sample[p][0]; //FIXME try a normal buffer
1429
1430             sample[p][0]= sample[p][1];
1431             sample[p][1]= temp;
1432
1433             sample[p][1][-1]= sample[p][0][0  ];
1434             sample[p][0][ w]= sample[p][0][w-1];
1435             decode_line(s, w, sample[p], (p+1)/2, 9);
1436         }
1437         for(x=0; x<w; x++){
1438             int g= sample[0][1][x];
1439             int b= sample[1][1][x];
1440             int r= sample[2][1][x];
1441             int a= sample[3][1][x];
1442
1443 //            assert(g>=0 && b>=0 && r>=0);
1444 //            assert(g<256 && b<512 && r<512);
1445
1446             b -= 0x100;
1447             r -= 0x100;
1448             g -= (b + r)>>2;
1449             b += g;
1450             r += g;
1451
1452             src[x + stride*y]= b + (g<<8) + (r<<16) + (a<<24);
1453         }
1454     }
1455 }
1456
1457 static int decode_slice(AVCodecContext *c, void *arg){
1458     FFV1Context *fs= *(void**)arg;
1459     FFV1Context *f= fs->avctx->priv_data;
1460     int width = fs->slice_width;
1461     int height= fs->slice_height;
1462     int x= fs->slice_x;
1463     int y= fs->slice_y;
1464     const int ps= (c->bits_per_raw_sample>8)+1;
1465     AVFrame * const p= &f->picture;
1466
1467     av_assert1(width && height);
1468     if(f->colorspace==0){
1469         const int chroma_width = -((-width )>>f->chroma_h_shift);
1470         const int chroma_height= -((-height)>>f->chroma_v_shift);
1471         const int cx= x>>f->chroma_h_shift;
1472         const int cy= y>>f->chroma_v_shift;
1473         decode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0);
1474
1475         if (f->chroma_planes){
1476             decode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
1477             decode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1);
1478         }
1479         if (fs->transparency)
1480             decode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2);
1481     }else{
1482         decode_rgb_frame(fs, (uint32_t*)p->data[0] + ps*x + y*(p->linesize[0]/4), width, height, p->linesize[0]/4);
1483     }
1484
1485     emms_c();
1486
1487     return 0;
1488 }
1489
1490 static int read_quant_table(RangeCoder *c, int16_t *quant_table, int scale){
1491     int v;
1492     int i=0;
1493     uint8_t state[CONTEXT_SIZE];
1494
1495     memset(state, 128, sizeof(state));
1496
1497     for(v=0; i<128 ; v++){
1498         int len= get_symbol(c, state, 0) + 1;
1499
1500         if(len + i > 128) return -1;
1501
1502         while(len--){
1503             quant_table[i] = scale*v;
1504             i++;
1505 //printf("%2d ",v);
1506 //if(i%16==0) printf("\n");
1507         }
1508     }
1509
1510     for(i=1; i<128; i++){
1511         quant_table[256-i]= -quant_table[i];
1512     }
1513     quant_table[128]= -quant_table[127];
1514
1515     return 2*v - 1;
1516 }
1517
1518 static int read_quant_tables(RangeCoder *c, int16_t quant_table[MAX_CONTEXT_INPUTS][256]){
1519     int i;
1520     int context_count=1;
1521
1522     for(i=0; i<5; i++){
1523         context_count*= read_quant_table(c, quant_table[i], context_count);
1524         if(context_count > 32768U){
1525             return -1;
1526         }
1527     }
1528     return (context_count+1)/2;
1529 }
1530
1531 static int read_extra_header(FFV1Context *f){
1532     RangeCoder * const c= &f->c;
1533     uint8_t state[CONTEXT_SIZE];
1534     int i, j, k;
1535     uint8_t state2[32][CONTEXT_SIZE];
1536
1537     memset(state2, 128, sizeof(state2));
1538     memset(state, 128, sizeof(state));
1539
1540     ff_init_range_decoder(c, f->avctx->extradata, f->avctx->extradata_size);
1541     ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1542
1543     f->version= get_symbol(c, state, 0);
1544     f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
1545     if(f->ac>1){
1546         for(i=1; i<256; i++){
1547             f->state_transition[i]= get_symbol(c, state, 1) + c->one_state[i];
1548         }
1549     }
1550     f->colorspace= get_symbol(c, state, 0); //YUV cs type
1551     f->avctx->bits_per_raw_sample= get_symbol(c, state, 0);
1552     get_rac(c, state); //no chroma = false
1553     f->chroma_h_shift= get_symbol(c, state, 0);
1554     f->chroma_v_shift= get_symbol(c, state, 0);
1555     f->transparency= get_rac(c, state);
1556     f->plane_count= 2 + f->transparency;
1557     f->num_h_slices= 1 + get_symbol(c, state, 0);
1558     f->num_v_slices= 1 + get_symbol(c, state, 0);
1559     if(f->num_h_slices > (unsigned)f->width || f->num_v_slices > (unsigned)f->height){
1560         av_log(f->avctx, AV_LOG_ERROR, "too many slices\n");
1561         return -1;
1562     }
1563
1564     f->quant_table_count= get_symbol(c, state, 0);
1565     if(f->quant_table_count > (unsigned)MAX_QUANT_TABLES)
1566         return -1;
1567     for(i=0; i<f->quant_table_count; i++){
1568         if((f->context_count[i]= read_quant_tables(c, f->quant_tables[i])) < 0){
1569             av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
1570             return -1;
1571         }
1572     }
1573
1574     if(allocate_initial_states(f) < 0)
1575         return AVERROR(ENOMEM);
1576
1577     for(i=0; i<f->quant_table_count; i++){
1578         if(get_rac(c, state)){
1579             for(j=0; j<f->context_count[i]; j++){
1580                 for(k=0; k<CONTEXT_SIZE; k++){
1581                     int pred= j ? f->initial_states[i][j-1][k] : 128;
1582                     f->initial_states[i][j][k]= (pred+get_symbol(c, state2[k], 1))&0xFF;
1583                 }
1584             }
1585         }
1586     }
1587
1588     return 0;
1589 }
1590
1591 static int read_header(FFV1Context *f){
1592     uint8_t state[CONTEXT_SIZE];
1593     int i, j, context_count;
1594     RangeCoder * const c= &f->slice_context[0]->c;
1595
1596     memset(state, 128, sizeof(state));
1597
1598     if(f->version < 2){
1599         f->version= get_symbol(c, state, 0);
1600         f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
1601         if(f->ac>1){
1602             for(i=1; i<256; i++){
1603                 f->state_transition[i]= get_symbol(c, state, 1) + c->one_state[i];
1604             }
1605         }
1606         f->colorspace= get_symbol(c, state, 0); //YUV cs type
1607         if(f->version>0)
1608             f->avctx->bits_per_raw_sample= get_symbol(c, state, 0);
1609         f->chroma_planes= get_rac(c, state);
1610         f->chroma_h_shift= get_symbol(c, state, 0);
1611         f->chroma_v_shift= get_symbol(c, state, 0);
1612         f->transparency= get_rac(c, state);
1613         f->plane_count= 2 + f->transparency;
1614     }
1615
1616     if(f->colorspace==0){
1617         if(!f->transparency && !f->chroma_planes){
1618             if (f->avctx->bits_per_raw_sample<=8)
1619                 f->avctx->pix_fmt= PIX_FMT_GRAY8;
1620             else
1621                 f->avctx->pix_fmt= PIX_FMT_GRAY16;
1622         }else if(f->avctx->bits_per_raw_sample<=8 && !f->transparency){
1623             switch(16*f->chroma_h_shift + f->chroma_v_shift){
1624             case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P; break;
1625             case 0x01: f->avctx->pix_fmt= PIX_FMT_YUV440P; break;
1626             case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P; break;
1627             case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P; break;
1628             case 0x20: f->avctx->pix_fmt= PIX_FMT_YUV411P; break;
1629             case 0x22: f->avctx->pix_fmt= PIX_FMT_YUV410P; break;
1630             default:
1631                 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1632                 return -1;
1633             }
1634         }else if(f->avctx->bits_per_raw_sample<=8 && f->transparency){
1635             switch(16*f->chroma_h_shift + f->chroma_v_shift){
1636             case 0x00: f->avctx->pix_fmt= PIX_FMT_YUVA444P; break;
1637             case 0x11: f->avctx->pix_fmt= PIX_FMT_YUVA420P; break;
1638             default:
1639                 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1640                 return -1;
1641             }
1642         }else if(f->avctx->bits_per_raw_sample==9) {
1643             f->packed_at_lsb=1;
1644             switch(16*f->chroma_h_shift + f->chroma_v_shift){
1645             case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P9; break;
1646             case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P9; break;
1647             case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P9; break;
1648             default:
1649                 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1650                 return -1;
1651             }
1652         }else if(f->avctx->bits_per_raw_sample==10) {
1653             f->packed_at_lsb=1;
1654             switch(16*f->chroma_h_shift + f->chroma_v_shift){
1655             case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P10; break;
1656             case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P10; break;
1657             case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P10; break;
1658             default:
1659                 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1660                 return -1;
1661             }
1662         }else {
1663             switch(16*f->chroma_h_shift + f->chroma_v_shift){
1664             case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P16; break;
1665             case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P16; break;
1666             case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P16; break;
1667             default:
1668                 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1669                 return -1;
1670             }
1671         }
1672     }else if(f->colorspace==1){
1673         if(f->chroma_h_shift || f->chroma_v_shift){
1674             av_log(f->avctx, AV_LOG_ERROR, "chroma subsampling not supported in this colorspace\n");
1675             return -1;
1676         }
1677         if(f->transparency) f->avctx->pix_fmt= PIX_FMT_RGB32;
1678         else                f->avctx->pix_fmt= PIX_FMT_0RGB32;
1679     }else{
1680         av_log(f->avctx, AV_LOG_ERROR, "colorspace not supported\n");
1681         return -1;
1682     }
1683
1684 //printf("%d %d %d\n", f->chroma_h_shift, f->chroma_v_shift,f->avctx->pix_fmt);
1685     if(f->version < 2){
1686         context_count= read_quant_tables(c, f->quant_table);
1687         if(context_count < 0){
1688                 av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
1689                 return -1;
1690         }
1691     }else{
1692         f->slice_count= get_symbol(c, state, 0);
1693         if(f->slice_count > (unsigned)MAX_SLICES)
1694             return -1;
1695     }
1696
1697     for(j=0; j<f->slice_count; j++){
1698         FFV1Context *fs= f->slice_context[j];
1699         fs->ac= f->ac;
1700         fs->packed_at_lsb= f->packed_at_lsb;
1701
1702         if(f->version >= 2){
1703             fs->slice_x     = get_symbol(c, state, 0)   *f->width ;
1704             fs->slice_y     = get_symbol(c, state, 0)   *f->height;
1705             fs->slice_width =(get_symbol(c, state, 0)+1)*f->width  + fs->slice_x;
1706             fs->slice_height=(get_symbol(c, state, 0)+1)*f->height + fs->slice_y;
1707
1708             fs->slice_x /= f->num_h_slices;
1709             fs->slice_y /= f->num_v_slices;
1710             fs->slice_width  = fs->slice_width /f->num_h_slices - fs->slice_x;
1711             fs->slice_height = fs->slice_height/f->num_v_slices - fs->slice_y;
1712             if((unsigned)fs->slice_width > f->width || (unsigned)fs->slice_height > f->height)
1713                 return -1;
1714             if(    (unsigned)fs->slice_x + (uint64_t)fs->slice_width  > f->width
1715                 || (unsigned)fs->slice_y + (uint64_t)fs->slice_height > f->height)
1716                 return -1;
1717         }
1718
1719         for(i=0; i<f->plane_count; i++){
1720             PlaneContext * const p= &fs->plane[i];
1721
1722             if(f->version >= 2){
1723                 int idx=get_symbol(c, state, 0);
1724                 if(idx > (unsigned)f->quant_table_count){
1725                     av_log(f->avctx, AV_LOG_ERROR, "quant_table_index out of range\n");
1726                     return -1;
1727                 }
1728                 p->quant_table_index= idx;
1729                 memcpy(p->quant_table, f->quant_tables[idx], sizeof(p->quant_table));
1730                 context_count= f->context_count[idx];
1731             }else{
1732                 memcpy(p->quant_table, f->quant_table, sizeof(p->quant_table));
1733             }
1734
1735             if(p->context_count < context_count){
1736                 av_freep(&p->state);
1737                 av_freep(&p->vlc_state);
1738             }
1739             p->context_count= context_count;
1740         }
1741     }
1742
1743     return 0;
1744 }
1745
1746 static av_cold int decode_init(AVCodecContext *avctx)
1747 {
1748     FFV1Context *f = avctx->priv_data;
1749
1750     common_init(avctx);
1751
1752     if(avctx->extradata && read_extra_header(f) < 0)
1753         return -1;
1754
1755     if(init_slice_contexts(f) < 0)
1756         return -1;
1757
1758     return 0;
1759 }
1760
1761 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){
1762     const uint8_t *buf = avpkt->data;
1763     int buf_size = avpkt->size;
1764     FFV1Context *f = avctx->priv_data;
1765     RangeCoder * const c= &f->slice_context[0]->c;
1766     AVFrame * const p= &f->picture;
1767     int bytes_read, i;
1768     uint8_t keystate= 128;
1769     const uint8_t *buf_p;
1770
1771     AVFrame *picture = data;
1772
1773     /* release previously stored data */
1774     if (p->data[0])
1775         avctx->release_buffer(avctx, p);
1776
1777     ff_init_range_decoder(c, buf, buf_size);
1778     ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1779
1780
1781     p->pict_type= AV_PICTURE_TYPE_I; //FIXME I vs. P
1782     if(get_rac(c, &keystate)){
1783         p->key_frame= 1;
1784         if(read_header(f) < 0)
1785             return -1;
1786         if(init_slice_state(f) < 0)
1787             return -1;
1788
1789         clear_state(f);
1790     }else{
1791         p->key_frame= 0;
1792     }
1793     if(f->ac>1){
1794         int i;
1795         for(i=1; i<256; i++){
1796             c->one_state[i]= f->state_transition[i];
1797             c->zero_state[256-i]= 256-c->one_state[i];
1798         }
1799     }
1800
1801     p->reference= 0;
1802     if(avctx->get_buffer(avctx, p) < 0){
1803         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1804         return -1;
1805     }
1806
1807     if(avctx->debug&FF_DEBUG_PICT_INFO)
1808         av_log(avctx, AV_LOG_ERROR, "keyframe:%d coder:%d\n", p->key_frame, f->ac);
1809
1810     if(!f->ac){
1811         bytes_read = c->bytestream - c->bytestream_start - 1;
1812         if(bytes_read ==0) av_log(avctx, AV_LOG_ERROR, "error at end of AC stream\n"); //FIXME
1813 //printf("pos=%d\n", bytes_read);
1814         init_get_bits(&f->slice_context[0]->gb, buf + bytes_read, (buf_size - bytes_read) * 8);
1815     } else {
1816         bytes_read = 0; /* avoid warning */
1817     }
1818
1819     buf_p= buf + buf_size;
1820     for(i=f->slice_count-1; i>0; i--){
1821         FFV1Context *fs= f->slice_context[i];
1822         int v= AV_RB24(buf_p-3)+3;
1823         if(buf_p - buf <= v){
1824             av_log(avctx, AV_LOG_ERROR, "Slice pointer chain broken\n");
1825             return -1;
1826         }
1827         buf_p -= v;
1828         if(fs->ac){
1829             ff_init_range_decoder(&fs->c, buf_p, v);
1830         }else{
1831             init_get_bits(&fs->gb, buf_p, v * 8);
1832         }
1833     }
1834
1835     avctx->execute(avctx, decode_slice, &f->slice_context[0], NULL, f->slice_count, sizeof(void*));
1836     f->picture_number++;
1837
1838     *picture= *p;
1839     *data_size = sizeof(AVFrame);
1840
1841     return buf_size;
1842 }
1843
1844 AVCodec ff_ffv1_decoder = {
1845     .name           = "ffv1",
1846     .type           = AVMEDIA_TYPE_VIDEO,
1847     .id             = CODEC_ID_FFV1,
1848     .priv_data_size = sizeof(FFV1Context),
1849     .init           = decode_init,
1850     .close          = common_end,
1851     .decode         = decode_frame,
1852     .capabilities   = CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/ | CODEC_CAP_SLICE_THREADS,
1853     .long_name= NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1854 };
1855
1856 #if CONFIG_FFV1_ENCODER
1857 AVCodec ff_ffv1_encoder = {
1858     .name           = "ffv1",
1859     .type           = AVMEDIA_TYPE_VIDEO,
1860     .id             = CODEC_ID_FFV1,
1861     .priv_data_size = sizeof(FFV1Context),
1862     .init           = encode_init,
1863     .encode2        = encode_frame,
1864     .close          = common_end,
1865     .capabilities = CODEC_CAP_SLICE_THREADS,
1866     .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_YUV444P9, PIX_FMT_YUV422P9, PIX_FMT_YUV420P9, PIX_FMT_YUV420P10, PIX_FMT_YUV422P10, PIX_FMT_YUV444P10, PIX_FMT_GRAY16, PIX_FMT_GRAY8, PIX_FMT_NONE},
1867     .long_name= NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1868 };
1869 #endif