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