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