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  f->version= get_symbol(c, state, 0);
1522  f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
1523  if(f->ac>1){
1524  for(i=1; i<256; i++){
1525  f->state_transition[i]= get_symbol(c, state, 1) + c->one_state[i];
1526  }
1527  }
1528  f->colorspace= get_symbol(c, state, 0); //YUV cs type
1529  if(f->version>0)
1530  f->avctx->bits_per_raw_sample= get_symbol(c, state, 0);
1531  get_rac(c, state); //no chroma = false
1532  f->chroma_h_shift= get_symbol(c, state, 0);
1533  f->chroma_v_shift= get_symbol(c, state, 0);
1534  get_rac(c, state); //transparency plane
1535  f->plane_count= 2;
1536  }
1537 
1538  if(f->colorspace==0){
1539  if(f->avctx->bits_per_raw_sample<=8){
1540  switch(16*f->chroma_h_shift + f->chroma_v_shift){
1541  case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P; break;
1542  case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P; break;
1543  case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P; break;
1544  case 0x20: f->avctx->pix_fmt= PIX_FMT_YUV411P; break;
1545  case 0x22: f->avctx->pix_fmt= PIX_FMT_YUV410P; break;
1546  default:
1547  av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1548  return -1;
1549  }
1550  }else{
1551  switch(16*f->chroma_h_shift + f->chroma_v_shift){
1552  case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P16; break;
1553  case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P16; break;
1554  case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P16; break;
1555  default:
1556  av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1557  return -1;
1558  }
1559  }
1560  }else if(f->colorspace==1){
1561  if(f->chroma_h_shift || f->chroma_v_shift){
1562  av_log(f->avctx, AV_LOG_ERROR, "chroma subsampling not supported in this colorspace\n");
1563  return -1;
1564  }
1566  }else{
1567  av_log(f->avctx, AV_LOG_ERROR, "colorspace not supported\n");
1568  return -1;
1569  }
1570 
1571 //printf("%d %d %d\n", f->chroma_h_shift, f->chroma_v_shift,f->avctx->pix_fmt);
1572  if(f->version < 2){
1573  context_count= read_quant_tables(c, f->quant_table);
1574  if(context_count < 0){
1575  av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
1576  return -1;
1577  }
1578  }else{
1579  f->slice_count= get_symbol(c, state, 0);
1580  if(f->slice_count > (unsigned)MAX_SLICES)
1581  return -1;
1582  }
1583 
1584  for(j=0; j<f->slice_count; j++){
1585  FFV1Context *fs= f->slice_context[j];
1586  fs->ac= f->ac;
1587 
1588  if(f->version >= 2){
1589  fs->slice_x = get_symbol(c, state, 0) *f->width ;
1590  fs->slice_y = get_symbol(c, state, 0) *f->height;
1591  fs->slice_width =(get_symbol(c, state, 0)+1)*f->width + fs->slice_x;
1592  fs->slice_height=(get_symbol(c, state, 0)+1)*f->height + fs->slice_y;
1593 
1594  fs->slice_x /= f->num_h_slices;
1595  fs->slice_y /= f->num_v_slices;
1596  fs->slice_width = fs->slice_width /f->num_h_slices - fs->slice_x;
1597  fs->slice_height = fs->slice_height/f->num_v_slices - fs->slice_y;
1598  if((unsigned)fs->slice_width > f->width || (unsigned)fs->slice_height > f->height)
1599  return -1;
1600  if( (unsigned)fs->slice_x + (uint64_t)fs->slice_width > f->width
1601  || (unsigned)fs->slice_y + (uint64_t)fs->slice_height > f->height)
1602  return -1;
1603  }
1604 
1605  for(i=0; i<f->plane_count; i++){
1606  PlaneContext * const p= &fs->plane[i];
1607 
1608  if(f->version >= 2){
1609  int idx=get_symbol(c, state, 0);
1610  if(idx > (unsigned)f->quant_table_count){
1611  av_log(f->avctx, AV_LOG_ERROR, "quant_table_index out of range\n");
1612  return -1;
1613  }
1614  p->quant_table_index= idx;
1615  memcpy(p->quant_table, f->quant_tables[idx], sizeof(p->quant_table));
1616  context_count= f->context_count[idx];
1617  }else{
1618  memcpy(p->quant_table, f->quant_table, sizeof(p->quant_table));
1619  }
1620 
1621  if(p->context_count < context_count){
1622  av_freep(&p->state);
1623  av_freep(&p->vlc_state);
1624  }
1626  }
1627  }
1628 
1629  return 0;
1630 }
1631 
1633 {
1634  FFV1Context *f = avctx->priv_data;
1635 
1636  common_init(avctx);
1637 
1638  if(avctx->extradata && read_extra_header(f) < 0)
1639  return -1;
1640 
1641  if(init_slice_contexts(f) < 0)
1642  return -1;
1643 
1644  return 0;
1645 }
1646 
1647 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){
1648  const uint8_t *buf = avpkt->data;
1649  int buf_size = avpkt->size;
1650  FFV1Context *f = avctx->priv_data;
1651  RangeCoder * const c= &f->slice_context[0]->c;
1652  AVFrame * const p= &f->picture;
1653  int bytes_read, i;
1654  uint8_t keystate= 128;
1655  const uint8_t *buf_p;
1656 
1657  AVFrame *picture = data;
1658 
1659  /* release previously stored data */
1660  if (p->data[0])
1661  avctx->release_buffer(avctx, p);
1662 
1663  ff_init_range_decoder(c, buf, buf_size);
1664  ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1665 
1666 
1667  p->pict_type= AV_PICTURE_TYPE_I; //FIXME I vs. P
1668  if(get_rac(c, &keystate)){
1669  p->key_frame= 1;
1670  if(read_header(f) < 0)
1671  return -1;
1672  if(init_slice_state(f) < 0)
1673  return -1;
1674 
1675  clear_state(f);
1676  }else{
1677  p->key_frame= 0;
1678  }
1679  if(f->ac>1){
1680  int i;
1681  for(i=1; i<256; i++){
1682  c->one_state[i]= f->state_transition[i];
1683  c->zero_state[256-i]= 256-c->one_state[i];
1684  }
1685  }
1686 
1687  p->reference= 0;
1688  if(avctx->get_buffer(avctx, p) < 0){
1689  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1690  return -1;
1691  }
1692 
1693  if(avctx->debug&FF_DEBUG_PICT_INFO)
1694  av_log(avctx, AV_LOG_ERROR, "keyframe:%d coder:%d\n", p->key_frame, f->ac);
1695 
1696  if(!f->ac){
1697  bytes_read = c->bytestream - c->bytestream_start - 1;
1698  if(bytes_read ==0) av_log(avctx, AV_LOG_ERROR, "error at end of AC stream\n"); //FIXME
1699 //printf("pos=%d\n", bytes_read);
1700  init_get_bits(&f->slice_context[0]->gb, buf + bytes_read, (buf_size - bytes_read) * 8);
1701  } else {
1702  bytes_read = 0; /* avoid warning */
1703  }
1704 
1705  buf_p= buf + buf_size;
1706  for(i=f->slice_count-1; i>0; i--){
1707  FFV1Context *fs= f->slice_context[i];
1708  int v= AV_RB24(buf_p-3)+3;
1709  if(buf_p - buf <= v){
1710  av_log(avctx, AV_LOG_ERROR, "Slice pointer chain broken\n");
1711  return -1;
1712  }
1713  buf_p -= v;
1714  if(fs->ac){
1715  ff_init_range_decoder(&fs->c, buf_p, v);
1716  }else{
1717  init_get_bits(&fs->gb, buf_p, v * 8);
1718  }
1719  }
1720 
1721  avctx->execute(avctx, decode_slice, &f->slice_context[0], NULL, f->slice_count, sizeof(void*));
1722  f->picture_number++;
1723 
1724  *picture= *p;
1725  *data_size = sizeof(AVFrame);
1726 
1727  return buf_size;
1728 }
1729 
1731  .name = "ffv1",
1732  .type = AVMEDIA_TYPE_VIDEO,
1733  .id = CODEC_ID_FFV1,
1734  .priv_data_size = sizeof(FFV1Context),
1735  .init = decode_init,
1736  .close = common_end,
1737  .decode = decode_frame,
1738  .capabilities = CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/ | CODEC_CAP_SLICE_THREADS,
1739  .long_name= NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1740 };
1741 
1742 #if CONFIG_FFV1_ENCODER
1743 AVCodec ff_ffv1_encoder = {
1744  .name = "ffv1",
1745  .type = AVMEDIA_TYPE_VIDEO,
1746  .id = CODEC_ID_FFV1,
1747  .priv_data_size = sizeof(FFV1Context),
1748  .init = encode_init,
1749  .encode = encode_frame,
1750  .close = common_end,
1751  .capabilities = CODEC_CAP_SLICE_THREADS,
1753  .long_name= NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1754 };
1755 #endif