ffv1.c
Go to the documentation of this file.
1 /*
2  * FFV1 codec for libavcodec
3  *
4  * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
5  *
6  * This file is part of Libav.
7  *
8  * Libav is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * Libav is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with Libav; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
28 #include "avcodec.h"
29 #include "get_bits.h"
30 #include "put_bits.h"
31 #include "dsputil.h"
32 #include "rangecoder.h"
33 #include "golomb.h"
34 #include "mathops.h"
35 #include "libavutil/avassert.h"
36 
37 #define MAX_PLANES 4
38 #define CONTEXT_SIZE 32
39 
40 #define MAX_QUANT_TABLES 8
41 #define MAX_CONTEXT_INPUTS 5
42 
43 extern const uint8_t ff_log2_run[41];
44 
45 static const int8_t quant5_10bit[256]={
46  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
50  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
51  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
52  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
53  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
54 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
55 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
56 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
57 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
58 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-1,
59 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
60 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
61 -1,-1,-1,-1,-1,-1,-0,-0,-0,-0,-0,-0,-0,-0,-0,-0,
62 };
63 
64 static const int8_t quant5[256]={
65  0, 1, 1, 1, 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, 2, 2, 2,
71  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
72  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
73 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
74 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
75 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
76 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
77 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
78 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
79 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
80 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-1,-1,-1,
81 };
82 
83 static const int8_t quant9_10bit[256]={
84  0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2,
85  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3,
86  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
87  3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
88  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
89  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
90  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
91  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
92 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
93 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
94 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
95 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
96 -4,-4,-4,-4,-4,-4,-4,-4,-4,-3,-3,-3,-3,-3,-3,-3,
97 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
98 -3,-3,-3,-3,-3,-3,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
99 -2,-2,-2,-2,-1,-1,-1,-1,-1,-1,-1,-1,-0,-0,-0,-0,
100 };
101 
102 static const int8_t quant11[256]={
103  0, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 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, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
106  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
107  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
108  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
109  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
110  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
111 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
112 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
113 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
114 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
115 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
116 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-4,-4,
117 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
118 -4,-4,-4,-4,-4,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-1,
119 };
120 
121 static const uint8_t ver2_state[256]= {
122  0, 10, 10, 10, 10, 16, 16, 16, 28, 16, 16, 29, 42, 49, 20, 49,
123  59, 25, 26, 26, 27, 31, 33, 33, 33, 34, 34, 37, 67, 38, 39, 39,
124  40, 40, 41, 79, 43, 44, 45, 45, 48, 48, 64, 50, 51, 52, 88, 52,
125  53, 74, 55, 57, 58, 58, 74, 60, 101, 61, 62, 84, 66, 66, 68, 69,
126  87, 82, 71, 97, 73, 73, 82, 75, 111, 77, 94, 78, 87, 81, 83, 97,
127  85, 83, 94, 86, 99, 89, 90, 99, 111, 92, 93, 134, 95, 98, 105, 98,
128  105, 110, 102, 108, 102, 118, 103, 106, 106, 113, 109, 112, 114, 112, 116, 125,
129  115, 116, 117, 117, 126, 119, 125, 121, 121, 123, 145, 124, 126, 131, 127, 129,
130  165, 130, 132, 138, 133, 135, 145, 136, 137, 139, 146, 141, 143, 142, 144, 148,
131  147, 155, 151, 149, 151, 150, 152, 157, 153, 154, 156, 168, 158, 162, 161, 160,
132  172, 163, 169, 164, 166, 184, 167, 170, 177, 174, 171, 173, 182, 176, 180, 178,
133  175, 189, 179, 181, 186, 183, 192, 185, 200, 187, 191, 188, 190, 197, 193, 196,
134  197, 194, 195, 196, 198, 202, 199, 201, 210, 203, 207, 204, 205, 206, 208, 214,
135  209, 211, 221, 212, 213, 215, 224, 216, 217, 218, 219, 220, 222, 228, 223, 225,
136  226, 224, 227, 229, 240, 230, 231, 232, 233, 234, 235, 236, 238, 239, 237, 242,
137  241, 243, 242, 244, 245, 246, 247, 248, 249, 250, 251, 252, 252, 253, 254, 255,
138 };
139 
140 typedef struct VlcState{
141  int16_t drift;
142  uint16_t error_sum;
143  int8_t bias;
144  uint8_t count;
145 } VlcState;
146 
147 typedef struct PlaneContext{
151  uint8_t (*state)[CONTEXT_SIZE];
154 } PlaneContext;
155 
156 #define MAX_SLICES 256
157 
158 typedef struct FFV1Context{
163  uint64_t rc_stat[256][2];
164  uint64_t (*rc_stat2[MAX_QUANT_TABLES])[32][2];
165  int version;
166  int width, height;
168  int flags;
172  int ac;
177  uint8_t state_transition[256];
181  int16_t *sample_buffer;
183 
185 
187 
194  int slice_x;
195  int slice_y;
196 }FFV1Context;
197 
198 static av_always_inline int fold(int diff, int bits){
199  if(bits==8)
200  diff= (int8_t)diff;
201  else{
202  diff+= 1<<(bits-1);
203  diff&=(1<<bits)-1;
204  diff-= 1<<(bits-1);
205  }
206 
207  return diff;
208 }
209 
210 static inline int predict(int16_t *src, int16_t *last)
211 {
212  const int LT= last[-1];
213  const int T= last[ 0];
214  const int L = src[-1];
215 
216  return mid_pred(L, L + T - LT, T);
217 }
218 
219 static inline int get_context(PlaneContext *p, int16_t *src,
220  int16_t *last, int16_t *last2)
221 {
222  const int LT= last[-1];
223  const int T= last[ 0];
224  const int RT= last[ 1];
225  const int L = src[-1];
226 
227  if(p->quant_table[3][127]){
228  const int TT= last2[0];
229  const int LL= src[-2];
230  return p->quant_table[0][(L-LT) & 0xFF] + p->quant_table[1][(LT-T) & 0xFF] + p->quant_table[2][(T-RT) & 0xFF]
231  +p->quant_table[3][(LL-L) & 0xFF] + p->quant_table[4][(TT-T) & 0xFF];
232  }else
233  return p->quant_table[0][(L-LT) & 0xFF] + p->quant_table[1][(LT-T) & 0xFF] + p->quant_table[2][(T-RT) & 0xFF];
234 }
235 
236 static void find_best_state(uint8_t best_state[256][256], const uint8_t one_state[256]){
237  int i,j,k,m;
238  double l2tab[256];
239 
240  for(i=1; i<256; i++)
241  l2tab[i]= log2(i/256.0);
242 
243  for(i=0; i<256; i++){
244  double best_len[256];
245  double p= i/256.0;
246 
247  for(j=0; j<256; j++)
248  best_len[j]= 1<<30;
249 
250  for(j=FFMAX(i-10,1); j<FFMIN(i+11,256); j++){
251  double occ[256]={0};
252  double len=0;
253  occ[j]=1.0;
254  for(k=0; k<256; k++){
255  double newocc[256]={0};
256  for(m=0; m<256; m++){
257  if(occ[m]){
258  len -=occ[m]*( p *l2tab[ m]
259  + (1-p)*l2tab[256-m]);
260  }
261  }
262  if(len < best_len[k]){
263  best_len[k]= len;
264  best_state[i][k]= j;
265  }
266  for(m=0; m<256; m++){
267  if(occ[m]){
268  newocc[ one_state[ m]] += occ[m]* p ;
269  newocc[256-one_state[256-m]] += occ[m]*(1-p);
270  }
271  }
272  memcpy(occ, newocc, sizeof(occ));
273  }
274  }
275  }
276 }
277 
278 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]){
279  int i;
280 
281 #define put_rac(C,S,B) \
282 do{\
283  if(rc_stat){\
284  rc_stat[*(S)][B]++;\
285  rc_stat2[(S)-state][B]++;\
286  }\
287  put_rac(C,S,B);\
288 }while(0)
289 
290  if(v){
291  const int a= FFABS(v);
292  const int e= av_log2(a);
293  put_rac(c, state+0, 0);
294  if(e<=9){
295  for(i=0; i<e; i++){
296  put_rac(c, state+1+i, 1); //1..10
297  }
298  put_rac(c, state+1+i, 0);
299 
300  for(i=e-1; i>=0; i--){
301  put_rac(c, state+22+i, (a>>i)&1); //22..31
302  }
303 
304  if(is_signed)
305  put_rac(c, state+11 + e, v < 0); //11..21
306  }else{
307  for(i=0; i<e; i++){
308  put_rac(c, state+1+FFMIN(i,9), 1); //1..10
309  }
310  put_rac(c, state+1+9, 0);
311 
312  for(i=e-1; i>=0; i--){
313  put_rac(c, state+22+FFMIN(i,9), (a>>i)&1); //22..31
314  }
315 
316  if(is_signed)
317  put_rac(c, state+11 + 10, v < 0); //11..21
318  }
319  }else{
320  put_rac(c, state+0, 1);
321  }
322 #undef put_rac
323 }
324 
325 static void av_noinline put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed){
326  put_symbol_inline(c, state, v, is_signed, NULL, NULL);
327 }
328 
329 static inline av_flatten int get_symbol_inline(RangeCoder *c, uint8_t *state, int is_signed){
330  if(get_rac(c, state+0))
331  return 0;
332  else{
333  int i, e, a;
334  e= 0;
335  while(get_rac(c, state+1 + FFMIN(e,9))){ //1..10
336  e++;
337  }
338 
339  a= 1;
340  for(i=e-1; i>=0; i--){
341  a += a + get_rac(c, state+22 + FFMIN(i,9)); //22..31
342  }
343 
344  e= -(is_signed && get_rac(c, state+11 + FFMIN(e, 10))); //11..21
345  return (a^e)-e;
346  }
347 }
348 
349 static int av_noinline get_symbol(RangeCoder *c, uint8_t *state, int is_signed){
350  return get_symbol_inline(c, state, is_signed);
351 }
352 
353 static inline void update_vlc_state(VlcState * const state, const int v){
354  int drift= state->drift;
355  int count= state->count;
356  state->error_sum += FFABS(v);
357  drift += v;
358 
359  if(count == 128){ //FIXME variable
360  count >>= 1;
361  drift >>= 1;
362  state->error_sum >>= 1;
363  }
364  count++;
365 
366  if(drift <= -count){
367  if(state->bias > -128) state->bias--;
368 
369  drift += count;
370  if(drift <= -count)
371  drift= -count + 1;
372  }else if(drift > 0){
373  if(state->bias < 127) state->bias++;
374 
375  drift -= count;
376  if(drift > 0)
377  drift= 0;
378  }
379 
380  state->drift= drift;
381  state->count= count;
382 }
383 
384 static inline void put_vlc_symbol(PutBitContext *pb, VlcState * const state, int v, int bits){
385  int i, k, code;
386 //printf("final: %d ", v);
387  v = fold(v - state->bias, bits);
388 
389  i= state->count;
390  k=0;
391  while(i < state->error_sum){ //FIXME optimize
392  k++;
393  i += i;
394  }
395 
396  assert(k<=8);
397 
398 #if 0 // JPEG LS
399  if(k==0 && 2*state->drift <= - state->count) code= v ^ (-1);
400  else code= v;
401 #else
402  code= v ^ ((2*state->drift + state->count)>>31);
403 #endif
404 
405 //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);
406  set_sr_golomb(pb, code, k, 12, bits);
407 
408  update_vlc_state(state, v);
409 }
410 
411 static inline int get_vlc_symbol(GetBitContext *gb, VlcState * const state, int bits){
412  int k, i, v, ret;
413 
414  i= state->count;
415  k=0;
416  while(i < state->error_sum){ //FIXME optimize
417  k++;
418  i += i;
419  }
420 
421  assert(k<=8);
422 
423  v= get_sr_golomb(gb, k, 12, bits);
424 //printf("v:%d bias:%d error:%d drift:%d count:%d k:%d", v, state->bias, state->error_sum, state->drift, state->count, k);
425 
426 #if 0 // JPEG LS
427  if(k==0 && 2*state->drift <= - state->count) v ^= (-1);
428 #else
429  v ^= ((2*state->drift + state->count)>>31);
430 #endif
431 
432  ret= fold(v + state->bias, bits);
433 
434  update_vlc_state(state, v);
435 //printf("final: %d\n", ret);
436  return ret;
437 }
438 
439 #if CONFIG_FFV1_ENCODER
440 static av_always_inline int encode_line(FFV1Context *s, int w,
441  int16_t *sample[2],
442  int plane_index, int bits)
443 {
444  PlaneContext * const p= &s->plane[plane_index];
445  RangeCoder * const c= &s->c;
446  int x;
447  int run_index= s->run_index;
448  int run_count=0;
449  int run_mode=0;
450 
451  if(s->ac){
452  if(c->bytestream_end - c->bytestream < w*20){
453  av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
454  return -1;
455  }
456  }else{
457  if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < w*4){
458  av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
459  return -1;
460  }
461  }
462 
463  for(x=0; x<w; x++){
464  int diff, context;
465 
466  context= get_context(p, sample[0]+x, sample[1]+x, sample[2]+x);
467  diff= sample[0][x] - predict(sample[0]+x, sample[1]+x);
468 
469  if(context < 0){
470  context = -context;
471  diff= -diff;
472  }
473 
474  diff= fold(diff, bits);
475 
476  if(s->ac){
477  if(s->flags & CODEC_FLAG_PASS1){
478  put_symbol_inline(c, p->state[context], diff, 1, s->rc_stat, s->rc_stat2[p->quant_table_index][context]);
479  }else{
480  put_symbol_inline(c, p->state[context], diff, 1, NULL, NULL);
481  }
482  }else{
483  if(context == 0) run_mode=1;
484 
485  if(run_mode){
486 
487  if(diff){
488  while(run_count >= 1<<ff_log2_run[run_index]){
489  run_count -= 1<<ff_log2_run[run_index];
490  run_index++;
491  put_bits(&s->pb, 1, 1);
492  }
493 
494  put_bits(&s->pb, 1 + ff_log2_run[run_index], run_count);
495  if(run_index) run_index--;
496  run_count=0;
497  run_mode=0;
498  if(diff>0) diff--;
499  }else{
500  run_count++;
501  }
502  }
503 
504 // 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));
505 
506  if(run_mode == 0)
507  put_vlc_symbol(&s->pb, &p->vlc_state[context], diff, bits);
508  }
509  }
510  if(run_mode){
511  while(run_count >= 1<<ff_log2_run[run_index]){
512  run_count -= 1<<ff_log2_run[run_index];
513  run_index++;
514  put_bits(&s->pb, 1, 1);
515  }
516 
517  if(run_count)
518  put_bits(&s->pb, 1, 1);
519  }
520  s->run_index= run_index;
521 
522  return 0;
523 }
524 
525 static void encode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
526  int x,y,i;
527  const int ring_size= s->avctx->context_model ? 3 : 2;
528  int16_t *sample[3];
529  s->run_index=0;
530 
531  memset(s->sample_buffer, 0, ring_size*(w+6)*sizeof(*s->sample_buffer));
532 
533  for(y=0; y<h; y++){
534  for(i=0; i<ring_size; i++)
535  sample[i]= s->sample_buffer + (w+6)*((h+i-y)%ring_size) + 3;
536 
537  sample[0][-1]= sample[1][0 ];
538  sample[1][ w]= sample[1][w-1];
539 //{START_TIMER
540  if(s->avctx->bits_per_raw_sample<=8){
541  for(x=0; x<w; x++){
542  sample[0][x]= src[x + stride*y];
543  }
544  encode_line(s, w, sample, plane_index, 8);
545  }else{
546  for(x=0; x<w; x++){
547  sample[0][x]= ((uint16_t*)(src + stride*y))[x] >> (16 - s->avctx->bits_per_raw_sample);
548  }
549  encode_line(s, w, sample, plane_index, s->avctx->bits_per_raw_sample);
550  }
551 //STOP_TIMER("encode line")}
552  }
553 }
554 
555 static void encode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
556  int x, y, p, i;
557  const int ring_size= s->avctx->context_model ? 3 : 2;
558  int16_t *sample[3][3];
559  s->run_index=0;
560 
561  memset(s->sample_buffer, 0, ring_size*3*(w+6)*sizeof(*s->sample_buffer));
562 
563  for(y=0; y<h; y++){
564  for(i=0; i<ring_size; i++)
565  for(p=0; p<3; p++)
566  sample[p][i]= s->sample_buffer + p*ring_size*(w+6) + ((h+i-y)%ring_size)*(w+6) + 3;
567 
568  for(x=0; x<w; x++){
569  int v= src[x + stride*y];
570  int b= v&0xFF;
571  int g= (v>>8)&0xFF;
572  int r= (v>>16)&0xFF;
573 
574  b -= g;
575  r -= g;
576  g += (b + r)>>2;
577  b += 0x100;
578  r += 0x100;
579 
580 // assert(g>=0 && b>=0 && r>=0);
581 // assert(g<256 && b<512 && r<512);
582  sample[0][0][x]= g;
583  sample[1][0][x]= b;
584  sample[2][0][x]= r;
585  }
586  for(p=0; p<3; p++){
587  sample[p][0][-1]= sample[p][1][0 ];
588  sample[p][1][ w]= sample[p][1][w-1];
589  encode_line(s, w, sample[p], FFMIN(p, 1), 9);
590  }
591  }
592 }
593 
594 static void write_quant_table(RangeCoder *c, int16_t *quant_table){
595  int last=0;
596  int i;
597  uint8_t state[CONTEXT_SIZE];
598  memset(state, 128, sizeof(state));
599 
600  for(i=1; i<128 ; i++){
601  if(quant_table[i] != quant_table[i-1]){
602  put_symbol(c, state, i-last-1, 0);
603  last= i;
604  }
605  }
606  put_symbol(c, state, i-last-1, 0);
607 }
608 
609 static void write_quant_tables(RangeCoder *c, int16_t quant_table[MAX_CONTEXT_INPUTS][256]){
610  int i;
611  for(i=0; i<5; i++)
612  write_quant_table(c, quant_table[i]);
613 }
614 
615 static void write_header(FFV1Context *f){
616  uint8_t state[CONTEXT_SIZE];
617  int i, j;
618  RangeCoder * const c= &f->slice_context[0]->c;
619 
620  memset(state, 128, sizeof(state));
621 
622  if(f->version < 2){
623  put_symbol(c, state, f->version, 0);
624  put_symbol(c, state, f->ac, 0);
625  if(f->ac>1){
626  for(i=1; i<256; i++){
627  put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
628  }
629  }
630  put_symbol(c, state, f->colorspace, 0); //YUV cs type
631  if(f->version>0)
632  put_symbol(c, state, f->avctx->bits_per_raw_sample, 0);
633  put_rac(c, state, 1); //chroma planes
634  put_symbol(c, state, f->chroma_h_shift, 0);
635  put_symbol(c, state, f->chroma_v_shift, 0);
636  put_rac(c, state, 0); //no transparency plane
637 
638  write_quant_tables(c, f->quant_table);
639  }else{
640  put_symbol(c, state, f->slice_count, 0);
641  for(i=0; i<f->slice_count; i++){
642  FFV1Context *fs= f->slice_context[i];
643  put_symbol(c, state, (fs->slice_x +1)*f->num_h_slices / f->width , 0);
644  put_symbol(c, state, (fs->slice_y +1)*f->num_v_slices / f->height , 0);
645  put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
646  put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
647  for(j=0; j<f->plane_count; j++){
648  put_symbol(c, state, f->plane[j].quant_table_index, 0);
650  }
651  }
652  }
653 }
654 #endif /* CONFIG_FFV1_ENCODER */
655 
657  FFV1Context *s = avctx->priv_data;
658 
659  s->avctx= avctx;
660  s->flags= avctx->flags;
661 
662  dsputil_init(&s->dsp, avctx);
663 
664  s->width = avctx->width;
665  s->height= avctx->height;
666 
667  assert(s->width && s->height);
668  //defaults
669  s->num_h_slices=1;
670  s->num_v_slices=1;
671 
672 
673  return 0;
674 }
675 
677  int i, j;
678 
679  for(i=0; i<f->slice_count; i++){
680  FFV1Context *fs= f->slice_context[i];
681  for(j=0; j<f->plane_count; j++){
682  PlaneContext * const p= &fs->plane[j];
683 
684  if(fs->ac){
685  if(!p-> state) p-> state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
686  if(!p-> state)
687  return AVERROR(ENOMEM);
688  }else{
689  if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
690  if(!p->vlc_state)
691  return AVERROR(ENOMEM);
692  }
693  }
694 
695  if (fs->ac>1){
696  //FIXME only redo if state_transition changed
697  for(j=1; j<256; j++){
698  fs->c.one_state [ j]= fs->state_transition[j];
699  fs->c.zero_state[256-j]= 256-fs->c.one_state [j];
700  }
701  }
702  }
703 
704  return 0;
705 }
706 
708  int i;
709 
711  if (f->slice_count <= 0) {
712  av_log(f->avctx, AV_LOG_ERROR, "Invalid number of slices\n");
713  return AVERROR(EINVAL);
714  }
715 
716  for(i=0; i<f->slice_count; i++){
717  FFV1Context *fs= av_mallocz(sizeof(*fs));
718  int sx= i % f->num_h_slices;
719  int sy= i / f->num_h_slices;
720  int sxs= f->avctx->width * sx / f->num_h_slices;
721  int sxe= f->avctx->width *(sx+1) / f->num_h_slices;
722  int sys= f->avctx->height* sy / f->num_v_slices;
723  int sye= f->avctx->height*(sy+1) / f->num_v_slices;
724  f->slice_context[i]= fs;
725  memcpy(fs, f, sizeof(*fs));
726  memset(fs->rc_stat2, 0, sizeof(fs->rc_stat2));
727 
728  fs->slice_width = sxe - sxs;
729  fs->slice_height= sye - sys;
730  fs->slice_x = sxs;
731  fs->slice_y = sys;
732 
733  fs->sample_buffer = av_malloc(9 * (fs->width+6) * sizeof(*fs->sample_buffer));
734  if (!fs->sample_buffer)
735  return AVERROR(ENOMEM);
736  }
737  return 0;
738 }
739 
741  int i;
742 
743  for(i=0; i<f->quant_table_count; i++){
744  f->initial_states[i]= av_malloc(f->context_count[i]*sizeof(*f->initial_states[i]));
745  if(!f->initial_states[i])
746  return AVERROR(ENOMEM);
747  memset(f->initial_states[i], 128, f->context_count[i]*sizeof(*f->initial_states[i]));
748  }
749  return 0;
750 }
751 
752 #if CONFIG_FFV1_ENCODER
753 static int write_extra_header(FFV1Context *f){
754  RangeCoder * const c= &f->c;
755  uint8_t state[CONTEXT_SIZE];
756  int i, j, k;
757  uint8_t state2[32][CONTEXT_SIZE];
758 
759  memset(state2, 128, sizeof(state2));
760  memset(state, 128, sizeof(state));
761 
762  f->avctx->extradata= av_malloc(f->avctx->extradata_size= 10000 + (11*11*5*5*5+11*11*11)*32);
764  ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
765 
766  put_symbol(c, state, f->version, 0);
767  put_symbol(c, state, f->ac, 0);
768  if(f->ac>1){
769  for(i=1; i<256; i++){
770  put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
771  }
772  }
773  put_symbol(c, state, f->colorspace, 0); //YUV cs type
774  put_symbol(c, state, f->avctx->bits_per_raw_sample, 0);
775  put_rac(c, state, 1); //chroma planes
776  put_symbol(c, state, f->chroma_h_shift, 0);
777  put_symbol(c, state, f->chroma_v_shift, 0);
778  put_rac(c, state, 0); //no transparency plane
779  put_symbol(c, state, f->num_h_slices-1, 0);
780  put_symbol(c, state, f->num_v_slices-1, 0);
781 
782  put_symbol(c, state, f->quant_table_count, 0);
783  for(i=0; i<f->quant_table_count; i++)
784  write_quant_tables(c, f->quant_tables[i]);
785 
786  for(i=0; i<f->quant_table_count; i++){
787  for(j=0; j<f->context_count[i]*CONTEXT_SIZE; j++)
788  if(f->initial_states[i] && f->initial_states[i][0][j] != 128)
789  break;
790  if(j<f->context_count[i]*CONTEXT_SIZE){
791  put_rac(c, state, 1);
792  for(j=0; j<f->context_count[i]; j++){
793  for(k=0; k<CONTEXT_SIZE; k++){
794  int pred= j ? f->initial_states[i][j-1][k] : 128;
795  put_symbol(c, state2[k], (int8_t)(f->initial_states[i][j][k]-pred), 1);
796  }
797  }
798  }else{
799  put_rac(c, state, 0);
800  }
801  }
802 
804 
805  return 0;
806 }
807 
808 static int sort_stt(FFV1Context *s, uint8_t stt[256]){
809  int i,i2,changed,print=0;
810 
811  do{
812  changed=0;
813  for(i=12; i<244; i++){
814  for(i2=i+1; i2<245 && i2<i+4; i2++){
815 #define COST(old, new) \
816  s->rc_stat[old][0]*-log2((256-(new))/256.0)\
817  +s->rc_stat[old][1]*-log2( (new) /256.0)
818 
819 #define COST2(old, new) \
820  COST(old, new)\
821  +COST(256-(old), 256-(new))
822 
823  double size0= COST2(i, i ) + COST2(i2, i2);
824  double sizeX= COST2(i, i2) + COST2(i2, i );
825  if(sizeX < size0 && i!=128 && i2!=128){
826  int j;
827  FFSWAP(int, stt[ i], stt[ i2]);
828  FFSWAP(int, s->rc_stat[i ][0],s->rc_stat[ i2][0]);
829  FFSWAP(int, s->rc_stat[i ][1],s->rc_stat[ i2][1]);
830  if(i != 256-i2){
831  FFSWAP(int, stt[256-i], stt[256-i2]);
832  FFSWAP(int, s->rc_stat[256-i][0],s->rc_stat[256-i2][0]);
833  FFSWAP(int, s->rc_stat[256-i][1],s->rc_stat[256-i2][1]);
834  }
835  for(j=1; j<256; j++){
836  if (stt[j] == i ) stt[j] = i2;
837  else if(stt[j] == i2) stt[j] = i ;
838  if(i != 256-i2){
839  if (stt[256-j] == 256-i ) stt[256-j] = 256-i2;
840  else if(stt[256-j] == 256-i2) stt[256-j] = 256-i ;
841  }
842  }
843  print=changed=1;
844  }
845  }
846  }
847  }while(changed);
848  return print;
849 }
850 
852 {
853  FFV1Context *s = avctx->priv_data;
854  int i, j, k, m;
855 
856  common_init(avctx);
857 
858  s->version=0;
859  s->ac= avctx->coder_type ? 2:0;
860 
861  if(s->ac>1)
862  for(i=1; i<256; i++)
863  s->state_transition[i]=ver2_state[i];
864 
865  s->plane_count=2;
866  for(i=0; i<256; i++){
867  s->quant_table_count=2;
868  if(avctx->bits_per_raw_sample <=8){
869  s->quant_tables[0][0][i]= quant11[i];
870  s->quant_tables[0][1][i]= 11*quant11[i];
871  s->quant_tables[0][2][i]= 11*11*quant11[i];
872  s->quant_tables[1][0][i]= quant11[i];
873  s->quant_tables[1][1][i]= 11*quant11[i];
874  s->quant_tables[1][2][i]= 11*11*quant5 [i];
875  s->quant_tables[1][3][i]= 5*11*11*quant5 [i];
876  s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
877  }else{
878  s->quant_tables[0][0][i]= quant9_10bit[i];
879  s->quant_tables[0][1][i]= 11*quant9_10bit[i];
880  s->quant_tables[0][2][i]= 11*11*quant9_10bit[i];
881  s->quant_tables[1][0][i]= quant9_10bit[i];
882  s->quant_tables[1][1][i]= 11*quant9_10bit[i];
883  s->quant_tables[1][2][i]= 11*11*quant5_10bit[i];
884  s->quant_tables[1][3][i]= 5*11*11*quant5_10bit[i];
885  s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
886  }
887  }
888  s->context_count[0]= (11*11*11+1)/2;
889  s->context_count[1]= (11*11*5*5*5+1)/2;
890  memcpy(s->quant_table, s->quant_tables[avctx->context_model], sizeof(s->quant_table));
891 
892  for(i=0; i<s->plane_count; i++){
893  PlaneContext * const p= &s->plane[i];
894 
895  memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
896  p->quant_table_index= avctx->context_model;
898  }
899 
900  if(allocate_initial_states(s) < 0)
901  return AVERROR(ENOMEM);
902 
903  avctx->coded_frame= &s->picture;
904  switch(avctx->pix_fmt){
905  case PIX_FMT_YUV444P16:
906  case PIX_FMT_YUV422P16:
907  case PIX_FMT_YUV420P16:
908  if(avctx->bits_per_raw_sample <=8){
909  av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
910  return -1;
911  }
912  if(!s->ac){
913  av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample of more than 8 needs -coder 1 currently\n");
914  return -1;
915  }
916  s->version= FFMAX(s->version, 1);
917  case PIX_FMT_YUV444P:
918  case PIX_FMT_YUV422P:
919  case PIX_FMT_YUV420P:
920  case PIX_FMT_YUV411P:
921  case PIX_FMT_YUV410P:
922  s->colorspace= 0;
923  break;
924  case PIX_FMT_RGB32:
925  s->colorspace= 1;
926  break;
927  default:
928  av_log(avctx, AV_LOG_ERROR, "format not supported\n");
929  return -1;
930  }
932 
933  s->picture_number=0;
934 
935  if(avctx->flags & (CODEC_FLAG_PASS1|CODEC_FLAG_PASS2)){
936  for(i=0; i<s->quant_table_count; i++){
937  s->rc_stat2[i]= av_mallocz(s->context_count[i]*sizeof(*s->rc_stat2[i]));
938  if(!s->rc_stat2[i])
939  return AVERROR(ENOMEM);
940  }
941  }
942  if(avctx->stats_in){
943  char *p= avctx->stats_in;
944  uint8_t best_state[256][256];
945  int gob_count=0;
946  char *next;
947 
948  av_assert0(s->version>=2);
949 
950  for(;;){
951  for(j=0; j<256; j++){
952  for(i=0; i<2; i++){
953  s->rc_stat[j][i]= strtol(p, &next, 0);
954  if(next==p){
955  av_log(avctx, AV_LOG_ERROR, "2Pass file invalid at %d %d [%s]\n", j,i,p);
956  return -1;
957  }
958  p=next;
959  }
960  }
961  for(i=0; i<s->quant_table_count; i++){
962  for(j=0; j<s->context_count[i]; j++){
963  for(k=0; k<32; k++){
964  for(m=0; m<2; m++){
965  s->rc_stat2[i][j][k][m]= strtol(p, &next, 0);
966  if(next==p){
967  av_log(avctx, AV_LOG_ERROR, "2Pass file invalid at %d %d %d %d [%s]\n", i,j,k,m,p);
968  return -1;
969  }
970  p=next;
971  }
972  }
973  }
974  }
975  gob_count= strtol(p, &next, 0);
976  if(next==p || gob_count <0){
977  av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
978  return -1;
979  }
980  p=next;
981  while(*p=='\n' || *p==' ') p++;
982  if(p[0]==0) break;
983  }
984  sort_stt(s, s->state_transition);
985 
986  find_best_state(best_state, s->state_transition);
987 
988  for(i=0; i<s->quant_table_count; i++){
989  for(j=0; j<s->context_count[i]; j++){
990  for(k=0; k<32; k++){
991  double p= 128;
992  if(s->rc_stat2[i][j][k][0]+s->rc_stat2[i][j][k][1]){
993  p=256.0*s->rc_stat2[i][j][k][1] / (s->rc_stat2[i][j][k][0]+s->rc_stat2[i][j][k][1]);
994  }
995  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)];
996  }
997  }
998  }
999  }
1000 
1001  if(s->version>1){
1002  s->num_h_slices=2;
1003  s->num_v_slices=2;
1004  write_extra_header(s);
1005  }
1006 
1007  if(init_slice_contexts(s) < 0)
1008  return -1;
1009  if(init_slice_state(s) < 0)
1010  return -1;
1011 
1012 #define STATS_OUT_SIZE 1024*1024*6
1013  if(avctx->flags & CODEC_FLAG_PASS1){
1014  avctx->stats_out= av_mallocz(STATS_OUT_SIZE);
1015  for(i=0; i<s->quant_table_count; i++){
1016  for(j=0; j<s->slice_count; j++){
1017  FFV1Context *sf= s->slice_context[j];
1018  av_assert0(!sf->rc_stat2[i]);
1019  sf->rc_stat2[i]= av_mallocz(s->context_count[i]*sizeof(*sf->rc_stat2[i]));
1020  if(!sf->rc_stat2[i])
1021  return AVERROR(ENOMEM);
1022  }
1023  }
1024  }
1025 
1026  return 0;
1027 }
1028 #endif /* CONFIG_FFV1_ENCODER */
1029 
1030 
1031 static void clear_state(FFV1Context *f){
1032  int i, si, j;
1033 
1034  for(si=0; si<f->slice_count; si++){
1035  FFV1Context *fs= f->slice_context[si];
1036  for(i=0; i<f->plane_count; i++){
1037  PlaneContext *p= &fs->plane[i];
1038 
1039  p->interlace_bit_state[0]= 128;
1040  p->interlace_bit_state[1]= 128;
1041 
1042  if(fs->ac){
1043  if(f->initial_states[p->quant_table_index]){
1044  memcpy(p->state, f->initial_states[p->quant_table_index], CONTEXT_SIZE*p->context_count);
1045  }else
1046  memset(p->state, 128, CONTEXT_SIZE*p->context_count);
1047  }else{
1048  for(j=0; j<p->context_count; j++){
1049  p->vlc_state[j].drift= 0;
1050  p->vlc_state[j].error_sum= 4; //FFMAX((RANGE + 32)/64, 2);
1051  p->vlc_state[j].bias= 0;
1052  p->vlc_state[j].count= 1;
1053  }
1054  }
1055  }
1056  }
1057 }
1058 
1059 #if CONFIG_FFV1_ENCODER
1060 static int encode_slice(AVCodecContext *c, void *arg){
1061  FFV1Context *fs= *(void**)arg;
1062  FFV1Context *f= fs->avctx->priv_data;
1063  int width = fs->slice_width;
1064  int height= fs->slice_height;
1065  int x= fs->slice_x;
1066  int y= fs->slice_y;
1067  AVFrame * const p= &f->picture;
1068 
1069  if(f->colorspace==0){
1070  const int chroma_width = -((-width )>>f->chroma_h_shift);
1071  const int chroma_height= -((-height)>>f->chroma_v_shift);
1072  const int cx= x>>f->chroma_h_shift;
1073  const int cy= y>>f->chroma_v_shift;
1074 
1075  encode_plane(fs, p->data[0] + x + y*p->linesize[0], width, height, p->linesize[0], 0);
1076 
1077  encode_plane(fs, p->data[1] + cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
1078  encode_plane(fs, p->data[2] + cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1);
1079  }else{
1080  encode_rgb_frame(fs, (uint32_t*)(p->data[0]) + x + y*(p->linesize[0]/4), width, height, p->linesize[0]/4);
1081  }
1082  emms_c();
1083 
1084  return 0;
1085 }
1086 
1087 static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
1088  FFV1Context *f = avctx->priv_data;
1089  RangeCoder * const c= &f->slice_context[0]->c;
1090  AVFrame *pict = data;
1091  AVFrame * const p= &f->picture;
1092  int used_count= 0;
1093  uint8_t keystate=128;
1094  uint8_t *buf_p;
1095  int i;
1096 
1097  ff_init_range_encoder(c, buf, buf_size);
1098  ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1099 
1100  *p = *pict;
1102 
1103  if(avctx->gop_size==0 || f->picture_number % avctx->gop_size == 0){
1104  put_rac(c, &keystate, 1);
1105  p->key_frame= 1;
1106  f->gob_count++;
1107  write_header(f);
1108  clear_state(f);
1109  }else{
1110  put_rac(c, &keystate, 0);
1111  p->key_frame= 0;
1112  }
1113 
1114  if(!f->ac){
1115  used_count += ff_rac_terminate(c);
1116 //printf("pos=%d\n", used_count);
1117  init_put_bits(&f->slice_context[0]->pb, buf + used_count, buf_size - used_count);
1118  }else if (f->ac>1){
1119  int i;
1120  for(i=1; i<256; i++){
1121  c->one_state[i]= f->state_transition[i];
1122  c->zero_state[256-i]= 256-c->one_state[i];
1123  }
1124  }
1125 
1126  for(i=1; i<f->slice_count; i++){
1127  FFV1Context *fs= f->slice_context[i];
1128  uint8_t *start= buf + (buf_size-used_count)*i/f->slice_count;
1129  int len= buf_size/f->slice_count;
1130 
1131  if(fs->ac){
1132  ff_init_range_encoder(&fs->c, start, len);
1133  }else{
1134  init_put_bits(&fs->pb, start, len);
1135  }
1136  }
1137  avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL, f->slice_count, sizeof(void*));
1138 
1139  buf_p=buf;
1140  for(i=0; i<f->slice_count; i++){
1141  FFV1Context *fs= f->slice_context[i];
1142  int bytes;
1143 
1144  if(fs->ac){
1145  uint8_t state=128;
1146  put_rac(&fs->c, &state, 0);
1147  bytes= ff_rac_terminate(&fs->c);
1148  }else{
1149  flush_put_bits(&fs->pb); //nicer padding FIXME
1150  bytes= used_count + (put_bits_count(&fs->pb)+7)/8;
1151  used_count= 0;
1152  }
1153  if(i>0){
1154  av_assert0(bytes < buf_size/f->slice_count);
1155  memmove(buf_p, fs->ac ? fs->c.bytestream_start : fs->pb.buf, bytes);
1156  av_assert0(bytes < (1<<24));
1157  AV_WB24(buf_p+bytes, bytes);
1158  bytes+=3;
1159  }
1160  buf_p += bytes;
1161  }
1162 
1163  if((avctx->flags&CODEC_FLAG_PASS1) && (f->picture_number&31)==0){
1164  int j, k, m;
1165  char *p= avctx->stats_out;
1166  char *end= p + STATS_OUT_SIZE;
1167 
1168  memset(f->rc_stat, 0, sizeof(f->rc_stat));
1169  for(i=0; i<f->quant_table_count; i++)
1170  memset(f->rc_stat2[i], 0, f->context_count[i]*sizeof(*f->rc_stat2[i]));
1171 
1172  for(j=0; j<f->slice_count; j++){
1173  FFV1Context *fs= f->slice_context[j];
1174  for(i=0; i<256; i++){
1175  f->rc_stat[i][0] += fs->rc_stat[i][0];
1176  f->rc_stat[i][1] += fs->rc_stat[i][1];
1177  }
1178  for(i=0; i<f->quant_table_count; i++){
1179  for(k=0; k<f->context_count[i]; k++){
1180  for(m=0; m<32; m++){
1181  f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1182  f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1183  }
1184  }
1185  }
1186  }
1187 
1188  for(j=0; j<256; j++){
1189  snprintf(p, end-p, "%"PRIu64" %"PRIu64" ", f->rc_stat[j][0], f->rc_stat[j][1]);
1190  p+= strlen(p);
1191  }
1192  snprintf(p, end-p, "\n");
1193 
1194  for(i=0; i<f->quant_table_count; i++){
1195  for(j=0; j<f->context_count[i]; j++){
1196  for(m=0; m<32; m++){
1197  snprintf(p, end-p, "%"PRIu64" %"PRIu64" ", f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1198  p+= strlen(p);
1199  }
1200  }
1201  }
1202  snprintf(p, end-p, "%d\n", f->gob_count);
1203  } else if(avctx->flags&CODEC_FLAG_PASS1)
1204  avctx->stats_out[0] = '\0';
1205 
1206  f->picture_number++;
1207  return buf_p-buf;
1208 }
1209 #endif /* CONFIG_FFV1_ENCODER */
1210 
1211 static av_cold int common_end(AVCodecContext *avctx){
1212  FFV1Context *s = avctx->priv_data;
1213  int i, j;
1214 
1215  if (avctx->codec->decode && s->picture.data[0])
1216  avctx->release_buffer(avctx, &s->picture);
1217 
1218  for(j=0; j<s->slice_count; j++){
1219  FFV1Context *fs= s->slice_context[j];
1220  for(i=0; i<s->plane_count; i++){
1221  PlaneContext *p= &fs->plane[i];
1222 
1223  av_freep(&p->state);
1224  av_freep(&p->vlc_state);
1225  }
1226  av_freep(&fs->sample_buffer);
1227  }
1228 
1229  av_freep(&avctx->stats_out);
1230  for(j=0; j<s->quant_table_count; j++){
1231  av_freep(&s->initial_states[j]);
1232  for(i=0; i<s->slice_count; i++){
1233  FFV1Context *sf= s->slice_context[i];
1234  av_freep(&sf->rc_stat2[j]);
1235  }
1236  av_freep(&s->rc_stat2[j]);
1237  }
1238 
1239  for(i=0; i<s->slice_count; i++){
1240  av_freep(&s->slice_context[i]);
1241  }
1242 
1243  return 0;
1244 }
1245 
1247  int16_t *sample[2],
1248  int plane_index, int bits)
1249 {
1250  PlaneContext * const p= &s->plane[plane_index];
1251  RangeCoder * const c= &s->c;
1252  int x;
1253  int run_count=0;
1254  int run_mode=0;
1255  int run_index= s->run_index;
1256 
1257  for(x=0; x<w; x++){
1258  int diff, context, sign;
1259 
1260  context= get_context(p, sample[1] + x, sample[0] + x, sample[1] + x);
1261  if(context < 0){
1262  context= -context;
1263  sign=1;
1264  }else
1265  sign=0;
1266 
1267  av_assert2(context < p->context_count);
1268 
1269  if(s->ac){
1270  diff= get_symbol_inline(c, p->state[context], 1);
1271  }else{
1272  if(context == 0 && run_mode==0) run_mode=1;
1273 
1274  if(run_mode){
1275  if(run_count==0 && run_mode==1){
1276  if(get_bits1(&s->gb)){
1277  run_count = 1<<ff_log2_run[run_index];
1278  if(x + run_count <= w) run_index++;
1279  }else{
1280  if(ff_log2_run[run_index]) run_count = get_bits(&s->gb, ff_log2_run[run_index]);
1281  else run_count=0;
1282  if(run_index) run_index--;
1283  run_mode=2;
1284  }
1285  }
1286  run_count--;
1287  if(run_count < 0){
1288  run_mode=0;
1289  run_count=0;
1290  diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
1291  if(diff>=0) diff++;
1292  }else
1293  diff=0;
1294  }else
1295  diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
1296 
1297 // 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));
1298  }
1299 
1300  if(sign) diff= -diff;
1301 
1302  sample[1][x]= (predict(sample[1] + x, sample[0] + x) + diff) & ((1<<bits)-1);
1303  }
1304  s->run_index= run_index;
1305 }
1306 
1307 static void decode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
1308  int x, y;
1309  int16_t *sample[2];
1310  sample[0]=s->sample_buffer +3;
1311  sample[1]=s->sample_buffer+w+6+3;
1312 
1313  s->run_index=0;
1314 
1315  memset(s->sample_buffer, 0, 2*(w+6)*sizeof(*s->sample_buffer));
1316 
1317  for(y=0; y<h; y++){
1318  int16_t *temp = sample[0]; //FIXME try a normal buffer
1319 
1320  sample[0]= sample[1];
1321  sample[1]= temp;
1322 
1323  sample[1][-1]= sample[0][0 ];
1324  sample[0][ w]= sample[0][w-1];
1325 
1326 //{START_TIMER
1327  if(s->avctx->bits_per_raw_sample <= 8){
1328  decode_line(s, w, sample, plane_index, 8);
1329  for(x=0; x<w; x++){
1330  src[x + stride*y]= sample[1][x];
1331  }
1332  }else{
1333  decode_line(s, w, sample, plane_index, s->avctx->bits_per_raw_sample);
1334  for(x=0; x<w; x++){
1335  ((uint16_t*)(src + stride*y))[x]= sample[1][x] << (16 - s->avctx->bits_per_raw_sample);
1336  }
1337  }
1338 //STOP_TIMER("decode-line")}
1339  }
1340 }
1341 
1342 static void decode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
1343  int x, y, p;
1344  int16_t *sample[3][2];
1345  for(x=0; x<3; x++){
1346  sample[x][0] = s->sample_buffer + x*2 *(w+6) + 3;
1347  sample[x][1] = s->sample_buffer + (x*2+1)*(w+6) + 3;
1348  }
1349 
1350  s->run_index=0;
1351 
1352  memset(s->sample_buffer, 0, 6*(w+6)*sizeof(*s->sample_buffer));
1353 
1354  for(y=0; y<h; y++){
1355  for(p=0; p<3; p++){
1356  int16_t *temp = sample[p][0]; //FIXME try a normal buffer
1357 
1358  sample[p][0]= sample[p][1];
1359  sample[p][1]= temp;
1360 
1361  sample[p][1][-1]= sample[p][0][0 ];
1362  sample[p][0][ w]= sample[p][0][w-1];
1363  decode_line(s, w, sample[p], FFMIN(p, 1), 9);
1364  }
1365  for(x=0; x<w; x++){
1366  int g= sample[0][1][x];
1367  int b= sample[1][1][x];
1368  int r= sample[2][1][x];
1369 
1370 // assert(g>=0 && b>=0 && r>=0);
1371 // assert(g<256 && b<512 && r<512);
1372 
1373  b -= 0x100;
1374  r -= 0x100;
1375  g -= (b + r)>>2;
1376  b += g;
1377  r += g;
1378 
1379  src[x + stride*y]= b + (g<<8) + (r<<16) + (0xFF<<24);
1380  }
1381  }
1382 }
1383 
1384 static int decode_slice(AVCodecContext *c, void *arg){
1385  FFV1Context *fs= *(void**)arg;
1386  FFV1Context *f= fs->avctx->priv_data;
1387  int width = fs->slice_width;
1388  int height= fs->slice_height;
1389  int x= fs->slice_x;
1390  int y= fs->slice_y;
1391  AVFrame * const p= &f->picture;
1392 
1393  av_assert1(width && height);
1394  if(f->colorspace==0){
1395  const int chroma_width = -((-width )>>f->chroma_h_shift);
1396  const int chroma_height= -((-height)>>f->chroma_v_shift);
1397  const int cx= x>>f->chroma_h_shift;
1398  const int cy= y>>f->chroma_v_shift;
1399  decode_plane(fs, p->data[0] + x + y*p->linesize[0], width, height, p->linesize[0], 0);
1400 
1401  decode_plane(fs, p->data[1] + cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
1402  decode_plane(fs, p->data[2] + cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[2], 1);
1403  }else{
1404  decode_rgb_frame(fs, (uint32_t*)p->data[0] + x + y*(p->linesize[0]/4), width, height, p->linesize[0]/4);
1405  }
1406 
1407  emms_c();
1408 
1409  return 0;
1410 }
1411 
1412 static int read_quant_table(RangeCoder *c, int16_t *quant_table, int scale){
1413  int v;
1414  int i=0;
1415  uint8_t state[CONTEXT_SIZE];
1416 
1417  memset(state, 128, sizeof(state));
1418 
1419  for(v=0; i<128 ; v++){
1420  int len= get_symbol(c, state, 0) + 1;
1421 
1422  if(len + i > 128) return -1;
1423 
1424  while(len--){
1425  quant_table[i] = scale*v;
1426  i++;
1427 //printf("%2d ",v);
1428 //if(i%16==0) printf("\n");
1429  }
1430  }
1431 
1432  for(i=1; i<128; i++){
1433  quant_table[256-i]= -quant_table[i];
1434  }
1435  quant_table[128]= -quant_table[127];
1436 
1437  return 2*v - 1;
1438 }
1439 
1440 static int read_quant_tables(RangeCoder *c, int16_t quant_table[MAX_CONTEXT_INPUTS][256]){
1441  int i;
1442  int context_count=1;
1443 
1444  for(i=0; i<5; i++){
1445  context_count*= read_quant_table(c, quant_table[i], context_count);
1446  if(context_count > 32768U){
1447  return -1;
1448  }
1449  }
1450  return (context_count+1)/2;
1451 }
1452 
1454  RangeCoder * const c= &f->c;
1455  uint8_t state[CONTEXT_SIZE];
1456  int i, j, k;
1457  uint8_t state2[32][CONTEXT_SIZE];
1458 
1459  memset(state2, 128, sizeof(state2));
1460  memset(state, 128, sizeof(state));
1461 
1463  ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1464 
1465  f->version= get_symbol(c, state, 0);
1466  f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
1467  if(f->ac>1){
1468  for(i=1; i<256; i++){
1469  f->state_transition[i]= get_symbol(c, state, 1) + c->one_state[i];
1470  }
1471  }
1472  f->colorspace= get_symbol(c, state, 0); //YUV cs type
1473  f->avctx->bits_per_raw_sample= get_symbol(c, state, 0);
1474  get_rac(c, state); //no chroma = false
1475  f->chroma_h_shift= get_symbol(c, state, 0);
1476  f->chroma_v_shift= get_symbol(c, state, 0);
1477  get_rac(c, state); //transparency plane
1478  f->plane_count= 2;
1479  f->num_h_slices= 1 + get_symbol(c, state, 0);
1480  f->num_v_slices= 1 + get_symbol(c, state, 0);
1481  if(f->num_h_slices > (unsigned)f->width || f->num_v_slices > (unsigned)f->height){
1482  av_log(f->avctx, AV_LOG_ERROR, "too many slices\n");
1483  return -1;
1484  }
1485 
1486  f->quant_table_count= get_symbol(c, state, 0);
1487  if(f->quant_table_count > (unsigned)MAX_QUANT_TABLES)
1488  return -1;
1489  for(i=0; i<f->quant_table_count; i++){
1490  if((f->context_count[i]= read_quant_tables(c, f->quant_tables[i])) < 0){
1491  av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
1492  return -1;
1493  }
1494  }
1495 
1496  if(allocate_initial_states(f) < 0)
1497  return AVERROR(ENOMEM);
1498 
1499  for(i=0; i<f->quant_table_count; i++){
1500  if(get_rac(c, state)){
1501  for(j=0; j<f->context_count[i]; j++){
1502  for(k=0; k<CONTEXT_SIZE; k++){
1503  int pred= j ? f->initial_states[i][j-1][k] : 128;
1504  f->initial_states[i][j][k]= (pred+get_symbol(c, state2[k], 1))&0xFF;
1505  }
1506  }
1507  }
1508  }
1509 
1510  return 0;
1511 }
1512 
1513 static int read_header(FFV1Context *f){
1514  uint8_t state[CONTEXT_SIZE];
1515  int i, j, context_count;
1516  RangeCoder * const c= &f->slice_context[0]->c;
1517 
1518  memset(state, 128, sizeof(state));
1519 
1520  if(f->version < 2){
1521  int chroma_h_shift, chroma_v_shift, colorspace, bits_per_raw_sample;
1522  unsigned v = get_symbol(c, state, 0);
1523  if (v > 1) {
1525  "invalid version %d in version 1 header\n", v);
1526  return AVERROR_INVALIDDATA;
1527  }
1528  f->version = v;
1529 
1530  f->ac = f->avctx->coder_type = get_symbol(c, state, 0);
1531 
1532  if (f->ac > 1) {
1533  for (i = 1; i < 256; i++)
1534  f->state_transition[i] =
1535  get_symbol(c, state, 1) + c->one_state[i];
1536  }
1537 
1538  colorspace = get_symbol(c, state, 0); //YUV cs type
1539  bits_per_raw_sample = f->version > 0 ? get_symbol(c, state, 0) : f->avctx->bits_per_raw_sample;
1540  get_rac(c, state); //no chroma = false
1541  chroma_h_shift = get_symbol(c, state, 0);
1542  chroma_v_shift = get_symbol(c, state, 0);
1543  get_rac(c, state); //transparency plane
1544 
1545  if (f->plane_count) {
1546  if (colorspace != f->colorspace ||
1547  bits_per_raw_sample != f->avctx->bits_per_raw_sample ||
1548  chroma_h_shift != f->chroma_h_shift ||
1549  chroma_v_shift != f->chroma_v_shift) {
1550  av_log(f->avctx, AV_LOG_ERROR, "Invalid change of global parameters\n");
1551  return AVERROR_INVALIDDATA;
1552  }
1553  }
1554 
1555  f->colorspace = colorspace;
1556  f->avctx->bits_per_raw_sample = bits_per_raw_sample;
1559 
1560  f->plane_count= 2;
1561  }
1562 
1563  if(f->colorspace==0){
1564  if(f->avctx->bits_per_raw_sample<=8){
1565  switch(16*f->chroma_h_shift + f->chroma_v_shift){
1566  case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P; break;
1567  case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P; break;
1568  case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P; break;
1569  case 0x20: f->avctx->pix_fmt= PIX_FMT_YUV411P; break;
1570  case 0x22: f->avctx->pix_fmt= PIX_FMT_YUV410P; break;
1571  default:
1572  av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1573  return -1;
1574  }
1575  }else{
1576  switch(16*f->chroma_h_shift + f->chroma_v_shift){
1577  case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P16; break;
1578  case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P16; break;
1579  case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P16; break;
1580  default:
1581  av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1582  return -1;
1583  }
1584  }
1585  }else if(f->colorspace==1){
1586  if(f->chroma_h_shift || f->chroma_v_shift){
1587  av_log(f->avctx, AV_LOG_ERROR, "chroma subsampling not supported in this colorspace\n");
1588  return -1;
1589  }
1591  }else{
1592  av_log(f->avctx, AV_LOG_ERROR, "colorspace not supported\n");
1593  return -1;
1594  }
1595 
1596 //printf("%d %d %d\n", f->chroma_h_shift, f->chroma_v_shift,f->avctx->pix_fmt);
1597  if(f->version < 2){
1598  context_count= read_quant_tables(c, f->quant_table);
1599  if(context_count < 0){
1600  av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
1601  return -1;
1602  }
1603  }else{
1604  f->slice_count= get_symbol(c, state, 0);
1605  if(f->slice_count > (unsigned)MAX_SLICES)
1606  return -1;
1607  }
1608 
1609  for(j=0; j<f->slice_count; j++){
1610  FFV1Context *fs= f->slice_context[j];
1611  fs->ac= f->ac;
1612 
1613  if(f->version >= 2){
1614  fs->slice_x = get_symbol(c, state, 0) *f->width ;
1615  fs->slice_y = get_symbol(c, state, 0) *f->height;
1616  fs->slice_width =(get_symbol(c, state, 0)+1)*f->width + fs->slice_x;
1617  fs->slice_height=(get_symbol(c, state, 0)+1)*f->height + fs->slice_y;
1618 
1619  fs->slice_x /= f->num_h_slices;
1620  fs->slice_y /= f->num_v_slices;
1621  fs->slice_width = fs->slice_width /f->num_h_slices - fs->slice_x;
1622  fs->slice_height = fs->slice_height/f->num_v_slices - fs->slice_y;
1623  if((unsigned)fs->slice_width > f->width || (unsigned)fs->slice_height > f->height)
1624  return -1;
1625  if( (unsigned)fs->slice_x + (uint64_t)fs->slice_width > f->width
1626  || (unsigned)fs->slice_y + (uint64_t)fs->slice_height > f->height)
1627  return -1;
1628  }
1629 
1630  for(i=0; i<f->plane_count; i++){
1631  PlaneContext * const p= &fs->plane[i];
1632 
1633  if(f->version >= 2){
1634  int idx=get_symbol(c, state, 0);
1635  if(idx > (unsigned)f->quant_table_count){
1636  av_log(f->avctx, AV_LOG_ERROR, "quant_table_index out of range\n");
1637  return -1;
1638  }
1639  p->quant_table_index= idx;
1640  memcpy(p->quant_table, f->quant_tables[idx], sizeof(p->quant_table));
1641  context_count= f->context_count[idx];
1642  }else{
1643  memcpy(p->quant_table, f->quant_table, sizeof(p->quant_table));
1644  }
1645 
1646  if(p->context_count < context_count){
1647  av_freep(&p->state);
1648  av_freep(&p->vlc_state);
1649  }
1651  }
1652  }
1653 
1654  return 0;
1655 }
1656 
1658 {
1659  FFV1Context *f = avctx->priv_data;
1660 
1661  common_init(avctx);
1662 
1663  if(avctx->extradata && read_extra_header(f) < 0)
1664  return -1;
1665 
1666  if(init_slice_contexts(f) < 0)
1667  return -1;
1668 
1669  return 0;
1670 }
1671 
1672 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){
1673  const uint8_t *buf = avpkt->data;
1674  int buf_size = avpkt->size;
1675  FFV1Context *f = avctx->priv_data;
1676  RangeCoder * const c= &f->slice_context[0]->c;
1677  AVFrame * const p= &f->picture;
1678  int bytes_read, i;
1679  uint8_t keystate= 128;
1680  const uint8_t *buf_p;
1681 
1682  AVFrame *picture = data;
1683 
1684  /* release previously stored data */
1685  if (p->data[0])
1686  avctx->release_buffer(avctx, p);
1687 
1688  ff_init_range_decoder(c, buf, buf_size);
1689  ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1690 
1691 
1692  p->pict_type= AV_PICTURE_TYPE_I; //FIXME I vs. P
1693  if(get_rac(c, &keystate)){
1694  p->key_frame= 1;
1695  if(read_header(f) < 0)
1696  return -1;
1697  if(init_slice_state(f) < 0)
1698  return -1;
1699 
1700  clear_state(f);
1701  }else{
1702  p->key_frame= 0;
1703  }
1704  if(f->ac>1){
1705  int i;
1706  for(i=1; i<256; i++){
1707  c->one_state[i]= f->state_transition[i];
1708  c->zero_state[256-i]= 256-c->one_state[i];
1709  }
1710  }
1711 
1712  p->reference= 0;
1713  if(avctx->get_buffer(avctx, p) < 0){
1714  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1715  return -1;
1716  }
1717 
1718  if(avctx->debug&FF_DEBUG_PICT_INFO)
1719  av_log(avctx, AV_LOG_ERROR, "keyframe:%d coder:%d\n", p->key_frame, f->ac);
1720 
1721  if(!f->ac){
1722  bytes_read = c->bytestream - c->bytestream_start - 1;
1723  if(bytes_read ==0) av_log(avctx, AV_LOG_ERROR, "error at end of AC stream\n"); //FIXME
1724 //printf("pos=%d\n", bytes_read);
1725  init_get_bits(&f->slice_context[0]->gb, buf + bytes_read, (buf_size - bytes_read) * 8);
1726  } else {
1727  bytes_read = 0; /* avoid warning */
1728  }
1729 
1730  buf_p= buf + buf_size;
1731  for(i=f->slice_count-1; i>0; i--){
1732  FFV1Context *fs= f->slice_context[i];
1733  int v= AV_RB24(buf_p-3)+3;
1734  if(buf_p - buf <= v){
1735  av_log(avctx, AV_LOG_ERROR, "Slice pointer chain broken\n");
1736  return -1;
1737  }
1738  buf_p -= v;
1739  if(fs->ac){
1740  ff_init_range_decoder(&fs->c, buf_p, v);
1741  }else{
1742  init_get_bits(&fs->gb, buf_p, v * 8);
1743  }
1744  }
1745 
1746  avctx->execute(avctx, decode_slice, &f->slice_context[0], NULL, f->slice_count, sizeof(void*));
1747  f->picture_number++;
1748 
1749  *picture= *p;
1750  *data_size = sizeof(AVFrame);
1751 
1752  return buf_size;
1753 }
1754 
1756  .name = "ffv1",
1757  .type = AVMEDIA_TYPE_VIDEO,
1758  .id = CODEC_ID_FFV1,
1759  .priv_data_size = sizeof(FFV1Context),
1760  .init = decode_init,
1761  .close = common_end,
1762  .decode = decode_frame,
1763  .capabilities = CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/ | CODEC_CAP_SLICE_THREADS,
1764  .long_name= NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1765 };
1766 
1767 #if CONFIG_FFV1_ENCODER
1768 AVCodec ff_ffv1_encoder = {
1769  .name = "ffv1",
1770  .type = AVMEDIA_TYPE_VIDEO,
1771  .id = CODEC_ID_FFV1,
1772  .priv_data_size = sizeof(FFV1Context),
1773  .init = encode_init,
1774  .encode = encode_frame,
1775  .close = common_end,
1776  .capabilities = CODEC_CAP_SLICE_THREADS,
1778  .long_name= NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1779 };
1780 #endif
static av_flatten int get_symbol_inline(RangeCoder *c, uint8_t *state, int is_signed)
Definition: ffv1.c:329
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:68
static int write_header(AVFormatContext *s)
Definition: assenc.c:28
#define put_rac(C, S, B)
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:154
int(* get_buffer)(struct AVCodecContext *c, AVFrame *pic)
Called at the beginning of each frame to get a buffer for it.
Definition: avcodec.h:1726
enum PixelFormat pix_fmt
Pixel format, see PIX_FMT_xxx.
Definition: avcodec.h:1426
static int read_quant_table(RangeCoder *c, int16_t *quant_table, int scale)
Definition: ffv1.c:1412
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:54
Audio Video Frame.
Definition: avcodec.h:985
void ff_init_range_encoder(RangeCoder *c, uint8_t *buf, int buf_size)
Definition: rangecoder.c:41
static av_always_inline int fold(int diff, int bits)
Definition: ffv1.c:198
static int read_quant_tables(RangeCoder *c, int16_t quant_table[MAX_CONTEXT_INPUTS][256])
Definition: ffv1.c:1440
int flags
Definition: ffv1.c:168
static const uint8_t ver2_state[256]
Definition: ffv1.c:121
void(* release_buffer)(struct AVCodecContext *c, AVFrame *pic)
Called to release buffers which were allocated with get_buffer.
Definition: avcodec.h:1737
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:237
int16_t quant_table[MAX_CONTEXT_INPUTS][256]
Definition: ffv1.c:148
int quant_table_count
Definition: ffv1.c:184
AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:2000
int slice_height
Definition: ffv1.c:193
int16_t * sample_buffer
Definition: ffv1.c:181
int version
Definition: ffv1.c:165
static av_cold int encode_init(AVCodecContext *avctx)
Definition: dpxenc.c:33
uint8_t zero_state[256]
Definition: rangecoder.h:39
Range coder.
uint8_t * bytestream_end
Definition: rangecoder.h:43
int size
Definition: avcodec.h:909
int width
Definition: rotozoom.c:164
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:71
AVCodec ff_ffv1_decoder
Definition: ffv1.c:1755
static int get_context(PlaneContext *p, int16_t *src, int16_t *last, int16_t *last2)
Definition: ffv1.c:219
char * stats_in
pass2 encoding statistics input buffer Concatenated stuff from stats_out of pass1 should be placed he...
Definition: avcodec.h:1783
#define b
Definition: swscale.c:1335
int(* decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt)
Definition: avcodec.h:3203
uint64_t(*[MAX_QUANT_TABLES] rc_stat2)[32][2]
Definition: ffv1.c:164
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:2863
struct AVCodec * codec
Definition: avcodec.h:1529
int height
Definition: ffv1.c:166
#define CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:638
int stride
Definition: mace.c:143
AVCodec.
Definition: avcodec.h:3189
uint8_t one_state[256]
Definition: rangecoder.h:40
#define v(n)
Definition: regs.h:34
#define log2(x)
Definition: libm.h:53
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
Definition: mem.c:147
#define PIX_FMT_YUV422P16
Definition: pixfmt.h:191
int plane_count
Definition: ffv1.c:171
int ff_rac_terminate(RangeCoder *c)
Definition: rangecoder.c:99
static int predict(int16_t *src, int16_t *last)
Definition: ffv1.c:210
int context_model
context model
Definition: avcodec.h:2227
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
Definition: mimic.c:228
const uint8_t ff_log2_run[41]
Definition: bitstream.c:35
uint64_t rc_stat[256][2]
Definition: ffv1.c:163
PutBitContext pb
Definition: ffv1.c:162
uint8_t bits
Definition: crc.c:31
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:64
#define av_cold
Definition: attributes.h:71
static int get_rac(RangeCoder *c, uint8_t *const state)
Definition: rangecoder.h:110
#define round(bias)
Definition: idct_mmx.c:31
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:63
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:70
#define FF_DEBUG_PICT_INFO
Definition: avcodec.h:2008
int8_t bias
Definition: ffv1.c:143
RangeCoder c
Definition: ffv1.c:160
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1387
#define PIX_FMT_YUV420P16
Definition: pixfmt.h:190
int slice_y
Definition: ffv1.c:195
uint8_t(*[MAX_QUANT_TABLES] initial_states)[32]
Definition: ffv1.c:178
const char data[16]
Definition: mxf.c:60
static int read_header(FFV1Context *f)
Definition: ffv1.c:1513
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])
Definition: ffv1.c:278
int coder_type
coder type
Definition: avcodec.h:2220
uint8_t * data
Definition: avcodec.h:908
uint8_t count
Definition: ffv1.c:144
static int init_slice_state(FFV1Context *f)
Definition: ffv1.c:676
bitstream reader API header.
static const int8_t quant9_10bit[256]
Definition: ffv1.c:83
VlcState * vlc_state
Definition: ffv1.c:152
char * stats_out
pass1 encoding statistics output buffer
Definition: avcodec.h:1775
av_cold void dsputil_init(DSPContext *c, AVCodecContext *avctx)
Definition: dsputil.c:2789
static int init(AVCodecParserContext *s)
Definition: h264_parser.c:336
int slice_width
Definition: ffv1.c:192
static void decode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride)
Definition: ffv1.c:1342
#define CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:719
GetBitContext gb
Definition: ffv1.c:161
static int decode_slice(AVCodecContext *c, void *arg)
Definition: ffv1.c:1384
static void decode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index)
Definition: ffv1.c:1307
#define CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:639
int16_t quant_tables[MAX_QUANT_TABLES][MAX_CONTEXT_INPUTS][256]
Definition: ffv1.c:175
#define MAX_QUANT_TABLES
Definition: ffv1.c:40
static const int8_t quant11[256]
Definition: ffv1.c:102
int reference
is this picture used as reference The values for this are the same as the MpegEncContext.picture_structure variable, that is 1->top field, 2->bottom field, 3->frame/both fields.
Definition: avcodec.h:1074
#define AVERROR(e)
Definition: error.h:43
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:191
g
Definition: yuv2rgb.c:481
int context_count
Definition: ffv1.c:150
int flags
CODEC_FLAG_*.
Definition: avcodec.h:1355
uint8_t * buf
Definition: put_bits.h:42
simple assert() macros that are a bit more flexible than ISO C assert().
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:140
const char * name
Name of the codec implementation.
Definition: avcodec.h:3196
static void put_bits(PutBitContext *s, int n, unsigned int value)
Write up to 31 bits into a bitstream.
Definition: put_bits.h:136
#define FFMAX(a, b)
Definition: common.h:53
static av_cold int common_init(AVCodecContext *avctx)
Definition: ffv1.c:656
uint8_t * bytestream
Definition: rangecoder.h:42
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:69
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:70
struct PlaneContext PlaneContext
static av_always_inline void emms_c(void)
Empty mmx state.
Definition: internal.h:240
int ac
1=range coder <-> 0=golomb rice
Definition: ffv1.c:172
int16_t quant_table[MAX_CONTEXT_INPUTS][256]
Definition: ffv1.c:174
int run_index
Definition: ffv1.c:179
Definition: ffv1.c:140
static int read_extra_header(FFV1Context *f)
Definition: ffv1.c:1453
#define av_flatten
Definition: attributes.h:79
uint8_t state_transition[256]
Definition: ffv1.c:177
static AVFrame * picture
#define T(x)
Definition: vp56_arith.h:29
enum AVPictureType pict_type
Picture type of the frame, see ?_TYPE below.
Definition: avcodec.h:1029
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
#define FFMIN(a, b)
Definition: common.h:55
#define f(n)
Definition: regs.h:33
int num_h_slices
Definition: ffv1.c:191
int width
picture width / height.
Definition: avcodec.h:1408
struct AVFrame AVFrame
Audio Video Frame.
int colorspace
Definition: ffv1.c:180
DSPContext dsp
Definition: ffv1.c:186
static float quant_table[96]
Definition: binkaudio.c:43
int slice_count
Definition: ffv1.c:189
#define AV_WB24(p, d)
Definition: intreadwrite.h:412
void ff_build_rac_states(RangeCoder *c, int factor, int max_p)
Definition: rangecoder.c:59
#define FFABS(a)
Definition: common.h:50
static av_cold int init_slice_contexts(FFV1Context *f)
Definition: ffv1.c:707
int16_t drift
Definition: ffv1.c:141
struct FFV1Context FFV1Context
static const int8_t quant5_10bit[256]
Definition: ffv1.c:45
static const float pred[4]
Definition: siprdata.h:259
NULL
Definition: eval.c:50
void avcodec_get_chroma_sub_sample(enum PixelFormat pix_fmt, int *h_shift, int *v_shift)
Definition: imgconvert.c:411
int context_count[MAX_QUANT_TABLES]
Definition: ffv1.c:176
static int av_noinline get_symbol(RangeCoder *c, uint8_t *state, int is_signed)
Definition: ffv1.c:349
external API header
static void av_noinline put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed)
Definition: ffv1.c:325
int AC3_NAME() encode_frame(AVCodecContext *avctx, unsigned char *frame, int buf_size, void *data)
int linesize[AV_NUM_DATA_POINTERS]
Size, in bytes, of the data for each picture/channel plane.
Definition: avcodec.h:1008
int debug
debug
Definition: avcodec.h:2007
static const int8_t quant5[256]
Definition: ffv1.c:64
main external API structure.
Definition: avcodec.h:1329
static void close(AVCodecParserContext *s)
Definition: h264_parser.c:327
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:111
uint8_t * buf_end
Definition: put_bits.h:42
#define MAX_PLANES
Definition: ffv1.c:37
int extradata_size
Definition: avcodec.h:1388
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:268
static void find_best_state(uint8_t best_state[256][256], const uint8_t one_state[256])
Definition: ffv1.c:236
void * av_malloc(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:64
static av_cold int common_end(AVCodecContext *avctx)
Definition: ffv1.c:1211
static void set_sr_golomb(PutBitContext *pb, int i, int k, int limit, int esc_len)
write signed golomb rice code (ffv1).
Definition: golomb.h:523
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:354
AVFrame picture
Definition: ffv1.c:170
#define mid_pred
Definition: mathops.h:88
int picture_number
Definition: ffv1.c:169
uint16_t error_sum
Definition: ffv1.c:142
void ff_init_range_decoder(RangeCoder *c, const uint8_t *buf, int buf_size)
Definition: rangecoder.c:52
static av_cold int decode_init(AVCodecContext *avctx)
Definition: ffv1.c:1657
static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt)
Definition: ffv1.c:1672
static uint32_t state
Definition: trasher.c:25
int gob_count
Definition: ffv1.c:182
static const uint16_t scale[4]
int quant_table_index
Definition: ffv1.c:149
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: avcodec.h:997
AV_WL32 AV_WL24 AV_WL16 AV_WB32 AV_RB24
Definition: bytestream.h:89
int height
Definition: gxfenc.c:73
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:1417
#define PIX_FMT_YUV444P16
Definition: pixfmt.h:192
#define r(n)
Definition: regs.h:32
PixelFormat
Pixel format.
Definition: pixfmt.h:62
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:86
#define CONTEXT_SIZE
Definition: ffv1.c:38
static int get_vlc_symbol(GetBitContext *gb, VlcState *const state, int bits)
Definition: ffv1.c:411
uint8_t(* state)[CONTEXT_SIZE]
Definition: ffv1.c:151
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:52
DSP utils.
uint8_t * bytestream_start
Definition: rangecoder.h:41
void * priv_data
Definition: avcodec.h:1531
int chroma_h_shift
Definition: ffv1.c:167
PlaneContext plane[MAX_PLANES]
Definition: ffv1.c:173
int(* execute)(struct AVCodecContext *c, int(*func)(struct AVCodecContext *c2, void *arg), void *arg2, int *ret, int count, int size)
The codec may call this to execute several independent things.
Definition: avcodec.h:2403
int chroma_v_shift
Definition: ffv1.c:167
#define PIX_FMT_RGB32
Definition: pixfmt.h:169
int len
static int allocate_initial_states(FFV1Context *f)
Definition: ffv1.c:740
#define CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: avcodec.h:792
int key_frame
1 -> keyframe, 0-> not
Definition: avcodec.h:1022
struct FFV1Context * slice_context[MAX_SLICES]
Definition: ffv1.c:188
Definition: vf_drawbox.c:32
static av_always_inline void decode_line(FFV1Context *s, int w, int16_t *sample[2], int plane_index, int bits)
Definition: ffv1.c:1246
static void put_vlc_symbol(PutBitContext *pb, VlcState *const state, int v, int bits)
Definition: ffv1.c:384
struct VlcState VlcState
#define av_noinline
Definition: attributes.h:47
uint8_t interlace_bit_state[2]
Definition: ffv1.c:153
#define MAX_SLICES
Definition: ffv1.c:156
#define av_always_inline
Definition: attributes.h:39
#define FFSWAP(type, a, b)
Definition: common.h:58
enum AVColorSpace colorspace
Definition: dirac.c:93
static void clear_state(FFV1Context *f)
Definition: ffv1.c:1031
static void update_vlc_state(VlcState *const state, const int v)
Definition: ffv1.c:353
static int get_sr_golomb(GetBitContext *gb, int k, int limit, int esc_len)
read signed golomb rice code (ffv1).
Definition: golomb.h:334
#define MAX_CONTEXT_INPUTS
Definition: ffv1.c:41
int num_v_slices
Definition: ffv1.c:190
exp golomb vlc stuff
AVCodecContext * avctx
Definition: ffv1.c:159
int slice_x
Definition: ffv1.c:194
int width
Definition: ffv1.c:166
DSPContext.
Definition: dsputil.h:226
bitstream writer API