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
 654     *p = *pict;
 655     p->pict_type= FF_I_TYPE;
 656
 657     if(avctx->gop_size==0 || f->picture_number % avctx->gop_size == 0){
 658         put_cabac_bypass(c, 1);
 659         p->key_frame= 1;
 660         write_header(f);
 661         clear_state(f);
 662     }else{
 663         put_cabac_bypass(c, 0);
 664         p->key_frame= 0;
 665     }
 666
 667     if(!f->ac){
 668         used_count += put_cabac_terminate(c, 1);
 669 //printf("pos=%d\n", used_count);
 670         init_put_bits(&f->pb, buf + used_count, buf_size - used_count);
 671     }
 672
 673     if(f->colorspace==0){
 674         const int chroma_width = -((-width )>>f->chroma_h_shift);
 675         const int chroma_height= -((-height)>>f->chroma_v_shift);
 676
 677         encode_plane(f, p->data[0], width, height, p->linesize[0], 0);
 678
 679         encode_plane(f, p->data[1], chroma_width, chroma_height, p->linesize[1], 1);
 680         encode_plane(f, p->data[2], chroma_width, chroma_height, p->linesize[2], 1);
 681     }else{
 682         encode_rgb_frame(f, (uint32_t*)(p->data[0]), width, height, p->linesize[0]/4);
 683     }
 684     emms_c();
 685
 686     f->picture_number++;
 687
 688     if(f->ac){
 689         return put_cabac_terminate(c, 1);
 690     }else{
 691         flush_put_bits(&f->pb); //nicer padding FIXME
 692         return used_count + (put_bits_count(&f->pb)+7)/8;
 693     }
 694 }
 695
 696 static void common_end(FFV1Context *s){
 697     int i;
 698
 699     for(i=0; i<s->plane_count; i++){
 700         PlaneContext *p= &s->plane[i];
 701
 702         av_freep(&p->state);
 703     }
 704 }
 705
 706 static int encode_end(AVCodecContext *avctx)
 707 {
 708     FFV1Context *s = avctx->priv_data;
 709
 710     common_end(s);
 711
 712     return 0;
 713 }
 714
 715 static inline void decode_line(FFV1Context *s, int w, int_fast16_t *sample[2], int plane_index, int bits){
 716     PlaneContext * const p= &s->plane[plane_index];
 717     CABACContext * const c= &s->c;
 718     int x;
 719     int run_count=0;
 720     int run_mode=0;
 721     int run_index= s->run_index;
 722
 723     for(x=0; x<w; x++){
 724         int diff, context, sign;
 725
 726         context= get_context(s, sample[1] + x, sample[0] + x, sample[1] + x);
 727         if(context < 0){
 728             context= -context;
 729             sign=1;
 730         }else
 731             sign=0;
 732
 733
 734         if(s->ac)
 735             diff= get_symbol(c, p->state[context], 1, bits-1);
 736         else{
 737             if(context == 0 && run_mode==0) run_mode=1;
 738
 739             if(run_mode){
 740                 if(run_count==0 && run_mode==1){
 741                     if(get_bits1(&s->gb)){
 742                         run_count = 1<<log2_run[run_index];
 743                         if(x + run_count <= w) run_index++;
 744                     }else{
 745                         if(log2_run[run_index]) run_count = get_bits(&s->gb, log2_run[run_index]);
 746                         else run_count=0;
 747                         if(run_index) run_index--;
 748                         run_mode=2;
 749                     }
 750                 }
 751                 run_count--;
 752                 if(run_count < 0){
 753                     run_mode=0;
 754                     run_count=0;
 755                     diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
 756                     if(diff>=0) diff++;
 757                 }else
 758                     diff=0;
 759             }else
 760                 diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
 761
 762 //            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));
 763         }
 764
 765         if(sign) diff= -diff;
 766
 767         sample[1][x]= (predict(sample[1] + x, sample[0] + x) + diff) & ((1<<bits)-1);
 768     }
 769     s->run_index= run_index;
 770 }
 771
 772 static void decode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
 773     int x, y;
 774     int_fast16_t sample_buffer[2][w+6];
 775     int_fast16_t *sample[2]= {sample_buffer[0]+3, sample_buffer[1]+3};
 776
 777     s->run_index=0;
 778
 779     memset(sample_buffer, 0, sizeof(sample_buffer));
 780
 781     for(y=0; y<h; y++){
 782         int_fast16_t *temp= sample[0]; //FIXME try a normal buffer
 783
 784         sample[0]= sample[1];
 785         sample[1]= temp;
 786
 787         sample[1][-1]= sample[0][0  ];
 788         sample[0][ w]= sample[0][w-1];
 789
 790 //{START_TIMER
 791         decode_line(s, w, sample, plane_index, 8);
 792         for(x=0; x<w; x++){
 793             src[x + stride*y]= sample[1][x];
 794         }
 795 //STOP_TIMER("decode-line")}
 796     }
 797 }
 798
 799 static void decode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
 800     int x, y, p;
 801     int_fast16_t sample_buffer[3][2][w+6];
 802     int_fast16_t *sample[3][2]= {
 803         {sample_buffer[0][0]+3, sample_buffer[0][1]+3},
 804         {sample_buffer[1][0]+3, sample_buffer[1][1]+3},
 805         {sample_buffer[2][0]+3, sample_buffer[2][1]+3}};
 806
 807     s->run_index=0;
 808
 809     memset(sample_buffer, 0, sizeof(sample_buffer));
 810
 811     for(y=0; y<h; y++){
 812         for(p=0; p<3; p++){
 813             int_fast16_t *temp= sample[p][0]; //FIXME try a normal buffer
 814
 815             sample[p][0]= sample[p][1];
 816             sample[p][1]= temp;
 817
 818             sample[p][1][-1]= sample[p][0][0  ];
 819             sample[p][0][ w]= sample[p][0][w-1];
 820             decode_line(s, w, sample[p], FFMIN(p, 1), 9);
 821         }
 822         for(x=0; x<w; x++){
 823             int g= sample[0][1][x];
 824             int b= sample[1][1][x];
 825             int r= sample[2][1][x];
 826
 827 //            assert(g>=0 && b>=0 && r>=0);
 828 //            assert(g<256 && b<512 && r<512);
 829
 830             b -= 0x100;
 831             r -= 0x100;
 832             g -= (b + r)>>2;
 833             b += g;
 834             r += g;
 835
 836             src[x + stride*y]= b + (g<<8) + (r<<16);
 837         }
 838     }
 839 }
 840
 841 static int read_quant_table(CABACContext *c, int16_t *quant_table, int scale){
 842     int v;
 843     int i=0;
 844     uint8_t state[CONTEXT_SIZE]={0};
 845
 846     for(v=0; i<128 ; v++){
 847         int len= get_symbol(c, state, 0, 7) + 1;
 848
 849         if(len + i > 128) return -1;
 850
 851         while(len--){
 852             quant_table[i] = scale*v;
 853             i++;
 854 //printf("%2d ",v);
 855 //if(i%16==0) printf("\n");
 856         }
 857     }
 858
 859     for(i=1; i<128; i++){
 860         quant_table[256-i]= -quant_table[i];
 861     }
 862     quant_table[128]= -quant_table[127];
 863
 864     return 2*v - 1;
 865 }
 866
 867 static int read_header(FFV1Context *f){
 868     uint8_t state[CONTEXT_SIZE]={0};
 869     int i, context_count;
 870     CABACContext * const c= &f->c;
 871
 872     f->version= get_symbol(c, state, 0, 7);
 873     f->ac= f->avctx->coder_type= get_symbol(c, state, 0, 7);
 874     f->colorspace= get_symbol(c, state, 0, 7); //YUV cs type
 875     get_cabac(c, state); //no chroma = false
 876     f->chroma_h_shift= get_symbol(c, state, 0, 7);
 877     f->chroma_v_shift= get_symbol(c, state, 0, 7);
 878     get_cabac(c, state); //transparency plane
 879     f->plane_count= 2;
 880
 881     if(f->colorspace==0){
 882         switch(16*f->chroma_h_shift + f->chroma_v_shift){
 883         case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P; break;
 884         case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P; break;
 885         case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P; break;
 886         case 0x20: f->avctx->pix_fmt= PIX_FMT_YUV411P; break;
 887         case 0x33: f->avctx->pix_fmt= PIX_FMT_YUV410P; break;
 888         default:
 889             av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
 890             return -1;
 891         }
 892     }else if(f->colorspace==1){
 893         if(f->chroma_h_shift || f->chroma_v_shift){
 894             av_log(f->avctx, AV_LOG_ERROR, "chroma subsampling not supported in this colorspace\n");
 895             return -1;
 896         }
 897         f->avctx->pix_fmt= PIX_FMT_RGBA32;
 898     }else{
 899         av_log(f->avctx, AV_LOG_ERROR, "colorspace not supported\n");
 900         return -1;
 901     }
 902
 903 //printf("%d %d %d\n", f->chroma_h_shift, f->chroma_v_shift,f->avctx->pix_fmt);
 904
 905     context_count=1;
 906     for(i=0; i<5; i++){
 907         context_count*= read_quant_table(c, f->quant_table[i], context_count);
 908         if(context_count < 0){
 909             av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
 910             return -1;
 911         }
 912     }
 913     context_count= (context_count+1)/2;
 914
 915     for(i=0; i<f->plane_count; i++){
 916         PlaneContext * const p= &f->plane[i];
 917
 918         p->context_count= context_count;
 919
 920         if(f->ac){
 921             if(!p->state) p->state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
 922         }else{
 923             if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
 924         }
 925     }
 926
 927     return 0;
 928 }
 929
 930 static int decode_init(AVCodecContext *avctx)
 931 {
 932 //    FFV1Context *s = avctx->priv_data;
 933
 934     common_init(avctx);
 935
 936     return 0;
 937 }
 938
 939 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8_t *buf, int buf_size){
 940     FFV1Context *f = avctx->priv_data;
 941     CABACContext * const c= &f->c;
 942     const int width= f->width;
 943     const int height= f->height;
 944     AVFrame * const p= &f->picture;
 945     int bytes_read;
 946
 947     AVFrame *picture = data;
 948
 949     *data_size = 0;
 950
 951     /* no supplementary picture */
 952     if (buf_size == 0)
 953         return 0;
 954
 955     ff_init_cabac_decoder(c, buf, buf_size);
 956     ff_init_cabac_states(c, ff_h264_lps_range, ff_h264_mps_state, ff_h264_lps_state, 64);
 957
 958     p->pict_type= FF_I_TYPE; //FIXME I vs. P
 959     if(get_cabac_bypass(c)){
 960         p->key_frame= 1;
 961         read_header(f);
 962         clear_state(f);
 963     }else{
 964         p->key_frame= 0;
 965     }
 966
 967     p->reference= 0;
 968     if(avctx->get_buffer(avctx, p) < 0){
 969         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 970         return -1;
 971     }
 972
 973     if(avctx->debug&FF_DEBUG_PICT_INFO)
 974         av_log(avctx, AV_LOG_ERROR, "keyframe:%d coder:%d\n", p->key_frame, f->ac);
 975
 976     if(!f->ac){
 977         bytes_read = get_cabac_terminate(c);
 978         if(bytes_read ==0) av_log(avctx, AV_LOG_ERROR, "error at end of AC stream\n");
 979 //printf("pos=%d\n", bytes_read);
 980         init_get_bits(&f->gb, buf + bytes_read, buf_size - bytes_read);
 981     } else {
 982         bytes_read = 0; /* avoid warning */
 983     }
 984
 985     if(f->colorspace==0){
 986         const int chroma_width = -((-width )>>f->chroma_h_shift);
 987         const int chroma_height= -((-height)>>f->chroma_v_shift);
 988         decode_plane(f, p->data[0], width, height, p->linesize[0], 0);
 989
 990         decode_plane(f, p->data[1], chroma_width, chroma_height, p->linesize[1], 1);
 991         decode_plane(f, p->data[2], chroma_width, chroma_height, p->linesize[2], 1);
 992     }else{
 993         decode_rgb_frame(f, (uint32_t*)p->data[0], width, height, p->linesize[0]/4);
 994     }
 995
 996     emms_c();
 997
 998     f->picture_number++;
 999
1000     *picture= *p;
1001
1002     avctx->release_buffer(avctx, p); //FIXME
1003
1004     *data_size = sizeof(AVFrame);
1005
1006     if(f->ac){
1007         bytes_read= get_cabac_terminate(c);
1008         if(bytes_read ==0) av_log(f->avctx, AV_LOG_ERROR, "error at end of frame\n");
1009     }else{
1010         bytes_read+= (get_bits_count(&f->gb)+7)/8;
1011     }
1012
1013     return bytes_read;
1014 }
1015
1016 static int decode_end(AVCodecContext *avctx)
1017 {
1018     FFV1Context *s = avctx->priv_data;
1019     int i;
1020
1021     if(avctx->get_buffer == avcodec_default_get_buffer){
1022         for(i=0; i<4; i++){
1023             av_freep(&s->picture.base[i]);
1024             s->picture.data[i]= NULL;
1025         }
1026         av_freep(&s->picture.opaque);
1027     }
1028
1029     return 0;
1030 }
1031
1032 AVCodec ffv1_decoder = {
1033     "ffv1",
1034     CODEC_TYPE_VIDEO,
1035     CODEC_ID_FFV1,
1036     sizeof(FFV1Context),
1037     decode_init,
1038     NULL,
1039     decode_end,
1040     decode_frame,
1041     CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/,
1042     NULL
1043 };
1044
1045 #ifdef CONFIG_ENCODERS
1046 AVCodec ffv1_encoder = {
1047     "ffv1",
1048     CODEC_TYPE_VIDEO,
1049     CODEC_ID_FFV1,
1050     sizeof(FFV1Context),
1051     encode_init,
1052     encode_frame,
1053     encode_end,
1054 };
1055 #endif