Merge commit 'cb52a17cb62297802b0a77e5af9850d87c3f925b'
[ffmpeg.git] / libavcodec / snow.c
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_array(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_ARRAY_OR_GOTO(avctx, s->spatial_idwt_buffer, width, height * sizeof(IDWTELEM), fail);
459     FF_ALLOCZ_ARRAY_OR_GOTO(avctx, s->spatial_dwt_buffer,  width, height * sizeof(DWTELEM),  fail); //FIXME this does not belong here
460     FF_ALLOCZ_ARRAY_OR_GOTO(avctx, s->temp_dwt_buffer,     width, sizeof(DWTELEM),  fail);
461     FF_ALLOCZ_ARRAY_OR_GOTO(avctx, s->temp_idwt_buffer,    width, sizeof(IDWTELEM), fail);
462     FF_ALLOC_ARRAY_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_ARRAY_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_array(((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 }