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 
83 int ff_snow_alloc_blocks(SnowContext *s){
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 
393 av_cold int ff_snow_common_init(AVCodecContext *avctx){
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);
461  avcodec_get_frame_defaults(&s->last_picture[i]);
462  }
463 
464  avcodec_get_frame_defaults(&s->mconly_picture);
465  avcodec_get_frame_defaults(&s->current_picture);
466 
467  return 0;
468 fail:
469  return AVERROR(ENOMEM);
470 }
471 
472 int ff_snow_common_init_after_header(AVCodecContext *avctx) {
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,
479  AV_GET_BUFFER_FLAG_REF)) < 0)
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 
512  b->stride_line = 1 << (s->spatial_decomposition_count - level);
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 
586 void ff_snow_release_buffer(AVCodecContext *avctx)
587 {
588  SnowContext *s = avctx->priv_data;
589  int i;
590 
591  if(s->last_picture[s->max_ref_frames-1].data[0]){
592  av_frame_unref(&s->last_picture[s->max_ref_frames-1]);
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 
599 int ff_snow_frame_start(SnowContext *s){
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)) {
606  s->dsp.draw_edges(s->current_picture.data[0],
607  s->current_picture.linesize[0], w , h ,
608  EDGE_WIDTH , EDGE_WIDTH , EDGE_TOP | EDGE_BOTTOM);
609  s->dsp.draw_edges(s->current_picture.data[1],
610  s->current_picture.linesize[1], w>>s->chroma_h_shift, h>>s->chroma_v_shift,
611  EDGE_WIDTH>>s->chroma_h_shift, EDGE_WIDTH>>s->chroma_v_shift, EDGE_TOP | EDGE_BOTTOM);
612  s->dsp.draw_edges(s->current_picture.data[2],
613  s->current_picture.linesize[2], w>>s->chroma_h_shift, h>>s->chroma_v_shift,
614  EDGE_WIDTH>>s->chroma_h_shift, EDGE_WIDTH>>s->chroma_v_shift, EDGE_TOP | EDGE_BOTTOM);
615  }
616 
617  ff_snow_release_buffer(s->avctx);
618 
619  av_frame_move_ref(&tmp, &s->last_picture[s->max_ref_frames-1]);
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);
623  if(USE_HALFPEL_PLANE && s->current_picture.data[0])
624  halfpel_interpol(s, s->halfpel_plane[0], &s->current_picture);
625  av_frame_move_ref(&s->last_picture[0], &s->current_picture);
626  av_frame_move_ref(&s->current_picture, &tmp);
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 
645  s->current_picture.key_frame= s->keyframe;
646 
647  return 0;
648 }
649 
650 av_cold void ff_snow_common_end(SnowContext *s)
651 {
652  int plane_index, level, orientation, i;
653 
654  av_freep(&s->spatial_dwt_buffer);
655  av_freep(&s->temp_dwt_buffer);
656  av_freep(&s->spatial_idwt_buffer);
657  av_freep(&s->temp_idwt_buffer);
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);
664  av_freep(&s->m.obmc_scratchpad);
665 
666  av_freep(&s->block);
667  av_freep(&s->scratchbuf);
668  av_freep(&s->emu_edge_buffer);
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]);
675  av_frame_unref(&s->last_picture[i]);
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  }
688  av_frame_unref(&s->mconly_picture);
689  av_frame_unref(&s->current_picture);
690 }
MotionEstContext::scratchpad
uint8_t * scratchpad
data area for the ME algo, so that the ME does not need to malloc/free
Definition: mpegvideo.h:190
SnowContext::m
MpegEncContext m
Definition: snow.h:171
SnowContext::mv_scale
int mv_scale
Definition: snow.h:153
av_mallocz
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
ff_snow_frame_start
int ff_snow_frame_start(SnowContext *s)
Definition: snow.c:599
ff_dsputil_init
av_cold void ff_dsputil_init(DSPContext *c, AVCodecContext *avctx)
Definition: dsputil.c:2675
v
float v
Definition: avf_showspectrum.c:88
s
const char * s
Definition: avisynth_c.h:668
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
SnowContext::avctx
AVCodecContext * avctx
Definition: snow.h:110
SnowContext::block_max_depth
int block_max_depth
Definition: snow.h:160
SnowContext::chroma_v_shift
int chroma_v_shift
Definition: snow.h:146
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:76
ff_snow_inner_add_yblock
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
SnowContext::run_buffer
int * run_buffer
Definition: snow.h:143
EDGE_TOP
#define EDGE_TOP
Definition: dsputil.h:265
BLOCK_INTRA
#define BLOCK_INTRA
Definition: snow.h:52
a0
#define a0
Definition: regdef.h:46
rangecoder.h
Range coder.
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: libavcodec/avcodec.h:1330
needs
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
mcf
#define mcf(dx, dy)
a1
#define a1
Definition: regdef.h:47
SnowContext::max_ref_frames
int max_ref_frames
Definition: snow.h:135
MotionEstContext::score_map
uint32_t * score_map
map to store the scores
Definition: mpegvideo.h:196
obmc4
static const uint8_t obmc4[16]
Definition: snowdata.h:96
ff_snow_common_init_after_header
int ff_snow_common_init_after_header(AVCodecContext *avctx)
Definition: snow.c:472
SnowContext::keyframe
int keyframe
Definition: snow.h:126
stride
int stride
Definition: mace.c:144
ff_snow_reset_contexts
void ff_snow_reset_contexts(SnowContext *s)
Definition: snow.c:69
IDWTELEM
short IDWTELEM
Definition: dirac_dwt.h:27
w
output residual component w
Definition: code Kat/hpsmodel.m:23
SnowContext::hdsp
HpelDSPContext hdsp
Definition: snow.h:113
av_freep
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
BlockNode
Definition: snow.h:45
HTAPS_MAX
#define HTAPS_MAX
Definition: snow.h:70
BlockNode::ref
uint8_t ref
Definition: snow.h:48
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
a3
#define a3
Definition: regdef.h:49
SnowContext::b_height
int b_height
Definition: snow.h:159
uint8_t
uint8_t
Definition: audio_convert.c:194
BlockNode::mx
int16_t mx
Definition: snow.h:46
av_cold
#define av_cold
Definition: attributes.h:78
FRAC_BITS
#define FRAC_BITS
Definition: g729postfilter.c:33
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:63
opt.h
AVOptions.
color
static const uint32_t color[16+AV_CLASS_CATEGORY_NB]
Definition: log.c:77
SnowContext::ref_scores
uint32_t * ref_scores[MAX_REF_FRAMES]
Definition: snow.h:138
b
#define b
Definition: input.c:42
MB_SIZE
#define MB_SIZE
Definition: snow.h:68
SnowContext::current_picture
AVFrame current_picture
Definition: snow.h:119
av_frame_move_ref
void av_frame_move_ref(AVFrame *dst, AVFrame *src)
Move everythnig contained in src to dst and reset src.
Definition: frame.c:352
BlockNode::my
int16_t my
Definition: snow.h:47
snow_dwt.h
lrintf
#define lrintf(x)
Definition: libm_mips.h:70
ff_snow_release_buffer
void ff_snow_release_buffer(AVCodecContext *avctx)
Definition: snow.c:586
frame
frame
Definition: stft.m:14
SnowContext::block
BlockNode * block
Definition: snow.h:163
x
Discrete Time axis x
Definition: FFT of a Simple Sinusoid.m:10
mca
#define mca(dx, dy, b_w)
Definition: snow.c:378
SnowContext::dwt
SnowDWTContext dwt
Definition: snow.h:116
slice_buffer_s
Used to minimize the amount of memory used in order to optimize cache performance.
Definition: snow_dwt.h:41
av_free
void av_free(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc(). ...
Definition: mem.c:183
SnowContext::ref_mvs
int16_t(*[MAX_REF_FRAMES] ref_mvs)[2]
Definition: snow.h:137
Plane::diag_mc
int diag_mc
Definition: snow.h:100
r
const char * r
Definition: vf_curves.c:94
mcfh
#define mcfh(dx, dy)
SnowContext::dsp
DSPContext dsp
Definition: snow.h:112
AVCodecContext::flags
int flags
CODEC_FLAG_*.
Definition: libavcodec/avcodec.h:1222
ff_videodsp_init
void ff_videodsp_init(VideoDSPContext *ctx, int bpc)
Definition: videodsp.c:37
av_log
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:246
init_qexp
static void init_qexp(void)
Definition: snow.c:95
FFMAX
#define FFMAX(a, b)
Definition: common.h:56
avcodec.h
external API header
H264QpelContext::put_h264_qpel_pixels_tab
qpel_mc_func put_h264_qpel_pixels_tab[4][16]
Definition: h264qpel.h:28
SnowContext::emu_edge_buffer
uint8_t * emu_edge_buffer
Definition: snow.h:174
BlockNode::color
uint8_t color[3]
Definition: snow.h:49
SnowContext::ref_frames
int ref_frames
Definition: snow.h:136
ff_hpeldsp_init
av_cold void ff_hpeldsp_init(HpelDSPContext *c, int flags)
Definition: hpeldsp.c:37
SubBand::x_coeff
x_and_coeff * x_coeff
Definition: snow.h:88
USE_HALFPEL_PLANE
#define USE_HALFPEL_PLANE
Definition: snow.c:542
mc_block
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
DSPContext::draw_edges
void(* draw_edges)(uint8_t *buf, int wrap, int width, int height, int w, int h, int sides)
Definition: dsputil.h:263
ret
ret
Definition: avfilter.c:821
halfpel_interpol
static void halfpel_interpol(SnowContext *s, uint8_t *halfpel[4][4], AVFrame *frame)
Definition: snow.c:544
AVCodecContext::width
int width
picture width / height.
Definition: libavcodec/avcodec.h:1302
SnowContext::scratchbuf
uint8_t * scratchbuf
Definition: snow.h:173
a2
#define a2
Definition: regdef.h:48
SnowContext::plane
Plane plane[MAX_PLANES]
Definition: snow.h:162
SnowContext::b_width
int b_width
Definition: snow.h:158
MpegEncContext::me
MotionEstContext me
Definition: mpegvideo.h:437
EDGE_BOTTOM
#define EDGE_BOTTOM
Definition: dsputil.h:266
level
FIXME Range Coding of cr are level
Definition: snow.txt:367
SnowContext::chroma_h_shift
int chroma_h_shift
Definition: snow.h:145
SnowContext::vdsp
VideoDSPContext vdsp
Definition: snow.h:114
SnowContext::halfpel_plane
uint8_t * halfpel_plane[MAX_REF_FRAMES][4][4]
Definition: snow.h:121
Plane::band
SubBand band[MAX_DWT_LEVELS][4]
Definition: libavcodec/diracdec.c:134
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: frame.h:134
SnowContext::block_state
uint8_t block_state[128+32 *128]
Definition: snow.h:125
NULL
NULL
Definition: eval.c:55
ff_scale_mv_ref
int ff_scale_mv_ref[MAX_REF_FRAMES][MAX_REF_FRAMES]
Definition: snowdata.h:129
width
static int width
Definition: tests/utils.c:158
a5
#define a5
Definition: regdef.h:51
src
AVS_Value src
Definition: avisynth_c.h:523
LOG2_OBMC_MAX
#define LOG2_OBMC_MAX
Definition: snow.h:43
SnowContext::spatial_decomposition_count
int spatial_decomposition_count
Definition: snow.h:132
DWTELEM
int DWTELEM
Definition: dirac_dwt.h:26
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:101
AVCodecContext
main external API structure.
Definition: libavcodec/avcodec.h:1134
Plane::hcoeff
int8_t hcoeff[HTAPS_MAX/2]
Definition: snow.h:99
QROOT
#define QROOT
Definition: snow.h:38
ff_snow_alloc_blocks
int ff_snow_alloc_blocks(SnowContext *s)
Definition: snow.c:83
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: libavcodec/utils.c:823
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:148
SubBand::parent
struct SubBand * parent
Definition: libavcodec/diracdec.c:105
height
BYTE int const BYTE int int int height
Definition: avisynth_c.h:713
av_malloc
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
avcodec_get_frame_defaults
void avcodec_get_frame_defaults(AVFrame *frame)
Set the fields of the given AVFrame to default values.
Definition: libavcodec/utils.c:927
i
synthesis window for stochastic i
Definition: code Kat/hpsmodel.m:34
SubBand::buf_y_offset
int buf_y_offset
Definition: snow.h:86
SnowContext::temp_dwt_buffer
DWTELEM * temp_dwt_buffer
Definition: snow.h:140
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:330
SnowContext::header_state
uint8_t header_state[32]
Definition: snow.h:124
AVERROR
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
weight
static int weight(int i, int blen, int offset)
Definition: libavcodec/diracdec.c:1247
ff_snow_common_init
int ff_snow_common_init(AVCodecContext *avctx)
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:87
ff_snow_pred_block
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
MAX_DECOMPOSITIONS
#define MAX_DECOMPOSITIONS
Definition: dirac_dwt.h:30
SnowContext::mconly_picture
AVFrame mconly_picture
Definition: snow.h:122
CODEC_FLAG_EMU_EDGE
#define CODEC_FLAG_EMU_EDGE
Don&#39;t draw edges.
Definition: libavcodec/avcodec.h:707
MID_STATE
#define MID_STATE
Definition: snow.h:34
internal.h
common internal api header.
ff_h264qpel_init
void ff_h264qpel_init(H264QpelContext *c, int bit_depth)
Definition: h264qpel.c:48
SnowContext::temp_idwt_buffer
IDWTELEM * temp_idwt_buffer
Definition: snow.h:142
SnowContext::h264qpel
H264QpelContext h264qpel
Definition: snow.h:115
FF_ALLOC_OR_GOTO
#define FF_ALLOC_OR_GOTO(ctx, p, size, label)
Definition: libavutil/internal.h:95
slice_buffer_get_line
#define slice_buffer_get_line(slice_buf, line_num)
Definition: snow_dwt.h:86
MpegEncContext::obmc_scratchpad
uint8_t * obmc_scratchpad
Definition: mpegvideo.h:366
LOG2_MB_SIZE
#define LOG2_MB_SIZE
Definition: snow.h:67
SnowContext::spatial_dwt_buffer
DWTELEM * spatial_dwt_buffer
Definition: snow.h:139
scale
Same thing on a dB scale
Definition: FFT of a Simple Sinusoid.m:36
y
function y
Definition: D.m:1
SubBand::state
uint8_t state[7+512][32]
Definition: snow.h:90
MotionEstContext::map
uint32_t * map
map to avoid duplicate evaluations
Definition: mpegvideo.h:195
SnowContext::spatial_idwt_buffer
IDWTELEM * spatial_idwt_buffer
Definition: snow.h:141
dsputil.h
DSP utils.
a4
#define a4
Definition: regdef.h:50
VideoDSPContext::emulated_edge_mc
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
MC_STRIDE
#define MC_STRIDE(x)
SubBand::buf_x_offset
int buf_x_offset
Definition: snow.h:85
dst
else dst[i][x+y *dst_stride[i]]
Definition: vf_mcdeint.c:160
EDGE_WIDTH
#define EDGE_WIDTH
Definition: dsputil.h:264
AVFrame::key_frame
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:139
SubBand::ibuf
IDWTELEM * ibuf
Definition: libavcodec/diracdec.c:104
Plane::fast_mc
int fast_mc
Definition: snow.h:101
ff_snow_common_end
av_cold void ff_snow_common_end(SnowContext *s)
Definition: snow.c:650
ff_qexp
uint8_t ff_qexp[QROOT]
Definition: snowdata.h:128
SubBand::buf
DWTELEM * buf
Definition: snow.h:83
MAX_REF_FRAMES
#define MAX_REF_FRAMES
Definition: snow.h:41
MotionEstContext::temp
uint8_t * temp
Definition: mpegvideo.h:193
BlockNode::type
uint8_t type
Definition: snow.h:50
x_and_coeff
Definition: snow.h:72
AV_GET_BUFFER_FLAG_REF
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
Definition: libavcodec/avcodec.h:909
FF_ALLOCZ_OR_GOTO
#define FF_ALLOCZ_OR_GOTO(ctx, p, size, label)
Definition: libavutil/internal.h:104
ff_dwt_init
void ff_dwt_init(SnowDWTContext *c)
Definition: snow_dwt.c:855
a
a
Definition: h264pred_template.c:466
SubBand::stride_line
int stride_line
Stride measured in lines, not pixels.
Definition: snow.h:87
SnowContext::last_picture
AVFrame last_picture[MAX_REF_FRAMES]
Definition: snow.h:120
Generated on Fri Dec 20 2024 06:56:07 for FFmpeg by   doxygen 1.8.11