FFmpeg  2.1.1
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 
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  if (!s->block)
93  return AVERROR(ENOMEM);
94 
95  return 0;
96 }
97 
98 static av_cold 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  av_assert2(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, ptrdiff_t 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 ? (2*s->mv_scale)>>s->chroma_h_shift : 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 >= FFMAX(w - b_w - (HTAPS_MAX-2), 0)
351  || (unsigned)sy >= FFMAX(h - b_h - (HTAPS_MAX-2), 0)){
352  s->vdsp.emulated_edge_mc(tmp + MB_SIZE, stride, src, stride,
353  b_w+HTAPS_MAX-1, b_h+HTAPS_MAX-1,
354  sx, sy, w, h);
355  src= tmp + MB_SIZE;
356  }
357 
358  av_assert2(s->chroma_h_shift == s->chroma_v_shift); // only one mv_scale
359 
360  av_assert2(b_w>1 && b_h>1);
361  av_assert2((tab_index>=0 && tab_index<4) || b_w==32);
362  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 )
363  mc_block(&s->plane[plane_index], dst, src, stride, b_w, b_h, dx, dy);
364  else if(b_w==32){
365  int y;
366  for(y=0; y<b_h; y+=16){
367  s->h264qpel.put_h264_qpel_pixels_tab[0][dy+(dx>>2)](dst + y*stride, src + 3 + (y+3)*stride,stride);
368  s->h264qpel.put_h264_qpel_pixels_tab[0][dy+(dx>>2)](dst + 16 + y*stride, src + 19 + (y+3)*stride,stride);
369  }
370  }else if(b_w==b_h)
371  s->h264qpel.put_h264_qpel_pixels_tab[tab_index ][dy+(dx>>2)](dst,src + 3 + 3*stride,stride);
372  else if(b_w==2*b_h){
373  s->h264qpel.put_h264_qpel_pixels_tab[tab_index+1][dy+(dx>>2)](dst ,src + 3 + 3*stride,stride);
374  s->h264qpel.put_h264_qpel_pixels_tab[tab_index+1][dy+(dx>>2)](dst+b_h,src + 3 + b_h + 3*stride,stride);
375  }else{
376  av_assert2(2*b_w==b_h);
377  s->h264qpel.put_h264_qpel_pixels_tab[tab_index ][dy+(dx>>2)](dst ,src + 3 + 3*stride ,stride);
378  s->h264qpel.put_h264_qpel_pixels_tab[tab_index ][dy+(dx>>2)](dst+b_w*stride,src + 3 + 3*stride+b_w*stride,stride);
379  }
380  }
381 }
382 
383 #define mca(dx,dy,b_w)\
384 static void mc_block_hpel ## dx ## dy ## b_w(uint8_t *dst, const uint8_t *src, ptrdiff_t stride, int h){\
385  av_assert2(h==b_w);\
386  mc_block(NULL, dst, src-(HTAPS_MAX/2-1)-(HTAPS_MAX/2-1)*stride, stride, b_w, b_w, dx, dy);\
387 }
388 
389 mca( 0, 0,16)
390 mca( 8, 0,16)
391 mca( 0, 8,16)
392 mca( 8, 8,16)
393 mca( 0, 0,8)
394 mca( 8, 0,8)
395 mca( 0, 8,8)
396 mca( 8, 8,8)
397 
399  SnowContext *s = avctx->priv_data;
400  int width, height;
401  int i, j;
402 
403  s->avctx= avctx;
404  s->max_ref_frames=1; //just make sure it's not an invalid value in case of no initial keyframe
405 
406  ff_dsputil_init(&s->dsp, avctx);
407  ff_hpeldsp_init(&s->hdsp, avctx->flags);
408  ff_videodsp_init(&s->vdsp, 8);
409  ff_dwt_init(&s->dwt);
410  ff_h264qpel_init(&s->h264qpel, 8);
411 
412 #define mcf(dx,dy)\
413  s->dsp.put_qpel_pixels_tab [0][dy+dx/4]=\
414  s->dsp.put_no_rnd_qpel_pixels_tab[0][dy+dx/4]=\
415  s->h264qpel.put_h264_qpel_pixels_tab[0][dy+dx/4];\
416  s->dsp.put_qpel_pixels_tab [1][dy+dx/4]=\
417  s->dsp.put_no_rnd_qpel_pixels_tab[1][dy+dx/4]=\
418  s->h264qpel.put_h264_qpel_pixels_tab[1][dy+dx/4];
419 
420  mcf( 0, 0)
421  mcf( 4, 0)
422  mcf( 8, 0)
423  mcf(12, 0)
424  mcf( 0, 4)
425  mcf( 4, 4)
426  mcf( 8, 4)
427  mcf(12, 4)
428  mcf( 0, 8)
429  mcf( 4, 8)
430  mcf( 8, 8)
431  mcf(12, 8)
432  mcf( 0,12)
433  mcf( 4,12)
434  mcf( 8,12)
435  mcf(12,12)
436 
437 #define mcfh(dx,dy)\
438  s->hdsp.put_pixels_tab [0][dy/4+dx/8]=\
439  s->hdsp.put_no_rnd_pixels_tab[0][dy/4+dx/8]=\
440  mc_block_hpel ## dx ## dy ## 16;\
441  s->hdsp.put_pixels_tab [1][dy/4+dx/8]=\
442  s->hdsp.put_no_rnd_pixels_tab[1][dy/4+dx/8]=\
443  mc_block_hpel ## dx ## dy ## 8;
444 
445  mcfh(0, 0)
446  mcfh(8, 0)
447  mcfh(0, 8)
448  mcfh(8, 8)
449 
450  init_qexp();
451 
452 // dec += FFMAX(s->chroma_h_shift, s->chroma_v_shift);
453 
454  width= s->avctx->width;
455  height= s->avctx->height;
456 
457  FF_ALLOCZ_OR_GOTO(avctx, s->spatial_idwt_buffer, width * height * sizeof(IDWTELEM), fail);
458  FF_ALLOCZ_OR_GOTO(avctx, s->spatial_dwt_buffer, width * height * sizeof(DWTELEM), fail); //FIXME this does not belong here
459  FF_ALLOCZ_OR_GOTO(avctx, s->temp_dwt_buffer, width * sizeof(DWTELEM), fail);
460  FF_ALLOCZ_OR_GOTO(avctx, s->temp_idwt_buffer, width * sizeof(IDWTELEM), fail);
461  FF_ALLOC_OR_GOTO(avctx, s->run_buffer, ((width + 1) >> 1) * ((height + 1) >> 1) * sizeof(*s->run_buffer), fail);
462 
463  for(i=0; i<MAX_REF_FRAMES; i++) {
464  for(j=0; j<MAX_REF_FRAMES; j++)
465  ff_scale_mv_ref[i][j] = 256*(i+1)/(j+1);
466  s->last_picture[i] = av_frame_alloc();
467  if (!s->last_picture[i])
468  goto fail;
469  }
470 
473  if (!s->mconly_picture || !s->current_picture)
474  goto fail;
475 
476  return 0;
477 fail:
478  return AVERROR(ENOMEM);
479 }
480 
482  SnowContext *s = avctx->priv_data;
483  int plane_index, level, orientation;
484  int ret, emu_buf_size;
485 
486  if(!s->scratchbuf) {
487  if ((ret = ff_get_buffer(s->avctx, s->mconly_picture,
489  return ret;
490  FF_ALLOCZ_OR_GOTO(avctx, s->scratchbuf, FFMAX(s->mconly_picture->linesize[0], 2*avctx->width+256)*7*MB_SIZE, fail);
491  emu_buf_size = FFMAX(s->mconly_picture->linesize[0], 2*avctx->width+256) * (2 * MB_SIZE + HTAPS_MAX - 1);
492  FF_ALLOC_OR_GOTO(avctx, s->emu_edge_buffer, emu_buf_size, fail);
493  }
494 
495  if(s->mconly_picture->format != avctx->pix_fmt) {
496  av_log(avctx, AV_LOG_ERROR, "pixel format changed\n");
497  return AVERROR_INVALIDDATA;
498  }
499 
500  for(plane_index=0; plane_index < s->nb_planes; plane_index++){
501  int w= s->avctx->width;
502  int h= s->avctx->height;
503 
504  if(plane_index){
505  w>>= s->chroma_h_shift;
506  h>>= s->chroma_v_shift;
507  }
508  s->plane[plane_index].width = w;
509  s->plane[plane_index].height= h;
510 
511  for(level=s->spatial_decomposition_count-1; level>=0; level--){
512  for(orientation=level ? 1 : 0; orientation<4; orientation++){
513  SubBand *b= &s->plane[plane_index].band[level][orientation];
514 
515  b->buf= s->spatial_dwt_buffer;
516  b->level= level;
517  b->stride= s->plane[plane_index].width << (s->spatial_decomposition_count - level);
518  b->width = (w + !(orientation&1))>>1;
519  b->height= (h + !(orientation>1))>>1;
520 
522  b->buf_x_offset = 0;
523  b->buf_y_offset = 0;
524 
525  if(orientation&1){
526  b->buf += (w+1)>>1;
527  b->buf_x_offset = (w+1)>>1;
528  }
529  if(orientation>1){
530  b->buf += b->stride>>1;
531  b->buf_y_offset = b->stride_line >> 1;
532  }
533  b->ibuf= s->spatial_idwt_buffer + (b->buf - s->spatial_dwt_buffer);
534 
535  if(level)
536  b->parent= &s->plane[plane_index].band[level-1][orientation];
537  //FIXME avoid this realloc
538  av_freep(&b->x_coeff);
539  b->x_coeff=av_mallocz(((b->width+1) * b->height+1)*sizeof(x_and_coeff));
540  if (!b->x_coeff)
541  goto fail;
542  }
543  w= (w+1)>>1;
544  h= (h+1)>>1;
545  }
546  }
547 
548  return 0;
549 fail:
550  return AVERROR(ENOMEM);
551 }
552 
553 #define USE_HALFPEL_PLANE 0
554 
555 static int halfpel_interpol(SnowContext *s, uint8_t *halfpel[4][4], AVFrame *frame){
556  int p,x,y;
557 
558  for(p=0; p < s->nb_planes; p++){
559  int is_chroma= !!p;
560  int w= is_chroma ? s->avctx->width >>s->chroma_h_shift : s->avctx->width;
561  int h= is_chroma ? s->avctx->height>>s->chroma_v_shift : s->avctx->height;
562  int ls= frame->linesize[p];
563  uint8_t *src= frame->data[p];
564 
565  halfpel[1][p] = (uint8_t*) av_malloc(ls * (h + 2 * EDGE_WIDTH)) + EDGE_WIDTH * (1 + ls);
566  halfpel[2][p] = (uint8_t*) av_malloc(ls * (h + 2 * EDGE_WIDTH)) + EDGE_WIDTH * (1 + ls);
567  halfpel[3][p] = (uint8_t*) av_malloc(ls * (h + 2 * EDGE_WIDTH)) + EDGE_WIDTH * (1 + ls);
568  if (!halfpel[1][p] || !halfpel[2][p] || !halfpel[3][p])
569  return AVERROR(ENOMEM);
570 
571  halfpel[0][p]= src;
572  for(y=0; y<h; y++){
573  for(x=0; x<w; x++){
574  int i= y*ls + x;
575 
576  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;
577  }
578  }
579  for(y=0; y<h; y++){
580  for(x=0; x<w; x++){
581  int i= y*ls + x;
582 
583  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;
584  }
585  }
586  src= halfpel[1][p];
587  for(y=0; y<h; y++){
588  for(x=0; x<w; x++){
589  int i= y*ls + x;
590 
591  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;
592  }
593  }
594 
595 //FIXME border!
596  }
597  return 0;
598 }
599 
601 {
602  SnowContext *s = avctx->priv_data;
603  int i;
604 
605  if(s->last_picture[s->max_ref_frames-1]->data[0]){
607  for(i=0; i<9; i++)
608  if(s->halfpel_plane[s->max_ref_frames-1][1+i/3][i%3])
609  av_free(s->halfpel_plane[s->max_ref_frames-1][1+i/3][i%3] - EDGE_WIDTH*(1+s->current_picture->linesize[i%3]));
610  }
611 }
612 
614  AVFrame *tmp;
615  int i, ret;
616  int w= s->avctx->width; //FIXME round up to x16 ?
617  int h= s->avctx->height;
618 
619  if (s->current_picture->data[0] && !(s->avctx->flags&CODEC_FLAG_EMU_EDGE)) {
621  s->current_picture->linesize[0], w , h ,
623  if (s->current_picture->data[2]) {
630  }
631  }
632 
634 
635  tmp= s->last_picture[s->max_ref_frames-1];
636  for(i=s->max_ref_frames-1; i>0; i--)
637  s->last_picture[i] = s->last_picture[i-1];
638  memmove(s->halfpel_plane+1, s->halfpel_plane, (s->max_ref_frames-1)*sizeof(void*)*4*4);
639  if(USE_HALFPEL_PLANE && s->current_picture->data[0]) {
640  if((ret = halfpel_interpol(s, s->halfpel_plane[0], s->current_picture)) < 0)
641  return ret;
642  }
643  s->last_picture[0] = s->current_picture;
644  s->current_picture = tmp;
645 
646  if(s->keyframe){
647  s->ref_frames= 0;
648  }else{
649  int i;
650  for(i=0; i<s->max_ref_frames && s->last_picture[i]->data[0]; i++)
651  if(i && s->last_picture[i-1]->key_frame)
652  break;
653  s->ref_frames= i;
654  if(s->ref_frames==0){
655  av_log(s->avctx,AV_LOG_ERROR, "No reference frames\n");
656  return -1;
657  }
658  }
659 
661  return ret;
662 
664 
665  return 0;
666 }
667 
669 {
670  int plane_index, level, orientation, i;
671 
676  av_freep(&s->run_buffer);
677 
678  s->m.me.temp= NULL;
679  av_freep(&s->m.me.scratchpad);
680  av_freep(&s->m.me.map);
681  av_freep(&s->m.me.score_map);
683 
684  av_freep(&s->block);
685  av_freep(&s->scratchbuf);
687 
688  for(i=0; i<MAX_REF_FRAMES; i++){
689  av_freep(&s->ref_mvs[i]);
690  av_freep(&s->ref_scores[i]);
691  if(s->last_picture[i]->data[0]) {
692  av_assert0(s->last_picture[i]->data[0] != s->current_picture->data[0]);
693  }
694  av_frame_free(&s->last_picture[i]);
695  }
696 
697  for(plane_index=0; plane_index < s->nb_planes; plane_index++){
698  for(level=s->spatial_decomposition_count-1; level>=0; level--){
699  for(orientation=level ? 1 : 0; orientation<4; orientation++){
700  SubBand *b= &s->plane[plane_index].band[level][orientation];
701 
702  av_freep(&b->x_coeff);
703  }
704  }
705  }
708 }
uint8_t * scratchpad
data area for the ME algo, so that the ME does not need to malloc/free
Definition: mpegvideo.h:194
av_cold int ff_snow_common_init(AVCodecContext *avctx)
Definition: snow.c:398
MpegEncContext m
Definition: snow.h:172
int mv_scale
Definition: snow.h:153
int ff_snow_frame_start(SnowContext *s)
Definition: snow.c:613
av_cold void ff_dsputil_init(DSPContext *c, AVCodecContext *avctx)
Definition: dsputil.c:2678
float v
const char * s
Definition: avisynth_c.h:668
AVCodecContext * avctx
Definition: snow.h:110
int block_max_depth
Definition: snow.h:160
AVFrame * mconly_picture
Definition: snow.h:122
int chroma_v_shift
Definition: snow.h:146
This structure describes decoded (raw) audio or video data.
Definition: frame.h:96
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
void(* emulated_edge_mc)(uint8_t *dst, ptrdiff_t dst_stride, const uint8_t *src, ptrdiff_t src_stride, 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:61
int * run_buffer
Definition: snow.h:143
#define EDGE_TOP
Definition: dsputil.h:262
#define BLOCK_INTRA
Definition: snow.h:52
#define a0
Definition: regdef.h:46
void(* draw_edges)(uint8_t *buf, int wrap, int width, int height, int w, int h, int sides)
Definition: dsputil.h:260
Range coder.
const char * b
Definition: vf_curves.c:105
void av_log(void *avcl, int level, const char *fmt,...) av_printf_format(3
Send the specified message to the log if the level is less than or equal to the current av_log_level...
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1342
#define mcf(dx, dy)
#define a1
Definition: regdef.h:47
int max_ref_frames
Definition: snow.h:135
uint32_t * score_map
map to store the scores
Definition: mpegvideo.h:200
static const uint8_t obmc4[16]
Definition: snowdata.h:96
int ff_snow_common_init_after_header(AVCodecContext *avctx)
Definition: snow.c:481
int keyframe
Definition: snow.h:126
int stride
Definition: mace.c:144
#define av_cold
Definition: avcodec.h:653
void ff_snow_reset_contexts(SnowContext *s)
Definition: snow.c:69
short IDWTELEM
Definition: dirac_dwt.h:27
HpelDSPContext hdsp
Definition: snow.h:113
void av_freep(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
Definition: mem.c:234
Definition: snow.h:45
int width
Definition: diracdec.c:101
#define HTAPS_MAX
Definition: snow.h:70
uint8_t ref
Definition: snow.h:48
#define a3
Definition: regdef.h:49
int b_height
Definition: snow.h:159
av_cold void ff_h264qpel_init(H264QpelContext *c, int bit_depth)
Definition: h264qpel.c:49
uint8_t
int16_t mx
Definition: snow.h:46
#define FRAC_BITS
static const uint32_t color[16+AV_CLASS_CATEGORY_NB]
Definition: log.c:83
uint32_t * ref_scores[MAX_REF_FRAMES]
Definition: snow.h:138
#define MB_SIZE
Definition: snow.h:68
#define FF_CEIL_RSHIFT(a, b)
Definition: avcodec.h:916
int16_t my
Definition: snow.h:47
#define lrintf(x)
Definition: libm_mips.h:70
void ff_snow_release_buffer(AVCodecContext *avctx)
Definition: snow.c:600
static AVFrame * frame
Definition: demuxing.c:51
BlockNode * block
Definition: snow.h:164
#define mca(dx, dy, b_w)
Definition: snow.c:383
SnowDWTContext dwt
Definition: snow.h:116
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: avcodec.h:4147
void av_free(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc(). ...
Definition: mem.c:219
int16_t(*[MAX_REF_FRAMES] ref_mvs)[2]
Definition: snow.h:137
static int halfpel_interpol(SnowContext *s, uint8_t *halfpel[4][4], AVFrame *frame)
Definition: snow.c:555
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:110
int diag_mc
Definition: snow.h:100
const char * r
Definition: vf_curves.c:103
#define mcfh(dx, dy)
DSPContext dsp
Definition: snow.h:112
int flags
CODEC_FLAG_*.
Definition: avcodec.h:1234
int stride
Definition: diracdec.c:100
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:123
Libavcodec external API header.
qpel_mc_func put_h264_qpel_pixels_tab[4][16]
Definition: h264qpel.h:28
uint8_t * emu_edge_buffer
Definition: snow.h:175
uint8_t color[3]
Definition: snow.h:49
int ref_frames
Definition: snow.h:136
av_cold void ff_hpeldsp_init(HpelDSPContext *c, int flags)
Definition: hpeldsp.c:37
x_and_coeff * x_coeff
Definition: snow.h:88
#define USE_HALFPEL_PLANE
Definition: snow.c:553
goto fail
Definition: avfilter.c:963
av_cold void ff_videodsp_init(VideoDSPContext *ctx, int bpc)
Definition: videodsp.c:38
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:351
float y
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
ret
Definition: avfilter.c:961
static av_cold void init_qexp(void)
Definition: snow.c:98
int width
picture width / height.
Definition: avcodec.h:1314
void * av_malloc(size_t size) av_malloc_attrib 1(1)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:73
uint8_t * scratchbuf
Definition: snow.h:174
#define a2
Definition: regdef.h:48
Plane plane[MAX_PLANES]
Definition: snow.h:163
int b_width
Definition: snow.h:158
MotionEstContext me
Definition: mpegvideo.h:441
#define EDGE_BOTTOM
Definition: dsputil.h:263
int chroma_h_shift
Definition: snow.h:145
VideoDSPContext vdsp
Definition: snow.h:114
uint8_t * halfpel_plane[MAX_REF_FRAMES][4][4]
Definition: snow.h:121
SubBand band[MAX_DWT_LEVELS][4]
Definition: diracdec.c:134
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: frame.h:157
uint8_t block_state[128+32 *128]
Definition: snow.h:125
int ff_scale_mv_ref[MAX_REF_FRAMES][MAX_REF_FRAMES]
Definition: snowdata.h:129
static int width
Definition: utils.c:158
#define a5
Definition: regdef.h:51
AVS_Value src
Definition: avisynth_c.h:523
#define FFMAX(a, b)
Definition: avcodec.h:923
#define LOG2_OBMC_MAX
Definition: snow.h:43
int spatial_decomposition_count
Definition: snow.h:132
int DWTELEM
Definition: dirac_dwt.h:26
main external API structure.
Definition: avcodec.h:1146
int8_t hcoeff[HTAPS_MAX/2]
Definition: snow.h:99
#define QROOT
Definition: snow.h:38
int ff_snow_alloc_blocks(SnowContext *s)
Definition: snow.c:83
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: utils.c:941
struct SubBand * parent
Definition: diracdec.c:105
BYTE int const BYTE int int int height
Definition: avisynth_c.h:713
int nb_planes
Definition: snow.h:162
int buf_y_offset
Definition: snow.h:86
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:124
DWTELEM * temp_dwt_buffer
Definition: snow.h:140
uint8_t header_state[32]
Definition: snow.h:124
static int weight(int i, int blen, int offset)
Definition: diracdec.c:1247
void * priv_data
Definition: avcodec.h:1182
static const uint16_t scale[4]
AVFrame * current_picture
Definition: snow.h:119
uint8_t level
Definition: svq3.c:146
#define MAX_DECOMPOSITIONS
Definition: dirac_dwt.h:30
#define CODEC_FLAG_EMU_EDGE
Don&#39;t draw edges.
Definition: avcodec.h:706
#define MID_STATE
Definition: snow.h:34
common internal api header.
IDWTELEM * temp_idwt_buffer
Definition: snow.h:142
H264QpelContext h264qpel
Definition: snow.h:115
#define FF_ALLOC_OR_GOTO(ctx, p, size, label)
Definition: internal.h:118
#define slice_buffer_get_line(slice_buf, line_num)
Definition: snow_dwt.h:86
uint8_t * obmc_scratchpad
Definition: mpegvideo.h:370
#define LOG2_MB_SIZE
Definition: snow.h:67
DWTELEM * spatial_dwt_buffer
Definition: snow.h:139
void ff_snow_pred_block(SnowContext *s, uint8_t *dst, uint8_t *tmp, ptrdiff_t stride, int sx, int sy, int b_w, int b_h, BlockNode *block, int plane_index, int w, int h)
Definition: snow.c:300
uint8_t state[7+512][32]
Definition: snow.h:90
uint32_t * map
map to avoid duplicate evaluations
Definition: mpegvideo.h:199
IDWTELEM * spatial_idwt_buffer
Definition: snow.h:141
DSP utils.
#define a4
Definition: regdef.h:50
#define MC_STRIDE(x)
#define AVERROR_INVALIDDATA
int buf_x_offset
Definition: snow.h:85
#define EDGE_WIDTH
Definition: dsputil.h:261
int key_frame
1 -&gt; keyframe, 0-&gt; not
Definition: frame.h:162
int height
Definition: diracdec.c:102
IDWTELEM * ibuf
Definition: diracdec.c:104
int fast_mc
Definition: snow.h:101
#define AVERROR(e)
int width
Definition: diracdec.c:113
av_cold void ff_snow_common_end(SnowContext *s)
Definition: snow.c:668
uint8_t ff_qexp[QROOT]
Definition: snowdata.h:128
DWTELEM * buf
Definition: snow.h:83
#define MAX_REF_FRAMES
Definition: snow.h:41
uint8_t * temp
Definition: mpegvideo.h:197
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
uint8_t type
Definition: snow.h:50
Used to minimize the amount of memory used in order to optimize cache performance.
Definition: snow_dwt.h:41
AVFrame * last_picture[MAX_REF_FRAMES]
Definition: snow.h:120
int height
Definition: diracdec.c:114
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
Definition: avcodec.h:910
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:107
#define FF_ALLOCZ_OR_GOTO(ctx, p, size, label)
Definition: internal.h:127
void ff_dwt_init(SnowDWTContext *c)
Definition: snow_dwt.c:855
void * av_mallocz(size_t size) av_malloc_attrib 1(1)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:241
int level
Definition: diracdec.c:98
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:63
int stride_line
Stride measured in lines, not pixels.
Definition: snow.h:87
static int16_t block[64]
Definition: dct-test.c:198