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