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