00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00028 #include "avcodec.h"
00029 #include "internal.h"
00030 #include "get_bits.h"
00031 #include "put_bits.h"
00032 #include "dsputil.h"
00033 #include "rangecoder.h"
00034 #include "golomb.h"
00035 #include "mathops.h"
00036 #include "libavutil/pixdesc.h"
00037 #include "libavutil/avassert.h"
00038 #include "libavutil/crc.h"
00039 #include "libavutil/opt.h"
00040
00041 #ifdef __INTEL_COMPILER
00042 #undef av_flatten
00043 #define av_flatten
00044 #endif
00045
00046 #define MAX_PLANES 4
00047 #define CONTEXT_SIZE 32
00048
00049 #define MAX_QUANT_TABLES 8
00050 #define MAX_CONTEXT_INPUTS 5
00051
00052 extern const uint8_t ff_log2_run[41];
00053
00054 static const int8_t quant5_10bit[256]={
00055 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
00056 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00057 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00058 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00059 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00060 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00061 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00062 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00063 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
00064 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
00065 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
00066 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
00067 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-1,
00068 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
00069 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
00070 -1,-1,-1,-1,-1,-1,-0,-0,-0,-0,-0,-0,-0,-0,-0,-0,
00071 };
00072
00073 static const int8_t quant5[256]={
00074 0, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00075 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00076 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00077 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00078 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00079 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00080 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00081 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00082 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
00083 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
00084 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
00085 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
00086 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
00087 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
00088 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
00089 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-1,-1,-1,
00090 };
00091
00092 static const int8_t quant9_10bit[256]={
00093 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2,
00094 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3,
00095 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
00096 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
00097 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
00098 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
00099 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
00100 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
00101 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
00102 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
00103 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
00104 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
00105 -4,-4,-4,-4,-4,-4,-4,-4,-4,-3,-3,-3,-3,-3,-3,-3,
00106 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
00107 -3,-3,-3,-3,-3,-3,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
00108 -2,-2,-2,-2,-1,-1,-1,-1,-1,-1,-1,-1,-0,-0,-0,-0,
00109 };
00110
00111 static const int8_t quant11[256]={
00112 0, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4,
00113 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
00114 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
00115 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
00116 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
00117 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
00118 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
00119 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
00120 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
00121 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
00122 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
00123 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
00124 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
00125 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-4,-4,
00126 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
00127 -4,-4,-4,-4,-4,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-1,
00128 };
00129
00130 static const uint8_t ver2_state[256]= {
00131 0, 10, 10, 10, 10, 16, 16, 16, 28, 16, 16, 29, 42, 49, 20, 49,
00132 59, 25, 26, 26, 27, 31, 33, 33, 33, 34, 34, 37, 67, 38, 39, 39,
00133 40, 40, 41, 79, 43, 44, 45, 45, 48, 48, 64, 50, 51, 52, 88, 52,
00134 53, 74, 55, 57, 58, 58, 74, 60, 101, 61, 62, 84, 66, 66, 68, 69,
00135 87, 82, 71, 97, 73, 73, 82, 75, 111, 77, 94, 78, 87, 81, 83, 97,
00136 85, 83, 94, 86, 99, 89, 90, 99, 111, 92, 93, 134, 95, 98, 105, 98,
00137 105, 110, 102, 108, 102, 118, 103, 106, 106, 113, 109, 112, 114, 112, 116, 125,
00138 115, 116, 117, 117, 126, 119, 125, 121, 121, 123, 145, 124, 126, 131, 127, 129,
00139 165, 130, 132, 138, 133, 135, 145, 136, 137, 139, 146, 141, 143, 142, 144, 148,
00140 147, 155, 151, 149, 151, 150, 152, 157, 153, 154, 156, 168, 158, 162, 161, 160,
00141 172, 163, 169, 164, 166, 184, 167, 170, 177, 174, 171, 173, 182, 176, 180, 178,
00142 175, 189, 179, 181, 186, 183, 192, 185, 200, 187, 191, 188, 190, 197, 193, 196,
00143 197, 194, 195, 196, 198, 202, 199, 201, 210, 203, 207, 204, 205, 206, 208, 214,
00144 209, 211, 221, 212, 213, 215, 224, 216, 217, 218, 219, 220, 222, 228, 223, 225,
00145 226, 224, 227, 229, 240, 230, 231, 232, 233, 234, 235, 236, 238, 239, 237, 242,
00146 241, 243, 242, 244, 245, 246, 247, 248, 249, 250, 251, 252, 252, 253, 254, 255,
00147 };
00148
00149 typedef struct VlcState{
00150 int16_t drift;
00151 uint16_t error_sum;
00152 int8_t bias;
00153 uint8_t count;
00154 } VlcState;
00155
00156 typedef struct PlaneContext{
00157 int16_t quant_table[MAX_CONTEXT_INPUTS][256];
00158 int quant_table_index;
00159 int context_count;
00160 uint8_t (*state)[CONTEXT_SIZE];
00161 VlcState *vlc_state;
00162 uint8_t interlace_bit_state[2];
00163 } PlaneContext;
00164
00165 #define MAX_SLICES 256
00166
00167 typedef struct FFV1Context{
00168 AVClass *class;
00169 AVCodecContext *avctx;
00170 RangeCoder c;
00171 GetBitContext gb;
00172 PutBitContext pb;
00173 uint64_t rc_stat[256][2];
00174 uint64_t (*rc_stat2[MAX_QUANT_TABLES])[32][2];
00175 int version;
00176 int minor_version;
00177 int width, height;
00178 int chroma_h_shift, chroma_v_shift;
00179 int chroma_planes;
00180 int transparency;
00181 int flags;
00182 int picture_number;
00183 AVFrame picture;
00184 int plane_count;
00185 int ac;
00186 int ac_byte_count;
00187 PlaneContext plane[MAX_PLANES];
00188 int16_t quant_table[MAX_CONTEXT_INPUTS][256];
00189 int16_t quant_tables[MAX_QUANT_TABLES][MAX_CONTEXT_INPUTS][256];
00190 int context_count[MAX_QUANT_TABLES];
00191 uint8_t state_transition[256];
00192 uint8_t (*initial_states[MAX_QUANT_TABLES])[32];
00193 int run_index;
00194 int colorspace;
00195 int16_t *sample_buffer;
00196 int gob_count;
00197 int packed_at_lsb;
00198 int ec;
00199 int key_frame_ok;
00200
00201 int quant_table_count;
00202
00203 DSPContext dsp;
00204
00205 struct FFV1Context *slice_context[MAX_SLICES];
00206 int slice_count;
00207 int num_v_slices;
00208 int num_h_slices;
00209 int slice_width;
00210 int slice_height;
00211 int slice_x;
00212 int slice_y;
00213 int bits_per_raw_sample;
00214 }FFV1Context;
00215
00216 static av_always_inline int fold(int diff, int bits){
00217 if(bits==8)
00218 diff= (int8_t)diff;
00219 else{
00220 diff+= 1<<(bits-1);
00221 diff&=(1<<bits)-1;
00222 diff-= 1<<(bits-1);
00223 }
00224
00225 return diff;
00226 }
00227
00228 static inline int predict(int16_t *src, int16_t *last)
00229 {
00230 const int LT= last[-1];
00231 const int T= last[ 0];
00232 const int L = src[-1];
00233
00234 return mid_pred(L, L + T - LT, T);
00235 }
00236
00237 static inline int get_context(PlaneContext *p, int16_t *src,
00238 int16_t *last, int16_t *last2)
00239 {
00240 const int LT= last[-1];
00241 const int T= last[ 0];
00242 const int RT= last[ 1];
00243 const int L = src[-1];
00244
00245 if(p->quant_table[3][127]){
00246 const int TT= last2[0];
00247 const int LL= src[-2];
00248 return p->quant_table[0][(L-LT) & 0xFF] + p->quant_table[1][(LT-T) & 0xFF] + p->quant_table[2][(T-RT) & 0xFF]
00249 +p->quant_table[3][(LL-L) & 0xFF] + p->quant_table[4][(TT-T) & 0xFF];
00250 }else
00251 return p->quant_table[0][(L-LT) & 0xFF] + p->quant_table[1][(LT-T) & 0xFF] + p->quant_table[2][(T-RT) & 0xFF];
00252 }
00253
00254 static void find_best_state(uint8_t best_state[256][256], const uint8_t one_state[256]){
00255 int i,j,k,m;
00256 double l2tab[256];
00257
00258 for(i=1; i<256; i++)
00259 l2tab[i]= log2(i/256.0);
00260
00261 for(i=0; i<256; i++){
00262 double best_len[256];
00263 double p= i/256.0;
00264
00265 for(j=0; j<256; j++)
00266 best_len[j]= 1<<30;
00267
00268 for(j=FFMAX(i-10,1); j<FFMIN(i+11,256); j++){
00269 double occ[256]={0};
00270 double len=0;
00271 occ[j]=1.0;
00272 for(k=0; k<256; k++){
00273 double newocc[256]={0};
00274 for(m=0; m<256; m++){
00275 if(occ[m]){
00276 len -=occ[m]*( p *l2tab[ m]
00277 + (1-p)*l2tab[256-m]);
00278 }
00279 }
00280 if(len < best_len[k]){
00281 best_len[k]= len;
00282 best_state[i][k]= j;
00283 }
00284 for(m=0; m<256; m++){
00285 if(occ[m]){
00286 newocc[ one_state[ m]] += occ[m]* p ;
00287 newocc[256-one_state[256-m]] += occ[m]*(1-p);
00288 }
00289 }
00290 memcpy(occ, newocc, sizeof(occ));
00291 }
00292 }
00293 }
00294 }
00295
00296 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]){
00297 int i;
00298
00299 #define put_rac(C,S,B) \
00300 do{\
00301 if(rc_stat){\
00302 rc_stat[*(S)][B]++;\
00303 rc_stat2[(S)-state][B]++;\
00304 }\
00305 put_rac(C,S,B);\
00306 }while(0)
00307
00308 if(v){
00309 const int a= FFABS(v);
00310 const int e= av_log2(a);
00311 put_rac(c, state+0, 0);
00312 if(e<=9){
00313 for(i=0; i<e; i++){
00314 put_rac(c, state+1+i, 1);
00315 }
00316 put_rac(c, state+1+i, 0);
00317
00318 for(i=e-1; i>=0; i--){
00319 put_rac(c, state+22+i, (a>>i)&1);
00320 }
00321
00322 if(is_signed)
00323 put_rac(c, state+11 + e, v < 0);
00324 }else{
00325 for(i=0; i<e; i++){
00326 put_rac(c, state+1+FFMIN(i,9), 1);
00327 }
00328 put_rac(c, state+1+9, 0);
00329
00330 for(i=e-1; i>=0; i--){
00331 put_rac(c, state+22+FFMIN(i,9), (a>>i)&1);
00332 }
00333
00334 if(is_signed)
00335 put_rac(c, state+11 + 10, v < 0);
00336 }
00337 }else{
00338 put_rac(c, state+0, 1);
00339 }
00340 #undef put_rac
00341 }
00342
00343 static av_noinline void put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed){
00344 put_symbol_inline(c, state, v, is_signed, NULL, NULL);
00345 }
00346
00347 static inline av_flatten int get_symbol_inline(RangeCoder *c, uint8_t *state, int is_signed){
00348 if(get_rac(c, state+0))
00349 return 0;
00350 else{
00351 int i, e, a;
00352 e= 0;
00353 while(get_rac(c, state+1 + FFMIN(e,9))){
00354 e++;
00355 }
00356
00357 a= 1;
00358 for(i=e-1; i>=0; i--){
00359 a += a + get_rac(c, state+22 + FFMIN(i,9));
00360 }
00361
00362 e= -(is_signed && get_rac(c, state+11 + FFMIN(e, 10)));
00363 return (a^e)-e;
00364 }
00365 }
00366
00367 static av_noinline int get_symbol(RangeCoder *c, uint8_t *state, int is_signed){
00368 return get_symbol_inline(c, state, is_signed);
00369 }
00370
00371 static inline void update_vlc_state(VlcState * const state, const int v){
00372 int drift= state->drift;
00373 int count= state->count;
00374 state->error_sum += FFABS(v);
00375 drift += v;
00376
00377 if(count == 128){
00378 count >>= 1;
00379 drift >>= 1;
00380 state->error_sum >>= 1;
00381 }
00382 count++;
00383
00384 if(drift <= -count){
00385 if(state->bias > -128) state->bias--;
00386
00387 drift += count;
00388 if(drift <= -count)
00389 drift= -count + 1;
00390 }else if(drift > 0){
00391 if(state->bias < 127) state->bias++;
00392
00393 drift -= count;
00394 if(drift > 0)
00395 drift= 0;
00396 }
00397
00398 state->drift= drift;
00399 state->count= count;
00400 }
00401
00402 static inline void put_vlc_symbol(PutBitContext *pb, VlcState * const state, int v, int bits){
00403 int i, k, code;
00404
00405 v = fold(v - state->bias, bits);
00406
00407 i= state->count;
00408 k=0;
00409 while(i < state->error_sum){
00410 k++;
00411 i += i;
00412 }
00413
00414 assert(k<=8);
00415
00416 #if 0 // JPEG LS
00417 if(k==0 && 2*state->drift <= - state->count) code= v ^ (-1);
00418 else code= v;
00419 #else
00420 code= v ^ ((2*state->drift + state->count)>>31);
00421 #endif
00422
00423
00424 set_sr_golomb(pb, code, k, 12, bits);
00425
00426 update_vlc_state(state, v);
00427 }
00428
00429 static inline int get_vlc_symbol(GetBitContext *gb, VlcState * const state, int bits){
00430 int k, i, v, ret;
00431
00432 i= state->count;
00433 k=0;
00434 while(i < state->error_sum){
00435 k++;
00436 i += i;
00437 }
00438
00439 assert(k<=8);
00440
00441 v= get_sr_golomb(gb, k, 12, bits);
00442
00443
00444 #if 0 // JPEG LS
00445 if(k==0 && 2*state->drift <= - state->count) v ^= (-1);
00446 #else
00447 v ^= ((2*state->drift + state->count)>>31);
00448 #endif
00449
00450 ret= fold(v + state->bias, bits);
00451
00452 update_vlc_state(state, v);
00453
00454 return ret;
00455 }
00456
00457 #if CONFIG_FFV1_ENCODER
00458 static av_always_inline int encode_line(FFV1Context *s, int w,
00459 int16_t *sample[3],
00460 int plane_index, int bits)
00461 {
00462 PlaneContext * const p= &s->plane[plane_index];
00463 RangeCoder * const c= &s->c;
00464 int x;
00465 int run_index= s->run_index;
00466 int run_count=0;
00467 int run_mode=0;
00468
00469 if(s->ac){
00470 if(c->bytestream_end - c->bytestream < w*20){
00471 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
00472 return -1;
00473 }
00474 }else{
00475 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < w*4){
00476 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
00477 return -1;
00478 }
00479 }
00480
00481 for(x=0; x<w; x++){
00482 int diff, context;
00483
00484 context= get_context(p, sample[0]+x, sample[1]+x, sample[2]+x);
00485 diff= sample[0][x] - predict(sample[0]+x, sample[1]+x);
00486
00487 if(context < 0){
00488 context = -context;
00489 diff= -diff;
00490 }
00491
00492 diff= fold(diff, bits);
00493
00494 if(s->ac){
00495 if(s->flags & CODEC_FLAG_PASS1){
00496 put_symbol_inline(c, p->state[context], diff, 1, s->rc_stat, s->rc_stat2[p->quant_table_index][context]);
00497 }else{
00498 put_symbol_inline(c, p->state[context], diff, 1, NULL, NULL);
00499 }
00500 }else{
00501 if(context == 0) run_mode=1;
00502
00503 if(run_mode){
00504
00505 if(diff){
00506 while(run_count >= 1<<ff_log2_run[run_index]){
00507 run_count -= 1<<ff_log2_run[run_index];
00508 run_index++;
00509 put_bits(&s->pb, 1, 1);
00510 }
00511
00512 put_bits(&s->pb, 1 + ff_log2_run[run_index], run_count);
00513 if(run_index) run_index--;
00514 run_count=0;
00515 run_mode=0;
00516 if(diff>0) diff--;
00517 }else{
00518 run_count++;
00519 }
00520 }
00521
00522
00523
00524 if(run_mode == 0)
00525 put_vlc_symbol(&s->pb, &p->vlc_state[context], diff, bits);
00526 }
00527 }
00528 if(run_mode){
00529 while(run_count >= 1<<ff_log2_run[run_index]){
00530 run_count -= 1<<ff_log2_run[run_index];
00531 run_index++;
00532 put_bits(&s->pb, 1, 1);
00533 }
00534
00535 if(run_count)
00536 put_bits(&s->pb, 1, 1);
00537 }
00538 s->run_index= run_index;
00539
00540 return 0;
00541 }
00542
00543 static void encode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
00544 int x,y,i;
00545 const int ring_size= s->avctx->context_model ? 3 : 2;
00546 int16_t *sample[3];
00547 s->run_index=0;
00548
00549 memset(s->sample_buffer, 0, ring_size*(w+6)*sizeof(*s->sample_buffer));
00550
00551 for(y=0; y<h; y++){
00552 for(i=0; i<ring_size; i++)
00553 sample[i]= s->sample_buffer + (w+6)*((h+i-y)%ring_size) + 3;
00554
00555 sample[0][-1]= sample[1][0 ];
00556 sample[1][ w]= sample[1][w-1];
00557
00558 if(s->bits_per_raw_sample<=8){
00559 for(x=0; x<w; x++){
00560 sample[0][x]= src[x + stride*y];
00561 }
00562 encode_line(s, w, sample, plane_index, 8);
00563 }else{
00564 if(s->packed_at_lsb){
00565 for(x=0; x<w; x++){
00566 sample[0][x]= ((uint16_t*)(src + stride*y))[x];
00567 }
00568 }else{
00569 for(x=0; x<w; x++){
00570 sample[0][x]= ((uint16_t*)(src + stride*y))[x] >> (16 - s->bits_per_raw_sample);
00571 }
00572 }
00573 encode_line(s, w, sample, plane_index, s->bits_per_raw_sample);
00574 }
00575
00576 }
00577 }
00578
00579 static void encode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
00580 int x, y, p, i;
00581 const int ring_size= s->avctx->context_model ? 3 : 2;
00582 int16_t *sample[4][3];
00583 s->run_index=0;
00584
00585 memset(s->sample_buffer, 0, ring_size*4*(w+6)*sizeof(*s->sample_buffer));
00586
00587 for(y=0; y<h; y++){
00588 for(i=0; i<ring_size; i++)
00589 for(p=0; p<4; p++)
00590 sample[p][i]= s->sample_buffer + p*ring_size*(w+6) + ((h+i-y)%ring_size)*(w+6) + 3;
00591
00592 for(x=0; x<w; x++){
00593 unsigned v= src[x + stride*y];
00594 int b= v&0xFF;
00595 int g= (v>>8)&0xFF;
00596 int r= (v>>16)&0xFF;
00597 int a= v>>24;
00598
00599 b -= g;
00600 r -= g;
00601 g += (b + r)>>2;
00602 b += 0x100;
00603 r += 0x100;
00604
00605
00606
00607 sample[0][0][x]= g;
00608 sample[1][0][x]= b;
00609 sample[2][0][x]= r;
00610 sample[3][0][x]= a;
00611 }
00612 for(p=0; p<3 + s->transparency; p++){
00613 sample[p][0][-1]= sample[p][1][0 ];
00614 sample[p][1][ w]= sample[p][1][w-1];
00615 encode_line(s, w, sample[p], (p+1)/2, 9);
00616 }
00617 }
00618 }
00619
00620 static void write_quant_table(RangeCoder *c, int16_t *quant_table){
00621 int last=0;
00622 int i;
00623 uint8_t state[CONTEXT_SIZE];
00624 memset(state, 128, sizeof(state));
00625
00626 for(i=1; i<128 ; i++){
00627 if(quant_table[i] != quant_table[i-1]){
00628 put_symbol(c, state, i-last-1, 0);
00629 last= i;
00630 }
00631 }
00632 put_symbol(c, state, i-last-1, 0);
00633 }
00634
00635 static void write_quant_tables(RangeCoder *c, int16_t quant_table[MAX_CONTEXT_INPUTS][256]){
00636 int i;
00637 for(i=0; i<5; i++)
00638 write_quant_table(c, quant_table[i]);
00639 }
00640
00641 static void write_header(FFV1Context *f){
00642 uint8_t state[CONTEXT_SIZE];
00643 int i, j;
00644 RangeCoder * const c= &f->slice_context[0]->c;
00645
00646 memset(state, 128, sizeof(state));
00647
00648 if(f->version < 2){
00649 put_symbol(c, state, f->version, 0);
00650 put_symbol(c, state, f->ac, 0);
00651 if(f->ac>1){
00652 for(i=1; i<256; i++){
00653 put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
00654 }
00655 }
00656 put_symbol(c, state, f->colorspace, 0);
00657 if(f->version>0)
00658 put_symbol(c, state, f->bits_per_raw_sample, 0);
00659 put_rac(c, state, f->chroma_planes);
00660 put_symbol(c, state, f->chroma_h_shift, 0);
00661 put_symbol(c, state, f->chroma_v_shift, 0);
00662 put_rac(c, state, f->transparency);
00663
00664 write_quant_tables(c, f->quant_table);
00665 }else if(f->version < 3){
00666 put_symbol(c, state, f->slice_count, 0);
00667 for(i=0; i<f->slice_count; i++){
00668 FFV1Context *fs= f->slice_context[i];
00669 put_symbol(c, state, (fs->slice_x +1)*f->num_h_slices / f->width , 0);
00670 put_symbol(c, state, (fs->slice_y +1)*f->num_v_slices / f->height , 0);
00671 put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
00672 put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
00673 for(j=0; j<f->plane_count; j++){
00674 put_symbol(c, state, f->plane[j].quant_table_index, 0);
00675 av_assert0(f->plane[j].quant_table_index == f->avctx->context_model);
00676 }
00677 }
00678 }
00679 }
00680 #endif
00681
00682 static av_cold int common_init(AVCodecContext *avctx){
00683 FFV1Context *s = avctx->priv_data;
00684
00685 s->avctx= avctx;
00686 s->flags= avctx->flags;
00687
00688 avcodec_get_frame_defaults(&s->picture);
00689
00690 ff_dsputil_init(&s->dsp, avctx);
00691
00692 s->width = avctx->width;
00693 s->height= avctx->height;
00694
00695 assert(s->width && s->height);
00696
00697 s->num_h_slices=1;
00698 s->num_v_slices=1;
00699
00700
00701 return 0;
00702 }
00703
00704 static int init_slice_state(FFV1Context *f, FFV1Context *fs){
00705 int j;
00706
00707 fs->plane_count= f->plane_count;
00708 fs->transparency= f->transparency;
00709 for(j=0; j<f->plane_count; j++){
00710 PlaneContext * const p= &fs->plane[j];
00711
00712 if(fs->ac){
00713 if(!p-> state) p-> state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
00714 if(!p-> state)
00715 return AVERROR(ENOMEM);
00716 }else{
00717 if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
00718 if(!p->vlc_state)
00719 return AVERROR(ENOMEM);
00720 }
00721 }
00722
00723 if (fs->ac>1){
00724
00725 for(j=1; j<256; j++){
00726 fs->c.one_state [ j]= f->state_transition[j];
00727 fs->c.zero_state[256-j]= 256-fs->c.one_state [j];
00728 }
00729 }
00730
00731 return 0;
00732 }
00733
00734 static int init_slices_state(FFV1Context *f){
00735 int i;
00736 for(i=0; i<f->slice_count; i++){
00737 FFV1Context *fs= f->slice_context[i];
00738 if(init_slice_state(f, fs) < 0)
00739 return -1;
00740 }
00741 return 0;
00742 }
00743
00744 static av_cold int init_slice_contexts(FFV1Context *f){
00745 int i;
00746
00747 f->slice_count= f->num_h_slices * f->num_v_slices;
00748
00749 for(i=0; i<f->slice_count; i++){
00750 FFV1Context *fs= av_mallocz(sizeof(*fs));
00751 int sx= i % f->num_h_slices;
00752 int sy= i / f->num_h_slices;
00753 int sxs= f->avctx->width * sx / f->num_h_slices;
00754 int sxe= f->avctx->width *(sx+1) / f->num_h_slices;
00755 int sys= f->avctx->height* sy / f->num_v_slices;
00756 int sye= f->avctx->height*(sy+1) / f->num_v_slices;
00757 f->slice_context[i]= fs;
00758 memcpy(fs, f, sizeof(*fs));
00759 memset(fs->rc_stat2, 0, sizeof(fs->rc_stat2));
00760
00761 fs->slice_width = sxe - sxs;
00762 fs->slice_height= sye - sys;
00763 fs->slice_x = sxs;
00764 fs->slice_y = sys;
00765
00766 fs->sample_buffer = av_malloc(3*4 * (fs->width+6) * sizeof(*fs->sample_buffer));
00767 if (!fs->sample_buffer)
00768 return AVERROR(ENOMEM);
00769 }
00770 return 0;
00771 }
00772
00773 static int allocate_initial_states(FFV1Context *f){
00774 int i;
00775
00776 for(i=0; i<f->quant_table_count; i++){
00777 f->initial_states[i]= av_malloc(f->context_count[i]*sizeof(*f->initial_states[i]));
00778 if(!f->initial_states[i])
00779 return AVERROR(ENOMEM);
00780 memset(f->initial_states[i], 128, f->context_count[i]*sizeof(*f->initial_states[i]));
00781 }
00782 return 0;
00783 }
00784
00785 #if CONFIG_FFV1_ENCODER
00786 static int write_extra_header(FFV1Context *f){
00787 RangeCoder * const c= &f->c;
00788 uint8_t state[CONTEXT_SIZE];
00789 int i, j, k;
00790 uint8_t state2[32][CONTEXT_SIZE];
00791 unsigned v;
00792
00793 memset(state2, 128, sizeof(state2));
00794 memset(state, 128, sizeof(state));
00795
00796 f->avctx->extradata= av_malloc(f->avctx->extradata_size= 10000 + (11*11*5*5*5+11*11*11)*32);
00797 ff_init_range_encoder(c, f->avctx->extradata, f->avctx->extradata_size);
00798 ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
00799
00800 put_symbol(c, state, f->version, 0);
00801 if(f->version > 2)
00802 put_symbol(c, state, f->minor_version, 0);
00803 put_symbol(c, state, f->ac, 0);
00804 if(f->ac>1){
00805 for(i=1; i<256; i++){
00806 put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
00807 }
00808 }
00809 put_symbol(c, state, f->colorspace, 0);
00810 put_symbol(c, state, f->bits_per_raw_sample, 0);
00811 put_rac(c, state, f->chroma_planes);
00812 put_symbol(c, state, f->chroma_h_shift, 0);
00813 put_symbol(c, state, f->chroma_v_shift, 0);
00814 put_rac(c, state, f->transparency);
00815 put_symbol(c, state, f->num_h_slices-1, 0);
00816 put_symbol(c, state, f->num_v_slices-1, 0);
00817
00818 put_symbol(c, state, f->quant_table_count, 0);
00819 for(i=0; i<f->quant_table_count; i++)
00820 write_quant_tables(c, f->quant_tables[i]);
00821
00822 for(i=0; i<f->quant_table_count; i++){
00823 for(j=0; j<f->context_count[i]*CONTEXT_SIZE; j++)
00824 if(f->initial_states[i] && f->initial_states[i][0][j] != 128)
00825 break;
00826 if(j<f->context_count[i]*CONTEXT_SIZE){
00827 put_rac(c, state, 1);
00828 for(j=0; j<f->context_count[i]; j++){
00829 for(k=0; k<CONTEXT_SIZE; k++){
00830 int pred= j ? f->initial_states[i][j-1][k] : 128;
00831 put_symbol(c, state2[k], (int8_t)(f->initial_states[i][j][k]-pred), 1);
00832 }
00833 }
00834 }else{
00835 put_rac(c, state, 0);
00836 }
00837 }
00838
00839 if(f->version > 2){
00840 put_symbol(c, state, f->ec, 0);
00841 }
00842
00843 f->avctx->extradata_size= ff_rac_terminate(c);
00844 v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, f->avctx->extradata, f->avctx->extradata_size);
00845 AV_WL32(f->avctx->extradata + f->avctx->extradata_size, v);
00846 f->avctx->extradata_size += 4;
00847
00848 return 0;
00849 }
00850
00851 static int sort_stt(FFV1Context *s, uint8_t stt[256]){
00852 int i,i2,changed,print=0;
00853
00854 do{
00855 changed=0;
00856 for(i=12; i<244; i++){
00857 for(i2=i+1; i2<245 && i2<i+4; i2++){
00858 #define COST(old, new) \
00859 s->rc_stat[old][0]*-log2((256-(new))/256.0)\
00860 +s->rc_stat[old][1]*-log2( (new) /256.0)
00861
00862 #define COST2(old, new) \
00863 COST(old, new)\
00864 +COST(256-(old), 256-(new))
00865
00866 double size0= COST2(i, i ) + COST2(i2, i2);
00867 double sizeX= COST2(i, i2) + COST2(i2, i );
00868 if(sizeX < size0 && i!=128 && i2!=128){
00869 int j;
00870 FFSWAP(int, stt[ i], stt[ i2]);
00871 FFSWAP(int, s->rc_stat[i ][0],s->rc_stat[ i2][0]);
00872 FFSWAP(int, s->rc_stat[i ][1],s->rc_stat[ i2][1]);
00873 if(i != 256-i2){
00874 FFSWAP(int, stt[256-i], stt[256-i2]);
00875 FFSWAP(int, s->rc_stat[256-i][0],s->rc_stat[256-i2][0]);
00876 FFSWAP(int, s->rc_stat[256-i][1],s->rc_stat[256-i2][1]);
00877 }
00878 for(j=1; j<256; j++){
00879 if (stt[j] == i ) stt[j] = i2;
00880 else if(stt[j] == i2) stt[j] = i ;
00881 if(i != 256-i2){
00882 if (stt[256-j] == 256-i ) stt[256-j] = 256-i2;
00883 else if(stt[256-j] == 256-i2) stt[256-j] = 256-i ;
00884 }
00885 }
00886 print=changed=1;
00887 }
00888 }
00889 }
00890 }while(changed);
00891 return print;
00892 }
00893
00894 static av_cold int encode_init(AVCodecContext *avctx)
00895 {
00896 FFV1Context *s = avctx->priv_data;
00897 int i, j, k, m;
00898
00899 common_init(avctx);
00900
00901 s->version=0;
00902
00903 if((avctx->flags & (CODEC_FLAG_PASS1|CODEC_FLAG_PASS2)) || avctx->slices>1)
00904 s->version = FFMAX(s->version, 2);
00905
00906 if(avctx->level == 3){
00907 s->version = 3;
00908 }
00909
00910 if(s->ec < 0){
00911 s->ec = (s->version >= 3);
00912 }
00913
00914 if(s->version >= 2 && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
00915 av_log(avctx, AV_LOG_ERROR, "Version 2 needed for requested features but version 2 is experimental and not enabled\n");
00916 return -1;
00917 }
00918
00919 s->ac= avctx->coder_type ? 2:0;
00920
00921 if(s->ac>1)
00922 for(i=1; i<256; i++)
00923 s->state_transition[i]=ver2_state[i];
00924
00925 s->plane_count=3;
00926 switch(avctx->pix_fmt){
00927 case PIX_FMT_YUV444P9:
00928 case PIX_FMT_YUV422P9:
00929 case PIX_FMT_YUV420P9:
00930 if (!avctx->bits_per_raw_sample)
00931 s->bits_per_raw_sample = 9;
00932 case PIX_FMT_YUV444P10:
00933 case PIX_FMT_YUV420P10:
00934 case PIX_FMT_YUV422P10:
00935 s->packed_at_lsb = 1;
00936 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
00937 s->bits_per_raw_sample = 10;
00938 case PIX_FMT_GRAY16:
00939 case PIX_FMT_YUV444P16:
00940 case PIX_FMT_YUV422P16:
00941 case PIX_FMT_YUV420P16:
00942 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {
00943 s->bits_per_raw_sample = 16;
00944 } else if (!s->bits_per_raw_sample){
00945 s->bits_per_raw_sample = avctx->bits_per_raw_sample;
00946 }
00947 if(s->bits_per_raw_sample <=8){
00948 av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
00949 return -1;
00950 }
00951 if(!s->ac){
00952 av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample of more than 8 needs -coder 1 currently\n");
00953 return -1;
00954 }
00955 s->version= FFMAX(s->version, 1);
00956 case PIX_FMT_GRAY8:
00957 case PIX_FMT_YUV444P:
00958 case PIX_FMT_YUV440P:
00959 case PIX_FMT_YUV422P:
00960 case PIX_FMT_YUV420P:
00961 case PIX_FMT_YUV411P:
00962 case PIX_FMT_YUV410P:
00963 s->chroma_planes= av_pix_fmt_descriptors[avctx->pix_fmt].nb_components < 3 ? 0 : 1;
00964 s->colorspace= 0;
00965 break;
00966 case PIX_FMT_YUVA444P:
00967 case PIX_FMT_YUVA422P:
00968 case PIX_FMT_YUVA420P:
00969 s->chroma_planes= 1;
00970 s->colorspace= 0;
00971 s->transparency= 1;
00972 break;
00973 case PIX_FMT_RGB32:
00974 s->colorspace= 1;
00975 s->transparency= 1;
00976 break;
00977 case PIX_FMT_0RGB32:
00978 s->colorspace= 1;
00979 break;
00980 default:
00981 av_log(avctx, AV_LOG_ERROR, "format not supported\n");
00982 return -1;
00983 }
00984 if (s->transparency) {
00985 av_log(avctx, AV_LOG_WARNING, "Storing alpha plane, this will require a recent FFV1 decoder to playback!\n");
00986 }
00987 if (avctx->context_model > 1U) {
00988 av_log(avctx, AV_LOG_ERROR, "Invalid context model %d, valid values are 0 and 1\n", avctx->context_model);
00989 return AVERROR(EINVAL);
00990 }
00991
00992 for(i=0; i<256; i++){
00993 s->quant_table_count=2;
00994 if(s->bits_per_raw_sample <=8){
00995 s->quant_tables[0][0][i]= quant11[i];
00996 s->quant_tables[0][1][i]= 11*quant11[i];
00997 s->quant_tables[0][2][i]= 11*11*quant11[i];
00998 s->quant_tables[1][0][i]= quant11[i];
00999 s->quant_tables[1][1][i]= 11*quant11[i];
01000 s->quant_tables[1][2][i]= 11*11*quant5 [i];
01001 s->quant_tables[1][3][i]= 5*11*11*quant5 [i];
01002 s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
01003 }else{
01004 s->quant_tables[0][0][i]= quant9_10bit[i];
01005 s->quant_tables[0][1][i]= 11*quant9_10bit[i];
01006 s->quant_tables[0][2][i]= 11*11*quant9_10bit[i];
01007 s->quant_tables[1][0][i]= quant9_10bit[i];
01008 s->quant_tables[1][1][i]= 11*quant9_10bit[i];
01009 s->quant_tables[1][2][i]= 11*11*quant5_10bit[i];
01010 s->quant_tables[1][3][i]= 5*11*11*quant5_10bit[i];
01011 s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
01012 }
01013 }
01014 s->context_count[0]= (11*11*11+1)/2;
01015 s->context_count[1]= (11*11*5*5*5+1)/2;
01016 memcpy(s->quant_table, s->quant_tables[avctx->context_model], sizeof(s->quant_table));
01017
01018 for(i=0; i<s->plane_count; i++){
01019 PlaneContext * const p= &s->plane[i];
01020
01021 memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
01022 p->quant_table_index= avctx->context_model;
01023 p->context_count= s->context_count[p->quant_table_index];
01024 }
01025
01026 if(allocate_initial_states(s) < 0)
01027 return AVERROR(ENOMEM);
01028
01029 avctx->coded_frame= &s->picture;
01030 if(!s->transparency)
01031 s->plane_count= 2;
01032 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
01033
01034 s->picture_number=0;
01035
01036 if(avctx->flags & (CODEC_FLAG_PASS1|CODEC_FLAG_PASS2)){
01037 for(i=0; i<s->quant_table_count; i++){
01038 s->rc_stat2[i]= av_mallocz(s->context_count[i]*sizeof(*s->rc_stat2[i]));
01039 if(!s->rc_stat2[i])
01040 return AVERROR(ENOMEM);
01041 }
01042 }
01043 if(avctx->stats_in){
01044 char *p= avctx->stats_in;
01045 uint8_t best_state[256][256];
01046 int gob_count=0;
01047 char *next;
01048
01049 av_assert0(s->version>=2);
01050
01051 for(;;){
01052 for(j=0; j<256; j++){
01053 for(i=0; i<2; i++){
01054 s->rc_stat[j][i]= strtol(p, &next, 0);
01055 if(next==p){
01056 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid at %d %d [%s]\n", j,i,p);
01057 return -1;
01058 }
01059 p=next;
01060 }
01061 }
01062 for(i=0; i<s->quant_table_count; i++){
01063 for(j=0; j<s->context_count[i]; j++){
01064 for(k=0; k<32; k++){
01065 for(m=0; m<2; m++){
01066 s->rc_stat2[i][j][k][m]= strtol(p, &next, 0);
01067 if(next==p){
01068 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid at %d %d %d %d [%s]\n", i,j,k,m,p);
01069 return -1;
01070 }
01071 p=next;
01072 }
01073 }
01074 }
01075 }
01076 gob_count= strtol(p, &next, 0);
01077 if(next==p || gob_count <0){
01078 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
01079 return -1;
01080 }
01081 p=next;
01082 while(*p=='\n' || *p==' ') p++;
01083 if(p[0]==0) break;
01084 }
01085 sort_stt(s, s->state_transition);
01086
01087 find_best_state(best_state, s->state_transition);
01088
01089 for(i=0; i<s->quant_table_count; i++){
01090 for(j=0; j<s->context_count[i]; j++){
01091 for(k=0; k<32; k++){
01092 double p= 128;
01093 if(s->rc_stat2[i][j][k][0]+s->rc_stat2[i][j][k][1]){
01094 p=256.0*s->rc_stat2[i][j][k][1] / (s->rc_stat2[i][j][k][0]+s->rc_stat2[i][j][k][1]);
01095 }
01096 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)];
01097 }
01098 }
01099 }
01100 }
01101
01102 if(s->version>1){
01103 for(s->num_v_slices=2; s->num_v_slices<9; s->num_v_slices++){
01104 for(s->num_h_slices=s->num_v_slices; s->num_h_slices<2*s->num_v_slices; s->num_h_slices++){
01105 if(avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= 64)
01106 goto slices_ok;
01107 }
01108 }
01109 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);
01110 return -1;
01111 slices_ok:
01112 write_extra_header(s);
01113 }
01114
01115 if(init_slice_contexts(s) < 0)
01116 return -1;
01117 if(init_slices_state(s) < 0)
01118 return -1;
01119
01120 #define STATS_OUT_SIZE 1024*1024*6
01121 if(avctx->flags & CODEC_FLAG_PASS1){
01122 avctx->stats_out= av_mallocz(STATS_OUT_SIZE);
01123 for(i=0; i<s->quant_table_count; i++){
01124 for(j=0; j<s->slice_count; j++){
01125 FFV1Context *sf= s->slice_context[j];
01126 av_assert0(!sf->rc_stat2[i]);
01127 sf->rc_stat2[i]= av_mallocz(s->context_count[i]*sizeof(*sf->rc_stat2[i]));
01128 if(!sf->rc_stat2[i])
01129 return AVERROR(ENOMEM);
01130 }
01131 }
01132 }
01133
01134 return 0;
01135 }
01136 #endif
01137
01138
01139 static void clear_slice_state(FFV1Context *f, FFV1Context *fs){
01140 int i, j;
01141
01142 for(i=0; i<f->plane_count; i++){
01143 PlaneContext *p= &fs->plane[i];
01144
01145 p->interlace_bit_state[0]= 128;
01146 p->interlace_bit_state[1]= 128;
01147
01148 if(fs->ac){
01149 if(f->initial_states[p->quant_table_index]){
01150 memcpy(p->state, f->initial_states[p->quant_table_index], CONTEXT_SIZE*p->context_count);
01151 }else
01152 memset(p->state, 128, CONTEXT_SIZE*p->context_count);
01153 }else{
01154 for(j=0; j<p->context_count; j++){
01155 p->vlc_state[j].drift= 0;
01156 p->vlc_state[j].error_sum= 4;
01157 p->vlc_state[j].bias= 0;
01158 p->vlc_state[j].count= 1;
01159 }
01160 }
01161 }
01162 }
01163
01164 #if CONFIG_FFV1_ENCODER
01165
01166 static void encode_slice_header(FFV1Context *f, FFV1Context *fs){
01167 RangeCoder *c = &fs->c;
01168 uint8_t state[CONTEXT_SIZE];
01169 int j;
01170 memset(state, 128, sizeof(state));
01171
01172 put_symbol(c, state, (fs->slice_x +1)*f->num_h_slices / f->width , 0);
01173 put_symbol(c, state, (fs->slice_y +1)*f->num_v_slices / f->height , 0);
01174 put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
01175 put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
01176 for(j=0; j<f->plane_count; j++){
01177 put_symbol(c, state, f->plane[j].quant_table_index, 0);
01178 av_assert0(f->plane[j].quant_table_index == f->avctx->context_model);
01179 }
01180 if(!f->picture.interlaced_frame) put_symbol(c, state, 3, 0);
01181 else put_symbol(c, state, 1 + !f->picture.top_field_first, 0);
01182 put_symbol(c, state, f->picture.sample_aspect_ratio.num, 0);
01183 put_symbol(c, state, f->picture.sample_aspect_ratio.den, 0);
01184 }
01185
01186 static int encode_slice(AVCodecContext *c, void *arg){
01187 FFV1Context *fs= *(void**)arg;
01188 FFV1Context *f= fs->avctx->priv_data;
01189 int width = fs->slice_width;
01190 int height= fs->slice_height;
01191 int x= fs->slice_x;
01192 int y= fs->slice_y;
01193 AVFrame * const p= &f->picture;
01194 const int ps= (f->bits_per_raw_sample>8)+1;
01195
01196 if(p->key_frame)
01197 clear_slice_state(f, fs);
01198 if(f->version > 2){
01199 encode_slice_header(f, fs);
01200 }
01201 if(!fs->ac){
01202 fs->ac_byte_count = f->version > 2 || (!x&&!y) ? ff_rac_terminate(&fs->c) : 0;
01203 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);
01204 }
01205
01206 if(f->colorspace==0){
01207 const int chroma_width = -((-width )>>f->chroma_h_shift);
01208 const int chroma_height= -((-height)>>f->chroma_v_shift);
01209 const int cx= x>>f->chroma_h_shift;
01210 const int cy= y>>f->chroma_v_shift;
01211
01212 encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0);
01213
01214 if (f->chroma_planes){
01215 encode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
01216 encode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1);
01217 }
01218 if (fs->transparency)
01219 encode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2);
01220 }else{
01221 encode_rgb_frame(fs, (uint32_t*)(p->data[0]) + ps*x + y*(p->linesize[0]/4), width, height, p->linesize[0]/4);
01222 }
01223 emms_c();
01224
01225 return 0;
01226 }
01227
01228 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
01229 const AVFrame *pict, int *got_packet)
01230 {
01231 FFV1Context *f = avctx->priv_data;
01232 RangeCoder * const c= &f->slice_context[0]->c;
01233 AVFrame * const p= &f->picture;
01234 int used_count= 0;
01235 uint8_t keystate=128;
01236 uint8_t *buf_p;
01237 int i, ret;
01238
01239 if ((ret = ff_alloc_packet2(avctx, pkt, avctx->width*avctx->height*((8*2+1+1)*4)/8
01240 + FF_MIN_BUFFER_SIZE)) < 0)
01241 return ret;
01242
01243 ff_init_range_encoder(c, pkt->data, pkt->size);
01244 ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
01245
01246 *p = *pict;
01247 p->pict_type= AV_PICTURE_TYPE_I;
01248
01249 if(avctx->gop_size==0 || f->picture_number % avctx->gop_size == 0){
01250 put_rac(c, &keystate, 1);
01251 p->key_frame= 1;
01252 f->gob_count++;
01253 write_header(f);
01254 }else{
01255 put_rac(c, &keystate, 0);
01256 p->key_frame= 0;
01257 }
01258
01259 if (f->ac>1){
01260 int i;
01261 for(i=1; i<256; i++){
01262 c->one_state[i]= f->state_transition[i];
01263 c->zero_state[256-i]= 256-c->one_state[i];
01264 }
01265 }
01266
01267 for(i=1; i<f->slice_count; i++){
01268 FFV1Context *fs= f->slice_context[i];
01269 uint8_t *start = pkt->data + (pkt->size-used_count)*i/f->slice_count;
01270 int len = pkt->size/f->slice_count;
01271
01272 ff_init_range_encoder(&fs->c, start, len);
01273 }
01274 avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL, f->slice_count, sizeof(void*));
01275
01276 buf_p = pkt->data;
01277 for(i=0; i<f->slice_count; i++){
01278 FFV1Context *fs= f->slice_context[i];
01279 int bytes;
01280
01281 if(fs->ac){
01282 uint8_t state=128;
01283 put_rac(&fs->c, &state, 0);
01284 bytes= ff_rac_terminate(&fs->c);
01285 }else{
01286 flush_put_bits(&fs->pb);
01287 bytes= fs->ac_byte_count + (put_bits_count(&fs->pb)+7)/8;
01288 }
01289 if(i>0 || f->version>2){
01290 av_assert0(bytes < pkt->size/f->slice_count);
01291 memmove(buf_p, fs->c.bytestream_start, bytes);
01292 av_assert0(bytes < (1<<24));
01293 AV_WB24(buf_p+bytes, bytes);
01294 bytes+=3;
01295 }
01296 if(f->ec){
01297 unsigned v;
01298 buf_p[bytes++] = 0;
01299 v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);
01300 AV_WL32(buf_p + bytes, v); bytes += 4;
01301 }
01302 buf_p += bytes;
01303 }
01304
01305 if((avctx->flags&CODEC_FLAG_PASS1) && (f->picture_number&31)==0){
01306 int j, k, m;
01307 char *p= avctx->stats_out;
01308 char *end= p + STATS_OUT_SIZE;
01309
01310 memset(f->rc_stat, 0, sizeof(f->rc_stat));
01311 for(i=0; i<f->quant_table_count; i++)
01312 memset(f->rc_stat2[i], 0, f->context_count[i]*sizeof(*f->rc_stat2[i]));
01313
01314 for(j=0; j<f->slice_count; j++){
01315 FFV1Context *fs= f->slice_context[j];
01316 for(i=0; i<256; i++){
01317 f->rc_stat[i][0] += fs->rc_stat[i][0];
01318 f->rc_stat[i][1] += fs->rc_stat[i][1];
01319 }
01320 for(i=0; i<f->quant_table_count; i++){
01321 for(k=0; k<f->context_count[i]; k++){
01322 for(m=0; m<32; m++){
01323 f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
01324 f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
01325 }
01326 }
01327 }
01328 }
01329
01330 for(j=0; j<256; j++){
01331 snprintf(p, end-p, "%"PRIu64" %"PRIu64" ", f->rc_stat[j][0], f->rc_stat[j][1]);
01332 p+= strlen(p);
01333 }
01334 snprintf(p, end-p, "\n");
01335
01336 for(i=0; i<f->quant_table_count; i++){
01337 for(j=0; j<f->context_count[i]; j++){
01338 for(m=0; m<32; m++){
01339 snprintf(p, end-p, "%"PRIu64" %"PRIu64" ", f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
01340 p+= strlen(p);
01341 }
01342 }
01343 }
01344 snprintf(p, end-p, "%d\n", f->gob_count);
01345 } else if(avctx->flags&CODEC_FLAG_PASS1)
01346 avctx->stats_out[0] = '\0';
01347
01348 f->picture_number++;
01349 pkt->size = buf_p - pkt->data;
01350 pkt->flags |= AV_PKT_FLAG_KEY*p->key_frame;
01351 *got_packet = 1;
01352
01353 return 0;
01354 }
01355 #endif
01356
01357 static av_cold int common_end(AVCodecContext *avctx){
01358 FFV1Context *s = avctx->priv_data;
01359 int i, j;
01360
01361 if (avctx->codec->decode && s->picture.data[0])
01362 avctx->release_buffer(avctx, &s->picture);
01363
01364 for(j=0; j<s->slice_count; j++){
01365 FFV1Context *fs= s->slice_context[j];
01366 for(i=0; i<s->plane_count; i++){
01367 PlaneContext *p= &fs->plane[i];
01368
01369 av_freep(&p->state);
01370 av_freep(&p->vlc_state);
01371 }
01372 av_freep(&fs->sample_buffer);
01373 }
01374
01375 av_freep(&avctx->stats_out);
01376 for(j=0; j<s->quant_table_count; j++){
01377 av_freep(&s->initial_states[j]);
01378 for(i=0; i<s->slice_count; i++){
01379 FFV1Context *sf= s->slice_context[i];
01380 av_freep(&sf->rc_stat2[j]);
01381 }
01382 av_freep(&s->rc_stat2[j]);
01383 }
01384
01385 for(i=0; i<s->slice_count; i++){
01386 av_freep(&s->slice_context[i]);
01387 }
01388
01389 return 0;
01390 }
01391
01392 static av_always_inline void decode_line(FFV1Context *s, int w,
01393 int16_t *sample[2],
01394 int plane_index, int bits)
01395 {
01396 PlaneContext * const p= &s->plane[plane_index];
01397 RangeCoder * const c= &s->c;
01398 int x;
01399 int run_count=0;
01400 int run_mode=0;
01401 int run_index= s->run_index;
01402
01403 for(x=0; x<w; x++){
01404 int diff, context, sign;
01405
01406 context= get_context(p, sample[1] + x, sample[0] + x, sample[1] + x);
01407 if(context < 0){
01408 context= -context;
01409 sign=1;
01410 }else
01411 sign=0;
01412
01413 av_assert2(context < p->context_count);
01414
01415 if(s->ac){
01416 diff= get_symbol_inline(c, p->state[context], 1);
01417 }else{
01418 if(context == 0 && run_mode==0) run_mode=1;
01419
01420 if(run_mode){
01421 if(run_count==0 && run_mode==1){
01422 if(get_bits1(&s->gb)){
01423 run_count = 1<<ff_log2_run[run_index];
01424 if(x + run_count <= w) run_index++;
01425 }else{
01426 if(ff_log2_run[run_index]) run_count = get_bits(&s->gb, ff_log2_run[run_index]);
01427 else run_count=0;
01428 if(run_index) run_index--;
01429 run_mode=2;
01430 }
01431 }
01432 run_count--;
01433 if(run_count < 0){
01434 run_mode=0;
01435 run_count=0;
01436 diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
01437 if(diff>=0) diff++;
01438 }else
01439 diff=0;
01440 }else
01441 diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
01442
01443
01444 }
01445
01446 if(sign) diff= -diff;
01447
01448 sample[1][x]= (predict(sample[1] + x, sample[0] + x) + diff) & ((1<<bits)-1);
01449 }
01450 s->run_index= run_index;
01451 }
01452
01453 static void decode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
01454 int x, y;
01455 int16_t *sample[2];
01456 sample[0]=s->sample_buffer +3;
01457 sample[1]=s->sample_buffer+w+6+3;
01458
01459 s->run_index=0;
01460
01461 memset(s->sample_buffer, 0, 2*(w+6)*sizeof(*s->sample_buffer));
01462
01463 for(y=0; y<h; y++){
01464 int16_t *temp = sample[0];
01465
01466 sample[0]= sample[1];
01467 sample[1]= temp;
01468
01469 sample[1][-1]= sample[0][0 ];
01470 sample[0][ w]= sample[0][w-1];
01471
01472
01473 if(s->avctx->bits_per_raw_sample <= 8){
01474 decode_line(s, w, sample, plane_index, 8);
01475 for(x=0; x<w; x++){
01476 src[x + stride*y]= sample[1][x];
01477 }
01478 }else{
01479 decode_line(s, w, sample, plane_index, s->avctx->bits_per_raw_sample);
01480 if(s->packed_at_lsb){
01481 for(x=0; x<w; x++){
01482 ((uint16_t*)(src + stride*y))[x]= sample[1][x];
01483 }
01484 }else{
01485 for(x=0; x<w; x++){
01486 ((uint16_t*)(src + stride*y))[x]= sample[1][x] << (16 - s->avctx->bits_per_raw_sample);
01487 }
01488 }
01489 }
01490
01491 }
01492 }
01493
01494 static void decode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
01495 int x, y, p;
01496 int16_t *sample[4][2];
01497 for(x=0; x<4; x++){
01498 sample[x][0] = s->sample_buffer + x*2 *(w+6) + 3;
01499 sample[x][1] = s->sample_buffer + (x*2+1)*(w+6) + 3;
01500 }
01501
01502 s->run_index=0;
01503
01504 memset(s->sample_buffer, 0, 8*(w+6)*sizeof(*s->sample_buffer));
01505
01506 for(y=0; y<h; y++){
01507 for(p=0; p<3 + s->transparency; p++){
01508 int16_t *temp = sample[p][0];
01509
01510 sample[p][0]= sample[p][1];
01511 sample[p][1]= temp;
01512
01513 sample[p][1][-1]= sample[p][0][0 ];
01514 sample[p][0][ w]= sample[p][0][w-1];
01515 decode_line(s, w, sample[p], (p+1)/2, 9);
01516 }
01517 for(x=0; x<w; x++){
01518 int g= sample[0][1][x];
01519 int b= sample[1][1][x];
01520 int r= sample[2][1][x];
01521 int a= sample[3][1][x];
01522
01523
01524
01525
01526 b -= 0x100;
01527 r -= 0x100;
01528 g -= (b + r)>>2;
01529 b += g;
01530 r += g;
01531
01532 src[x + stride*y]= b + (g<<8) + (r<<16) + (a<<24);
01533 }
01534 }
01535 }
01536
01537 static int decode_slice_header(FFV1Context *f, FFV1Context *fs){
01538 RangeCoder *c = &fs->c;
01539 uint8_t state[CONTEXT_SIZE];
01540 unsigned ps, i, context_count;
01541 memset(state, 128, sizeof(state));
01542
01543 av_assert0(f->version > 2);
01544
01545 fs->slice_x = get_symbol(c, state, 0) *f->width ;
01546 fs->slice_y = get_symbol(c, state, 0) *f->height;
01547 fs->slice_width =(get_symbol(c, state, 0)+1)*f->width + fs->slice_x;
01548 fs->slice_height=(get_symbol(c, state, 0)+1)*f->height + fs->slice_y;
01549
01550 fs->slice_x /= f->num_h_slices;
01551 fs->slice_y /= f->num_v_slices;
01552 fs->slice_width = fs->slice_width /f->num_h_slices - fs->slice_x;
01553 fs->slice_height = fs->slice_height/f->num_v_slices - fs->slice_y;
01554 if((unsigned)fs->slice_width > f->width || (unsigned)fs->slice_height > f->height)
01555 return -1;
01556 if( (unsigned)fs->slice_x + (uint64_t)fs->slice_width > f->width
01557 || (unsigned)fs->slice_y + (uint64_t)fs->slice_height > f->height)
01558 return -1;
01559
01560 for(i=0; i<f->plane_count; i++){
01561 PlaneContext * const p= &fs->plane[i];
01562 int idx=get_symbol(c, state, 0);
01563 if(idx > (unsigned)f->quant_table_count){
01564 av_log(f->avctx, AV_LOG_ERROR, "quant_table_index out of range\n");
01565 return -1;
01566 }
01567 p->quant_table_index= idx;
01568 memcpy(p->quant_table, f->quant_tables[idx], sizeof(p->quant_table));
01569 context_count= f->context_count[idx];
01570
01571 if(p->context_count < context_count){
01572 av_freep(&p->state);
01573 av_freep(&p->vlc_state);
01574 }
01575 p->context_count= context_count;
01576 }
01577
01578 ps = get_symbol(c, state, 0);
01579 if(ps==1){
01580 f->picture.interlaced_frame = 1;
01581 f->picture.top_field_first = 1;
01582 } else if(ps==2){
01583 f->picture.interlaced_frame = 1;
01584 f->picture.top_field_first = 0;
01585 } else if(ps==3){
01586 f->picture.interlaced_frame = 0;
01587 }
01588 f->picture.sample_aspect_ratio.num = get_symbol(c, state, 0);
01589 f->picture.sample_aspect_ratio.den = get_symbol(c, state, 0);
01590
01591 return 0;
01592 }
01593
01594 static int decode_slice(AVCodecContext *c, void *arg){
01595 FFV1Context *fs= *(void**)arg;
01596 FFV1Context *f= fs->avctx->priv_data;
01597 int width, height, x, y;
01598 const int ps= (c->bits_per_raw_sample>8)+1;
01599 AVFrame * const p= &f->picture;
01600
01601 if(f->version > 2){
01602 if(init_slice_state(f, fs) < 0)
01603 return AVERROR(ENOMEM);
01604 if(decode_slice_header(f, fs) < 0)
01605 return AVERROR_INVALIDDATA;
01606 }
01607 if(init_slice_state(f, fs) < 0)
01608 return AVERROR(ENOMEM);
01609 if(f->picture.key_frame)
01610 clear_slice_state(f, fs);
01611 width = fs->slice_width;
01612 height= fs->slice_height;
01613 x= fs->slice_x;
01614 y= fs->slice_y;
01615
01616 if(!fs->ac){
01617 fs->ac_byte_count = f->version > 2 || (!x&&!y) ? fs->c.bytestream - fs->c.bytestream_start - 1 : 0;
01618 init_get_bits(&fs->gb,
01619 fs->c.bytestream_start + fs->ac_byte_count,
01620 (fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count) * 8);
01621 }
01622
01623 av_assert1(width && height);
01624 if(f->colorspace==0){
01625 const int chroma_width = -((-width )>>f->chroma_h_shift);
01626 const int chroma_height= -((-height)>>f->chroma_v_shift);
01627 const int cx= x>>f->chroma_h_shift;
01628 const int cy= y>>f->chroma_v_shift;
01629 decode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0);
01630
01631 if (f->chroma_planes){
01632 decode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
01633 decode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1);
01634 }
01635 if (fs->transparency)
01636 decode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2);
01637 }else{
01638 decode_rgb_frame(fs, (uint32_t*)p->data[0] + ps*x + y*(p->linesize[0]/4), width, height, p->linesize[0]/4);
01639 }
01640
01641 emms_c();
01642
01643 return 0;
01644 }
01645
01646 static int read_quant_table(RangeCoder *c, int16_t *quant_table, int scale){
01647 int v;
01648 int i=0;
01649 uint8_t state[CONTEXT_SIZE];
01650
01651 memset(state, 128, sizeof(state));
01652
01653 for(v=0; i<128 ; v++){
01654 unsigned len= get_symbol(c, state, 0) + 1;
01655
01656 if(len > 128 - i) return -1;
01657
01658 while(len--){
01659 quant_table[i] = scale*v;
01660 i++;
01661
01662
01663 }
01664 }
01665
01666 for(i=1; i<128; i++){
01667 quant_table[256-i]= -quant_table[i];
01668 }
01669 quant_table[128]= -quant_table[127];
01670
01671 return 2*v - 1;
01672 }
01673
01674 static int read_quant_tables(RangeCoder *c, int16_t quant_table[MAX_CONTEXT_INPUTS][256]){
01675 int i;
01676 int context_count=1;
01677
01678 for(i=0; i<5; i++){
01679 context_count*= read_quant_table(c, quant_table[i], context_count);
01680 if(context_count > 32768U){
01681 return -1;
01682 }
01683 }
01684 return (context_count+1)/2;
01685 }
01686
01687 static int read_extra_header(FFV1Context *f){
01688 RangeCoder * const c= &f->c;
01689 uint8_t state[CONTEXT_SIZE];
01690 int i, j, k;
01691 uint8_t state2[32][CONTEXT_SIZE];
01692
01693 memset(state2, 128, sizeof(state2));
01694 memset(state, 128, sizeof(state));
01695
01696 ff_init_range_decoder(c, f->avctx->extradata, f->avctx->extradata_size);
01697 ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
01698
01699 f->version= get_symbol(c, state, 0);
01700 if(f->version > 2) {
01701 c->bytestream_end -= 4;
01702 f->minor_version= get_symbol(c, state, 0);
01703 }
01704 f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
01705 if(f->ac>1){
01706 for(i=1; i<256; i++){
01707 f->state_transition[i]= get_symbol(c, state, 1) + c->one_state[i];
01708 }
01709 }
01710 f->colorspace= get_symbol(c, state, 0);
01711 f->avctx->bits_per_raw_sample= get_symbol(c, state, 0);
01712 f->chroma_planes= get_rac(c, state);
01713 f->chroma_h_shift= get_symbol(c, state, 0);
01714 f->chroma_v_shift= get_symbol(c, state, 0);
01715 f->transparency= get_rac(c, state);
01716 f->plane_count= 2 + f->transparency;
01717 f->num_h_slices= 1 + get_symbol(c, state, 0);
01718 f->num_v_slices= 1 + get_symbol(c, state, 0);
01719 if(f->num_h_slices > (unsigned)f->width || f->num_v_slices > (unsigned)f->height){
01720 av_log(f->avctx, AV_LOG_ERROR, "too many slices\n");
01721 return -1;
01722 }
01723
01724 f->quant_table_count= get_symbol(c, state, 0);
01725 if(f->quant_table_count > (unsigned)MAX_QUANT_TABLES)
01726 return -1;
01727 for(i=0; i<f->quant_table_count; i++){
01728 if((f->context_count[i]= read_quant_tables(c, f->quant_tables[i])) < 0){
01729 av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
01730 return -1;
01731 }
01732 }
01733
01734 if(allocate_initial_states(f) < 0)
01735 return AVERROR(ENOMEM);
01736
01737 for(i=0; i<f->quant_table_count; i++){
01738 if(get_rac(c, state)){
01739 for(j=0; j<f->context_count[i]; j++){
01740 for(k=0; k<CONTEXT_SIZE; k++){
01741 int pred= j ? f->initial_states[i][j-1][k] : 128;
01742 f->initial_states[i][j][k]= (pred+get_symbol(c, state2[k], 1))&0xFF;
01743 }
01744 }
01745 }
01746 }
01747
01748 if(f->version > 2){
01749 f->ec = get_symbol(c, state, 0);
01750 }
01751
01752 if(f->version > 2){
01753 unsigned v;
01754 v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, f->avctx->extradata, f->avctx->extradata_size);
01755 if(v){
01756 av_log(f->avctx, AV_LOG_ERROR, "CRC mismatch %X!\n", v);
01757 return AVERROR_INVALIDDATA;
01758 }
01759 }
01760
01761 return 0;
01762 }
01763
01764 static int read_header(FFV1Context *f){
01765 uint8_t state[CONTEXT_SIZE];
01766 int i, j, context_count;
01767 RangeCoder * const c= &f->slice_context[0]->c;
01768
01769 memset(state, 128, sizeof(state));
01770
01771 if(f->version < 2){
01772 unsigned v= get_symbol(c, state, 0);
01773 if(v >= 2){
01774 av_log(f->avctx, AV_LOG_ERROR, "invalid version %d in ver01 header\n", v);
01775 return AVERROR_INVALIDDATA;
01776 }
01777 f->version = v;
01778 f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
01779 if(f->ac>1){
01780 for(i=1; i<256; i++){
01781 f->state_transition[i]= get_symbol(c, state, 1) + c->one_state[i];
01782 }
01783 }
01784 f->colorspace= get_symbol(c, state, 0);
01785 if(f->version>0)
01786 f->avctx->bits_per_raw_sample= get_symbol(c, state, 0);
01787 f->chroma_planes= get_rac(c, state);
01788 f->chroma_h_shift= get_symbol(c, state, 0);
01789 f->chroma_v_shift= get_symbol(c, state, 0);
01790 f->transparency= get_rac(c, state);
01791 f->plane_count= 2 + f->transparency;
01792 }
01793
01794 if(f->colorspace==0){
01795 if(!f->transparency && !f->chroma_planes){
01796 if (f->avctx->bits_per_raw_sample<=8)
01797 f->avctx->pix_fmt= PIX_FMT_GRAY8;
01798 else
01799 f->avctx->pix_fmt= PIX_FMT_GRAY16;
01800 }else if(f->avctx->bits_per_raw_sample<=8 && !f->transparency){
01801 switch(16*f->chroma_h_shift + f->chroma_v_shift){
01802 case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P; break;
01803 case 0x01: f->avctx->pix_fmt= PIX_FMT_YUV440P; break;
01804 case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P; break;
01805 case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P; break;
01806 case 0x20: f->avctx->pix_fmt= PIX_FMT_YUV411P; break;
01807 case 0x22: f->avctx->pix_fmt= PIX_FMT_YUV410P; break;
01808 default:
01809 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
01810 return -1;
01811 }
01812 }else if(f->avctx->bits_per_raw_sample<=8 && f->transparency){
01813 switch(16*f->chroma_h_shift + f->chroma_v_shift){
01814 case 0x00: f->avctx->pix_fmt= PIX_FMT_YUVA444P; break;
01815 case 0x10: f->avctx->pix_fmt= PIX_FMT_YUVA422P; break;
01816 case 0x11: f->avctx->pix_fmt= PIX_FMT_YUVA420P; break;
01817 default:
01818 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
01819 return -1;
01820 }
01821 }else if(f->avctx->bits_per_raw_sample==9) {
01822 f->packed_at_lsb=1;
01823 switch(16*f->chroma_h_shift + f->chroma_v_shift){
01824 case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P9; break;
01825 case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P9; break;
01826 case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P9; break;
01827 default:
01828 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
01829 return -1;
01830 }
01831 }else if(f->avctx->bits_per_raw_sample==10) {
01832 f->packed_at_lsb=1;
01833 switch(16*f->chroma_h_shift + f->chroma_v_shift){
01834 case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P10; break;
01835 case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P10; break;
01836 case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P10; break;
01837 default:
01838 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
01839 return -1;
01840 }
01841 }else {
01842 switch(16*f->chroma_h_shift + f->chroma_v_shift){
01843 case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P16; break;
01844 case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P16; break;
01845 case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P16; break;
01846 default:
01847 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
01848 return -1;
01849 }
01850 }
01851 }else if(f->colorspace==1){
01852 if(f->chroma_h_shift || f->chroma_v_shift){
01853 av_log(f->avctx, AV_LOG_ERROR, "chroma subsampling not supported in this colorspace\n");
01854 return -1;
01855 }
01856 if(f->transparency) f->avctx->pix_fmt= PIX_FMT_RGB32;
01857 else f->avctx->pix_fmt= PIX_FMT_0RGB32;
01858 }else{
01859 av_log(f->avctx, AV_LOG_ERROR, "colorspace not supported\n");
01860 return -1;
01861 }
01862
01863
01864 if(f->version < 2){
01865 context_count= read_quant_tables(c, f->quant_table);
01866 if(context_count < 0){
01867 av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
01868 return -1;
01869 }
01870 }else if(f->version < 3){
01871 f->slice_count= get_symbol(c, state, 0);
01872 }else{
01873 const uint8_t *p= c->bytestream_end;
01874 for(f->slice_count = 0; f->slice_count < MAX_SLICES && 3 < p - c->bytestream_start; f->slice_count++){
01875 int trailer = 3 + 5*!!f->ec;
01876 int size = AV_RB24(p-trailer);
01877 if(size + trailer > p - c->bytestream_start)
01878 break;
01879 p -= size + trailer;
01880 }
01881 }
01882 if(f->slice_count > (unsigned)MAX_SLICES || f->slice_count <= 0){
01883 av_log(f->avctx, AV_LOG_ERROR, "slice count %d is invalid\n", f->slice_count);
01884 return -1;
01885 }
01886
01887 for(j=0; j<f->slice_count; j++){
01888 FFV1Context *fs= f->slice_context[j];
01889 fs->ac= f->ac;
01890 fs->packed_at_lsb= f->packed_at_lsb;
01891
01892 if(f->version == 2){
01893 fs->slice_x = get_symbol(c, state, 0) *f->width ;
01894 fs->slice_y = get_symbol(c, state, 0) *f->height;
01895 fs->slice_width =(get_symbol(c, state, 0)+1)*f->width + fs->slice_x;
01896 fs->slice_height=(get_symbol(c, state, 0)+1)*f->height + fs->slice_y;
01897
01898 fs->slice_x /= f->num_h_slices;
01899 fs->slice_y /= f->num_v_slices;
01900 fs->slice_width = fs->slice_width /f->num_h_slices - fs->slice_x;
01901 fs->slice_height = fs->slice_height/f->num_v_slices - fs->slice_y;
01902 if((unsigned)fs->slice_width > f->width || (unsigned)fs->slice_height > f->height)
01903 return -1;
01904 if( (unsigned)fs->slice_x + (uint64_t)fs->slice_width > f->width
01905 || (unsigned)fs->slice_y + (uint64_t)fs->slice_height > f->height)
01906 return -1;
01907 }
01908
01909 for(i=0; i<f->plane_count; i++){
01910 PlaneContext * const p= &fs->plane[i];
01911
01912 if(f->version == 2){
01913 int idx=get_symbol(c, state, 0);
01914 if(idx > (unsigned)f->quant_table_count){
01915 av_log(f->avctx, AV_LOG_ERROR, "quant_table_index out of range\n");
01916 return -1;
01917 }
01918 p->quant_table_index= idx;
01919 memcpy(p->quant_table, f->quant_tables[idx], sizeof(p->quant_table));
01920 context_count= f->context_count[idx];
01921 }else{
01922 memcpy(p->quant_table, f->quant_table, sizeof(p->quant_table));
01923 }
01924
01925 if(f->version <= 2){
01926 if(p->context_count < context_count){
01927 av_freep(&p->state);
01928 av_freep(&p->vlc_state);
01929 }
01930 p->context_count= context_count;
01931 }
01932 }
01933 }
01934 return 0;
01935 }
01936
01937 static av_cold int decode_init(AVCodecContext *avctx)
01938 {
01939 FFV1Context *f = avctx->priv_data;
01940
01941 common_init(avctx);
01942
01943 if(avctx->extradata && read_extra_header(f) < 0)
01944 return -1;
01945
01946 if(init_slice_contexts(f) < 0)
01947 return -1;
01948
01949 return 0;
01950 }
01951
01952 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){
01953 const uint8_t *buf = avpkt->data;
01954 int buf_size = avpkt->size;
01955 FFV1Context *f = avctx->priv_data;
01956 RangeCoder * const c= &f->slice_context[0]->c;
01957 AVFrame * const p= &f->picture;
01958 int i;
01959 uint8_t keystate= 128;
01960 const uint8_t *buf_p;
01961
01962 AVFrame *picture = data;
01963
01964
01965 if (p->data[0])
01966 avctx->release_buffer(avctx, p);
01967
01968 ff_init_range_decoder(c, buf, buf_size);
01969 ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
01970
01971
01972 p->pict_type= AV_PICTURE_TYPE_I;
01973 if(get_rac(c, &keystate)){
01974 p->key_frame= 1;
01975 f->key_frame_ok = 0;
01976 if(read_header(f) < 0)
01977 return -1;
01978 f->key_frame_ok = 1;
01979 }else{
01980 if (!f->key_frame_ok) {
01981 av_log(avctx, AV_LOG_ERROR, "Cant decode non keyframe without valid keyframe\n");
01982 return AVERROR_INVALIDDATA;
01983 }
01984 p->key_frame= 0;
01985 }
01986
01987 p->reference= 0;
01988 if(avctx->get_buffer(avctx, p) < 0){
01989 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
01990 return -1;
01991 }
01992
01993 if(avctx->debug&FF_DEBUG_PICT_INFO)
01994 av_log(avctx, AV_LOG_DEBUG, "ver:%d keyframe:%d coder:%d ec:%d slices:%d\n",
01995 f->version, p->key_frame, f->ac, f->ec, f->slice_count);
01996
01997 buf_p= buf + buf_size;
01998 for(i=f->slice_count-1; i>=0; i--){
01999 FFV1Context *fs= f->slice_context[i];
02000 int trailer = 3 + 5*!!f->ec;
02001 int v;
02002
02003 if(i || f->version>2) v = AV_RB24(buf_p-trailer)+trailer;
02004 else v = buf_p - c->bytestream_start;
02005 if(buf_p - c->bytestream_start < v){
02006 av_log(avctx, AV_LOG_ERROR, "Slice pointer chain broken\n");
02007 return -1;
02008 }
02009 buf_p -= v;
02010
02011 if(f->ec){
02012 unsigned crc = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, v);
02013 if(crc){
02014 av_log(f->avctx, AV_LOG_ERROR, "CRC mismatch %X!\n", crc);
02015 }
02016 }
02017
02018 if(i){
02019 ff_init_range_decoder(&fs->c, buf_p, v);
02020 }
02021 }
02022
02023 avctx->execute(avctx, decode_slice, &f->slice_context[0], NULL, f->slice_count, sizeof(void*));
02024 f->picture_number++;
02025
02026 *picture= *p;
02027 *data_size = sizeof(AVFrame);
02028
02029 return buf_size;
02030 }
02031
02032 AVCodec ff_ffv1_decoder = {
02033 .name = "ffv1",
02034 .type = AVMEDIA_TYPE_VIDEO,
02035 .id = CODEC_ID_FFV1,
02036 .priv_data_size = sizeof(FFV1Context),
02037 .init = decode_init,
02038 .close = common_end,
02039 .decode = decode_frame,
02040 .capabilities = CODEC_CAP_DR1 |
02041 CODEC_CAP_SLICE_THREADS,
02042 .long_name = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
02043 };
02044
02045 #if CONFIG_FFV1_ENCODER
02046
02047 #define OFFSET(x) offsetof(FFV1Context, x)
02048 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
02049 static const AVOption options[] = {
02050 { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_INT, {-1}, -1, 1, VE},
02051 {NULL}
02052 };
02053
02054 static const AVClass class = {
02055 .class_name = "ffv1 encoder",
02056 .item_name = av_default_item_name,
02057 .option = options,
02058 .version = LIBAVUTIL_VERSION_INT,
02059 };
02060
02061 AVCodec ff_ffv1_encoder = {
02062 .name = "ffv1",
02063 .type = AVMEDIA_TYPE_VIDEO,
02064 .id = CODEC_ID_FFV1,
02065 .priv_data_size = sizeof(FFV1Context),
02066 .init = encode_init,
02067 .encode2 = encode_frame,
02068 .close = common_end,
02069 .capabilities = CODEC_CAP_SLICE_THREADS,
02070 .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_YUVA420P, PIX_FMT_YUV444P, PIX_FMT_YUVA444P, PIX_FMT_YUV440P, PIX_FMT_YUV422P, PIX_FMT_YUV411P, PIX_FMT_YUV410P, PIX_FMT_0RGB32, PIX_FMT_RGB32, PIX_FMT_YUV420P16, PIX_FMT_YUV422P16, PIX_FMT_YUV444P16, PIX_FMT_YUV444P9, PIX_FMT_YUV422P9, PIX_FMT_YUV420P9, PIX_FMT_YUV420P10, PIX_FMT_YUV422P10, PIX_FMT_YUV444P10, PIX_FMT_GRAY16, PIX_FMT_GRAY8, PIX_FMT_NONE},
02071 .long_name = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
02072 .priv_class = &class,
02073 };
02074 #endif
