snow.c
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2004 Michael Niedermayer <michaelni@gmx.at>
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 #include "libavutil/intmath.h"
22 #include "libavutil/log.h"
23 #include "libavutil/opt.h"
24 #include "avcodec.h"
25 #include "dsputil.h"
26 #include "snow_dwt.h"
27 #include "internal.h"
28 #include "snow.h"
29 #include "snowdata.h"
30 
31 #include "rangecoder.h"
32 #include "mathops.h"
33 #include "h263.h"
34 
35 
36 void ff_snow_inner_add_yblock(const uint8_t *obmc, const int obmc_stride, uint8_t * * block, int b_w, int b_h,
37  int src_x, int src_y, int src_stride, slice_buffer * sb, int add, uint8_t * dst8){
38  int y, x;
39  IDWTELEM * dst;
40  for(y=0; y<b_h; y++){
41  //FIXME ugly misuse of obmc_stride
42  const uint8_t *obmc1= obmc + y*obmc_stride;
43  const uint8_t *obmc2= obmc1+ (obmc_stride>>1);
44  const uint8_t *obmc3= obmc1+ obmc_stride*(obmc_stride>>1);
45  const uint8_t *obmc4= obmc3+ (obmc_stride>>1);
46  dst = slice_buffer_get_line(sb, src_y + y);
47  for(x=0; x<b_w; x++){
48  int v= obmc1[x] * block[3][x + y*src_stride]
49  +obmc2[x] * block[2][x + y*src_stride]
50  +obmc3[x] * block[1][x + y*src_stride]
51  +obmc4[x] * block[0][x + y*src_stride];
52 
53  v <<= 8 - LOG2_OBMC_MAX;
54  if(FRAC_BITS != 8){
55  v >>= 8 - FRAC_BITS;
56  }
57  if(add){
58  v += dst[x + src_x];
59  v = (v + (1<<(FRAC_BITS-1))) >> FRAC_BITS;
60  if(v&(~255)) v= ~(v>>31);
61  dst8[x + y*src_stride] = v;
62  }else{
63  dst[x + src_x] -= v;
64  }
65  }
66  }
67 }
68 
69 void ff_snow_reset_contexts(SnowContext *s){ //FIXME better initial contexts
70  int plane_index, level, orientation;
71 
72  for(plane_index=0; plane_index<3; plane_index++){
73  for(level=0; level<MAX_DECOMPOSITIONS; level++){
74  for(orientation=level ? 1:0; orientation<4; orientation++){
75  memset(s->plane[plane_index].band[level][orientation].state, MID_STATE, sizeof(s->plane[plane_index].band[level][orientation].state));
76  }
77  }
78  }
79  memset(s->header_state, MID_STATE, sizeof(s->header_state));
80  memset(s->block_state, MID_STATE, sizeof(s->block_state));
81 }
82 
84  int w= -((-s->avctx->width )>>LOG2_MB_SIZE);
85  int h= -((-s->avctx->height)>>LOG2_MB_SIZE);
86 
87  s->b_width = w;
88  s->b_height= h;
89 
90  av_free(s->block);
91  s->block= av_mallocz(w * h * sizeof(BlockNode) << (s->block_max_depth*2));
92  return 0;
93 }
94 
95 static void init_qexp(void){
96  int i;
97  double v=128;
98 
99  for(i=0; i<QROOT; i++){
100  ff_qexp[i]= lrintf(v);
101  v *= pow(2, 1.0 / QROOT);
102  }
103 }
104 static void mc_block(Plane *p, uint8_t *dst, const uint8_t *src, int stride, int b_w, int b_h, int dx, int dy){
105  static const uint8_t weight[64]={
106  8,7,6,5,4,3,2,1,
107  7,7,0,0,0,0,0,1,
108  6,0,6,0,0,0,2,0,
109  5,0,0,5,0,3,0,0,
110  4,0,0,0,4,0,0,0,
111  3,0,0,5,0,3,0,0,
112  2,0,6,0,0,0,2,0,
113  1,7,0,0,0,0,0,1,
114  };
115 
116  static const uint8_t brane[256]={
117  0x00,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x11,0x12,0x12,0x12,0x12,0x12,0x12,0x12,
118  0x04,0x05,0xcc,0xcc,0xcc,0xcc,0xcc,0x41,0x15,0x16,0xcc,0xcc,0xcc,0xcc,0xcc,0x52,
119  0x04,0xcc,0x05,0xcc,0xcc,0xcc,0x41,0xcc,0x15,0xcc,0x16,0xcc,0xcc,0xcc,0x52,0xcc,
120  0x04,0xcc,0xcc,0x05,0xcc,0x41,0xcc,0xcc,0x15,0xcc,0xcc,0x16,0xcc,0x52,0xcc,0xcc,
121  0x04,0xcc,0xcc,0xcc,0x41,0xcc,0xcc,0xcc,0x15,0xcc,0xcc,0xcc,0x16,0xcc,0xcc,0xcc,
122  0x04,0xcc,0xcc,0x41,0xcc,0x05,0xcc,0xcc,0x15,0xcc,0xcc,0x52,0xcc,0x16,0xcc,0xcc,
123  0x04,0xcc,0x41,0xcc,0xcc,0xcc,0x05,0xcc,0x15,0xcc,0x52,0xcc,0xcc,0xcc,0x16,0xcc,
124  0x04,0x41,0xcc,0xcc,0xcc,0xcc,0xcc,0x05,0x15,0x52,0xcc,0xcc,0xcc,0xcc,0xcc,0x16,
125  0x44,0x45,0x45,0x45,0x45,0x45,0x45,0x45,0x55,0x56,0x56,0x56,0x56,0x56,0x56,0x56,
126  0x48,0x49,0xcc,0xcc,0xcc,0xcc,0xcc,0x85,0x59,0x5A,0xcc,0xcc,0xcc,0xcc,0xcc,0x96,
127  0x48,0xcc,0x49,0xcc,0xcc,0xcc,0x85,0xcc,0x59,0xcc,0x5A,0xcc,0xcc,0xcc,0x96,0xcc,
128  0x48,0xcc,0xcc,0x49,0xcc,0x85,0xcc,0xcc,0x59,0xcc,0xcc,0x5A,0xcc,0x96,0xcc,0xcc,
129  0x48,0xcc,0xcc,0xcc,0x49,0xcc,0xcc,0xcc,0x59,0xcc,0xcc,0xcc,0x96,0xcc,0xcc,0xcc,
130  0x48,0xcc,0xcc,0x85,0xcc,0x49,0xcc,0xcc,0x59,0xcc,0xcc,0x96,0xcc,0x5A,0xcc,0xcc,
131  0x48,0xcc,0x85,0xcc,0xcc,0xcc,0x49,0xcc,0x59,0xcc,0x96,0xcc,0xcc,0xcc,0x5A,0xcc,
132  0x48,0x85,0xcc,0xcc,0xcc,0xcc,0xcc,0x49,0x59,0x96,0xcc,0xcc,0xcc,0xcc,0xcc,0x5A,
133  };
134 
135  static const uint8_t needs[16]={
136  0,1,0,0,
137  2,4,2,0,
138  0,1,0,0,
139  15
140  };
141 
142  int x, y, b, r, l;
143  int16_t tmpIt [64*(32+HTAPS_MAX)];
144  uint8_t tmp2t[3][64*(32+HTAPS_MAX)];
145  int16_t *tmpI= tmpIt;
146  uint8_t *tmp2= tmp2t[0];
147  const uint8_t *hpel[11];
148  av_assert2(dx<16 && dy<16);
149  r= brane[dx + 16*dy]&15;
150  l= brane[dx + 16*dy]>>4;
151 
152  b= needs[l] | needs[r];
153  if(p && !p->diag_mc)
154  b= 15;
155 
156  if(b&5){
157  for(y=0; y < b_h+HTAPS_MAX-1; y++){
158  for(x=0; x < b_w; x++){
159  int a_1=src[x + HTAPS_MAX/2-4];
160  int a0= src[x + HTAPS_MAX/2-3];
161  int a1= src[x + HTAPS_MAX/2-2];
162  int a2= src[x + HTAPS_MAX/2-1];
163  int a3= src[x + HTAPS_MAX/2+0];
164  int a4= src[x + HTAPS_MAX/2+1];
165  int a5= src[x + HTAPS_MAX/2+2];
166  int a6= src[x + HTAPS_MAX/2+3];
167  int am=0;
168  if(!p || p->fast_mc){
169  am= 20*(a2+a3) - 5*(a1+a4) + (a0+a5);
170  tmpI[x]= am;
171  am= (am+16)>>5;
172  }else{
173  am= p->hcoeff[0]*(a2+a3) + p->hcoeff[1]*(a1+a4) + p->hcoeff[2]*(a0+a5) + p->hcoeff[3]*(a_1+a6);
174  tmpI[x]= am;
175  am= (am+32)>>6;
176  }
177 
178  if(am&(~255)) am= ~(am>>31);
179  tmp2[x]= am;
180  }
181  tmpI+= 64;
182  tmp2+= 64;
183  src += stride;
184  }
185  src -= stride*y;
186  }
187  src += HTAPS_MAX/2 - 1;
188  tmp2= tmp2t[1];
189 
190  if(b&2){
191  for(y=0; y < b_h; y++){
192  for(x=0; x < b_w+1; x++){
193  int a_1=src[x + (HTAPS_MAX/2-4)*stride];
194  int a0= src[x + (HTAPS_MAX/2-3)*stride];
195  int a1= src[x + (HTAPS_MAX/2-2)*stride];
196  int a2= src[x + (HTAPS_MAX/2-1)*stride];
197  int a3= src[x + (HTAPS_MAX/2+0)*stride];
198  int a4= src[x + (HTAPS_MAX/2+1)*stride];
199  int a5= src[x + (HTAPS_MAX/2+2)*stride];
200  int a6= src[x + (HTAPS_MAX/2+3)*stride];
201  int am=0;
202  if(!p || p->fast_mc)
203  am= (20*(a2+a3) - 5*(a1+a4) + (a0+a5) + 16)>>5;
204  else
205  am= (p->hcoeff[0]*(a2+a3) + p->hcoeff[1]*(a1+a4) + p->hcoeff[2]*(a0+a5) + p->hcoeff[3]*(a_1+a6) + 32)>>6;
206 
207  if(am&(~255)) am= ~(am>>31);
208  tmp2[x]= am;
209  }
210  src += stride;
211  tmp2+= 64;
212  }
213  src -= stride*y;
214  }
215  src += stride*(HTAPS_MAX/2 - 1);
216  tmp2= tmp2t[2];
217  tmpI= tmpIt;
218  if(b&4){
219  for(y=0; y < b_h; y++){
220  for(x=0; x < b_w; x++){
221  int a_1=tmpI[x + (HTAPS_MAX/2-4)*64];
222  int a0= tmpI[x + (HTAPS_MAX/2-3)*64];
223  int a1= tmpI[x + (HTAPS_MAX/2-2)*64];
224  int a2= tmpI[x + (HTAPS_MAX/2-1)*64];
225  int a3= tmpI[x + (HTAPS_MAX/2+0)*64];
226  int a4= tmpI[x + (HTAPS_MAX/2+1)*64];
227  int a5= tmpI[x + (HTAPS_MAX/2+2)*64];
228  int a6= tmpI[x + (HTAPS_MAX/2+3)*64];
229  int am=0;
230  if(!p || p->fast_mc)
231  am= (20*(a2+a3) - 5*(a1+a4) + (a0+a5) + 512)>>10;
232  else
233  am= (p->hcoeff[0]*(a2+a3) + p->hcoeff[1]*(a1+a4) + p->hcoeff[2]*(a0+a5) + p->hcoeff[3]*(a_1+a6) + 2048)>>12;
234  if(am&(~255)) am= ~(am>>31);
235  tmp2[x]= am;
236  }
237  tmpI+= 64;
238  tmp2+= 64;
239  }
240  }
241 
242  hpel[ 0]= src;
243  hpel[ 1]= tmp2t[0] + 64*(HTAPS_MAX/2-1);
244  hpel[ 2]= src + 1;
245 
246  hpel[ 4]= tmp2t[1];
247  hpel[ 5]= tmp2t[2];
248  hpel[ 6]= tmp2t[1] + 1;
249 
250  hpel[ 8]= src + stride;
251  hpel[ 9]= hpel[1] + 64;
252  hpel[10]= hpel[8] + 1;
253 
254 #define MC_STRIDE(x) (needs[x] ? 64 : stride)
255 
256  if(b==15){
257  int dxy = dx / 8 + dy / 8 * 4;
258  const uint8_t *src1 = hpel[dxy ];
259  const uint8_t *src2 = hpel[dxy + 1];
260  const uint8_t *src3 = hpel[dxy + 4];
261  const uint8_t *src4 = hpel[dxy + 5];
262  int stride1 = MC_STRIDE(dxy);
263  int stride2 = MC_STRIDE(dxy + 1);
264  int stride3 = MC_STRIDE(dxy + 4);
265  int stride4 = MC_STRIDE(dxy + 5);
266  dx&=7;
267  dy&=7;
268  for(y=0; y < b_h; y++){
269  for(x=0; x < b_w; x++){
270  dst[x]= ((8-dx)*(8-dy)*src1[x] + dx*(8-dy)*src2[x]+
271  (8-dx)* dy *src3[x] + dx* dy *src4[x]+32)>>6;
272  }
273  src1+=stride1;
274  src2+=stride2;
275  src3+=stride3;
276  src4+=stride4;
277  dst +=stride;
278  }
279  }else{
280  const uint8_t *src1= hpel[l];
281  const uint8_t *src2= hpel[r];
282  int stride1 = MC_STRIDE(l);
283  int stride2 = MC_STRIDE(r);
284  int a= weight[((dx&7) + (8*(dy&7)))];
285  int b= 8-a;
286  for(y=0; y < b_h; y++){
287  for(x=0; x < b_w; x++){
288  dst[x]= (a*src1[x] + b*src2[x] + 4)>>3;
289  }
290  src1+=stride1;
291  src2+=stride2;
292  dst +=stride;
293  }
294  }
295 }
296 
297 void ff_snow_pred_block(SnowContext *s, uint8_t *dst, uint8_t *tmp, int stride, int sx, int sy, int b_w, int b_h, BlockNode *block, int plane_index, int w, int h){
298  if(block->type & BLOCK_INTRA){
299  int x, y;
300  const unsigned color = block->color[plane_index];
301  const unsigned color4 = color*0x01010101;
302  if(b_w==32){
303  for(y=0; y < b_h; y++){
304  *(uint32_t*)&dst[0 + y*stride]= color4;
305  *(uint32_t*)&dst[4 + y*stride]= color4;
306  *(uint32_t*)&dst[8 + y*stride]= color4;
307  *(uint32_t*)&dst[12+ y*stride]= color4;
308  *(uint32_t*)&dst[16+ y*stride]= color4;
309  *(uint32_t*)&dst[20+ y*stride]= color4;
310  *(uint32_t*)&dst[24+ y*stride]= color4;
311  *(uint32_t*)&dst[28+ y*stride]= color4;
312  }
313  }else if(b_w==16){
314  for(y=0; y < b_h; y++){
315  *(uint32_t*)&dst[0 + y*stride]= color4;
316  *(uint32_t*)&dst[4 + y*stride]= color4;
317  *(uint32_t*)&dst[8 + y*stride]= color4;
318  *(uint32_t*)&dst[12+ y*stride]= color4;
319  }
320  }else if(b_w==8){
321  for(y=0; y < b_h; y++){
322  *(uint32_t*)&dst[0 + y*stride]= color4;
323  *(uint32_t*)&dst[4 + y*stride]= color4;
324  }
325  }else if(b_w==4){
326  for(y=0; y < b_h; y++){
327  *(uint32_t*)&dst[0 + y*stride]= color4;
328  }
329  }else{
330  for(y=0; y < b_h; y++){
331  for(x=0; x < b_w; x++){
332  dst[x + y*stride]= color;
333  }
334  }
335  }
336  }else{
337  uint8_t *src= s->last_picture[block->ref].data[plane_index];
338  const int scale= plane_index ? (2*s->mv_scale)>>s->chroma_h_shift : 2*s->mv_scale;
339  int mx= block->mx*scale;
340  int my= block->my*scale;
341  const int dx= mx&15;
342  const int dy= my&15;
343  const int tab_index= 3 - (b_w>>2) + (b_w>>4);
344  sx += (mx>>4) - (HTAPS_MAX/2-1);
345  sy += (my>>4) - (HTAPS_MAX/2-1);
346  src += sx + sy*stride;
347  if( (unsigned)sx >= FFMAX(w - b_w - (HTAPS_MAX-2), 0)
348  || (unsigned)sy >= FFMAX(h - b_h - (HTAPS_MAX-2), 0)){
349  s->vdsp.emulated_edge_mc(tmp + MB_SIZE, src, stride, b_w+HTAPS_MAX-1, b_h+HTAPS_MAX-1, sx, sy, w, h);
350  src= tmp + MB_SIZE;
351  }
352 
353  av_assert2(s->chroma_h_shift == s->chroma_v_shift); // only one mv_scale
354 
355  av_assert2(b_w>1 && b_h>1);
356  av_assert2((tab_index>=0 && tab_index<4) || b_w==32);
357  if((dx&3) || (dy&3) || !(b_w == b_h || 2*b_w == b_h || b_w == 2*b_h) || (b_w&(b_w-1)) || !s->plane[plane_index].fast_mc )
358  mc_block(&s->plane[plane_index], dst, src, stride, b_w, b_h, dx, dy);
359  else if(b_w==32){
360  int y;
361  for(y=0; y<b_h; y+=16){
362  s->h264qpel.put_h264_qpel_pixels_tab[0][dy+(dx>>2)](dst + y*stride, src + 3 + (y+3)*stride,stride);
363  s->h264qpel.put_h264_qpel_pixels_tab[0][dy+(dx>>2)](dst + 16 + y*stride, src + 19 + (y+3)*stride,stride);
364  }
365  }else if(b_w==b_h)
366  s->h264qpel.put_h264_qpel_pixels_tab[tab_index ][dy+(dx>>2)](dst,src + 3 + 3*stride,stride);
367  else if(b_w==2*b_h){
368  s->h264qpel.put_h264_qpel_pixels_tab[tab_index+1][dy+(dx>>2)](dst ,src + 3 + 3*stride,stride);
369  s->h264qpel.put_h264_qpel_pixels_tab[tab_index+1][dy+(dx>>2)](dst+b_h,src + 3 + b_h + 3*stride,stride);
370  }else{
371  av_assert2(2*b_w==b_h);
372  s->h264qpel.put_h264_qpel_pixels_tab[tab_index ][dy+(dx>>2)](dst ,src + 3 + 3*stride ,stride);
373  s->h264qpel.put_h264_qpel_pixels_tab[tab_index ][dy+(dx>>2)](dst+b_w*stride,src + 3 + 3*stride+b_w*stride,stride);
374  }
375  }
376 }
377 
378 #define mca(dx,dy,b_w)\
379 static void mc_block_hpel ## dx ## dy ## b_w(uint8_t *dst, const uint8_t *src, ptrdiff_t stride, int h){\
380  av_assert2(h==b_w);\
381  mc_block(NULL, dst, src-(HTAPS_MAX/2-1)-(HTAPS_MAX/2-1)*stride, stride, b_w, b_w, dx, dy);\
382 }
383 
384 mca( 0, 0,16)
385 mca( 8, 0,16)
386 mca( 0, 8,16)
387 mca( 8, 8,16)
388 mca( 0, 0,8)
389 mca( 8, 0,8)
390 mca( 0, 8,8)
391 mca( 8, 8,8)
392 
394  SnowContext *s = avctx->priv_data;
395  int width, height;
396  int i, j;
397 
398  s->avctx= avctx;
399  s->max_ref_frames=1; //just make sure it's not an invalid value in case of no initial keyframe
400 
401  ff_dsputil_init(&s->dsp, avctx);
402  ff_hpeldsp_init(&s->hdsp, avctx->flags);
403  ff_videodsp_init(&s->vdsp, 8);
404  ff_dwt_init(&s->dwt);
405  ff_h264qpel_init(&s->h264qpel, 8);
406 
407 #define mcf(dx,dy)\
408  s->dsp.put_qpel_pixels_tab [0][dy+dx/4]=\
409  s->dsp.put_no_rnd_qpel_pixels_tab[0][dy+dx/4]=\
410  s->h264qpel.put_h264_qpel_pixels_tab[0][dy+dx/4];\
411  s->dsp.put_qpel_pixels_tab [1][dy+dx/4]=\
412  s->dsp.put_no_rnd_qpel_pixels_tab[1][dy+dx/4]=\
413  s->h264qpel.put_h264_qpel_pixels_tab[1][dy+dx/4];
414 
415  mcf( 0, 0)
416  mcf( 4, 0)
417  mcf( 8, 0)
418  mcf(12, 0)
419  mcf( 0, 4)
420  mcf( 4, 4)
421  mcf( 8, 4)
422  mcf(12, 4)
423  mcf( 0, 8)
424  mcf( 4, 8)
425  mcf( 8, 8)
426  mcf(12, 8)
427  mcf( 0,12)
428  mcf( 4,12)
429  mcf( 8,12)
430  mcf(12,12)
431 
432 #define mcfh(dx,dy)\
433  s->hdsp.put_pixels_tab [0][dy/4+dx/8]=\
434  s->hdsp.put_no_rnd_pixels_tab[0][dy/4+dx/8]=\
435  mc_block_hpel ## dx ## dy ## 16;\
436  s->hdsp.put_pixels_tab [1][dy/4+dx/8]=\
437  s->hdsp.put_no_rnd_pixels_tab[1][dy/4+dx/8]=\
438  mc_block_hpel ## dx ## dy ## 8;
439 
440  mcfh(0, 0)
441  mcfh(8, 0)
442  mcfh(0, 8)
443  mcfh(8, 8)
444 
445  init_qexp();
446 
447 // dec += FFMAX(s->chroma_h_shift, s->chroma_v_shift);
448 
449  width= s->avctx->width;
450  height= s->avctx->height;
451 
452  FF_ALLOCZ_OR_GOTO(avctx, s->spatial_idwt_buffer, width * height * sizeof(IDWTELEM), fail);
453  FF_ALLOCZ_OR_GOTO(avctx, s->spatial_dwt_buffer, width * height * sizeof(DWTELEM), fail); //FIXME this does not belong here
454  FF_ALLOCZ_OR_GOTO(avctx, s->temp_dwt_buffer, width * sizeof(DWTELEM), fail);
455  FF_ALLOCZ_OR_GOTO(avctx, s->temp_idwt_buffer, width * sizeof(IDWTELEM), fail);
456  FF_ALLOC_OR_GOTO(avctx, s->run_buffer, ((width + 1) >> 1) * ((height + 1) >> 1) * sizeof(*s->run_buffer), fail);
457 
458  for(i=0; i<MAX_REF_FRAMES; i++) {
459  for(j=0; j<MAX_REF_FRAMES; j++)
460  ff_scale_mv_ref[i][j] = 256*(i+1)/(j+1);
462  }
463 
466 
467  return 0;
468 fail:
469  return AVERROR(ENOMEM);
470 }
471 
473  SnowContext *s = avctx->priv_data;
474  int plane_index, level, orientation;
475  int ret, emu_buf_size;
476 
477  if(!s->scratchbuf) {
478  if ((ret = ff_get_buffer(s->avctx, &s->mconly_picture,
480  return ret;
481  FF_ALLOCZ_OR_GOTO(avctx, s->scratchbuf, FFMAX(s->mconly_picture.linesize[0], 2*avctx->width+256)*7*MB_SIZE, fail);
482  emu_buf_size = FFMAX(s->mconly_picture.linesize[0], 2*avctx->width+256) * (2 * MB_SIZE + HTAPS_MAX - 1);
483  FF_ALLOC_OR_GOTO(avctx, s->emu_edge_buffer, emu_buf_size, fail);
484  }
485 
486  if(s->mconly_picture.format != avctx->pix_fmt) {
487  av_log(avctx, AV_LOG_ERROR, "pixel format changed\n");
488  return AVERROR_INVALIDDATA;
489  }
490 
491  for(plane_index=0; plane_index<3; plane_index++){
492  int w= s->avctx->width;
493  int h= s->avctx->height;
494 
495  if(plane_index){
496  w>>= s->chroma_h_shift;
497  h>>= s->chroma_v_shift;
498  }
499  s->plane[plane_index].width = w;
500  s->plane[plane_index].height= h;
501 
502  for(level=s->spatial_decomposition_count-1; level>=0; level--){
503  for(orientation=level ? 1 : 0; orientation<4; orientation++){
504  SubBand *b= &s->plane[plane_index].band[level][orientation];
505 
506  b->buf= s->spatial_dwt_buffer;
507  b->level= level;
508  b->stride= s->plane[plane_index].width << (s->spatial_decomposition_count - level);
509  b->width = (w + !(orientation&1))>>1;
510  b->height= (h + !(orientation>1))>>1;
511 
513  b->buf_x_offset = 0;
514  b->buf_y_offset = 0;
515 
516  if(orientation&1){
517  b->buf += (w+1)>>1;
518  b->buf_x_offset = (w+1)>>1;
519  }
520  if(orientation>1){
521  b->buf += b->stride>>1;
522  b->buf_y_offset = b->stride_line >> 1;
523  }
524  b->ibuf= s->spatial_idwt_buffer + (b->buf - s->spatial_dwt_buffer);
525 
526  if(level)
527  b->parent= &s->plane[plane_index].band[level-1][orientation];
528  //FIXME avoid this realloc
529  av_freep(&b->x_coeff);
530  b->x_coeff=av_mallocz(((b->width+1) * b->height+1)*sizeof(x_and_coeff));
531  }
532  w= (w+1)>>1;
533  h= (h+1)>>1;
534  }
535  }
536 
537  return 0;
538 fail:
539  return AVERROR(ENOMEM);
540 }
541 
542 #define USE_HALFPEL_PLANE 0
543 
544 static void halfpel_interpol(SnowContext *s, uint8_t *halfpel[4][4], AVFrame *frame){
545  int p,x,y;
546 
547  for(p=0; p<3; p++){
548  int is_chroma= !!p;
549  int w= is_chroma ? s->avctx->width >>s->chroma_h_shift : s->avctx->width;
550  int h= is_chroma ? s->avctx->height>>s->chroma_v_shift : s->avctx->height;
551  int ls= frame->linesize[p];
552  uint8_t *src= frame->data[p];
553 
554  halfpel[1][p] = (uint8_t*) av_malloc(ls * (h + 2 * EDGE_WIDTH)) + EDGE_WIDTH * (1 + ls);
555  halfpel[2][p] = (uint8_t*) av_malloc(ls * (h + 2 * EDGE_WIDTH)) + EDGE_WIDTH * (1 + ls);
556  halfpel[3][p] = (uint8_t*) av_malloc(ls * (h + 2 * EDGE_WIDTH)) + EDGE_WIDTH * (1 + ls);
557 
558  halfpel[0][p]= src;
559  for(y=0; y<h; y++){
560  for(x=0; x<w; x++){
561  int i= y*ls + x;
562 
563  halfpel[1][p][i]= (20*(src[i] + src[i+1]) - 5*(src[i-1] + src[i+2]) + (src[i-2] + src[i+3]) + 16 )>>5;
564  }
565  }
566  for(y=0; y<h; y++){
567  for(x=0; x<w; x++){
568  int i= y*ls + x;
569 
570  halfpel[2][p][i]= (20*(src[i] + src[i+ls]) - 5*(src[i-ls] + src[i+2*ls]) + (src[i-2*ls] + src[i+3*ls]) + 16 )>>5;
571  }
572  }
573  src= halfpel[1][p];
574  for(y=0; y<h; y++){
575  for(x=0; x<w; x++){
576  int i= y*ls + x;
577 
578  halfpel[3][p][i]= (20*(src[i] + src[i+ls]) - 5*(src[i-ls] + src[i+2*ls]) + (src[i-2*ls] + src[i+3*ls]) + 16 )>>5;
579  }
580  }
581 
582 //FIXME border!
583  }
584 }
585 
587 {
588  SnowContext *s = avctx->priv_data;
589  int i;
590 
591  if(s->last_picture[s->max_ref_frames-1].data[0]){
593  for(i=0; i<9; i++)
594  if(s->halfpel_plane[s->max_ref_frames-1][1+i/3][i%3])
595  av_free(s->halfpel_plane[s->max_ref_frames-1][1+i/3][i%3] - EDGE_WIDTH*(1+s->current_picture.linesize[i%3]));
596  }
597 }
598 
600  AVFrame tmp;
601  int i, ret;
602  int w= s->avctx->width; //FIXME round up to x16 ?
603  int h= s->avctx->height;
604 
605  if (s->current_picture.data[0] && !(s->avctx->flags&CODEC_FLAG_EMU_EDGE)) {
607  s->current_picture.linesize[0], w , h ,
615  }
616 
618 
620  for(i=s->max_ref_frames-1; i>0; i--)
621  av_frame_move_ref(&s->last_picture[i+1], &s->last_picture[i]);
622  memmove(s->halfpel_plane+1, s->halfpel_plane, (s->max_ref_frames-1)*sizeof(void*)*4*4);
627 
628  if(s->keyframe){
629  s->ref_frames= 0;
630  }else{
631  int i;
632  for(i=0; i<s->max_ref_frames && s->last_picture[i].data[0]; i++)
633  if(i && s->last_picture[i-1].key_frame)
634  break;
635  s->ref_frames= i;
636  if(s->ref_frames==0){
637  av_log(s->avctx,AV_LOG_ERROR, "No reference frames\n");
638  return -1;
639  }
640  }
641 
642  if ((ret = ff_get_buffer(s->avctx, &s->current_picture, AV_GET_BUFFER_FLAG_REF)) < 0)
643  return ret;
644 
646 
647  return 0;
648 }
649 
651 {
652  int plane_index, level, orientation, i;
653 
658  av_freep(&s->run_buffer);
659 
660  s->m.me.temp= NULL;
661  av_freep(&s->m.me.scratchpad);
662  av_freep(&s->m.me.map);
663  av_freep(&s->m.me.score_map);
665 
666  av_freep(&s->block);
667  av_freep(&s->scratchbuf);
669 
670  for(i=0; i<MAX_REF_FRAMES; i++){
671  av_freep(&s->ref_mvs[i]);
672  av_freep(&s->ref_scores[i]);
673  if(s->last_picture[i].data[0]) {
674  av_assert0(s->last_picture[i].data[0] != s->current_picture.data[0]);
676  }
677  }
678 
679  for(plane_index=0; plane_index<3; plane_index++){
680  for(level=s->spatial_decomposition_count-1; level>=0; level--){
681  for(orientation=level ? 1 : 0; orientation<4; orientation++){
682  SubBand *b= &s->plane[plane_index].band[level][orientation];
683 
684  av_freep(&b->x_coeff);
685  }
686  }
687  }
690 }
uint8_t * scratchpad
data area for the ME algo, so that the ME does not need to malloc/free
Definition: mpegvideo.h:190
MpegEncContext m
Definition: snow.h:171
int mv_scale
Definition: snow.h:153
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:205
int ff_snow_frame_start(SnowContext *s)
Definition: snow.c:599
av_cold void ff_dsputil_init(DSPContext *c, AVCodecContext *avctx)
Definition: dsputil.c:2675
float v
const char * s
Definition: avisynth_c.h:668
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
AVCodecContext * avctx
Definition: snow.h:110
int block_max_depth
Definition: snow.h:160
int chroma_v_shift
Definition: snow.h:146
This structure describes decoded (raw) audio or video data.
Definition: frame.h:76
void ff_snow_inner_add_yblock(const uint8_t *obmc, const int obmc_stride, uint8_t **block, int b_w, int b_h, int src_x, int src_y, int src_stride, slice_buffer *sb, int add, uint8_t *dst8)
Definition: snow.c:36
int * run_buffer
Definition: snow.h:143
#define EDGE_TOP
Definition: dsputil.h:265
#define BLOCK_INTRA
Definition: snow.h:52
#define a0
Definition: regdef.h:46
Range coder.
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
FFmpeg Automated Testing Environment ************************************Table of Contents *****************FFmpeg Automated Testing Environment Introduction Using FATE from your FFmpeg source directory Submitting the results to the FFmpeg result aggregation server FATE makefile targets and variables Makefile targets Makefile variables Examples Introduction **************FATE is an extended regression suite on the client side and a means for results aggregation and presentation on the server side The first part of this document explains how you can use FATE from your FFmpeg source directory to test your ffmpeg binary The second part describes how you can run FATE to submit the results to FFmpeg s FATE server In any way you can have a look at the publicly viewable FATE results by visiting this as it can be seen if some test on some platform broke with their recent contribution This usually happens on the platforms the developers could not test on The second part of this document describes how you can run FATE to submit your results to FFmpeg s FATE server If you want to submit your results be sure to check that your combination of OS and compiler is not already listed on the above mentioned website In the third part you can find a comprehensive listing of FATE makefile targets and variables Using FATE from your FFmpeg source directory **********************************************If you want to run FATE on your machine you need to have the samples in place You can get the samples via the build target fate rsync Use this command from the top level source this will cause FATE to fail NOTE To use a custom wrapper to run the pass target exec to configure or set the TARGET_EXEC Make variable Submitting the results to the FFmpeg result aggregation server ****************************************************************To submit your results to the server you should run fate through the shell script tests fate sh from the FFmpeg sources This script needs to be invoked with a configuration file as its first argument tests fate sh path to fate_config A configuration file template with comments describing the individual configuration variables can be found at doc fate_config sh template Create a configuration that suits your needs
Definition: fate.txt:34
#define mcf(dx, dy)
#define a1
Definition: regdef.h:47
int max_ref_frames
Definition: snow.h:135
uint32_t * score_map
map to store the scores
Definition: mpegvideo.h:196
static const uint8_t obmc4[16]
Definition: snowdata.h:96
int ff_snow_common_init_after_header(AVCodecContext *avctx)
Definition: snow.c:472
int keyframe
Definition: snow.h:126
int stride
Definition: mace.c:144
void ff_snow_reset_contexts(SnowContext *s)
Definition: snow.c:69
short IDWTELEM
Definition: dirac_dwt.h:27
output residual component w
HpelDSPContext hdsp
Definition: snow.h:113
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
Definition: mem.c:198
Definition: snow.h:45
#define HTAPS_MAX
Definition: snow.h:70
uint8_t ref
Definition: snow.h:48
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
#define a3
Definition: regdef.h:49
int b_height
Definition: snow.h:159
uint8_t
int16_t mx
Definition: snow.h:46
#define av_cold
Definition: attributes.h:78
#define FRAC_BITS
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:63
AVOptions.
static const uint32_t color[16+AV_CLASS_CATEGORY_NB]
Definition: log.c:77
uint32_t * ref_scores[MAX_REF_FRAMES]
Definition: snow.h:138
#define b
Definition: input.c:42
#define MB_SIZE
Definition: snow.h:68
AVFrame current_picture
Definition: snow.h:119
void av_frame_move_ref(AVFrame *dst, AVFrame *src)
Move everythnig contained in src to dst and reset src.
Definition: frame.c:352
int16_t my
Definition: snow.h:47
#define lrintf(x)
Definition: libm_mips.h:70
void ff_snow_release_buffer(AVCodecContext *avctx)
Definition: snow.c:586
frame
Definition: stft.m:14
BlockNode * block
Definition: snow.h:163
Discrete Time axis x
#define mca(dx, dy, b_w)
Definition: snow.c:378
SnowDWTContext dwt
Definition: snow.h:116
Used to minimize the amount of memory used in order to optimize cache performance.
Definition: snow_dwt.h:41
void av_free(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc(). ...
Definition: mem.c:183
int16_t(*[MAX_REF_FRAMES] ref_mvs)[2]
Definition: snow.h:137
int diag_mc
Definition: snow.h:100
const char * r
Definition: vf_curves.c:94
#define mcfh(dx, dy)
DSPContext dsp
Definition: snow.h:112
int flags
CODEC_FLAG_*.
void ff_videodsp_init(VideoDSPContext *ctx, int bpc)
Definition: videodsp.c:37
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:246
static void init_qexp(void)
Definition: snow.c:95
#define FFMAX(a, b)
Definition: common.h:56
external API header
qpel_mc_func put_h264_qpel_pixels_tab[4][16]
Definition: h264qpel.h:28
uint8_t * emu_edge_buffer
Definition: snow.h:174
uint8_t color[3]
Definition: snow.h:49
int ref_frames
Definition: snow.h:136
av_cold void ff_hpeldsp_init(HpelDSPContext *c, int flags)
Definition: hpeldsp.c:37
x_and_coeff * x_coeff
Definition: snow.h:88
#define USE_HALFPEL_PLANE
Definition: snow.c:542
static void mc_block(Plane *p, uint8_t *dst, const uint8_t *src, int stride, int b_w, int b_h, int dx, int dy)
Definition: snow.c:104
void(* draw_edges)(uint8_t *buf, int wrap, int width, int height, int w, int h, int sides)
Definition: dsputil.h:263
ret
Definition: avfilter.c:821
static void halfpel_interpol(SnowContext *s, uint8_t *halfpel[4][4], AVFrame *frame)
Definition: snow.c:544
int width
picture width / height.
uint8_t * scratchbuf
Definition: snow.h:173
#define a2
Definition: regdef.h:48
Plane plane[MAX_PLANES]
Definition: snow.h:162
int b_width
Definition: snow.h:158
MotionEstContext me
Definition: mpegvideo.h:437
#define EDGE_BOTTOM
Definition: dsputil.h:266
FIXME Range Coding of cr are level
Definition: snow.txt:367
int chroma_h_shift
Definition: snow.h:145
VideoDSPContext vdsp
Definition: snow.h:114
uint8_t * halfpel_plane[MAX_REF_FRAMES][4][4]
Definition: snow.h:121
SubBand band[MAX_DWT_LEVELS][4]
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: frame.h:134
uint8_t block_state[128+32 *128]
Definition: snow.h:125
NULL
Definition: eval.c:55
int ff_scale_mv_ref[MAX_REF_FRAMES][MAX_REF_FRAMES]
Definition: snowdata.h:129
static int width
Definition: tests/utils.c:158
#define a5
Definition: regdef.h:51
AVS_Value src
Definition: avisynth_c.h:523
#define LOG2_OBMC_MAX
Definition: snow.h:43
int spatial_decomposition_count
Definition: snow.h:132
int DWTELEM
Definition: dirac_dwt.h:26
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:101
main external API structure.
int8_t hcoeff[HTAPS_MAX/2]
Definition: snow.h:99
#define QROOT
Definition: snow.h:38
int ff_snow_alloc_blocks(SnowContext *s)
Definition: snow.c:83
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:148
struct SubBand * parent
BYTE int const BYTE int int int height
Definition: avisynth_c.h:713
void * av_malloc(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:73
void avcodec_get_frame_defaults(AVFrame *frame)
Set the fields of the given AVFrame to default values.
synthesis window for stochastic i
int buf_y_offset
Definition: snow.h:86
DWTELEM * temp_dwt_buffer
Definition: snow.h:140
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:330
uint8_t header_state[32]
Definition: snow.h:124
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFilterBuffer structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Buffer references ownership and permissions
static int weight(int i, int blen, int offset)
int ff_snow_common_init(AVCodecContext *avctx)
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:87
void ff_snow_pred_block(SnowContext *s, uint8_t *dst, uint8_t *tmp, int stride, int sx, int sy, int b_w, int b_h, BlockNode *block, int plane_index, int w, int h)
Definition: snow.c:297
#define MAX_DECOMPOSITIONS
Definition: dirac_dwt.h:30
AVFrame mconly_picture
Definition: snow.h:122
#define CODEC_FLAG_EMU_EDGE
Don&#39;t draw edges.
#define MID_STATE
Definition: snow.h:34
common internal api header.
void ff_h264qpel_init(H264QpelContext *c, int bit_depth)
Definition: h264qpel.c:48
IDWTELEM * temp_idwt_buffer
Definition: snow.h:142
H264QpelContext h264qpel
Definition: snow.h:115
#define FF_ALLOC_OR_GOTO(ctx, p, size, label)
#define slice_buffer_get_line(slice_buf, line_num)
Definition: snow_dwt.h:86
uint8_t * obmc_scratchpad
Definition: mpegvideo.h:366
#define LOG2_MB_SIZE
Definition: snow.h:67
DWTELEM * spatial_dwt_buffer
Definition: snow.h:139
Same thing on a dB scale
function y
Definition: D.m:1
uint8_t state[7+512][32]
Definition: snow.h:90
uint32_t * map
map to avoid duplicate evaluations
Definition: mpegvideo.h:195
IDWTELEM * spatial_idwt_buffer
Definition: snow.h:141
DSP utils.
#define a4
Definition: regdef.h:50
void(* emulated_edge_mc)(uint8_t *buf, const uint8_t *src, ptrdiff_t linesize, int block_w, int block_h, int src_x, int src_y, int w, int h)
Copy a rectangular area of samples to a temporary buffer and replicate the border samples...
Definition: videodsp.h:58
#define MC_STRIDE(x)
int buf_x_offset
Definition: snow.h:85
else dst[i][x+y *dst_stride[i]]
Definition: vf_mcdeint.c:160
#define EDGE_WIDTH
Definition: dsputil.h:264
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:139
IDWTELEM * ibuf
int fast_mc
Definition: snow.h:101
av_cold void ff_snow_common_end(SnowContext *s)
Definition: snow.c:650
uint8_t ff_qexp[QROOT]
Definition: snowdata.h:128
DWTELEM * buf
Definition: snow.h:83
#define MAX_REF_FRAMES
Definition: snow.h:41
uint8_t * temp
Definition: mpegvideo.h:193
uint8_t type
Definition: snow.h:50
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
#define FF_ALLOCZ_OR_GOTO(ctx, p, size, label)
void ff_dwt_init(SnowDWTContext *c)
Definition: snow_dwt.c:855
int stride_line
Stride measured in lines, not pixels.
Definition: snow.h:87
AVFrame last_picture[MAX_REF_FRAMES]
Definition: snow.h:120