FFmpeg
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
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 // assert(b_w == b_h || 2*b_w == b_h || b_w == 2*b_h);
356 // assert(!(b_w&(b_w-1)));
357  av_assert2(b_w>1 && b_h>1);
358  av_assert2((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->h264qpel.put_h264_qpel_pixels_tab[0][dy+(dx>>2)](dst + y*stride, src + 3 + (y+3)*stride,stride);
365  s->h264qpel.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->h264qpel.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->h264qpel.put_h264_qpel_pixels_tab[tab_index+1][dy+(dx>>2)](dst ,src + 3 + 3*stride,stride);
371  s->h264qpel.put_h264_qpel_pixels_tab[tab_index+1][dy+(dx>>2)](dst+b_h,src + 3 + b_h + 3*stride,stride);
372  }else{
373  av_assert2(2*b_w==b_h);
374  s->h264qpel.put_h264_qpel_pixels_tab[tab_index ][dy+(dx>>2)](dst ,src + 3 + 3*stride ,stride);
375  s->h264qpel.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, ptrdiff_t stride, int h){\
382  av_assert2(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 
395 av_cold int ff_snow_common_init(AVCodecContext *avctx){
396  SnowContext *s = avctx->priv_data;
397  int width, height;
398  int i, j;
399 
400  s->avctx= avctx;
401  s->max_ref_frames=1; //just make sure it's not an invalid value in case of no initial keyframe
402 
403  ff_dsputil_init(&s->dsp, avctx);
404  ff_videodsp_init(&s->vdsp, 8);
405  ff_dwt_init(&s->dwt);
406  ff_h264qpel_init(&s->h264qpel, 8);
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->h264qpel.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->h264qpel.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  return 0;
464 fail:
465  return AVERROR(ENOMEM);
466 }
467 
468 int ff_snow_common_init_after_header(AVCodecContext *avctx) {
469  SnowContext *s = avctx->priv_data;
470  int plane_index, level, orientation;
471  int ret, emu_buf_size;
472 
473  if(!s->scratchbuf) {
474  if ((ret = ff_get_buffer(s->avctx, &s->mconly_picture)) < 0) {
475  av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
476  return ret;
477  }
478  FF_ALLOCZ_OR_GOTO(avctx, s->scratchbuf, FFMAX(s->mconly_picture.linesize[0], 2*avctx->width+256)*7*MB_SIZE, fail);
479  emu_buf_size = FFMAX(s->mconly_picture.linesize[0], 2*avctx->width+256) * (2 * MB_SIZE + HTAPS_MAX - 1);
480  FF_ALLOC_OR_GOTO(avctx, s->emu_edge_buffer, emu_buf_size, fail);
481  }
482 
483  if(s->mconly_picture.format != avctx->pix_fmt) {
484  av_log(avctx, AV_LOG_ERROR, "pixel format changed\n");
485  return AVERROR_INVALIDDATA;
486  }
487 
488  for(plane_index=0; plane_index<3; plane_index++){
489  int w= s->avctx->width;
490  int h= s->avctx->height;
491 
492  if(plane_index){
493  w>>= s->chroma_h_shift;
494  h>>= s->chroma_v_shift;
495  }
496  s->plane[plane_index].width = w;
497  s->plane[plane_index].height= h;
498 
499  for(level=s->spatial_decomposition_count-1; level>=0; level--){
500  for(orientation=level ? 1 : 0; orientation<4; orientation++){
501  SubBand *b= &s->plane[plane_index].band[level][orientation];
502 
503  b->buf= s->spatial_dwt_buffer;
504  b->level= level;
505  b->stride= s->plane[plane_index].width << (s->spatial_decomposition_count - level);
506  b->width = (w + !(orientation&1))>>1;
507  b->height= (h + !(orientation>1))>>1;
508 
509  b->stride_line = 1 << (s->spatial_decomposition_count - level);
510  b->buf_x_offset = 0;
511  b->buf_y_offset = 0;
512 
513  if(orientation&1){
514  b->buf += (w+1)>>1;
515  b->buf_x_offset = (w+1)>>1;
516  }
517  if(orientation>1){
518  b->buf += b->stride>>1;
519  b->buf_y_offset = b->stride_line >> 1;
520  }
521  b->ibuf= s->spatial_idwt_buffer + (b->buf - s->spatial_dwt_buffer);
522 
523  if(level)
524  b->parent= &s->plane[plane_index].band[level-1][orientation];
525  //FIXME avoid this realloc
526  av_freep(&b->x_coeff);
527  b->x_coeff=av_mallocz(((b->width+1) * b->height+1)*sizeof(x_and_coeff));
528  }
529  w= (w+1)>>1;
530  h= (h+1)>>1;
531  }
532  }
533 
534  return 0;
535 fail:
536  return AVERROR(ENOMEM);
537 }
538 
539 #define USE_HALFPEL_PLANE 0
540 
541 static void halfpel_interpol(SnowContext *s, uint8_t *halfpel[4][4], AVFrame *frame){
542  int p,x,y;
543 
544  for(p=0; p<3; p++){
545  int is_chroma= !!p;
546  int w= is_chroma ? s->avctx->width >>s->chroma_h_shift : s->avctx->width;
547  int h= is_chroma ? s->avctx->height>>s->chroma_v_shift : s->avctx->height;
548  int ls= frame->linesize[p];
549  uint8_t *src= frame->data[p];
550 
551  halfpel[1][p] = (uint8_t*) av_malloc(ls * (h + 2 * EDGE_WIDTH)) + EDGE_WIDTH * (1 + ls);
552  halfpel[2][p] = (uint8_t*) av_malloc(ls * (h + 2 * EDGE_WIDTH)) + EDGE_WIDTH * (1 + ls);
553  halfpel[3][p] = (uint8_t*) av_malloc(ls * (h + 2 * EDGE_WIDTH)) + EDGE_WIDTH * (1 + ls);
554 
555  halfpel[0][p]= src;
556  for(y=0; y<h; y++){
557  for(x=0; x<w; x++){
558  int i= y*ls + x;
559 
560  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;
561  }
562  }
563  for(y=0; y<h; y++){
564  for(x=0; x<w; x++){
565  int i= y*ls + x;
566 
567  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;
568  }
569  }
570  src= halfpel[1][p];
571  for(y=0; y<h; y++){
572  for(x=0; x<w; x++){
573  int i= y*ls + x;
574 
575  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;
576  }
577  }
578 
579 //FIXME border!
580  }
581 }
582 
583 void ff_snow_release_buffer(AVCodecContext *avctx)
584 {
585  SnowContext *s = avctx->priv_data;
586  int i;
587 
588  if(s->last_picture[s->max_ref_frames-1].data[0]){
589  avctx->release_buffer(avctx, &s->last_picture[s->max_ref_frames-1]);
590  for(i=0; i<9; i++)
591  if(s->halfpel_plane[s->max_ref_frames-1][1+i/3][i%3])
592  av_free(s->halfpel_plane[s->max_ref_frames-1][1+i/3][i%3] - EDGE_WIDTH*(1+s->current_picture.linesize[i%3]));
593  }
594 }
595 
596 int ff_snow_frame_start(SnowContext *s){
597  AVFrame tmp;
598  int w= s->avctx->width; //FIXME round up to x16 ?
599  int h= s->avctx->height;
600 
601  if (s->current_picture.data[0] && !(s->avctx->flags&CODEC_FLAG_EMU_EDGE)) {
602  s->dsp.draw_edges(s->current_picture.data[0],
603  s->current_picture.linesize[0], w , h ,
604  EDGE_WIDTH , EDGE_WIDTH , EDGE_TOP | EDGE_BOTTOM);
605  s->dsp.draw_edges(s->current_picture.data[1],
606  s->current_picture.linesize[1], w>>s->chroma_h_shift, h>>s->chroma_v_shift,
607  EDGE_WIDTH>>s->chroma_h_shift, EDGE_WIDTH>>s->chroma_v_shift, EDGE_TOP | EDGE_BOTTOM);
608  s->dsp.draw_edges(s->current_picture.data[2],
609  s->current_picture.linesize[2], w>>s->chroma_h_shift, h>>s->chroma_v_shift,
610  EDGE_WIDTH>>s->chroma_h_shift, EDGE_WIDTH>>s->chroma_v_shift, EDGE_TOP | EDGE_BOTTOM);
611  }
612 
613  ff_snow_release_buffer(s->avctx);
614 
615  tmp= s->last_picture[s->max_ref_frames-1];
616  memmove(s->last_picture+1, s->last_picture, (s->max_ref_frames-1)*sizeof(AVFrame));
617  memmove(s->halfpel_plane+1, s->halfpel_plane, (s->max_ref_frames-1)*sizeof(void*)*4*4);
618  if(USE_HALFPEL_PLANE && s->current_picture.data[0])
619  halfpel_interpol(s, s->halfpel_plane[0], &s->current_picture);
620  s->last_picture[0]= s->current_picture;
621  s->current_picture= tmp;
622 
623  if(s->keyframe){
624  s->ref_frames= 0;
625  }else{
626  int i;
627  for(i=0; i<s->max_ref_frames && s->last_picture[i].data[0]; i++)
628  if(i && s->last_picture[i-1].key_frame)
629  break;
630  s->ref_frames= i;
631  if(s->ref_frames==0){
632  av_log(s->avctx,AV_LOG_ERROR, "No reference frames\n");
633  return -1;
634  }
635  }
636 
637  s->current_picture.reference= 3;
638  if(ff_get_buffer(s->avctx, &s->current_picture) < 0){
639  av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
640  return -1;
641  }
642 
643  s->current_picture.key_frame= s->keyframe;
644 
645  return 0;
646 }
647 
648 av_cold void ff_snow_common_end(SnowContext *s)
649 {
650  int plane_index, level, orientation, i;
651 
652  av_freep(&s->spatial_dwt_buffer);
653  av_freep(&s->temp_dwt_buffer);
654  av_freep(&s->spatial_idwt_buffer);
655  av_freep(&s->temp_idwt_buffer);
656  av_freep(&s->run_buffer);
657 
658  s->m.me.temp= NULL;
659  av_freep(&s->m.me.scratchpad);
660  av_freep(&s->m.me.map);
661  av_freep(&s->m.me.score_map);
662  av_freep(&s->m.obmc_scratchpad);
663 
664  av_freep(&s->block);
665  av_freep(&s->scratchbuf);
666  av_freep(&s->emu_edge_buffer);
667 
668  for(i=0; i<MAX_REF_FRAMES; i++){
669  av_freep(&s->ref_mvs[i]);
670  av_freep(&s->ref_scores[i]);
671  if(s->last_picture[i].data[0]) {
672  av_assert0(s->last_picture[i].data[0] != s->current_picture.data[0]);
673  s->avctx->release_buffer(s->avctx, &s->last_picture[i]);
674  }
675  }
676 
677  for(plane_index=0; plane_index<3; plane_index++){
678  for(level=s->spatial_decomposition_count-1; level>=0; level--){
679  for(orientation=level ? 1 : 0; orientation<4; orientation++){
680  SubBand *b= &s->plane[plane_index].band[level][orientation];
681 
682  av_freep(&b->x_coeff);
683  }
684  }
685  }
686  if (s->mconly_picture.data[0])
687  s->avctx->release_buffer(s->avctx, &s->mconly_picture);
688  if (s->current_picture.data[0])
689  s->avctx->release_buffer(s->avctx, &s->current_picture);
690 }
Generated on Sat May 25 2013 04:01:10 for FFmpeg by   doxygen 1.8.2