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 library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  */
  21
  22 /**
  23  * @file ffv1.c
  24  * FF Video Codec 1 (an experimental lossless codec)
  25  */
  26
  27 #include "common.h"
  28 #include "avcodec.h"
  29 #include "dsputil.h"
  30 #include "cabac.h"
  31 #include "golomb.h"
  32
  33 #define MAX_PLANES 4
  34 #define CONTEXT_SIZE 32
  35
  36 static const int8_t quant3[256]={
  37  0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  38  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  39  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  40  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  41  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  42  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  43  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  44  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  45 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
  46 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
  47 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
  48 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
  49 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
  50 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
  51 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
  52 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, 0,
  53 };
  54 static const int8_t quant5[256]={
  55  0, 1, 1, 1, 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, 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,-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,-1,-1,-1,
  71 };
  72 static const int8_t quant7[256]={
  73  0, 1, 1, 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, 3, 3, 3, 3, 3, 3, 3, 3,
  76  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
  77  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
  78  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
  79  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
  80  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
  81 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
  82 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
  83 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
  84 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
  85 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
  86 -3,-3,-3,-3,-3,-3,-3,-3,-3,-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,-1,-1,
  89 };
  90 static const int8_t quant9[256]={
  91  0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3,
  92  3, 3, 3, 3, 3, 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, 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,-4,-4,-4,-3,-3,-3,-3,
 106 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-2,-1,-1,
 107 };
 108 static const int8_t quant11[256]={
 109  0, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4,
 110  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
 111  4, 4, 4, 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,-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,-4,-4,
 123 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
 124 -4,-4,-4,-4,-4,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-1,
 125 };
 126 static const int8_t quant13[256]={
 127  0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
 128  4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
 129  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
 130  5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
 131  6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
 132  6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
 133  6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
 134  6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
 135 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
 136 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
 137 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
 138 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
 139 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-5,
 140 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
 141 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
 142 -4,-4,-4,-4,-4,-4,-4,-4,-4,-3,-3,-3,-3,-2,-2,-1,
 143 };
 144
 145 static const uint8_t log2_run[32]={
 146  0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3,
 147  4, 4, 5, 5, 6, 6, 7, 7,
 148  8, 9,10,11,12,13,14,15,
 149 };
 150
 151 typedef struct VlcState{
 152     int16_t drift;
 153     uint16_t error_sum;
 154     int8_t bias;
 155     uint8_t count;
 156 } VlcState;
 157
 158 typedef struct PlaneContext{
 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 typedef struct FFV1Context{
 166     AVCodecContext *avctx;
 167     CABACContext c;
 168     GetBitContext gb;
 169     PutBitContext pb;
 170     int version;
 171     int width, height;
 172     int chroma_h_shift, chroma_v_shift;
 173     int flags;
 174     int picture_number;
 175     AVFrame picture;
 176     int plane_count;
 177     int ac;                              ///< 1-> CABAC 0-> golomb rice
 178     PlaneContext plane[MAX_PLANES];
 179     int16_t quant_table[5][256];
 180     int run_index;
 181     int colorspace;
 182
 183     DSPContext dsp;
 184 }FFV1Context;
 185
 186 static always_inline int fold(int diff, int bits){
 187     if(bits==8)
 188         diff= (int8_t)diff;
 189     else{
 190         diff+= 1<<(bits-1);
 191         diff&=(1<<bits)-1;
 192         diff-= 1<<(bits-1);
 193     }
 194
 195     return diff;
 196 }
 197
 198 static inline int predict(int_fast16_t *src, int_fast16_t *last){
 199     const int LT= last[-1];
 200     const int  T= last[ 0];
 201     const int L =  src[-1];
 202
 203     return mid_pred(L, L + T - LT, T);
 204 }
 205
 206 static inline int get_context(FFV1Context *f, int_fast16_t *src, int_fast16_t *last, int_fast16_t *last2){
 207     const int LT= last[-1];
 208     const int  T= last[ 0];
 209     const int RT= last[ 1];
 210     const int L =  src[-1];
 211
 212     if(f->quant_table[3][127]){
 213         const int TT= last2[0];
 214         const int LL=  src[-2];
 215         return f->quant_table[0][(L-LT) & 0xFF] + f->quant_table[1][(LT-T) & 0xFF] + f->quant_table[2][(T-RT) & 0xFF]
 216               +f->quant_table[3][(LL-L) & 0xFF] + f->quant_table[4][(TT-T) & 0xFF];
 217     }else
 218         return f->quant_table[0][(L-LT) & 0xFF] + f->quant_table[1][(LT-T) & 0xFF] + f->quant_table[2][(T-RT) & 0xFF];
 219 }
 220
 221 /**
 222  * put
 223  */
 224 static inline void put_symbol(CABACContext *c, uint8_t *state, int v, int is_signed, int max_exp){
 225     int i;
 226
 227     if(v){
 228         const int a= ABS(v);
 229         const int e= av_log2(a);
 230
 231         put_cabac(c, state+0, 0);
 232
 233         for(i=0; i<e; i++){
 234             put_cabac(c, state+1+i, 1);  //1..8
 235         }
 236
 237         if(e<max_exp){
 238             put_cabac(c, state+1+i, 0);      //1..8
 239
 240             for(i=e-1; i>=0; i--){
 241                 put_cabac(c, state+16+e+i, (a>>i)&1); //17..29
 242             }
 243             if(is_signed)
 244                 put_cabac(c, state+9 + e, v < 0); //9..16
 245         }
 246     }else{
 247         put_cabac(c, state+0, 1);
 248     }
 249 }
 250
 251 static inline int get_symbol(CABACContext *c, uint8_t *state, int is_signed, int max_exp){
 252     if(get_cabac(c, state+0))
 253         return 0;
 254     else{
 255         int i, e;
 256
 257         for(e=0; e<max_exp; e++){
 258             int a= 1<<e;
 259
 260             if(get_cabac(c, state + 1 + e)==0){ // 1..8
 261                 for(i=e-1; i>=0; i--){
 262                     a += get_cabac(c, state+16+e+i)<<i; //17..29
 263                 }
 264
 265                 if(is_signed && get_cabac(c, state+9 + e)) //9..16
 266                     return -a;
 267                 else
 268                     return a;
 269             }
 270         }
 271         return -(1<<e);
 272     }
 273 }
 274
 275 static inline void update_vlc_state(VlcState * const state, const int v){
 276     int drift= state->drift;
 277     int count= state->count;
 278     state->error_sum += ABS(v);
 279     drift += v;
 280
 281     if(count == 128){ //FIXME variable
 282         count >>= 1;
 283         drift >>= 1;
 284         state->error_sum >>= 1;
 285     }
 286     count++;
 287
 288     if(drift <= -count){
 289         if(state->bias > -128) state->bias--;
 290
 291         drift += count;
 292         if(drift <= -count)
 293             drift= -count + 1;
 294     }else if(drift > 0){
 295         if(state->bias <  127) state->bias++;
 296
 297         drift -= count;
 298         if(drift > 0)
 299             drift= 0;
 300     }
 301
 302     state->drift= drift;
 303     state->count= count;
 304 }
 305
 306 static inline void put_vlc_symbol(PutBitContext *pb, VlcState * const state, int v, int bits){
 307     int i, k, code;
 308 //printf("final: %d ", v);
 309     v = fold(v - state->bias, bits);
 310
 311     i= state->count;
 312     k=0;
 313     while(i < state->error_sum){ //FIXME optimize
 314         k++;
 315         i += i;
 316     }
 317
 318     assert(k<=8);
 319
 320 #if 0 // JPEG LS
 321     if(k==0 && 2*state->drift <= - state->count) code= v ^ (-1);
 322     else                                         code= v;
 323 #else
 324      code= v ^ ((2*state->drift + state->count)>>31);
 325 #endif
 326
 327     code = -2*code-1;
 328     code^= (code>>31);
 329 //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);
 330     set_ur_golomb(pb, code, k, 12, bits);
 331
 332     update_vlc_state(state, v);
 333 }
 334
 335 static inline int get_vlc_symbol(GetBitContext *gb, VlcState * const state, int bits){
 336     int k, i, v, ret;
 337
 338     i= state->count;
 339     k=0;
 340     while(i < state->error_sum){ //FIXME optimize
 341         k++;
 342         i += i;
 343     }
 344
 345     assert(k<=8);
 346
 347     v= get_ur_golomb(gb, k, 12, bits);
 348 //printf("v:%d bias:%d error:%d drift:%d count:%d k:%d", v, state->bias, state->error_sum, state->drift, state->count, k);
 349
 350     v++;
 351     if(v&1) v=  (v>>1);
 352     else    v= -(v>>1);
 353
 354 #if 0 // JPEG LS
 355     if(k==0 && 2*state->drift <= - state->count) v ^= (-1);
 356 #else
 357      v ^= ((2*state->drift + state->count)>>31);
 358 #endif
 359
 360     ret= fold(v + state->bias, bits);
 361
 362     update_vlc_state(state, v);
 363 //printf("final: %d\n", ret);
 364     return ret;
 365 }
 366
 367 static inline void encode_line(FFV1Context *s, int w, int_fast16_t *sample[2], int plane_index, int bits){
 368     PlaneContext * const p= &s->plane[plane_index];
 369     CABACContext * const c= &s->c;
 370     int x;
 371     int run_index= s->run_index;
 372     int run_count=0;
 373     int run_mode=0;
 374
 375     for(x=0; x<w; x++){
 376         int diff, context;
 377
 378         context= get_context(s, sample[1]+x, sample[0]+x, sample[2]+x);
 379         diff= sample[1][x] - predict(sample[1]+x, sample[0]+x);
 380
 381         if(context < 0){
 382             context = -context;
 383             diff= -diff;
 384         }
 385
 386         diff= fold(diff, bits);
 387
 388         if(s->ac){
 389             put_symbol(c, p->state[context], diff, 1, bits-1);
 390         }else{
 391             if(context == 0) run_mode=1;
 392
 393             if(run_mode){
 394
 395                 if(diff){
 396                     while(run_count >= 1<<log2_run[run_index]){
 397                         run_count -= 1<<log2_run[run_index];
 398                         run_index++;
 399                         put_bits(&s->pb, 1, 1);
 400                     }
 401
 402                     put_bits(&s->pb, 1 + log2_run[run_index], run_count);
 403                     if(run_index) run_index--;
 404                     run_count=0;
 405                     run_mode=0;
 406                     if(diff>0) diff--;
 407                 }else{
 408                     run_count++;
 409                 }
 410             }
 411
 412 //            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));
 413
 414             if(run_mode == 0)
 415                 put_vlc_symbol(&s->pb, &p->vlc_state[context], diff, bits);
 416         }
 417     }
 418     if(run_mode){
 419         while(run_count >= 1<<log2_run[run_index]){
 420             run_count -= 1<<log2_run[run_index];
 421             run_index++;
 422             put_bits(&s->pb, 1, 1);
 423         }
 424
 425         if(run_count)
 426             put_bits(&s->pb, 1, 1);
 427     }
 428     s->run_index= run_index;
 429 }
 430
 431 static void encode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
 432     int x,y;
 433     int_fast16_t sample_buffer[3][w+6];
 434     int_fast16_t *sample[3]= {sample_buffer[0]+3, sample_buffer[1]+3, sample_buffer[2]+3};
 435     s->run_index=0;
 436
 437     memset(sample_buffer, 0, sizeof(sample_buffer));
 438
 439     for(y=0; y<h; y++){
 440         int_fast16_t *temp= sample[0]; //FIXME try a normal buffer
 441
 442         sample[0]= sample[1];
 443         sample[1]= sample[2];
 444         sample[2]= temp;
 445
 446         sample[1][-1]= sample[0][0  ];
 447         sample[0][ w]= sample[0][w-1];
 448 //{START_TIMER
 449         for(x=0; x<w; x++){
 450             sample[1][x]= src[x + stride*y];
 451         }
 452         encode_line(s, w, sample, plane_index, 8);
 453 //STOP_TIMER("encode line")}
 454     }
 455 }
 456
 457 static void encode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
 458     int x, y, p;
 459     int_fast16_t sample_buffer[3][2][w+6];
 460     int_fast16_t *sample[3][2]= {
 461         {sample_buffer[0][0]+3, sample_buffer[0][1]+3},
 462         {sample_buffer[1][0]+3, sample_buffer[1][1]+3},
 463         {sample_buffer[2][0]+3, sample_buffer[2][1]+3}};
 464     s->run_index=0;
 465
 466     memset(sample_buffer, 0, sizeof(sample_buffer));
 467
 468     for(y=0; y<h; y++){
 469         for(x=0; x<w; x++){
 470             int v= src[x + stride*y];
 471             int b= v&0xFF;
 472             int g= (v>>8)&0xFF;
 473             int r= (v>>16)&0xFF;
 474
 475             b -= g;
 476             r -= g;
 477             g += (b + r)>>2;
 478             b += 0x100;
 479             r += 0x100;
 480
 481 //            assert(g>=0 && b>=0 && r>=0);
 482 //            assert(g<256 && b<512 && r<512);
 483             sample[0][0][x]= g;
 484             sample[1][0][x]= b;
 485             sample[2][0][x]= r;
 486         }
 487         for(p=0; p<3; p++){
 488             int_fast16_t *temp= sample[p][0]; //FIXME try a normal buffer
 489
 490             sample[p][0]= sample[p][1];
 491             sample[p][1]= temp;
 492
 493             sample[p][1][-1]= sample[p][0][0  ];
 494             sample[p][0][ w]= sample[p][0][w-1];
 495             encode_line(s, w, sample[p], FFMIN(p, 1), 9);
 496         }
 497     }
 498 }
 499
 500 static void write_quant_table(CABACContext *c, int16_t *quant_table){
 501     int last=0;
 502     int i;
 503     uint8_t state[CONTEXT_SIZE]={0};
 504
 505     for(i=1; i<128 ; i++){
 506         if(quant_table[i] != quant_table[i-1]){
 507             put_symbol(c, state, i-last-1, 0, 7);
 508             last= i;
 509         }
 510     }
 511     put_symbol(c, state, i-last-1, 0, 7);
 512 }
 513
 514 static void write_header(FFV1Context *f){
 515     uint8_t state[CONTEXT_SIZE]={0};
 516     int i;
 517     CABACContext * const c= &f->c;
 518
 519     put_symbol(c, state, f->version, 0, 7);
 520     put_symbol(c, state, f->avctx->coder_type, 0, 7);
 521     put_symbol(c, state, f->colorspace, 0, 7); //YUV cs type
 522     put_cabac(c, state, 1); //chroma planes
 523         put_symbol(c, state, f->chroma_h_shift, 0, 7);
 524         put_symbol(c, state, f->chroma_v_shift, 0, 7);
 525     put_cabac(c, state, 0); //no transparency plane
 526
 527     for(i=0; i<5; i++)
 528         write_quant_table(c, f->quant_table[i]);
 529 }
 530
 531 static int common_init(AVCodecContext *avctx){
 532     FFV1Context *s = avctx->priv_data;
 533     int width, height;
 534
 535     s->avctx= avctx;
 536     s->flags= avctx->flags;
 537
 538     dsputil_init(&s->dsp, avctx);
 539
 540     width= s->width= avctx->width;
 541     height= s->height= avctx->height;
 542
 543     assert(width && height);
 544
 545     return 0;
 546 }
 547
 548 static int encode_init(AVCodecContext *avctx)
 549 {
 550     FFV1Context *s = avctx->priv_data;
 551     int i;
 552
 553     common_init(avctx);
 554
 555     s->version=0;
 556     s->ac= avctx->coder_type;
 557
 558     s->plane_count=2;
 559     for(i=0; i<256; i++){
 560         s->quant_table[0][i]=           quant11[i];
 561         s->quant_table[1][i]=        11*quant11[i];
 562         if(avctx->context_model==0){
 563             s->quant_table[2][i]=     11*11*quant11[i];
 564             s->quant_table[3][i]=
 565             s->quant_table[4][i]=0;
 566         }else{
 567             s->quant_table[2][i]=     11*11*quant5 [i];
 568             s->quant_table[3][i]=   5*11*11*quant5 [i];
 569             s->quant_table[4][i]= 5*5*11*11*quant5 [i];
 570         }
 571     }
 572
 573     for(i=0; i<s->plane_count; i++){
 574         PlaneContext * const p= &s->plane[i];
 575
 576         if(avctx->context_model==0){
 577             p->context_count= (11*11*11+1)/2;
 578         }else{
 579             p->context_count= (11*11*5*5*5+1)/2;
 580         }
 581
 582         if(s->ac){
 583             if(!p->state) p->state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
 584         }else{
 585             if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
 586         }
 587     }
 588
 589     avctx->coded_frame= &s->picture;
 590     switch(avctx->pix_fmt){
 591     case PIX_FMT_YUV444P:
 592     case PIX_FMT_YUV422P:
 593     case PIX_FMT_YUV420P:
 594     case PIX_FMT_YUV411P:
 595     case PIX_FMT_YUV410P:
 596         s->colorspace= 0;
 597         break;
 598     case PIX_FMT_RGBA32:
 599         s->colorspace= 1;
 600         break;
 601     default:
 602         av_log(avctx, AV_LOG_ERROR, "format not supported\n");
 603         return -1;
 604     }
 605     avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
 606
 607     s->picture_number=0;
 608
 609     return 0;
 610 }
 611
 612
 613 static void clear_state(FFV1Context *f){
 614     int i, j;
 615
 616     for(i=0; i<f->plane_count; i++){
 617         PlaneContext *p= &f->plane[i];
 618
 619         p->interlace_bit_state[0]= 0;
 620         p->interlace_bit_state[1]= 0;
 621
 622         for(j=0; j<p->context_count; j++){
 623             if(f->ac){
 624                 memset(p->state[j], 0, sizeof(uint8_t)*CONTEXT_SIZE);
 625                 p->state[j][7] = 2*62;
 626             }else{
 627                 p->vlc_state[j].drift= 0;
 628                 p->vlc_state[j].error_sum= 4; //FFMAX((RANGE + 32)/64, 2);
 629                 p->vlc_state[j].bias= 0;
 630                 p->vlc_state[j].count= 1;
 631             }
 632         }
 633     }
 634 }
 635
 636 static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
 637     FFV1Context *f = avctx->priv_data;
 638     CABACContext * const c= &f->c;
 639     AVFrame *pict = data;
 640     const int width= f->width;
 641     const int height= f->height;
 642     AVFrame * const p= &f->picture;
 643     int used_count= 0;
 644
 645     if(avctx->strict_std_compliance >= 0){
 646         av_log(avctx, AV_LOG_ERROR, "this codec is under development, files encoded with it wont be decodeable with future versions!!!\n"
 647                "use vstrict=-1 to use it anyway\n");
 648         return -1;
 649     }
 650
 651     ff_init_cabac_encoder(c, buf, buf_size);
 652     ff_init_cabac_states(c, ff_h264_lps_range, ff_h264_mps_state, ff_h264_lps_state, 64);
 653     c->lps_state[2] = 1;
 654     c->lps_state[3] = 0;
 655
 656     *p = *pict;
 657     p->pict_type= FF_I_TYPE;
 658
 659     if(avctx->gop_size==0 || f->picture_number % avctx->gop_size == 0){
 660         put_cabac_bypass(c, 1);
 661         p->key_frame= 1;
 662         write_header(f);
 663         clear_state(f);
 664     }else{
 665         put_cabac_bypass(c, 0);
 666         p->key_frame= 0;
 667     }
 668
 669     if(!f->ac){
 670         used_count += put_cabac_terminate(c, 1);
 671 //printf("pos=%d\n", used_count);
 672         init_put_bits(&f->pb, buf + used_count, buf_size - used_count);
 673     }
 674
 675     if(f->colorspace==0){
 676         const int chroma_width = -((-width )>>f->chroma_h_shift);
 677         const int chroma_height= -((-height)>>f->chroma_v_shift);
 678
 679         encode_plane(f, p->data[0], width, height, p->linesize[0], 0);
 680
 681         encode_plane(f, p->data[1], chroma_width, chroma_height, p->linesize[1], 1);
 682         encode_plane(f, p->data[2], chroma_width, chroma_height, p->linesize[2], 1);
 683     }else{
 684         encode_rgb_frame(f, (uint32_t*)(p->data[0]), width, height, p->linesize[0]/4);
 685     }
 686     emms_c();
 687
 688     f->picture_number++;
 689
 690     if(f->ac){
 691         return put_cabac_terminate(c, 1);
 692     }else{
 693         flush_put_bits(&f->pb); //nicer padding FIXME
 694         return used_count + (put_bits_count(&f->pb)+7)/8;
 695     }
 696 }
 697
 698 static void common_end(FFV1Context *s){
 699     int i;
 700
 701     for(i=0; i<s->plane_count; i++){
 702         PlaneContext *p= &s->plane[i];
 703
 704         av_freep(&p->state);
 705     }
 706 }
 707
 708 static int encode_end(AVCodecContext *avctx)
 709 {
 710     FFV1Context *s = avctx->priv_data;
 711
 712     common_end(s);
 713
 714     return 0;
 715 }
 716
 717 static inline void decode_line(FFV1Context *s, int w, int_fast16_t *sample[2], int plane_index, int bits){
 718     PlaneContext * const p= &s->plane[plane_index];
 719     CABACContext * const c= &s->c;
 720     int x;
 721     int run_count=0;
 722     int run_mode=0;
 723     int run_index= s->run_index;
 724
 725     for(x=0; x<w; x++){
 726         int diff, context, sign;
 727
 728         context= get_context(s, sample[1] + x, sample[0] + x, sample[1] + x);
 729         if(context < 0){
 730             context= -context;
 731             sign=1;
 732         }else
 733             sign=0;
 734
 735
 736         if(s->ac)
 737             diff= get_symbol(c, p->state[context], 1, bits-1);
 738         else{
 739             if(context == 0 && run_mode==0) run_mode=1;
 740
 741             if(run_mode){
 742                 if(run_count==0 && run_mode==1){
 743                     if(get_bits1(&s->gb)){
 744                         run_count = 1<<log2_run[run_index];
 745                         if(x + run_count <= w) run_index++;
 746                     }else{
 747                         if(log2_run[run_index]) run_count = get_bits(&s->gb, log2_run[run_index]);
 748                         else run_count=0;
 749                         if(run_index) run_index--;
 750                         run_mode=2;
 751                     }
 752                 }
 753                 run_count--;
 754                 if(run_count < 0){
 755                     run_mode=0;
 756                     run_count=0;
 757                     diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
 758                     if(diff>=0) diff++;
 759                 }else
 760                     diff=0;
 761             }else
 762                 diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
 763
 764 //            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));
 765         }
 766
 767         if(sign) diff= -diff;
 768
 769         sample[1][x]= (predict(sample[1] + x, sample[0] + x) + diff) & ((1<<bits)-1);
 770     }
 771     s->run_index= run_index;
 772 }
 773
 774 static void decode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
 775     int x, y;
 776     int_fast16_t sample_buffer[2][w+6];
 777     int_fast16_t *sample[2]= {sample_buffer[0]+3, sample_buffer[1]+3};
 778
 779     s->run_index=0;
 780
 781     memset(sample_buffer, 0, sizeof(sample_buffer));
 782
 783     for(y=0; y<h; y++){
 784         int_fast16_t *temp= sample[0]; //FIXME try a normal buffer
 785
 786         sample[0]= sample[1];
 787         sample[1]= temp;
 788
 789         sample[1][-1]= sample[0][0  ];
 790         sample[0][ w]= sample[0][w-1];
 791
 792 //{START_TIMER
 793         decode_line(s, w, sample, plane_index, 8);
 794         for(x=0; x<w; x++){
 795             src[x + stride*y]= sample[1][x];
 796         }
 797 //STOP_TIMER("decode-line")}
 798     }
 799 }
 800
 801 static void decode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
 802     int x, y, p;
 803     int_fast16_t sample_buffer[3][2][w+6];
 804     int_fast16_t *sample[3][2]= {
 805         {sample_buffer[0][0]+3, sample_buffer[0][1]+3},
 806         {sample_buffer[1][0]+3, sample_buffer[1][1]+3},
 807         {sample_buffer[2][0]+3, sample_buffer[2][1]+3}};
 808
 809     s->run_index=0;
 810
 811     memset(sample_buffer, 0, sizeof(sample_buffer));
 812
 813     for(y=0; y<h; y++){
 814         for(p=0; p<3; p++){
 815             int_fast16_t *temp= sample[p][0]; //FIXME try a normal buffer
 816
 817             sample[p][0]= sample[p][1];
 818             sample[p][1]= temp;
 819
 820             sample[p][1][-1]= sample[p][0][0  ];
 821             sample[p][0][ w]= sample[p][0][w-1];
 822             decode_line(s, w, sample[p], FFMIN(p, 1), 9);
 823         }
 824         for(x=0; x<w; x++){
 825             int g= sample[0][1][x];
 826             int b= sample[1][1][x];
 827             int r= sample[2][1][x];
 828
 829 //            assert(g>=0 && b>=0 && r>=0);
 830 //            assert(g<256 && b<512 && r<512);
 831
 832             b -= 0x100;
 833             r -= 0x100;
 834             g -= (b + r)>>2;
 835             b += g;
 836             r += g;
 837
 838             src[x + stride*y]= b + (g<<8) + (r<<16);
 839         }
 840     }
 841 }
 842
 843 static int read_quant_table(CABACContext *c, int16_t *quant_table, int scale){
 844     int v;
 845     int i=0;
 846     uint8_t state[CONTEXT_SIZE]={0};
 847
 848     for(v=0; i<128 ; v++){
 849         int len= get_symbol(c, state, 0, 7) + 1;
 850
 851         if(len + i > 128) return -1;
 852
 853         while(len--){
 854             quant_table[i] = scale*v;
 855             i++;
 856 //printf("%2d ",v);
 857 //if(i%16==0) printf("\n");
 858         }
 859     }
 860
 861     for(i=1; i<128; i++){
 862         quant_table[256-i]= -quant_table[i];
 863     }
 864     quant_table[128]= -quant_table[127];
 865
 866     return 2*v - 1;
 867 }
 868
 869 static int read_header(FFV1Context *f){
 870     uint8_t state[CONTEXT_SIZE]={0};
 871     int i, context_count;
 872     CABACContext * const c= &f->c;
 873
 874     f->version= get_symbol(c, state, 0, 7);
 875     f->ac= f->avctx->coder_type= get_symbol(c, state, 0, 7);
 876     f->colorspace= get_symbol(c, state, 0, 7); //YUV cs type
 877     get_cabac(c, state); //no chroma = false
 878     f->chroma_h_shift= get_symbol(c, state, 0, 7);
 879     f->chroma_v_shift= get_symbol(c, state, 0, 7);
 880     get_cabac(c, state); //transparency plane
 881     f->plane_count= 2;
 882
 883     if(f->colorspace==0){
 884         switch(16*f->chroma_h_shift + f->chroma_v_shift){
 885         case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P; break;
 886         case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P; break;
 887         case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P; break;
 888         case 0x20: f->avctx->pix_fmt= PIX_FMT_YUV411P; break;
 889         case 0x33: f->avctx->pix_fmt= PIX_FMT_YUV410P; break;
 890         default:
 891             av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
 892             return -1;
 893         }
 894     }else if(f->colorspace==1){
 895         if(f->chroma_h_shift || f->chroma_v_shift){
 896             av_log(f->avctx, AV_LOG_ERROR, "chroma subsampling not supported in this colorspace\n");
 897             return -1;
 898         }
 899         f->avctx->pix_fmt= PIX_FMT_RGBA32;
 900     }else{
 901         av_log(f->avctx, AV_LOG_ERROR, "colorspace not supported\n");
 902         return -1;
 903     }
 904
 905 //printf("%d %d %d\n", f->chroma_h_shift, f->chroma_v_shift,f->avctx->pix_fmt);
 906
 907     context_count=1;
 908     for(i=0; i<5; i++){
 909         context_count*= read_quant_table(c, f->quant_table[i], context_count);
 910         if(context_count < 0){
 911             av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
 912             return -1;
 913         }
 914     }
 915     context_count= (context_count+1)/2;
 916
 917     for(i=0; i<f->plane_count; i++){
 918         PlaneContext * const p= &f->plane[i];
 919
 920         p->context_count= context_count;
 921
 922         if(f->ac){
 923             if(!p->state) p->state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
 924         }else{
 925             if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
 926         }
 927     }
 928
 929     return 0;
 930 }
 931
 932 static int decode_init(AVCodecContext *avctx)
 933 {
 934 //    FFV1Context *s = avctx->priv_data;
 935
 936     common_init(avctx);
 937
 938     return 0;
 939 }
 940
 941 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8_t *buf, int buf_size){
 942     FFV1Context *f = avctx->priv_data;
 943     CABACContext * const c= &f->c;
 944     const int width= f->width;
 945     const int height= f->height;
 946     AVFrame * const p= &f->picture;
 947     int bytes_read;
 948
 949     AVFrame *picture = data;
 950
 951     *data_size = 0;
 952
 953     /* no supplementary picture */
 954     if (buf_size == 0)
 955         return 0;
 956
 957     ff_init_cabac_decoder(c, buf, buf_size);
 958     ff_init_cabac_states(c, ff_h264_lps_range, ff_h264_mps_state, ff_h264_lps_state, 64);
 959     c->lps_state[2] = 1;
 960     c->lps_state[3] = 0;
 961
 962
 963     p->pict_type= FF_I_TYPE; //FIXME I vs. P
 964     if(get_cabac_bypass(c)){
 965         p->key_frame= 1;
 966         read_header(f);
 967         clear_state(f);
 968     }else{
 969         p->key_frame= 0;
 970     }
 971
 972     p->reference= 0;
 973     if(avctx->get_buffer(avctx, p) < 0){
 974         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 975         return -1;
 976     }
 977
 978     if(avctx->debug&FF_DEBUG_PICT_INFO)
 979         av_log(avctx, AV_LOG_ERROR, "keyframe:%d coder:%d\n", p->key_frame, f->ac);
 980
 981     if(!f->ac){
 982         bytes_read = get_cabac_terminate(c);
 983         if(bytes_read ==0) av_log(avctx, AV_LOG_ERROR, "error at end of AC stream\n");
 984 //printf("pos=%d\n", bytes_read);
 985         init_get_bits(&f->gb, buf + bytes_read, buf_size - bytes_read);
 986     } else {
 987         bytes_read = 0; /* avoid warning */
 988     }
 989
 990     if(f->colorspace==0){
 991         const int chroma_width = -((-width )>>f->chroma_h_shift);
 992         const int chroma_height= -((-height)>>f->chroma_v_shift);
 993         decode_plane(f, p->data[0], width, height, p->linesize[0], 0);
 994
 995         decode_plane(f, p->data[1], chroma_width, chroma_height, p->linesize[1], 1);
 996         decode_plane(f, p->data[2], chroma_width, chroma_height, p->linesize[2], 1);
 997     }else{
 998         decode_rgb_frame(f, (uint32_t*)p->data[0], width, height, p->linesize[0]/4);
 999     }
1000
1001     emms_c();
1002
1003     f->picture_number++;
1004
1005     *picture= *p;
1006
1007     avctx->release_buffer(avctx, p); //FIXME
1008
1009     *data_size = sizeof(AVFrame);
1010
1011     if(f->ac){
1012         bytes_read= get_cabac_terminate(c);
1013         if(bytes_read ==0) av_log(f->avctx, AV_LOG_ERROR, "error at end of frame\n");
1014     }else{
1015         bytes_read+= (get_bits_count(&f->gb)+7)/8;
1016     }
1017
1018     return bytes_read;
1019 }
1020
1021 AVCodec ffv1_decoder = {
1022     "ffv1",
1023     CODEC_TYPE_VIDEO,
1024     CODEC_ID_FFV1,
1025     sizeof(FFV1Context),
1026     decode_init,
1027     NULL,
1028     NULL,
1029     decode_frame,
1030     CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/,
1031     NULL
1032 };
1033
1034 #ifdef CONFIG_ENCODERS
1035 AVCodec ffv1_encoder = {
1036     "ffv1",
1037     CODEC_TYPE_VIDEO,
1038     CODEC_ID_FFV1,
1039     sizeof(FFV1Context),
1040     encode_init,
1041     encode_frame,
1042     encode_end,
1043 };
1044 #endif