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