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