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  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 
398 av_cold int ff_snow_common_init(AVCodecContext *avctx){
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 
471  s->mconly_picture = av_frame_alloc();
472  s->current_picture = av_frame_alloc();
473  if (!s->mconly_picture || !s->current_picture)
474  goto fail;
475 
476  return 0;
477 fail:
478  return AVERROR(ENOMEM);
479 }
480 
481 int ff_snow_common_init_after_header(AVCodecContext *avctx) {
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,
488  AV_GET_BUFFER_FLAG_REF)) < 0)
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 
521  b->stride_line = 1 << (s->spatial_decomposition_count - level);
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 
600 void ff_snow_release_buffer(AVCodecContext *avctx)
601 {
602  SnowContext *s = avctx->priv_data;
603  int i;
604 
605  if(s->last_picture[s->max_ref_frames-1]->data[0]){
606  av_frame_unref(s->last_picture[s->max_ref_frames-1]);
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 
613 int ff_snow_frame_start(SnowContext *s){
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)) {
620  s->dsp.draw_edges(s->current_picture->data[0],
621  s->current_picture->linesize[0], w , h ,
622  EDGE_WIDTH , EDGE_WIDTH , EDGE_TOP | EDGE_BOTTOM);
623  if (s->current_picture->data[2]) {
624  s->dsp.draw_edges(s->current_picture->data[1],
625  s->current_picture->linesize[1], w>>s->chroma_h_shift, h>>s->chroma_v_shift,
626  EDGE_WIDTH>>s->chroma_h_shift, EDGE_WIDTH>>s->chroma_v_shift, EDGE_TOP | EDGE_BOTTOM);
627  s->dsp.draw_edges(s->current_picture->data[2],
628  s->current_picture->linesize[2], w>>s->chroma_h_shift, h>>s->chroma_v_shift,
629  EDGE_WIDTH>>s->chroma_h_shift, EDGE_WIDTH>>s->chroma_v_shift, EDGE_TOP | EDGE_BOTTOM);
630  }
631  }
632 
633  ff_snow_release_buffer(s->avctx);
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 
660  if ((ret = ff_get_buffer(s->avctx, s->current_picture, AV_GET_BUFFER_FLAG_REF)) < 0)
661  return ret;
662 
663  s->current_picture->key_frame= s->keyframe;
664 
665  return 0;
666 }
667 
668 av_cold void ff_snow_common_end(SnowContext *s)
669 {
670  int plane_index, level, orientation, i;
671 
672  av_freep(&s->spatial_dwt_buffer);
673  av_freep(&s->temp_dwt_buffer);
674  av_freep(&s->spatial_idwt_buffer);
675  av_freep(&s->temp_idwt_buffer);
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);
682  av_freep(&s->m.obmc_scratchpad);
683 
684  av_freep(&s->block);
685  av_freep(&s->scratchbuf);
686  av_freep(&s->emu_edge_buffer);
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  }
706  av_frame_free(&s->mconly_picture);
707  av_frame_free(&s->current_picture);
708 }
Generated on Sat Jan 25 2014 19:51:54 for FFmpeg by   doxygen 1.8.2