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 Libav.
5  *
6  * Libav 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  * Libav 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 Libav; 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 "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 #undef NDEBUG
36 #include <assert.h>
37 
38 
39 void ff_snow_inner_add_yblock(const uint8_t *obmc, const int obmc_stride, uint8_t * * block, int b_w, int b_h,
40  int src_x, int src_y, int src_stride, slice_buffer * sb, int add, uint8_t * dst8){
41  int y, x;
42  IDWTELEM * dst;
43  for(y=0; y<b_h; y++){
44  //FIXME ugly misuse of obmc_stride
45  const uint8_t *obmc1= obmc + y*obmc_stride;
46  const uint8_t *obmc2= obmc1+ (obmc_stride>>1);
47  const uint8_t *obmc3= obmc1+ obmc_stride*(obmc_stride>>1);
48  const uint8_t *obmc4= obmc3+ (obmc_stride>>1);
49  dst = slice_buffer_get_line(sb, src_y + y);
50  for(x=0; x<b_w; x++){
51  int v= obmc1[x] * block[3][x + y*src_stride]
52  +obmc2[x] * block[2][x + y*src_stride]
53  +obmc3[x] * block[1][x + y*src_stride]
54  +obmc4[x] * block[0][x + y*src_stride];
55 
56  v <<= 8 - LOG2_OBMC_MAX;
57  if(FRAC_BITS != 8){
58  v >>= 8 - FRAC_BITS;
59  }
60  if(add){
61  v += dst[x + src_x];
62  v = (v + (1<<(FRAC_BITS-1))) >> FRAC_BITS;
63  if(v&(~255)) v= ~(v>>31);
64  dst8[x + y*src_stride] = v;
65  }else{
66  dst[x + src_x] -= v;
67  }
68  }
69  }
70 }
71 
72 void ff_snow_reset_contexts(SnowContext *s){ //FIXME better initial contexts
73  int plane_index, level, orientation;
74 
75  for(plane_index=0; plane_index<3; plane_index++){
76  for(level=0; level<MAX_DECOMPOSITIONS; level++){
77  for(orientation=level ? 1:0; orientation<4; orientation++){
78  memset(s->plane[plane_index].band[level][orientation].state, MID_STATE, sizeof(s->plane[plane_index].band[level][orientation].state));
79  }
80  }
81  }
82  memset(s->header_state, MID_STATE, sizeof(s->header_state));
83  memset(s->block_state, MID_STATE, sizeof(s->block_state));
84 }
85 
87  int w= -((-s->avctx->width )>>LOG2_MB_SIZE);
88  int h= -((-s->avctx->height)>>LOG2_MB_SIZE);
89 
90  s->b_width = w;
91  s->b_height= h;
92 
93  av_free(s->block);
94  s->block= av_mallocz(w * h * sizeof(BlockNode) << (s->block_max_depth*2));
95  return 0;
96 }
97 
98 static void init_qexp(void){
99  int i;
100  double v=128;
101 
102  for(i=0; i<QROOT; i++){
103  ff_qexp[i]= lrintf(v);
104  v *= pow(2, 1.0 / QROOT);
105  }
106 }
107 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){
108  static const uint8_t weight[64]={
109  8,7,6,5,4,3,2,1,
110  7,7,0,0,0,0,0,1,
111  6,0,6,0,0,0,2,0,
112  5,0,0,5,0,3,0,0,
113  4,0,0,0,4,0,0,0,
114  3,0,0,5,0,3,0,0,
115  2,0,6,0,0,0,2,0,
116  1,7,0,0,0,0,0,1,
117  };
118 
119  static const uint8_t brane[256]={
120  0x00,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x11,0x12,0x12,0x12,0x12,0x12,0x12,0x12,
121  0x04,0x05,0xcc,0xcc,0xcc,0xcc,0xcc,0x41,0x15,0x16,0xcc,0xcc,0xcc,0xcc,0xcc,0x52,
122  0x04,0xcc,0x05,0xcc,0xcc,0xcc,0x41,0xcc,0x15,0xcc,0x16,0xcc,0xcc,0xcc,0x52,0xcc,
123  0x04,0xcc,0xcc,0x05,0xcc,0x41,0xcc,0xcc,0x15,0xcc,0xcc,0x16,0xcc,0x52,0xcc,0xcc,
124  0x04,0xcc,0xcc,0xcc,0x41,0xcc,0xcc,0xcc,0x15,0xcc,0xcc,0xcc,0x16,0xcc,0xcc,0xcc,
125  0x04,0xcc,0xcc,0x41,0xcc,0x05,0xcc,0xcc,0x15,0xcc,0xcc,0x52,0xcc,0x16,0xcc,0xcc,
126  0x04,0xcc,0x41,0xcc,0xcc,0xcc,0x05,0xcc,0x15,0xcc,0x52,0xcc,0xcc,0xcc,0x16,0xcc,
127  0x04,0x41,0xcc,0xcc,0xcc,0xcc,0xcc,0x05,0x15,0x52,0xcc,0xcc,0xcc,0xcc,0xcc,0x16,
128  0x44,0x45,0x45,0x45,0x45,0x45,0x45,0x45,0x55,0x56,0x56,0x56,0x56,0x56,0x56,0x56,
129  0x48,0x49,0xcc,0xcc,0xcc,0xcc,0xcc,0x85,0x59,0x5A,0xcc,0xcc,0xcc,0xcc,0xcc,0x96,
130  0x48,0xcc,0x49,0xcc,0xcc,0xcc,0x85,0xcc,0x59,0xcc,0x5A,0xcc,0xcc,0xcc,0x96,0xcc,
131  0x48,0xcc,0xcc,0x49,0xcc,0x85,0xcc,0xcc,0x59,0xcc,0xcc,0x5A,0xcc,0x96,0xcc,0xcc,
132  0x48,0xcc,0xcc,0xcc,0x49,0xcc,0xcc,0xcc,0x59,0xcc,0xcc,0xcc,0x96,0xcc,0xcc,0xcc,
133  0x48,0xcc,0xcc,0x85,0xcc,0x49,0xcc,0xcc,0x59,0xcc,0xcc,0x96,0xcc,0x5A,0xcc,0xcc,
134  0x48,0xcc,0x85,0xcc,0xcc,0xcc,0x49,0xcc,0x59,0xcc,0x96,0xcc,0xcc,0xcc,0x5A,0xcc,
135  0x48,0x85,0xcc,0xcc,0xcc,0xcc,0xcc,0x49,0x59,0x96,0xcc,0xcc,0xcc,0xcc,0xcc,0x5A,
136  };
137 
138  static const uint8_t needs[16]={
139  0,1,0,0,
140  2,4,2,0,
141  0,1,0,0,
142  15
143  };
144 
145  int x, y, b, r, l;
146  int16_t tmpIt [64*(32+HTAPS_MAX)];
147  uint8_t tmp2t[3][64*(32+HTAPS_MAX)];
148  int16_t *tmpI= tmpIt;
149  uint8_t *tmp2= tmp2t[0];
150  const uint8_t *hpel[11];
151  assert(dx<16 && dy<16);
152  r= brane[dx + 16*dy]&15;
153  l= brane[dx + 16*dy]>>4;
154 
155  b= needs[l] | needs[r];
156  if(p && !p->diag_mc)
157  b= 15;
158 
159  if(b&5){
160  for(y=0; y < b_h+HTAPS_MAX-1; y++){
161  for(x=0; x < b_w; x++){
162  int a_1=src[x + HTAPS_MAX/2-4];
163  int a0= src[x + HTAPS_MAX/2-3];
164  int a1= src[x + HTAPS_MAX/2-2];
165  int a2= src[x + HTAPS_MAX/2-1];
166  int a3= src[x + HTAPS_MAX/2+0];
167  int a4= src[x + HTAPS_MAX/2+1];
168  int a5= src[x + HTAPS_MAX/2+2];
169  int a6= src[x + HTAPS_MAX/2+3];
170  int am=0;
171  if(!p || p->fast_mc){
172  am= 20*(a2+a3) - 5*(a1+a4) + (a0+a5);
173  tmpI[x]= am;
174  am= (am+16)>>5;
175  }else{
176  am= p->hcoeff[0]*(a2+a3) + p->hcoeff[1]*(a1+a4) + p->hcoeff[2]*(a0+a5) + p->hcoeff[3]*(a_1+a6);
177  tmpI[x]= am;
178  am= (am+32)>>6;
179  }
180 
181  if(am&(~255)) am= ~(am>>31);
182  tmp2[x]= am;
183  }
184  tmpI+= 64;
185  tmp2+= 64;
186  src += stride;
187  }
188  src -= stride*y;
189  }
190  src += HTAPS_MAX/2 - 1;
191  tmp2= tmp2t[1];
192 
193  if(b&2){
194  for(y=0; y < b_h; y++){
195  for(x=0; x < b_w+1; x++){
196  int a_1=src[x + (HTAPS_MAX/2-4)*stride];
197  int a0= src[x + (HTAPS_MAX/2-3)*stride];
198  int a1= src[x + (HTAPS_MAX/2-2)*stride];
199  int a2= src[x + (HTAPS_MAX/2-1)*stride];
200  int a3= src[x + (HTAPS_MAX/2+0)*stride];
201  int a4= src[x + (HTAPS_MAX/2+1)*stride];
202  int a5= src[x + (HTAPS_MAX/2+2)*stride];
203  int a6= src[x + (HTAPS_MAX/2+3)*stride];
204  int am=0;
205  if(!p || p->fast_mc)
206  am= (20*(a2+a3) - 5*(a1+a4) + (a0+a5) + 16)>>5;
207  else
208  am= (p->hcoeff[0]*(a2+a3) + p->hcoeff[1]*(a1+a4) + p->hcoeff[2]*(a0+a5) + p->hcoeff[3]*(a_1+a6) + 32)>>6;
209 
210  if(am&(~255)) am= ~(am>>31);
211  tmp2[x]= am;
212  }
213  src += stride;
214  tmp2+= 64;
215  }
216  src -= stride*y;
217  }
218  src += stride*(HTAPS_MAX/2 - 1);
219  tmp2= tmp2t[2];
220  tmpI= tmpIt;
221  if(b&4){
222  for(y=0; y < b_h; y++){
223  for(x=0; x < b_w; x++){
224  int a_1=tmpI[x + (HTAPS_MAX/2-4)*64];
225  int a0= tmpI[x + (HTAPS_MAX/2-3)*64];
226  int a1= tmpI[x + (HTAPS_MAX/2-2)*64];
227  int a2= tmpI[x + (HTAPS_MAX/2-1)*64];
228  int a3= tmpI[x + (HTAPS_MAX/2+0)*64];
229  int a4= tmpI[x + (HTAPS_MAX/2+1)*64];
230  int a5= tmpI[x + (HTAPS_MAX/2+2)*64];
231  int a6= tmpI[x + (HTAPS_MAX/2+3)*64];
232  int am=0;
233  if(!p || p->fast_mc)
234  am= (20*(a2+a3) - 5*(a1+a4) + (a0+a5) + 512)>>10;
235  else
236  am= (p->hcoeff[0]*(a2+a3) + p->hcoeff[1]*(a1+a4) + p->hcoeff[2]*(a0+a5) + p->hcoeff[3]*(a_1+a6) + 2048)>>12;
237  if(am&(~255)) am= ~(am>>31);
238  tmp2[x]= am;
239  }
240  tmpI+= 64;
241  tmp2+= 64;
242  }
243  }
244 
245  hpel[ 0]= src;
246  hpel[ 1]= tmp2t[0] + 64*(HTAPS_MAX/2-1);
247  hpel[ 2]= src + 1;
248 
249  hpel[ 4]= tmp2t[1];
250  hpel[ 5]= tmp2t[2];
251  hpel[ 6]= tmp2t[1] + 1;
252 
253  hpel[ 8]= src + stride;
254  hpel[ 9]= hpel[1] + 64;
255  hpel[10]= hpel[8] + 1;
256 
257 #define MC_STRIDE(x) (needs[x] ? 64 : stride)
258 
259  if(b==15){
260  int dxy = dx / 8 + dy / 8 * 4;
261  const uint8_t *src1 = hpel[dxy ];
262  const uint8_t *src2 = hpel[dxy + 1];
263  const uint8_t *src3 = hpel[dxy + 4];
264  const uint8_t *src4 = hpel[dxy + 5];
265  int stride1 = MC_STRIDE(dxy);
266  int stride2 = MC_STRIDE(dxy + 1);
267  int stride3 = MC_STRIDE(dxy + 4);
268  int stride4 = MC_STRIDE(dxy + 5);
269  dx&=7;
270  dy&=7;
271  for(y=0; y < b_h; y++){
272  for(x=0; x < b_w; x++){
273  dst[x]= ((8-dx)*(8-dy)*src1[x] + dx*(8-dy)*src2[x]+
274  (8-dx)* dy *src3[x] + dx* dy *src4[x]+32)>>6;
275  }
276  src1+=stride1;
277  src2+=stride2;
278  src3+=stride3;
279  src4+=stride4;
280  dst +=stride;
281  }
282  }else{
283  const uint8_t *src1= hpel[l];
284  const uint8_t *src2= hpel[r];
285  int stride1 = MC_STRIDE(l);
286  int stride2 = MC_STRIDE(r);
287  int a= weight[((dx&7) + (8*(dy&7)))];
288  int b= 8-a;
289  for(y=0; y < b_h; y++){
290  for(x=0; x < b_w; x++){
291  dst[x]= (a*src1[x] + b*src2[x] + 4)>>3;
292  }
293  src1+=stride1;
294  src2+=stride2;
295  dst +=stride;
296  }
297  }
298 }
299 
300 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){
301  if(block->type & BLOCK_INTRA){
302  int x, y;
303  const unsigned color = block->color[plane_index];
304  const unsigned color4 = color*0x01010101;
305  if(b_w==32){
306  for(y=0; y < b_h; y++){
307  *(uint32_t*)&dst[0 + y*stride]= color4;
308  *(uint32_t*)&dst[4 + y*stride]= color4;
309  *(uint32_t*)&dst[8 + y*stride]= color4;
310  *(uint32_t*)&dst[12+ y*stride]= color4;
311  *(uint32_t*)&dst[16+ y*stride]= color4;
312  *(uint32_t*)&dst[20+ y*stride]= color4;
313  *(uint32_t*)&dst[24+ y*stride]= color4;
314  *(uint32_t*)&dst[28+ y*stride]= color4;
315  }
316  }else if(b_w==16){
317  for(y=0; y < b_h; y++){
318  *(uint32_t*)&dst[0 + y*stride]= color4;
319  *(uint32_t*)&dst[4 + y*stride]= color4;
320  *(uint32_t*)&dst[8 + y*stride]= color4;
321  *(uint32_t*)&dst[12+ y*stride]= color4;
322  }
323  }else if(b_w==8){
324  for(y=0; y < b_h; y++){
325  *(uint32_t*)&dst[0 + y*stride]= color4;
326  *(uint32_t*)&dst[4 + y*stride]= color4;
327  }
328  }else if(b_w==4){
329  for(y=0; y < b_h; y++){
330  *(uint32_t*)&dst[0 + y*stride]= color4;
331  }
332  }else{
333  for(y=0; y < b_h; y++){
334  for(x=0; x < b_w; x++){
335  dst[x + y*stride]= color;
336  }
337  }
338  }
339  }else{
340  uint8_t *src= s->last_picture[block->ref].data[plane_index];
341  const int scale= plane_index ? s->mv_scale : 2*s->mv_scale;
342  int mx= block->mx*scale;
343  int my= block->my*scale;
344  const int dx= mx&15;
345  const int dy= my&15;
346  const int tab_index= 3 - (b_w>>2) + (b_w>>4);
347  sx += (mx>>4) - (HTAPS_MAX/2-1);
348  sy += (my>>4) - (HTAPS_MAX/2-1);
349  src += sx + sy*stride;
350  if( (unsigned)sx >= w - b_w - (HTAPS_MAX-2)
351  || (unsigned)sy >= h - b_h - (HTAPS_MAX-2)){
352  s->vdsp.emulated_edge_mc(tmp + MB_SIZE, src, stride, b_w+HTAPS_MAX-1, b_h+HTAPS_MAX-1, sx, sy, w, h);
353  src= tmp + MB_SIZE;
354  }
355 // assert(b_w == b_h || 2*b_w == b_h || b_w == 2*b_h);
356 // assert(!(b_w&(b_w-1)));
357  assert(b_w>1 && b_h>1);
358  assert((tab_index>=0 && tab_index<4) || b_w==32);
359  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 )
360  mc_block(&s->plane[plane_index], dst, src, stride, b_w, b_h, dx, dy);
361  else if(b_w==32){
362  int y;
363  for(y=0; y<b_h; y+=16){
364  s->dsp.put_h264_qpel_pixels_tab[0][dy+(dx>>2)](dst + y*stride, src + 3 + (y+3)*stride,stride);
365  s->dsp.put_h264_qpel_pixels_tab[0][dy+(dx>>2)](dst + 16 + y*stride, src + 19 + (y+3)*stride,stride);
366  }
367  }else if(b_w==b_h)
368  s->dsp.put_h264_qpel_pixels_tab[tab_index ][dy+(dx>>2)](dst,src + 3 + 3*stride,stride);
369  else if(b_w==2*b_h){
370  s->dsp.put_h264_qpel_pixels_tab[tab_index+1][dy+(dx>>2)](dst ,src + 3 + 3*stride,stride);
371  s->dsp.put_h264_qpel_pixels_tab[tab_index+1][dy+(dx>>2)](dst+b_h,src + 3 + b_h + 3*stride,stride);
372  }else{
373  assert(2*b_w==b_h);
374  s->dsp.put_h264_qpel_pixels_tab[tab_index ][dy+(dx>>2)](dst ,src + 3 + 3*stride ,stride);
375  s->dsp.put_h264_qpel_pixels_tab[tab_index ][dy+(dx>>2)](dst+b_w*stride,src + 3 + 3*stride+b_w*stride,stride);
376  }
377  }
378 }
379 
380 #define mca(dx,dy,b_w)\
381 static void mc_block_hpel ## dx ## dy ## b_w(uint8_t *dst, const uint8_t *src, int stride, int h){\
382  assert(h==b_w);\
383  mc_block(NULL, dst, src-(HTAPS_MAX/2-1)-(HTAPS_MAX/2-1)*stride, stride, b_w, b_w, dx, dy);\
384 }
385 
386 mca( 0, 0,16)
387 mca( 8, 0,16)
388 mca( 0, 8,16)
389 mca( 8, 8,16)
390 mca( 0, 0,8)
391 mca( 8, 0,8)
392 mca( 0, 8,8)
393 mca( 8, 8,8)
394 
396  SnowContext *s = avctx->priv_data;
397  int width, height;
398  int i, j, ret;
399  int emu_buf_size;
400 
401  s->avctx= avctx;
402  s->max_ref_frames=1; //just make sure its not an invalid value in case of no initial keyframe
403 
404  ff_dsputil_init(&s->dsp, avctx);
405  ff_videodsp_init(&s->vdsp, 8);
406  ff_dwt_init(&s->dwt);
407 
408 #define mcf(dx,dy)\
409  s->dsp.put_qpel_pixels_tab [0][dy+dx/4]=\
410  s->dsp.put_no_rnd_qpel_pixels_tab[0][dy+dx/4]=\
411  s->dsp.put_h264_qpel_pixels_tab[0][dy+dx/4];\
412  s->dsp.put_qpel_pixels_tab [1][dy+dx/4]=\
413  s->dsp.put_no_rnd_qpel_pixels_tab[1][dy+dx/4]=\
414  s->dsp.put_h264_qpel_pixels_tab[1][dy+dx/4];
415 
416  mcf( 0, 0)
417  mcf( 4, 0)
418  mcf( 8, 0)
419  mcf(12, 0)
420  mcf( 0, 4)
421  mcf( 4, 4)
422  mcf( 8, 4)
423  mcf(12, 4)
424  mcf( 0, 8)
425  mcf( 4, 8)
426  mcf( 8, 8)
427  mcf(12, 8)
428  mcf( 0,12)
429  mcf( 4,12)
430  mcf( 8,12)
431  mcf(12,12)
432 
433 #define mcfh(dx,dy)\
434  s->dsp.put_pixels_tab [0][dy/4+dx/8]=\
435  s->dsp.put_no_rnd_pixels_tab[0][dy/4+dx/8]=\
436  mc_block_hpel ## dx ## dy ## 16;\
437  s->dsp.put_pixels_tab [1][dy/4+dx/8]=\
438  s->dsp.put_no_rnd_pixels_tab[1][dy/4+dx/8]=\
439  mc_block_hpel ## dx ## dy ## 8;
440 
441  mcfh(0, 0)
442  mcfh(8, 0)
443  mcfh(0, 8)
444  mcfh(8, 8)
445 
446  init_qexp();
447 
448 // dec += FFMAX(s->chroma_h_shift, s->chroma_v_shift);
449 
450  width= s->avctx->width;
451  height= s->avctx->height;
452 
453  FF_ALLOCZ_OR_GOTO(avctx, s->spatial_idwt_buffer, width * height * sizeof(IDWTELEM), fail);
454  FF_ALLOCZ_OR_GOTO(avctx, s->spatial_dwt_buffer, width * height * sizeof(DWTELEM), fail); //FIXME this does not belong here
455  FF_ALLOCZ_OR_GOTO(avctx, s->temp_dwt_buffer, width * sizeof(DWTELEM), fail);
456  FF_ALLOCZ_OR_GOTO(avctx, s->temp_idwt_buffer, width * sizeof(IDWTELEM), fail);
457  FF_ALLOC_OR_GOTO(avctx, s->run_buffer, ((width + 1) >> 1) * ((height + 1) >> 1) * sizeof(*s->run_buffer), fail);
458 
459  for(i=0; i<MAX_REF_FRAMES; i++)
460  for(j=0; j<MAX_REF_FRAMES; j++)
461  ff_scale_mv_ref[i][j] = 256*(i+1)/(j+1);
462 
463  if ((ret = ff_get_buffer(s->avctx, &s->mconly_picture)) < 0) {
464  av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
465  return ret;
466  }
467  FF_ALLOC_OR_GOTO(avctx, s->scratchbuf, s->mconly_picture.linesize[0]*7*MB_SIZE, fail);
468  emu_buf_size = s->mconly_picture.linesize[0] * (2 * MB_SIZE + HTAPS_MAX - 1);
469  FF_ALLOC_OR_GOTO(avctx, s->emu_edge_buffer, emu_buf_size, fail);
470 
471  return 0;
472 fail:
473  return AVERROR(ENOMEM);
474 }
475 
477  SnowContext *s = avctx->priv_data;
478  int plane_index, level, orientation;
479 
480  for(plane_index=0; plane_index<3; plane_index++){
481  int w= s->avctx->width;
482  int h= s->avctx->height;
483 
484  if(plane_index){
485  w>>= s->chroma_h_shift;
486  h>>= s->chroma_v_shift;
487  }
488  s->plane[plane_index].width = w;
489  s->plane[plane_index].height= h;
490 
491  for(level=s->spatial_decomposition_count-1; level>=0; level--){
492  for(orientation=level ? 1 : 0; orientation<4; orientation++){
493  SubBand *b= &s->plane[plane_index].band[level][orientation];
494 
495  b->buf= s->spatial_dwt_buffer;
496  b->level= level;
497  b->stride= s->plane[plane_index].width << (s->spatial_decomposition_count - level);
498  b->width = (w + !(orientation&1))>>1;
499  b->height= (h + !(orientation>1))>>1;
500 
502  b->buf_x_offset = 0;
503  b->buf_y_offset = 0;
504 
505  if(orientation&1){
506  b->buf += (w+1)>>1;
507  b->buf_x_offset = (w+1)>>1;
508  }
509  if(orientation>1){
510  b->buf += b->stride>>1;
511  b->buf_y_offset = b->stride_line >> 1;
512  }
513  b->ibuf= s->spatial_idwt_buffer + (b->buf - s->spatial_dwt_buffer);
514 
515  if(level)
516  b->parent= &s->plane[plane_index].band[level-1][orientation];
517  //FIXME avoid this realloc
518  av_freep(&b->x_coeff);
519  b->x_coeff=av_mallocz(((b->width+1) * b->height+1)*sizeof(x_and_coeff));
520  }
521  w= (w+1)>>1;
522  h= (h+1)>>1;
523  }
524  }
525 
526  return 0;
527 }
528 
529 #define USE_HALFPEL_PLANE 0
530 
531 static void halfpel_interpol(SnowContext *s, uint8_t *halfpel[4][4], AVFrame *frame){
532  int p,x,y;
533 
534  for(p=0; p<3; p++){
535  int is_chroma= !!p;
536  int w= s->avctx->width >>is_chroma;
537  int h= s->avctx->height >>is_chroma;
538  int ls= frame->linesize[p];
539  uint8_t *src= frame->data[p];
540 
541  halfpel[1][p] = (uint8_t*) av_malloc(ls * (h + 2 * EDGE_WIDTH)) + EDGE_WIDTH * (1 + ls);
542  halfpel[2][p] = (uint8_t*) av_malloc(ls * (h + 2 * EDGE_WIDTH)) + EDGE_WIDTH * (1 + ls);
543  halfpel[3][p] = (uint8_t*) av_malloc(ls * (h + 2 * EDGE_WIDTH)) + EDGE_WIDTH * (1 + ls);
544 
545  halfpel[0][p]= src;
546  for(y=0; y<h; y++){
547  for(x=0; x<w; x++){
548  int i= y*ls + x;
549 
550  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;
551  }
552  }
553  for(y=0; y<h; y++){
554  for(x=0; x<w; x++){
555  int i= y*ls + x;
556 
557  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;
558  }
559  }
560  src= halfpel[1][p];
561  for(y=0; y<h; y++){
562  for(x=0; x<w; x++){
563  int i= y*ls + x;
564 
565  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;
566  }
567  }
568 
569 //FIXME border!
570  }
571 }
572 
574 {
575  SnowContext *s = avctx->priv_data;
576  int i;
577 
578  if(s->last_picture[s->max_ref_frames-1].data[0]){
579  avctx->release_buffer(avctx, &s->last_picture[s->max_ref_frames-1]);
580  for(i=0; i<9; i++)
581  if(s->halfpel_plane[s->max_ref_frames-1][1+i/3][i%3])
582  av_free(s->halfpel_plane[s->max_ref_frames-1][1+i/3][i%3] - EDGE_WIDTH*(1+s->current_picture.linesize[i%3]));
583  }
584 }
585 
587  AVFrame tmp;
588  int w= s->avctx->width; //FIXME round up to x16 ?
589  int h= s->avctx->height;
590 
591  if (s->current_picture.data[0] && !(s->avctx->flags&CODEC_FLAG_EMU_EDGE)) {
593  s->current_picture.linesize[0], w , h ,
596  s->current_picture.linesize[1], w>>1, h>>1,
599  s->current_picture.linesize[2], w>>1, h>>1,
601  }
602 
604 
605  tmp= s->last_picture[s->max_ref_frames-1];
606  memmove(s->last_picture+1, s->last_picture, (s->max_ref_frames-1)*sizeof(AVFrame));
607  memmove(s->halfpel_plane+1, s->halfpel_plane, (s->max_ref_frames-1)*sizeof(void*)*4*4);
610  s->last_picture[0]= s->current_picture;
611  s->current_picture= tmp;
612 
613  if(s->keyframe){
614  s->ref_frames= 0;
615  }else{
616  int i;
617  for(i=0; i<s->max_ref_frames && s->last_picture[i].data[0]; i++)
618  if(i && s->last_picture[i-1].key_frame)
619  break;
620  s->ref_frames= i;
621  if(s->ref_frames==0){
622  av_log(s->avctx,AV_LOG_ERROR, "No reference frames\n");
623  return -1;
624  }
625  }
626 
628  if(ff_get_buffer(s->avctx, &s->current_picture) < 0){
629  av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
630  return -1;
631  }
632 
634 
635  return 0;
636 }
637 
639 {
640  int plane_index, level, orientation, i;
641 
646  av_freep(&s->run_buffer);
647 
648  s->m.me.temp= NULL;
649  av_freep(&s->m.me.scratchpad);
650  av_freep(&s->m.me.map);
651  av_freep(&s->m.me.score_map);
653 
654  av_freep(&s->block);
655  av_freep(&s->scratchbuf);
657 
658  for(i=0; i<MAX_REF_FRAMES; i++){
659  av_freep(&s->ref_mvs[i]);
660  av_freep(&s->ref_scores[i]);
661  if(s->last_picture[i].data[0])
662  s->avctx->release_buffer(s->avctx, &s->last_picture[i]);
663  }
664 
665  for(plane_index=0; plane_index<3; plane_index++){
666  for(level=s->spatial_decomposition_count-1; level>=0; level--){
667  for(orientation=level ? 1 : 0; orientation<4; orientation++){
668  SubBand *b= &s->plane[plane_index].band[level][orientation];
669 
670  av_freep(&b->x_coeff);
671  }
672  }
673  }
674  if (s->mconly_picture.data[0])
676  if (s->current_picture.data[0])
678 }
uint8_t * scratchpad
data area for the ME algo, so that the ME does not need to malloc/free
Definition: mpegvideo.h:161
#define slice_buffer_get_line(slice_buf, line_num)
Definition: dwt.h:83
MpegEncContext m
Definition: snow.h:166
int mv_scale
Definition: snow.h:149
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:61
DWTContext dwt
Definition: snow.h:112
int ff_snow_frame_start(SnowContext *s)
Definition: snow.c:586
av_cold void ff_dsputil_init(DSPContext *c, AVCodecContext *avctx)
Definition: dsputil.c:2656
AVCodecContext * avctx
Definition: snow.h:108
int block_max_depth
Definition: snow.h:156
int chroma_v_shift
Definition: snow.h:142
This structure describes decoded (raw) audio or video data.
Definition: avcodec.h:989
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:39
void(* release_buffer)(struct AVCodecContext *c, AVFrame *pic)
Called to release buffers which were allocated with get_buffer.
Definition: avcodec.h:2259
int * run_buffer
Definition: snow.h:139
#define EDGE_TOP
Definition: dsputil.h:441
#define BLOCK_INTRA
Definition: snow.h:50
#define a0
Definition: regdef.h:46
IDWTELEM * ibuf
Definition: snow.h:82
void(* draw_edges)(uint8_t *buf, int wrap, int width, int height, int w, int h, int sides)
Definition: dsputil.h:439
Range coder.
struct SubBand * parent
Definition: snow.h:87
#define mcf(dx, dy)
#define a1
Definition: regdef.h:47
int max_ref_frames
Definition: snow.h:131
uint32_t * score_map
map to store the scores
Definition: mpegvideo.h:167
static const uint8_t obmc4[16]
Definition: snowdata.h:96
int ff_snow_common_init_after_header(AVCodecContext *avctx)
Definition: snow.c:476
int keyframe
Definition: snow.h:122
int stride
Definition: mace.c:144
void ff_snow_reset_contexts(SnowContext *s)
Definition: snow.c:72
void ff_dwt_init(DWTContext *c)
Definition: dwt.c:853
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:151
Definition: snow.h:43
int width
Definition: snow.h:78
short IDWTELEM
Definition: dwt.h:27
#define HTAPS_MAX
Definition: snow.h:68
uint8_t ref
Definition: snow.h:46
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:50
#define a3
Definition: regdef.h:49
int b_height
Definition: snow.h:155
uint8_t
int16_t mx
Definition: snow.h:44
AVOptions.
uint32_t * ref_scores[MAX_REF_FRAMES]
Definition: snow.h:134
#define b
Definition: input.c:52
#define MB_SIZE
Definition: snow.h:66
AVFrame current_picture
Definition: snow.h:115
int16_t my
Definition: snow.h:45
#define MAX_DECOMPOSITIONS
Definition: dwt.h:60
void ff_snow_release_buffer(AVCodecContext *avctx)
Definition: snow.c:573
Definition: snow.h:75
#define r
Definition: input.c:51
BlockNode * block
Definition: snow.h:159
#define mca(dx, dy, b_w)
Definition: snow.c:380
Used to minimize the amount of memory used in order to optimize cache performance.
Definition: dwt.h:39
void av_free(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc(). ...
Definition: mem.c:139
int16_t(*[MAX_REF_FRAMES] ref_mvs)[2]
Definition: snow.h:133
uint32_t width
Definition: indeo3.c:66
int reference
is this picture used as reference The values for this are the same as the MpegEncContext.picture_structure variable, that is 1->top field, 2->bottom field, 3->frame/both fields.
Definition: avcodec.h:1132
int diag_mc
Definition: snow.h:98
#define mcfh(dx, dy)
DSPContext dsp
Definition: snow.h:110
int flags
CODEC_FLAG_*.
Definition: avcodec.h:1434
void ff_videodsp_init(VideoDSPContext *ctx, int bpc)
Definition: videodsp.c:36
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:146
int stride
Definition: snow.h:77
static void init_qexp(void)
Definition: snow.c:98
uint8_t * emu_edge_buffer
Definition: snow.h:169
uint8_t color[3]
Definition: snow.h:47
int ref_frames
Definition: snow.h:132
x_and_coeff * x_coeff
Definition: snow.h:86
#define USE_HALFPEL_PLANE
Definition: snow.c:529
static DCTELEM block[64]
Definition: dct-test.c:169
SubBand band[MAX_DECOMPOSITIONS][4]
Definition: snow.h:94
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:107
static void halfpel_interpol(SnowContext *s, uint8_t *halfpel[4][4], AVFrame *frame)
Definition: snow.c:531
int width
picture width / height.
Definition: avcodec.h:1508
uint8_t * scratchbuf
Definition: snow.h:168
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame)
Get a buffer for a frame.
Definition: utils.c:464
#define a2
Definition: regdef.h:48
Plane plane[MAX_PLANES]
Definition: snow.h:158
static av_always_inline av_const long int lrintf(float x)
Definition: libm.h:144
int b_width
Definition: snow.h:154
MotionEstContext me
Definition: mpegvideo.h:406
#define EDGE_BOTTOM
Definition: dsputil.h:442
int chroma_h_shift
Definition: snow.h:141
VideoDSPContext vdsp
Definition: snow.h:111
uint8_t * halfpel_plane[MAX_REF_FRAMES][4][4]
Definition: snow.h:117
uint8_t block_state[128+32 *128]
Definition: snow.h:121
NULL
Definition: eval.c:52
int ff_scale_mv_ref[MAX_REF_FRAMES][MAX_REF_FRAMES]
Definition: snowdata.h:129
static int width
Definition: utils.c:156
#define a5
Definition: regdef.h:51
external API header
#define LOG2_OBMC_MAX
Definition: snow.h:41
int spatial_decomposition_count
Definition: snow.h:128
int linesize[AV_NUM_DATA_POINTERS]
Size, in bytes, of the data for each picture/channel plane.
Definition: avcodec.h:1008
main external API structure.
Definition: avcodec.h:1339
int8_t hcoeff[HTAPS_MAX/2]
Definition: snow.h:97
#define QROOT
Definition: snow.h:36
int ff_snow_alloc_blocks(SnowContext *s)
Definition: snow.c:86
int buf_y_offset
Definition: snow.h:84
DWTELEM * temp_dwt_buffer
Definition: snow.h:136
uint8_t header_state[32]
Definition: snow.h:120
int DWTELEM
Definition: dwt.h:26
#define FRAC_BITS
Definition: lsp.c:27
int ff_snow_common_init(AVCodecContext *avctx)
static const uint16_t scale[4]
qpel_mc_func put_h264_qpel_pixels_tab[4][16]
Definition: dsputil.h:324
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: avcodec.h:997
uint8_t level
Definition: svq3.c:133
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:300
int height
Definition: gxfenc.c:72
AVFrame mconly_picture
Definition: snow.h:118
#define MID_STATE
Definition: snow.h:32
common internal api header.
IDWTELEM * temp_idwt_buffer
Definition: snow.h:138
#define FF_ALLOC_OR_GOTO(ctx, p, size, label)
Definition: internal.h:60
uint8_t * obmc_scratchpad
Definition: mpegvideo.h:340
#define LOG2_MB_SIZE
Definition: snow.h:65
DWTELEM * spatial_dwt_buffer
Definition: snow.h:135
static const uint8_t color[]
Definition: log.c:52
uint8_t state[7+512][32]
Definition: snow.h:88
uint32_t * map
map to avoid duplicate evaluations
Definition: mpegvideo.h:166
IDWTELEM * spatial_idwt_buffer
Definition: snow.h:137
DSP utils.
#define a4
Definition: regdef.h:50
void * priv_data
Definition: avcodec.h:1382
#define MC_STRIDE(x)
int buf_x_offset
Definition: snow.h:83
#define EDGE_WIDTH
Definition: dsputil.h:440
int key_frame
1 -> keyframe, 0-> not
Definition: avcodec.h:1058
int height
Definition: snow.h:79
int fast_mc
Definition: snow.h:99
av_cold void ff_snow_common_end(SnowContext *s)
Definition: snow.c:638
uint8_t ff_qexp[QROOT]
Definition: snowdata.h:128
DWTELEM * buf
Definition: snow.h:81
#define MAX_REF_FRAMES
Definition: snow.h:39
uint8_t * temp
Definition: mpegvideo.h:164
uint8_t type
Definition: snow.h:48
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:158
#define FF_ALLOCZ_OR_GOTO(ctx, p, size, label)
Definition: internal.h:69
Definition: indeo3.c:63
int level
Definition: snow.h:76
int stride_line
Stride measured in lines, not pixels.
Definition: snow.h:85
uint32_t height
Definition: indeo3.c:67
AVFrame last_picture[MAX_REF_FRAMES]
Definition: snow.h:116