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, src,
353  stride, stride,
354  b_w+HTAPS_MAX-1, b_h+HTAPS_MAX-1,
355  sx, sy, w, h);
356  src= tmp + MB_SIZE;
357  }
358 
359  av_assert2(s->chroma_h_shift == s->chroma_v_shift); // only one mv_scale
360 
361  av_assert2(b_w>1 && b_h>1);
362  av_assert2((tab_index>=0 && tab_index<4) || b_w==32);
363  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 )
364  mc_block(&s->plane[plane_index], dst, src, stride, b_w, b_h, dx, dy);
365  else if(b_w==32){
366  int y;
367  for(y=0; y<b_h; y+=16){
368  s->h264qpel.put_h264_qpel_pixels_tab[0][dy+(dx>>2)](dst + y*stride, src + 3 + (y+3)*stride,stride);
369  s->h264qpel.put_h264_qpel_pixels_tab[0][dy+(dx>>2)](dst + 16 + y*stride, src + 19 + (y+3)*stride,stride);
370  }
371  }else if(b_w==b_h)
372  s->h264qpel.put_h264_qpel_pixels_tab[tab_index ][dy+(dx>>2)](dst,src + 3 + 3*stride,stride);
373  else if(b_w==2*b_h){
374  s->h264qpel.put_h264_qpel_pixels_tab[tab_index+1][dy+(dx>>2)](dst ,src + 3 + 3*stride,stride);
375  s->h264qpel.put_h264_qpel_pixels_tab[tab_index+1][dy+(dx>>2)](dst+b_h,src + 3 + b_h + 3*stride,stride);
376  }else{
377  av_assert2(2*b_w==b_h);
378  s->h264qpel.put_h264_qpel_pixels_tab[tab_index ][dy+(dx>>2)](dst ,src + 3 + 3*stride ,stride);
379  s->h264qpel.put_h264_qpel_pixels_tab[tab_index ][dy+(dx>>2)](dst+b_w*stride,src + 3 + 3*stride+b_w*stride,stride);
380  }
381  }
382 }
383 
384 #define mca(dx,dy,b_w)\
385 static void mc_block_hpel ## dx ## dy ## b_w(uint8_t *dst, const uint8_t *src, ptrdiff_t stride, int h){\
386  av_assert2(h==b_w);\
387  mc_block(NULL, dst, src-(HTAPS_MAX/2-1)-(HTAPS_MAX/2-1)*stride, stride, b_w, b_w, dx, dy);\
388 }
389 
390 mca( 0, 0,16)
391 mca( 8, 0,16)
392 mca( 0, 8,16)
393 mca( 8, 8,16)
394 mca( 0, 0,8)
395 mca( 8, 0,8)
396 mca( 0, 8,8)
397 mca( 8, 8,8)
398 
399 av_cold int ff_snow_common_init(AVCodecContext *avctx){
400  SnowContext *s = avctx->priv_data;
401  int width, height;
402  int i, j;
403 
404  s->avctx= avctx;
405  s->max_ref_frames=1; //just make sure it's not an invalid value in case of no initial keyframe
406 
407  ff_dsputil_init(&s->dsp, avctx);
408  ff_hpeldsp_init(&s->hdsp, avctx->flags);
409  ff_videodsp_init(&s->vdsp, 8);
410  ff_dwt_init(&s->dwt);
411  ff_h264qpel_init(&s->h264qpel, 8);
412 
413 #define mcf(dx,dy)\
414  s->dsp.put_qpel_pixels_tab [0][dy+dx/4]=\
415  s->dsp.put_no_rnd_qpel_pixels_tab[0][dy+dx/4]=\
416  s->h264qpel.put_h264_qpel_pixels_tab[0][dy+dx/4];\
417  s->dsp.put_qpel_pixels_tab [1][dy+dx/4]=\
418  s->dsp.put_no_rnd_qpel_pixels_tab[1][dy+dx/4]=\
419  s->h264qpel.put_h264_qpel_pixels_tab[1][dy+dx/4];
420 
421  mcf( 0, 0)
422  mcf( 4, 0)
423  mcf( 8, 0)
424  mcf(12, 0)
425  mcf( 0, 4)
426  mcf( 4, 4)
427  mcf( 8, 4)
428  mcf(12, 4)
429  mcf( 0, 8)
430  mcf( 4, 8)
431  mcf( 8, 8)
432  mcf(12, 8)
433  mcf( 0,12)
434  mcf( 4,12)
435  mcf( 8,12)
436  mcf(12,12)
437 
438 #define mcfh(dx,dy)\
439  s->hdsp.put_pixels_tab [0][dy/4+dx/8]=\
440  s->hdsp.put_no_rnd_pixels_tab[0][dy/4+dx/8]=\
441  mc_block_hpel ## dx ## dy ## 16;\
442  s->hdsp.put_pixels_tab [1][dy/4+dx/8]=\
443  s->hdsp.put_no_rnd_pixels_tab[1][dy/4+dx/8]=\
444  mc_block_hpel ## dx ## dy ## 8;
445 
446  mcfh(0, 0)
447  mcfh(8, 0)
448  mcfh(0, 8)
449  mcfh(8, 8)
450 
451  init_qexp();
452 
453 // dec += FFMAX(s->chroma_h_shift, s->chroma_v_shift);
454 
455  width= s->avctx->width;
456  height= s->avctx->height;
457 
458  FF_ALLOCZ_OR_GOTO(avctx, s->spatial_idwt_buffer, width * height * sizeof(IDWTELEM), fail);
459  FF_ALLOCZ_OR_GOTO(avctx, s->spatial_dwt_buffer, width * height * sizeof(DWTELEM), fail); //FIXME this does not belong here
460  FF_ALLOCZ_OR_GOTO(avctx, s->temp_dwt_buffer, width * sizeof(DWTELEM), fail);
461  FF_ALLOCZ_OR_GOTO(avctx, s->temp_idwt_buffer, width * sizeof(IDWTELEM), fail);
462  FF_ALLOC_OR_GOTO(avctx, s->run_buffer, ((width + 1) >> 1) * ((height + 1) >> 1) * sizeof(*s->run_buffer), fail);
463 
464  for(i=0; i<MAX_REF_FRAMES; i++) {
465  for(j=0; j<MAX_REF_FRAMES; j++)
466  ff_scale_mv_ref[i][j] = 256*(i+1)/(j+1);
467  s->last_picture[i] = av_frame_alloc();
468  if (!s->last_picture[i])
469  goto fail;
470  }
471 
472  s->mconly_picture = av_frame_alloc();
473  s->current_picture = av_frame_alloc();
474  if (!s->mconly_picture || !s->current_picture)
475  goto fail;
476 
477  return 0;
478 fail:
479  return AVERROR(ENOMEM);
480 }
481 
482 int ff_snow_common_init_after_header(AVCodecContext *avctx) {
483  SnowContext *s = avctx->priv_data;
484  int plane_index, level, orientation;
485  int ret, emu_buf_size;
486 
487  if(!s->scratchbuf) {
488  if ((ret = ff_get_buffer(s->avctx, s->mconly_picture,
489  AV_GET_BUFFER_FLAG_REF)) < 0)
490  return ret;
491  FF_ALLOCZ_OR_GOTO(avctx, s->scratchbuf, FFMAX(s->mconly_picture->linesize[0], 2*avctx->width+256)*7*MB_SIZE, fail);
492  emu_buf_size = FFMAX(s->mconly_picture->linesize[0], 2*avctx->width+256) * (2 * MB_SIZE + HTAPS_MAX - 1);
493  FF_ALLOC_OR_GOTO(avctx, s->emu_edge_buffer, emu_buf_size, fail);
494  }
495 
496  if(s->mconly_picture->format != avctx->pix_fmt) {
497  av_log(avctx, AV_LOG_ERROR, "pixel format changed\n");
498  return AVERROR_INVALIDDATA;
499  }
500 
501  for(plane_index=0; plane_index < s->nb_planes; plane_index++){
502  int w= s->avctx->width;
503  int h= s->avctx->height;
504 
505  if(plane_index){
506  w>>= s->chroma_h_shift;
507  h>>= s->chroma_v_shift;
508  }
509  s->plane[plane_index].width = w;
510  s->plane[plane_index].height= h;
511 
512  for(level=s->spatial_decomposition_count-1; level>=0; level--){
513  for(orientation=level ? 1 : 0; orientation<4; orientation++){
514  SubBand *b= &s->plane[plane_index].band[level][orientation];
515 
516  b->buf= s->spatial_dwt_buffer;
517  b->level= level;
518  b->stride= s->plane[plane_index].width << (s->spatial_decomposition_count - level);
519  b->width = (w + !(orientation&1))>>1;
520  b->height= (h + !(orientation>1))>>1;
521 
522  b->stride_line = 1 << (s->spatial_decomposition_count - level);
523  b->buf_x_offset = 0;
524  b->buf_y_offset = 0;
525 
526  if(orientation&1){
527  b->buf += (w+1)>>1;
528  b->buf_x_offset = (w+1)>>1;
529  }
530  if(orientation>1){
531  b->buf += b->stride>>1;
532  b->buf_y_offset = b->stride_line >> 1;
533  }
534  b->ibuf= s->spatial_idwt_buffer + (b->buf - s->spatial_dwt_buffer);
535 
536  if(level)
537  b->parent= &s->plane[plane_index].band[level-1][orientation];
538  //FIXME avoid this realloc
539  av_freep(&b->x_coeff);
540  b->x_coeff=av_mallocz(((b->width+1) * b->height+1)*sizeof(x_and_coeff));
541  if (!b->x_coeff)
542  goto fail;
543  }
544  w= (w+1)>>1;
545  h= (h+1)>>1;
546  }
547  }
548 
549  return 0;
550 fail:
551  return AVERROR(ENOMEM);
552 }
553 
554 #define USE_HALFPEL_PLANE 0
555 
556 static int halfpel_interpol(SnowContext *s, uint8_t *halfpel[4][4], AVFrame *frame){
557  int p,x,y;
558 
559  for(p=0; p < s->nb_planes; p++){
560  int is_chroma= !!p;
561  int w= is_chroma ? s->avctx->width >>s->chroma_h_shift : s->avctx->width;
562  int h= is_chroma ? s->avctx->height>>s->chroma_v_shift : s->avctx->height;
563  int ls= frame->linesize[p];
564  uint8_t *src= frame->data[p];
565 
566  halfpel[1][p] = (uint8_t*) av_malloc(ls * (h + 2 * EDGE_WIDTH)) + EDGE_WIDTH * (1 + ls);
567  halfpel[2][p] = (uint8_t*) av_malloc(ls * (h + 2 * EDGE_WIDTH)) + EDGE_WIDTH * (1 + ls);
568  halfpel[3][p] = (uint8_t*) av_malloc(ls * (h + 2 * EDGE_WIDTH)) + EDGE_WIDTH * (1 + ls);
569  if (!halfpel[1][p] || !halfpel[2][p] || !halfpel[3][p])
570  return AVERROR(ENOMEM);
571 
572  halfpel[0][p]= src;
573  for(y=0; y<h; y++){
574  for(x=0; x<w; x++){
575  int i= y*ls + x;
576 
577  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;
578  }
579  }
580  for(y=0; y<h; y++){
581  for(x=0; x<w; x++){
582  int i= y*ls + x;
583 
584  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;
585  }
586  }
587  src= halfpel[1][p];
588  for(y=0; y<h; y++){
589  for(x=0; x<w; x++){
590  int i= y*ls + x;
591 
592  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;
593  }
594  }
595 
596 //FIXME border!
597  }
598  return 0;
599 }
600 
601 void ff_snow_release_buffer(AVCodecContext *avctx)
602 {
603  SnowContext *s = avctx->priv_data;
604  int i;
605 
606  if(s->last_picture[s->max_ref_frames-1]->data[0]){
607  av_frame_unref(s->last_picture[s->max_ref_frames-1]);
608  for(i=0; i<9; i++)
609  if(s->halfpel_plane[s->max_ref_frames-1][1+i/3][i%3])
610  av_free(s->halfpel_plane[s->max_ref_frames-1][1+i/3][i%3] - EDGE_WIDTH*(1+s->current_picture->linesize[i%3]));
611  }
612 }
613 
614 int ff_snow_frame_start(SnowContext *s){
615  AVFrame *tmp;
616  int i, ret;
617  int w= s->avctx->width; //FIXME round up to x16 ?
618  int h= s->avctx->height;
619 
620  if (s->current_picture->data[0] && !(s->avctx->flags&CODEC_FLAG_EMU_EDGE)) {
621  s->dsp.draw_edges(s->current_picture->data[0],
622  s->current_picture->linesize[0], w , h ,
623  EDGE_WIDTH , EDGE_WIDTH , EDGE_TOP | EDGE_BOTTOM);
624  if (s->current_picture->data[2]) {
625  s->dsp.draw_edges(s->current_picture->data[1],
626  s->current_picture->linesize[1], w>>s->chroma_h_shift, h>>s->chroma_v_shift,
627  EDGE_WIDTH>>s->chroma_h_shift, EDGE_WIDTH>>s->chroma_v_shift, EDGE_TOP | EDGE_BOTTOM);
628  s->dsp.draw_edges(s->current_picture->data[2],
629  s->current_picture->linesize[2], w>>s->chroma_h_shift, h>>s->chroma_v_shift,
630  EDGE_WIDTH>>s->chroma_h_shift, EDGE_WIDTH>>s->chroma_v_shift, EDGE_TOP | EDGE_BOTTOM);
631  }
632  }
633 
634  ff_snow_release_buffer(s->avctx);
635 
636  tmp= s->last_picture[s->max_ref_frames-1];
637  for(i=s->max_ref_frames-1; i>0; i--)
638  s->last_picture[i] = s->last_picture[i-1];
639  memmove(s->halfpel_plane+1, s->halfpel_plane, (s->max_ref_frames-1)*sizeof(void*)*4*4);
640  if(USE_HALFPEL_PLANE && s->current_picture->data[0]) {
641  if((ret = halfpel_interpol(s, s->halfpel_plane[0], s->current_picture)) < 0)
642  return ret;
643  }
644  s->last_picture[0] = s->current_picture;
645  s->current_picture = tmp;
646 
647  if(s->keyframe){
648  s->ref_frames= 0;
649  }else{
650  int i;
651  for(i=0; i<s->max_ref_frames && s->last_picture[i]->data[0]; i++)
652  if(i && s->last_picture[i-1]->key_frame)
653  break;
654  s->ref_frames= i;
655  if(s->ref_frames==0){
656  av_log(s->avctx,AV_LOG_ERROR, "No reference frames\n");
657  return -1;
658  }
659  }
660 
661  if ((ret = ff_get_buffer(s->avctx, s->current_picture, AV_GET_BUFFER_FLAG_REF)) < 0)
662  return ret;
663 
664  s->current_picture->key_frame= s->keyframe;
665 
666  return 0;
667 }
668 
669 av_cold void ff_snow_common_end(SnowContext *s)
670 {
671  int plane_index, level, orientation, i;
672 
673  av_freep(&s->spatial_dwt_buffer);
674  av_freep(&s->temp_dwt_buffer);
675  av_freep(&s->spatial_idwt_buffer);
676  av_freep(&s->temp_idwt_buffer);
677  av_freep(&s->run_buffer);
678 
679  s->m.me.temp= NULL;
680  av_freep(&s->m.me.scratchpad);
681  av_freep(&s->m.me.map);
682  av_freep(&s->m.me.score_map);
683  av_freep(&s->m.obmc_scratchpad);
684 
685  av_freep(&s->block);
686  av_freep(&s->scratchbuf);
687  av_freep(&s->emu_edge_buffer);
688 
689  for(i=0; i<MAX_REF_FRAMES; i++){
690  av_freep(&s->ref_mvs[i]);
691  av_freep(&s->ref_scores[i]);
692  if(s->last_picture[i]->data[0]) {
693  av_assert0(s->last_picture[i]->data[0] != s->current_picture->data[0]);
694  }
695  av_frame_free(&s->last_picture[i]);
696  }
697 
698  for(plane_index=0; plane_index < s->nb_planes; plane_index++){
699  for(level=s->spatial_decomposition_count-1; level>=0; level--){
700  for(orientation=level ? 1 : 0; orientation<4; orientation++){
701  SubBand *b= &s->plane[plane_index].band[level][orientation];
702 
703  av_freep(&b->x_coeff);
704  }
705  }
706  }
707  av_frame_free(&s->mconly_picture);
708  av_frame_free(&s->current_picture);
709 }
Generated on Thu Dec 12 2013 19:21:02 for FFmpeg by   doxygen 1.8.2