FFmpeg
 All Data Structures Namespaces 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= FF_CEIL_RSHIFT(s->avctx->width, LOG2_MB_SIZE);
85  int h= FF_CEIL_RSHIFT(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 av_cold void init_qexp(void){
96  int i;
97  double v=128;
98 
99  for(i=0; i<QROOT; i++){
100  ff_qexp[i]= lrintf(v);
101  v *= pow(2, 1.0 / QROOT);
102  }
103 }
104 static void mc_block(Plane *p, uint8_t *dst, const uint8_t *src, int stride, int b_w, int b_h, int dx, int dy){
105  static const uint8_t weight[64]={
106  8,7,6,5,4,3,2,1,
107  7,7,0,0,0,0,0,1,
108  6,0,6,0,0,0,2,0,
109  5,0,0,5,0,3,0,0,
110  4,0,0,0,4,0,0,0,
111  3,0,0,5,0,3,0,0,
112  2,0,6,0,0,0,2,0,
113  1,7,0,0,0,0,0,1,
114  };
115 
116  static const uint8_t brane[256]={
117  0x00,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x11,0x12,0x12,0x12,0x12,0x12,0x12,0x12,
118  0x04,0x05,0xcc,0xcc,0xcc,0xcc,0xcc,0x41,0x15,0x16,0xcc,0xcc,0xcc,0xcc,0xcc,0x52,
119  0x04,0xcc,0x05,0xcc,0xcc,0xcc,0x41,0xcc,0x15,0xcc,0x16,0xcc,0xcc,0xcc,0x52,0xcc,
120  0x04,0xcc,0xcc,0x05,0xcc,0x41,0xcc,0xcc,0x15,0xcc,0xcc,0x16,0xcc,0x52,0xcc,0xcc,
121  0x04,0xcc,0xcc,0xcc,0x41,0xcc,0xcc,0xcc,0x15,0xcc,0xcc,0xcc,0x16,0xcc,0xcc,0xcc,
122  0x04,0xcc,0xcc,0x41,0xcc,0x05,0xcc,0xcc,0x15,0xcc,0xcc,0x52,0xcc,0x16,0xcc,0xcc,
123  0x04,0xcc,0x41,0xcc,0xcc,0xcc,0x05,0xcc,0x15,0xcc,0x52,0xcc,0xcc,0xcc,0x16,0xcc,
124  0x04,0x41,0xcc,0xcc,0xcc,0xcc,0xcc,0x05,0x15,0x52,0xcc,0xcc,0xcc,0xcc,0xcc,0x16,
125  0x44,0x45,0x45,0x45,0x45,0x45,0x45,0x45,0x55,0x56,0x56,0x56,0x56,0x56,0x56,0x56,
126  0x48,0x49,0xcc,0xcc,0xcc,0xcc,0xcc,0x85,0x59,0x5A,0xcc,0xcc,0xcc,0xcc,0xcc,0x96,
127  0x48,0xcc,0x49,0xcc,0xcc,0xcc,0x85,0xcc,0x59,0xcc,0x5A,0xcc,0xcc,0xcc,0x96,0xcc,
128  0x48,0xcc,0xcc,0x49,0xcc,0x85,0xcc,0xcc,0x59,0xcc,0xcc,0x5A,0xcc,0x96,0xcc,0xcc,
129  0x48,0xcc,0xcc,0xcc,0x49,0xcc,0xcc,0xcc,0x59,0xcc,0xcc,0xcc,0x96,0xcc,0xcc,0xcc,
130  0x48,0xcc,0xcc,0x85,0xcc,0x49,0xcc,0xcc,0x59,0xcc,0xcc,0x96,0xcc,0x5A,0xcc,0xcc,
131  0x48,0xcc,0x85,0xcc,0xcc,0xcc,0x49,0xcc,0x59,0xcc,0x96,0xcc,0xcc,0xcc,0x5A,0xcc,
132  0x48,0x85,0xcc,0xcc,0xcc,0xcc,0xcc,0x49,0x59,0x96,0xcc,0xcc,0xcc,0xcc,0xcc,0x5A,
133  };
134 
135  static const uint8_t needs[16]={
136  0,1,0,0,
137  2,4,2,0,
138  0,1,0,0,
139  15
140  };
141 
142  int x, y, b, r, l;
143  int16_t tmpIt [64*(32+HTAPS_MAX)];
144  uint8_t tmp2t[3][64*(32+HTAPS_MAX)];
145  int16_t *tmpI= tmpIt;
146  uint8_t *tmp2= tmp2t[0];
147  const uint8_t *hpel[11];
148  av_assert2(dx<16 && dy<16);
149  r= brane[dx + 16*dy]&15;
150  l= brane[dx + 16*dy]>>4;
151 
152  b= needs[l] | needs[r];
153  if(p && !p->diag_mc)
154  b= 15;
155 
156  if(b&5){
157  for(y=0; y < b_h+HTAPS_MAX-1; y++){
158  for(x=0; x < b_w; x++){
159  int a_1=src[x + HTAPS_MAX/2-4];
160  int a0= src[x + HTAPS_MAX/2-3];
161  int a1= src[x + HTAPS_MAX/2-2];
162  int a2= src[x + HTAPS_MAX/2-1];
163  int a3= src[x + HTAPS_MAX/2+0];
164  int a4= src[x + HTAPS_MAX/2+1];
165  int a5= src[x + HTAPS_MAX/2+2];
166  int a6= src[x + HTAPS_MAX/2+3];
167  int am=0;
168  if(!p || p->fast_mc){
169  am= 20*(a2+a3) - 5*(a1+a4) + (a0+a5);
170  tmpI[x]= am;
171  am= (am+16)>>5;
172  }else{
173  am= p->hcoeff[0]*(a2+a3) + p->hcoeff[1]*(a1+a4) + p->hcoeff[2]*(a0+a5) + p->hcoeff[3]*(a_1+a6);
174  tmpI[x]= am;
175  am= (am+32)>>6;
176  }
177 
178  if(am&(~255)) am= ~(am>>31);
179  tmp2[x]= am;
180  }
181  tmpI+= 64;
182  tmp2+= 64;
183  src += stride;
184  }
185  src -= stride*y;
186  }
187  src += HTAPS_MAX/2 - 1;
188  tmp2= tmp2t[1];
189 
190  if(b&2){
191  for(y=0; y < b_h; y++){
192  for(x=0; x < b_w+1; x++){
193  int a_1=src[x + (HTAPS_MAX/2-4)*stride];
194  int a0= src[x + (HTAPS_MAX/2-3)*stride];
195  int a1= src[x + (HTAPS_MAX/2-2)*stride];
196  int a2= src[x + (HTAPS_MAX/2-1)*stride];
197  int a3= src[x + (HTAPS_MAX/2+0)*stride];
198  int a4= src[x + (HTAPS_MAX/2+1)*stride];
199  int a5= src[x + (HTAPS_MAX/2+2)*stride];
200  int a6= src[x + (HTAPS_MAX/2+3)*stride];
201  int am=0;
202  if(!p || p->fast_mc)
203  am= (20*(a2+a3) - 5*(a1+a4) + (a0+a5) + 16)>>5;
204  else
205  am= (p->hcoeff[0]*(a2+a3) + p->hcoeff[1]*(a1+a4) + p->hcoeff[2]*(a0+a5) + p->hcoeff[3]*(a_1+a6) + 32)>>6;
206 
207  if(am&(~255)) am= ~(am>>31);
208  tmp2[x]= am;
209  }
210  src += stride;
211  tmp2+= 64;
212  }
213  src -= stride*y;
214  }
215  src += stride*(HTAPS_MAX/2 - 1);
216  tmp2= tmp2t[2];
217  tmpI= tmpIt;
218  if(b&4){
219  for(y=0; y < b_h; y++){
220  for(x=0; x < b_w; x++){
221  int a_1=tmpI[x + (HTAPS_MAX/2-4)*64];
222  int a0= tmpI[x + (HTAPS_MAX/2-3)*64];
223  int a1= tmpI[x + (HTAPS_MAX/2-2)*64];
224  int a2= tmpI[x + (HTAPS_MAX/2-1)*64];
225  int a3= tmpI[x + (HTAPS_MAX/2+0)*64];
226  int a4= tmpI[x + (HTAPS_MAX/2+1)*64];
227  int a5= tmpI[x + (HTAPS_MAX/2+2)*64];
228  int a6= tmpI[x + (HTAPS_MAX/2+3)*64];
229  int am=0;
230  if(!p || p->fast_mc)
231  am= (20*(a2+a3) - 5*(a1+a4) + (a0+a5) + 512)>>10;
232  else
233  am= (p->hcoeff[0]*(a2+a3) + p->hcoeff[1]*(a1+a4) + p->hcoeff[2]*(a0+a5) + p->hcoeff[3]*(a_1+a6) + 2048)>>12;
234  if(am&(~255)) am= ~(am>>31);
235  tmp2[x]= am;
236  }
237  tmpI+= 64;
238  tmp2+= 64;
239  }
240  }
241 
242  hpel[ 0]= src;
243  hpel[ 1]= tmp2t[0] + 64*(HTAPS_MAX/2-1);
244  hpel[ 2]= src + 1;
245 
246  hpel[ 4]= tmp2t[1];
247  hpel[ 5]= tmp2t[2];
248  hpel[ 6]= tmp2t[1] + 1;
249 
250  hpel[ 8]= src + stride;
251  hpel[ 9]= hpel[1] + 64;
252  hpel[10]= hpel[8] + 1;
253 
254 #define MC_STRIDE(x) (needs[x] ? 64 : stride)
255 
256  if(b==15){
257  int dxy = dx / 8 + dy / 8 * 4;
258  const uint8_t *src1 = hpel[dxy ];
259  const uint8_t *src2 = hpel[dxy + 1];
260  const uint8_t *src3 = hpel[dxy + 4];
261  const uint8_t *src4 = hpel[dxy + 5];
262  int stride1 = MC_STRIDE(dxy);
263  int stride2 = MC_STRIDE(dxy + 1);
264  int stride3 = MC_STRIDE(dxy + 4);
265  int stride4 = MC_STRIDE(dxy + 5);
266  dx&=7;
267  dy&=7;
268  for(y=0; y < b_h; y++){
269  for(x=0; x < b_w; x++){
270  dst[x]= ((8-dx)*(8-dy)*src1[x] + dx*(8-dy)*src2[x]+
271  (8-dx)* dy *src3[x] + dx* dy *src4[x]+32)>>6;
272  }
273  src1+=stride1;
274  src2+=stride2;
275  src3+=stride3;
276  src4+=stride4;
277  dst +=stride;
278  }
279  }else{
280  const uint8_t *src1= hpel[l];
281  const uint8_t *src2= hpel[r];
282  int stride1 = MC_STRIDE(l);
283  int stride2 = MC_STRIDE(r);
284  int a= weight[((dx&7) + (8*(dy&7)))];
285  int b= 8-a;
286  for(y=0; y < b_h; y++){
287  for(x=0; x < b_w; x++){
288  dst[x]= (a*src1[x] + b*src2[x] + 4)>>3;
289  }
290  src1+=stride1;
291  src2+=stride2;
292  dst +=stride;
293  }
294  }
295 }
296 
297 void ff_snow_pred_block(SnowContext *s, uint8_t *dst, uint8_t *tmp, int stride, int sx, int sy, int b_w, int b_h, BlockNode *block, int plane_index, int w, int h){
298  if(block->type & BLOCK_INTRA){
299  int x, y;
300  const unsigned color = block->color[plane_index];
301  const unsigned color4 = color*0x01010101;
302  if(b_w==32){
303  for(y=0; y < b_h; y++){
304  *(uint32_t*)&dst[0 + y*stride]= color4;
305  *(uint32_t*)&dst[4 + y*stride]= color4;
306  *(uint32_t*)&dst[8 + y*stride]= color4;
307  *(uint32_t*)&dst[12+ y*stride]= color4;
308  *(uint32_t*)&dst[16+ y*stride]= color4;
309  *(uint32_t*)&dst[20+ y*stride]= color4;
310  *(uint32_t*)&dst[24+ y*stride]= color4;
311  *(uint32_t*)&dst[28+ y*stride]= color4;
312  }
313  }else if(b_w==16){
314  for(y=0; y < b_h; y++){
315  *(uint32_t*)&dst[0 + y*stride]= color4;
316  *(uint32_t*)&dst[4 + y*stride]= color4;
317  *(uint32_t*)&dst[8 + y*stride]= color4;
318  *(uint32_t*)&dst[12+ y*stride]= color4;
319  }
320  }else if(b_w==8){
321  for(y=0; y < b_h; y++){
322  *(uint32_t*)&dst[0 + y*stride]= color4;
323  *(uint32_t*)&dst[4 + y*stride]= color4;
324  }
325  }else if(b_w==4){
326  for(y=0; y < b_h; y++){
327  *(uint32_t*)&dst[0 + y*stride]= color4;
328  }
329  }else{
330  for(y=0; y < b_h; y++){
331  for(x=0; x < b_w; x++){
332  dst[x + y*stride]= color;
333  }
334  }
335  }
336  }else{
337  uint8_t *src= s->last_picture[block->ref].data[plane_index];
338  const int scale= plane_index ? (2*s->mv_scale)>>s->chroma_h_shift : 2*s->mv_scale;
339  int mx= block->mx*scale;
340  int my= block->my*scale;
341  const int dx= mx&15;
342  const int dy= my&15;
343  const int tab_index= 3 - (b_w>>2) + (b_w>>4);
344  sx += (mx>>4) - (HTAPS_MAX/2-1);
345  sy += (my>>4) - (HTAPS_MAX/2-1);
346  src += sx + sy*stride;
347  if( (unsigned)sx >= FFMAX(w - b_w - (HTAPS_MAX-2), 0)
348  || (unsigned)sy >= FFMAX(h - b_h - (HTAPS_MAX-2), 0)){
349  s->vdsp.emulated_edge_mc(tmp + MB_SIZE, src, stride, b_w+HTAPS_MAX-1, b_h+HTAPS_MAX-1, sx, sy, w, h);
350  src= tmp + MB_SIZE;
351  }
352 
353  av_assert2(s->chroma_h_shift == s->chroma_v_shift); // only one mv_scale
354 
355  av_assert2(b_w>1 && b_h>1);
356  av_assert2((tab_index>=0 && tab_index<4) || b_w==32);
357  if((dx&3) || (dy&3) || !(b_w == b_h || 2*b_w == b_h || b_w == 2*b_h) || (b_w&(b_w-1)) || !s->plane[plane_index].fast_mc )
358  mc_block(&s->plane[plane_index], dst, src, stride, b_w, b_h, dx, dy);
359  else if(b_w==32){
360  int y;
361  for(y=0; y<b_h; y+=16){
362  s->h264qpel.put_h264_qpel_pixels_tab[0][dy+(dx>>2)](dst + y*stride, src + 3 + (y+3)*stride,stride);
363  s->h264qpel.put_h264_qpel_pixels_tab[0][dy+(dx>>2)](dst + 16 + y*stride, src + 19 + (y+3)*stride,stride);
364  }
365  }else if(b_w==b_h)
366  s->h264qpel.put_h264_qpel_pixels_tab[tab_index ][dy+(dx>>2)](dst,src + 3 + 3*stride,stride);
367  else if(b_w==2*b_h){
368  s->h264qpel.put_h264_qpel_pixels_tab[tab_index+1][dy+(dx>>2)](dst ,src + 3 + 3*stride,stride);
369  s->h264qpel.put_h264_qpel_pixels_tab[tab_index+1][dy+(dx>>2)](dst+b_h,src + 3 + b_h + 3*stride,stride);
370  }else{
371  av_assert2(2*b_w==b_h);
372  s->h264qpel.put_h264_qpel_pixels_tab[tab_index ][dy+(dx>>2)](dst ,src + 3 + 3*stride ,stride);
373  s->h264qpel.put_h264_qpel_pixels_tab[tab_index ][dy+(dx>>2)](dst+b_w*stride,src + 3 + 3*stride+b_w*stride,stride);
374  }
375  }
376 }
377 
378 #define mca(dx,dy,b_w)\
379 static void mc_block_hpel ## dx ## dy ## b_w(uint8_t *dst, const uint8_t *src, ptrdiff_t stride, int h){\
380  av_assert2(h==b_w);\
381  mc_block(NULL, dst, src-(HTAPS_MAX/2-1)-(HTAPS_MAX/2-1)*stride, stride, b_w, b_w, dx, dy);\
382 }
383 
384 mca( 0, 0,16)
385 mca( 8, 0,16)
386 mca( 0, 8,16)
387 mca( 8, 8,16)
388 mca( 0, 0,8)
389 mca( 8, 0,8)
390 mca( 0, 8,8)
391 mca( 8, 8,8)
392 
393 av_cold int ff_snow_common_init(AVCodecContext *avctx){
394  SnowContext *s = avctx->priv_data;
395  int width, height;
396  int i, j;
397 
398  s->avctx= avctx;
399  s->max_ref_frames=1; //just make sure it's not an invalid value in case of no initial keyframe
400 
401  ff_dsputil_init(&s->dsp, avctx);
402  ff_hpeldsp_init(&s->hdsp, avctx->flags);
403  ff_videodsp_init(&s->vdsp, 8);
404  ff_dwt_init(&s->dwt);
405  ff_h264qpel_init(&s->h264qpel, 8);
406 
407 #define mcf(dx,dy)\
408  s->dsp.put_qpel_pixels_tab [0][dy+dx/4]=\
409  s->dsp.put_no_rnd_qpel_pixels_tab[0][dy+dx/4]=\
410  s->h264qpel.put_h264_qpel_pixels_tab[0][dy+dx/4];\
411  s->dsp.put_qpel_pixels_tab [1][dy+dx/4]=\
412  s->dsp.put_no_rnd_qpel_pixels_tab[1][dy+dx/4]=\
413  s->h264qpel.put_h264_qpel_pixels_tab[1][dy+dx/4];
414 
415  mcf( 0, 0)
416  mcf( 4, 0)
417  mcf( 8, 0)
418  mcf(12, 0)
419  mcf( 0, 4)
420  mcf( 4, 4)
421  mcf( 8, 4)
422  mcf(12, 4)
423  mcf( 0, 8)
424  mcf( 4, 8)
425  mcf( 8, 8)
426  mcf(12, 8)
427  mcf( 0,12)
428  mcf( 4,12)
429  mcf( 8,12)
430  mcf(12,12)
431 
432 #define mcfh(dx,dy)\
433  s->hdsp.put_pixels_tab [0][dy/4+dx/8]=\
434  s->hdsp.put_no_rnd_pixels_tab[0][dy/4+dx/8]=\
435  mc_block_hpel ## dx ## dy ## 16;\
436  s->hdsp.put_pixels_tab [1][dy/4+dx/8]=\
437  s->hdsp.put_no_rnd_pixels_tab[1][dy/4+dx/8]=\
438  mc_block_hpel ## dx ## dy ## 8;
439 
440  mcfh(0, 0)
441  mcfh(8, 0)
442  mcfh(0, 8)
443  mcfh(8, 8)
444 
445  init_qexp();
446 
447 // dec += FFMAX(s->chroma_h_shift, s->chroma_v_shift);
448 
449  width= s->avctx->width;
450  height= s->avctx->height;
451 
452  FF_ALLOCZ_OR_GOTO(avctx, s->spatial_idwt_buffer, width * height * sizeof(IDWTELEM), fail);
453  FF_ALLOCZ_OR_GOTO(avctx, s->spatial_dwt_buffer, width * height * sizeof(DWTELEM), fail); //FIXME this does not belong here
454  FF_ALLOCZ_OR_GOTO(avctx, s->temp_dwt_buffer, width * sizeof(DWTELEM), fail);
455  FF_ALLOCZ_OR_GOTO(avctx, s->temp_idwt_buffer, width * sizeof(IDWTELEM), fail);
456  FF_ALLOC_OR_GOTO(avctx, s->run_buffer, ((width + 1) >> 1) * ((height + 1) >> 1) * sizeof(*s->run_buffer), fail);
457 
458  for(i=0; i<MAX_REF_FRAMES; i++) {
459  for(j=0; j<MAX_REF_FRAMES; j++)
460  ff_scale_mv_ref[i][j] = 256*(i+1)/(j+1);
461  avcodec_get_frame_defaults(&s->last_picture[i]);
462  }
463 
464  avcodec_get_frame_defaults(&s->mconly_picture);
465  avcodec_get_frame_defaults(&s->current_picture);
466 
467  return 0;
468 fail:
469  return AVERROR(ENOMEM);
470 }
471 
472 int ff_snow_common_init_after_header(AVCodecContext *avctx) {
473  SnowContext *s = avctx->priv_data;
474  int plane_index, level, orientation;
475  int ret, emu_buf_size;
476 
477  if(!s->scratchbuf) {
478  if ((ret = ff_get_buffer(s->avctx, &s->mconly_picture,
479  AV_GET_BUFFER_FLAG_REF)) < 0)
480  return ret;
481  FF_ALLOCZ_OR_GOTO(avctx, s->scratchbuf, FFMAX(s->mconly_picture.linesize[0], 2*avctx->width+256)*7*MB_SIZE, fail);
482  emu_buf_size = FFMAX(s->mconly_picture.linesize[0], 2*avctx->width+256) * (2 * MB_SIZE + HTAPS_MAX - 1);
483  FF_ALLOC_OR_GOTO(avctx, s->emu_edge_buffer, emu_buf_size, fail);
484  }
485 
486  if(s->mconly_picture.format != avctx->pix_fmt) {
487  av_log(avctx, AV_LOG_ERROR, "pixel format changed\n");
488  return AVERROR_INVALIDDATA;
489  }
490 
491  for(plane_index=0; plane_index<3; plane_index++){
492  int w= s->avctx->width;
493  int h= s->avctx->height;
494 
495  if(plane_index){
496  w>>= s->chroma_h_shift;
497  h>>= s->chroma_v_shift;
498  }
499  s->plane[plane_index].width = w;
500  s->plane[plane_index].height= h;
501 
502  for(level=s->spatial_decomposition_count-1; level>=0; level--){
503  for(orientation=level ? 1 : 0; orientation<4; orientation++){
504  SubBand *b= &s->plane[plane_index].band[level][orientation];
505 
506  b->buf= s->spatial_dwt_buffer;
507  b->level= level;
508  b->stride= s->plane[plane_index].width << (s->spatial_decomposition_count - level);
509  b->width = (w + !(orientation&1))>>1;
510  b->height= (h + !(orientation>1))>>1;
511 
512  b->stride_line = 1 << (s->spatial_decomposition_count - level);
513  b->buf_x_offset = 0;
514  b->buf_y_offset = 0;
515 
516  if(orientation&1){
517  b->buf += (w+1)>>1;
518  b->buf_x_offset = (w+1)>>1;
519  }
520  if(orientation>1){
521  b->buf += b->stride>>1;
522  b->buf_y_offset = b->stride_line >> 1;
523  }
524  b->ibuf= s->spatial_idwt_buffer + (b->buf - s->spatial_dwt_buffer);
525 
526  if(level)
527  b->parent= &s->plane[plane_index].band[level-1][orientation];
528  //FIXME avoid this realloc
529  av_freep(&b->x_coeff);
530  b->x_coeff=av_mallocz(((b->width+1) * b->height+1)*sizeof(x_and_coeff));
531  }
532  w= (w+1)>>1;
533  h= (h+1)>>1;
534  }
535  }
536 
537  return 0;
538 fail:
539  return AVERROR(ENOMEM);
540 }
541 
542 #define USE_HALFPEL_PLANE 0
543 
544 static void halfpel_interpol(SnowContext *s, uint8_t *halfpel[4][4], AVFrame *frame){
545  int p,x,y;
546 
547  for(p=0; p<3; p++){
548  int is_chroma= !!p;
549  int w= is_chroma ? s->avctx->width >>s->chroma_h_shift : s->avctx->width;
550  int h= is_chroma ? s->avctx->height>>s->chroma_v_shift : s->avctx->height;
551  int ls= frame->linesize[p];
552  uint8_t *src= frame->data[p];
553 
554  halfpel[1][p] = (uint8_t*) av_malloc(ls * (h + 2 * EDGE_WIDTH)) + EDGE_WIDTH * (1 + ls);
555  halfpel[2][p] = (uint8_t*) av_malloc(ls * (h + 2 * EDGE_WIDTH)) + EDGE_WIDTH * (1 + ls);
556  halfpel[3][p] = (uint8_t*) av_malloc(ls * (h + 2 * EDGE_WIDTH)) + EDGE_WIDTH * (1 + ls);
557 
558  halfpel[0][p]= src;
559  for(y=0; y<h; y++){
560  for(x=0; x<w; x++){
561  int i= y*ls + x;
562 
563  halfpel[1][p][i]= (20*(src[i] + src[i+1]) - 5*(src[i-1] + src[i+2]) + (src[i-2] + src[i+3]) + 16 )>>5;
564  }
565  }
566  for(y=0; y<h; y++){
567  for(x=0; x<w; x++){
568  int i= y*ls + x;
569 
570  halfpel[2][p][i]= (20*(src[i] + src[i+ls]) - 5*(src[i-ls] + src[i+2*ls]) + (src[i-2*ls] + src[i+3*ls]) + 16 )>>5;
571  }
572  }
573  src= halfpel[1][p];
574  for(y=0; y<h; y++){
575  for(x=0; x<w; x++){
576  int i= y*ls + x;
577 
578  halfpel[3][p][i]= (20*(src[i] + src[i+ls]) - 5*(src[i-ls] + src[i+2*ls]) + (src[i-2*ls] + src[i+3*ls]) + 16 )>>5;
579  }
580  }
581 
582 //FIXME border!
583  }
584 }
585 
586 void ff_snow_release_buffer(AVCodecContext *avctx)
587 {
588  SnowContext *s = avctx->priv_data;
589  int i;
590 
591  if(s->last_picture[s->max_ref_frames-1].data[0]){
592  av_frame_unref(&s->last_picture[s->max_ref_frames-1]);
593  for(i=0; i<9; i++)
594  if(s->halfpel_plane[s->max_ref_frames-1][1+i/3][i%3])
595  av_free(s->halfpel_plane[s->max_ref_frames-1][1+i/3][i%3] - EDGE_WIDTH*(1+s->current_picture.linesize[i%3]));
596  }
597 }
598 
599 int ff_snow_frame_start(SnowContext *s){
600  AVFrame tmp;
601  int i, ret;
602  int w= s->avctx->width; //FIXME round up to x16 ?
603  int h= s->avctx->height;
604 
605  if (s->current_picture.data[0] && !(s->avctx->flags&CODEC_FLAG_EMU_EDGE)) {
606  s->dsp.draw_edges(s->current_picture.data[0],
607  s->current_picture.linesize[0], w , h ,
608  EDGE_WIDTH , EDGE_WIDTH , EDGE_TOP | EDGE_BOTTOM);
609  s->dsp.draw_edges(s->current_picture.data[1],
610  s->current_picture.linesize[1], w>>s->chroma_h_shift, h>>s->chroma_v_shift,
611  EDGE_WIDTH>>s->chroma_h_shift, EDGE_WIDTH>>s->chroma_v_shift, EDGE_TOP | EDGE_BOTTOM);
612  s->dsp.draw_edges(s->current_picture.data[2],
613  s->current_picture.linesize[2], w>>s->chroma_h_shift, h>>s->chroma_v_shift,
614  EDGE_WIDTH>>s->chroma_h_shift, EDGE_WIDTH>>s->chroma_v_shift, EDGE_TOP | EDGE_BOTTOM);
615  }
616 
617  ff_snow_release_buffer(s->avctx);
618 
619  av_frame_move_ref(&tmp, &s->last_picture[s->max_ref_frames-1]);
620  for(i=s->max_ref_frames-1; i>0; i--)
621  av_frame_move_ref(&s->last_picture[i], &s->last_picture[i-1]);
622  memmove(s->halfpel_plane+1, s->halfpel_plane, (s->max_ref_frames-1)*sizeof(void*)*4*4);
623  if(USE_HALFPEL_PLANE && s->current_picture.data[0])
624  halfpel_interpol(s, s->halfpel_plane[0], &s->current_picture);
625  av_frame_move_ref(&s->last_picture[0], &s->current_picture);
626  av_frame_move_ref(&s->current_picture, &tmp);
627 
628  if(s->keyframe){
629  s->ref_frames= 0;
630  }else{
631  int i;
632  for(i=0; i<s->max_ref_frames && s->last_picture[i].data[0]; i++)
633  if(i && s->last_picture[i-1].key_frame)
634  break;
635  s->ref_frames= i;
636  if(s->ref_frames==0){
637  av_log(s->avctx,AV_LOG_ERROR, "No reference frames\n");
638  return -1;
639  }
640  }
641 
642  if ((ret = ff_get_buffer(s->avctx, &s->current_picture, AV_GET_BUFFER_FLAG_REF)) < 0)
643  return ret;
644 
645  s->current_picture.key_frame= s->keyframe;
646 
647  return 0;
648 }
649 
650 av_cold void ff_snow_common_end(SnowContext *s)
651 {
652  int plane_index, level, orientation, i;
653 
654  av_freep(&s->spatial_dwt_buffer);
655  av_freep(&s->temp_dwt_buffer);
656  av_freep(&s->spatial_idwt_buffer);
657  av_freep(&s->temp_idwt_buffer);
658  av_freep(&s->run_buffer);
659 
660  s->m.me.temp= NULL;
661  av_freep(&s->m.me.scratchpad);
662  av_freep(&s->m.me.map);
663  av_freep(&s->m.me.score_map);
664  av_freep(&s->m.obmc_scratchpad);
665 
666  av_freep(&s->block);
667  av_freep(&s->scratchbuf);
668  av_freep(&s->emu_edge_buffer);
669 
670  for(i=0; i<MAX_REF_FRAMES; i++){
671  av_freep(&s->ref_mvs[i]);
672  av_freep(&s->ref_scores[i]);
673  if(s->last_picture[i].data[0]) {
674  av_assert0(s->last_picture[i].data[0] != s->current_picture.data[0]);
675  av_frame_unref(&s->last_picture[i]);
676  }
677  }
678 
679  for(plane_index=0; plane_index<3; plane_index++){
680  for(level=s->spatial_decomposition_count-1; level>=0; level--){
681  for(orientation=level ? 1 : 0; orientation<4; orientation++){
682  SubBand *b= &s->plane[plane_index].band[level][orientation];
683 
684  av_freep(&b->x_coeff);
685  }
686  }
687  }
688  av_frame_unref(&s->mconly_picture);
689  av_frame_unref(&s->current_picture);
690 }
Generated on Wed Jul 10 2013 23:48:05 for FFmpeg by   doxygen 1.8.2