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/log.h"
  22 #include "libavutil/thread.h"
  23 #include "avcodec.h"
  24 #include "snow_dwt.h"
  25 #include "snow.h"
  26 #include "snowdata.h"
  27
  28
  29 void ff_snow_inner_add_yblock(const uint8_t *obmc, const int obmc_stride, uint8_t * * block, int b_w, int b_h,
  30                               int src_x, int src_y, int src_stride, slice_buffer * sb, int add, uint8_t * dst8){
  31     int y, x;
  32     IDWTELEM * dst;
  33     for(y=0; y<b_h; y++){
  34         //FIXME ugly misuse of obmc_stride
  35         const uint8_t *obmc1= obmc + y*obmc_stride;
  36         const uint8_t *obmc2= obmc1+ (obmc_stride>>1);
  37         const uint8_t *obmc3= obmc1+ obmc_stride*(obmc_stride>>1);
  38         const uint8_t *obmc4= obmc3+ (obmc_stride>>1);
  39         dst = slice_buffer_get_line(sb, src_y + y);
  40         for(x=0; x<b_w; x++){
  41             int v=   obmc1[x] * block[3][x + y*src_stride]
  42                     +obmc2[x] * block[2][x + y*src_stride]
  43                     +obmc3[x] * block[1][x + y*src_stride]
  44                     +obmc4[x] * block[0][x + y*src_stride];
  45
  46             v <<= 8 - LOG2_OBMC_MAX;
  47             if(FRAC_BITS != 8){
  48                 v >>= 8 - FRAC_BITS;
  49             }
  50             if(add){
  51                 v += dst[x + src_x];
  52                 v = (v + (1<<(FRAC_BITS-1))) >> FRAC_BITS;
  53                 if(v&(~255)) v= ~(v>>31);
  54                 dst8[x + y*src_stride] = v;
  55             }else{
  56                 dst[x + src_x] -= v;
  57             }
  58         }
  59     }
  60 }
  61
  62 void ff_snow_reset_contexts(SnowContext *s){ //FIXME better initial contexts
  63     int plane_index, level, orientation;
  64
  65     for(plane_index=0; plane_index<3; plane_index++){
  66         for(level=0; level<MAX_DECOMPOSITIONS; level++){
  67             for(orientation=level ? 1:0; orientation<4; orientation++){
  68                 memset(s->plane[plane_index].band[level][orientation].state, MID_STATE, sizeof(s->plane[plane_index].band[level][orientation].state));
  69             }
  70         }
  71     }
  72     memset(s->header_state, MID_STATE, sizeof(s->header_state));
  73     memset(s->block_state, MID_STATE, sizeof(s->block_state));
  74 }
  75
  76 int ff_snow_alloc_blocks(SnowContext *s){
  77     int w= AV_CEIL_RSHIFT(s->avctx->width,  LOG2_MB_SIZE);
  78     int h= AV_CEIL_RSHIFT(s->avctx->height, LOG2_MB_SIZE);
  79
  80     s->b_width = w;
  81     s->b_height= h;
  82
  83     av_free(s->block);
  84     s->block = av_calloc(w * h,  sizeof(*s->block) << (s->block_max_depth*2));
  85     if (!s->block)
  86         return AVERROR(ENOMEM);
  87
  88     return 0;
  89 }
  90
  91 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){
  92     static const uint8_t weight[64]={
  93     8,7,6,5,4,3,2,1,
  94     7,7,0,0,0,0,0,1,
  95     6,0,6,0,0,0,2,0,
  96     5,0,0,5,0,3,0,0,
  97     4,0,0,0,4,0,0,0,
  98     3,0,0,5,0,3,0,0,
  99     2,0,6,0,0,0,2,0,
 100     1,7,0,0,0,0,0,1,
 101     };
 102
 103     static const uint8_t brane[256]={
 104     0x00,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x11,0x12,0x12,0x12,0x12,0x12,0x12,0x12,
 105     0x04,0x05,0xcc,0xcc,0xcc,0xcc,0xcc,0x41,0x15,0x16,0xcc,0xcc,0xcc,0xcc,0xcc,0x52,
 106     0x04,0xcc,0x05,0xcc,0xcc,0xcc,0x41,0xcc,0x15,0xcc,0x16,0xcc,0xcc,0xcc,0x52,0xcc,
 107     0x04,0xcc,0xcc,0x05,0xcc,0x41,0xcc,0xcc,0x15,0xcc,0xcc,0x16,0xcc,0x52,0xcc,0xcc,
 108     0x04,0xcc,0xcc,0xcc,0x41,0xcc,0xcc,0xcc,0x15,0xcc,0xcc,0xcc,0x16,0xcc,0xcc,0xcc,
 109     0x04,0xcc,0xcc,0x41,0xcc,0x05,0xcc,0xcc,0x15,0xcc,0xcc,0x52,0xcc,0x16,0xcc,0xcc,
 110     0x04,0xcc,0x41,0xcc,0xcc,0xcc,0x05,0xcc,0x15,0xcc,0x52,0xcc,0xcc,0xcc,0x16,0xcc,
 111     0x04,0x41,0xcc,0xcc,0xcc,0xcc,0xcc,0x05,0x15,0x52,0xcc,0xcc,0xcc,0xcc,0xcc,0x16,
 112     0x44,0x45,0x45,0x45,0x45,0x45,0x45,0x45,0x55,0x56,0x56,0x56,0x56,0x56,0x56,0x56,
 113     0x48,0x49,0xcc,0xcc,0xcc,0xcc,0xcc,0x85,0x59,0x5A,0xcc,0xcc,0xcc,0xcc,0xcc,0x96,
 114     0x48,0xcc,0x49,0xcc,0xcc,0xcc,0x85,0xcc,0x59,0xcc,0x5A,0xcc,0xcc,0xcc,0x96,0xcc,
 115     0x48,0xcc,0xcc,0x49,0xcc,0x85,0xcc,0xcc,0x59,0xcc,0xcc,0x5A,0xcc,0x96,0xcc,0xcc,
 116     0x48,0xcc,0xcc,0xcc,0x49,0xcc,0xcc,0xcc,0x59,0xcc,0xcc,0xcc,0x96,0xcc,0xcc,0xcc,
 117     0x48,0xcc,0xcc,0x85,0xcc,0x49,0xcc,0xcc,0x59,0xcc,0xcc,0x96,0xcc,0x5A,0xcc,0xcc,
 118     0x48,0xcc,0x85,0xcc,0xcc,0xcc,0x49,0xcc,0x59,0xcc,0x96,0xcc,0xcc,0xcc,0x5A,0xcc,
 119     0x48,0x85,0xcc,0xcc,0xcc,0xcc,0xcc,0x49,0x59,0x96,0xcc,0xcc,0xcc,0xcc,0xcc,0x5A,
 120     };
 121
 122     static const uint8_t needs[16]={
 123     0,1,0,0,
 124     2,4,2,0,
 125     0,1,0,0,
 126     15
 127     };
 128
 129     int x, y, b, r, l;
 130     int16_t tmpIt   [64*(32+HTAPS_MAX)];
 131     uint8_t tmp2t[3][64*(32+HTAPS_MAX)];
 132     int16_t *tmpI= tmpIt;
 133     uint8_t *tmp2= tmp2t[0];
 134     const uint8_t *hpel[11];
 135     av_assert2(dx<16 && dy<16);
 136     r= brane[dx + 16*dy]&15;
 137     l= brane[dx + 16*dy]>>4;
 138
 139     b= needs[l] | needs[r];
 140     if(p && !p->diag_mc)
 141         b= 15;
 142
 143     if(b&5){
 144         for(y=0; y < b_h+HTAPS_MAX-1; y++){
 145             for(x=0; x < b_w; x++){
 146                 int a_1=src[x + HTAPS_MAX/2-4];
 147                 int a0= src[x + HTAPS_MAX/2-3];
 148                 int a1= src[x + HTAPS_MAX/2-2];
 149                 int a2= src[x + HTAPS_MAX/2-1];
 150                 int a3= src[x + HTAPS_MAX/2+0];
 151                 int a4= src[x + HTAPS_MAX/2+1];
 152                 int a5= src[x + HTAPS_MAX/2+2];
 153                 int a6= src[x + HTAPS_MAX/2+3];
 154                 int am=0;
 155                 if(!p || p->fast_mc){
 156                     am= 20*(a2+a3) - 5*(a1+a4) + (a0+a5);
 157                     tmpI[x]= am;
 158                     am= (am+16)>>5;
 159                 }else{
 160                     am= p->hcoeff[0]*(a2+a3) + p->hcoeff[1]*(a1+a4) + p->hcoeff[2]*(a0+a5) + p->hcoeff[3]*(a_1+a6);
 161                     tmpI[x]= am;
 162                     am= (am+32)>>6;
 163                 }
 164
 165                 if(am&(~255)) am= ~(am>>31);
 166                 tmp2[x]= am;
 167             }
 168             tmpI+= 64;
 169             tmp2+= 64;
 170             src += stride;
 171         }
 172         src -= stride*y;
 173     }
 174     src += HTAPS_MAX/2 - 1;
 175     tmp2= tmp2t[1];
 176
 177     if(b&2){
 178         for(y=0; y < b_h; y++){
 179             for(x=0; x < b_w+1; x++){
 180                 int a_1=src[x + (HTAPS_MAX/2-4)*stride];
 181                 int a0= src[x + (HTAPS_MAX/2-3)*stride];
 182                 int a1= src[x + (HTAPS_MAX/2-2)*stride];
 183                 int a2= src[x + (HTAPS_MAX/2-1)*stride];
 184                 int a3= src[x + (HTAPS_MAX/2+0)*stride];
 185                 int a4= src[x + (HTAPS_MAX/2+1)*stride];
 186                 int a5= src[x + (HTAPS_MAX/2+2)*stride];
 187                 int a6= src[x + (HTAPS_MAX/2+3)*stride];
 188                 int am=0;
 189                 if(!p || p->fast_mc)
 190                     am= (20*(a2+a3) - 5*(a1+a4) + (a0+a5) + 16)>>5;
 191                 else
 192                     am= (p->hcoeff[0]*(a2+a3) + p->hcoeff[1]*(a1+a4) + p->hcoeff[2]*(a0+a5) + p->hcoeff[3]*(a_1+a6) + 32)>>6;
 193
 194                 if(am&(~255)) am= ~(am>>31);
 195                 tmp2[x]= am;
 196             }
 197             src += stride;
 198             tmp2+= 64;
 199         }
 200         src -= stride*y;
 201     }
 202     src += stride*(HTAPS_MAX/2 - 1);
 203     tmp2= tmp2t[2];
 204     tmpI= tmpIt;
 205     if(b&4){
 206         for(y=0; y < b_h; y++){
 207             for(x=0; x < b_w; x++){
 208                 int a_1=tmpI[x + (HTAPS_MAX/2-4)*64];
 209                 int a0= tmpI[x + (HTAPS_MAX/2-3)*64];
 210                 int a1= tmpI[x + (HTAPS_MAX/2-2)*64];
 211                 int a2= tmpI[x + (HTAPS_MAX/2-1)*64];
 212                 int a3= tmpI[x + (HTAPS_MAX/2+0)*64];
 213                 int a4= tmpI[x + (HTAPS_MAX/2+1)*64];
 214                 int a5= tmpI[x + (HTAPS_MAX/2+2)*64];
 215                 int a6= tmpI[x + (HTAPS_MAX/2+3)*64];
 216                 int am=0;
 217                 if(!p || p->fast_mc)
 218                     am= (20*(a2+a3) - 5*(a1+a4) + (a0+a5) + 512)>>10;
 219                 else
 220                     am= (p->hcoeff[0]*(a2+a3) + p->hcoeff[1]*(a1+a4) + p->hcoeff[2]*(a0+a5) + p->hcoeff[3]*(a_1+a6) + 2048)>>12;
 221                 if(am&(~255)) am= ~(am>>31);
 222                 tmp2[x]= am;
 223             }
 224             tmpI+= 64;
 225             tmp2+= 64;
 226         }
 227     }
 228
 229     hpel[ 0]= src;
 230     hpel[ 1]= tmp2t[0] + 64*(HTAPS_MAX/2-1);
 231     hpel[ 2]= src + 1;
 232
 233     hpel[ 4]= tmp2t[1];
 234     hpel[ 5]= tmp2t[2];
 235     hpel[ 6]= tmp2t[1] + 1;
 236
 237     hpel[ 8]= src + stride;
 238     hpel[ 9]= hpel[1] + 64;
 239     hpel[10]= hpel[8] + 1;
 240
 241 #define MC_STRIDE(x) (needs[x] ? 64 : stride)
 242
 243     if(b==15){
 244         int dxy = dx / 8 + dy / 8 * 4;
 245         const uint8_t *src1 = hpel[dxy    ];
 246         const uint8_t *src2 = hpel[dxy + 1];
 247         const uint8_t *src3 = hpel[dxy + 4];
 248         const uint8_t *src4 = hpel[dxy + 5];
 249         int stride1 = MC_STRIDE(dxy);
 250         int stride2 = MC_STRIDE(dxy + 1);
 251         int stride3 = MC_STRIDE(dxy + 4);
 252         int stride4 = MC_STRIDE(dxy + 5);
 253         dx&=7;
 254         dy&=7;
 255         for(y=0; y < b_h; y++){
 256             for(x=0; x < b_w; x++){
 257                 dst[x]= ((8-dx)*(8-dy)*src1[x] + dx*(8-dy)*src2[x]+
 258                          (8-dx)*   dy *src3[x] + dx*   dy *src4[x]+32)>>6;
 259             }
 260             src1+=stride1;
 261             src2+=stride2;
 262             src3+=stride3;
 263             src4+=stride4;
 264             dst +=stride;
 265         }
 266     }else{
 267         const uint8_t *src1= hpel[l];
 268         const uint8_t *src2= hpel[r];
 269         int stride1 = MC_STRIDE(l);
 270         int stride2 = MC_STRIDE(r);
 271         int a= weight[((dx&7) + (8*(dy&7)))];
 272         int b= 8-a;
 273         for(y=0; y < b_h; y++){
 274             for(x=0; x < b_w; x++){
 275                 dst[x]= (a*src1[x] + b*src2[x] + 4)>>3;
 276             }
 277             src1+=stride1;
 278             src2+=stride2;
 279             dst +=stride;
 280         }
 281     }
 282 }
 283
 284 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, const BlockNode *block, int plane_index, int w, int h){
 285     if(block->type & BLOCK_INTRA){
 286         int x, y;
 287         const unsigned color  = block->color[plane_index];
 288         const unsigned color4 = color*0x01010101;
 289         if(b_w==32){
 290             for(y=0; y < b_h; y++){
 291                 *(uint32_t*)&dst[0 + y*stride]= color4;
 292                 *(uint32_t*)&dst[4 + y*stride]= color4;
 293                 *(uint32_t*)&dst[8 + y*stride]= color4;
 294                 *(uint32_t*)&dst[12+ y*stride]= color4;
 295                 *(uint32_t*)&dst[16+ y*stride]= color4;
 296                 *(uint32_t*)&dst[20+ y*stride]= color4;
 297                 *(uint32_t*)&dst[24+ y*stride]= color4;
 298                 *(uint32_t*)&dst[28+ y*stride]= color4;
 299             }
 300         }else if(b_w==16){
 301             for(y=0; y < b_h; y++){
 302                 *(uint32_t*)&dst[0 + y*stride]= color4;
 303                 *(uint32_t*)&dst[4 + y*stride]= color4;
 304                 *(uint32_t*)&dst[8 + y*stride]= color4;
 305                 *(uint32_t*)&dst[12+ y*stride]= color4;
 306             }
 307         }else if(b_w==8){
 308             for(y=0; y < b_h; y++){
 309                 *(uint32_t*)&dst[0 + y*stride]= color4;
 310                 *(uint32_t*)&dst[4 + y*stride]= color4;
 311             }
 312         }else if(b_w==4){
 313             for(y=0; y < b_h; y++){
 314                 *(uint32_t*)&dst[0 + y*stride]= color4;
 315             }
 316         }else{
 317             for(y=0; y < b_h; y++){
 318                 for(x=0; x < b_w; x++){
 319                     dst[x + y*stride]= color;
 320                 }
 321             }
 322         }
 323     }else{
 324         const uint8_t *src = s->last_picture[block->ref]->data[plane_index];
 325         const int scale= plane_index ?  (2*s->mv_scale)>>s->chroma_h_shift : 2*s->mv_scale;
 326         int mx= block->mx*scale;
 327         int my= block->my*scale;
 328         const int dx= mx&15;
 329         const int dy= my&15;
 330         const int tab_index= 3 - (b_w>>2) + (b_w>>4);
 331         sx += (mx>>4) - (HTAPS_MAX/2-1);
 332         sy += (my>>4) - (HTAPS_MAX/2-1);
 333         src += sx + sy*stride;
 334         if(   (unsigned)sx >= FFMAX(w - b_w - (HTAPS_MAX-2), 0)
 335            || (unsigned)sy >= FFMAX(h - b_h - (HTAPS_MAX-2), 0)){
 336             s->vdsp.emulated_edge_mc(tmp + MB_SIZE, src,
 337                                      stride, stride,
 338                                      b_w+HTAPS_MAX-1, b_h+HTAPS_MAX-1,
 339                                      sx, sy, w, h);
 340             src= tmp + MB_SIZE;
 341         }
 342
 343         av_assert2(s->chroma_h_shift == s->chroma_v_shift); // only one mv_scale
 344
 345         av_assert2((tab_index>=0 && tab_index<4) || b_w==32);
 346         if(    (dx&3) || (dy&3)
 347             || !(b_w == b_h || 2*b_w == b_h || b_w == 2*b_h)
 348             || (b_w&(b_w-1))
 349             || b_w == 1
 350             || b_h == 1
 351             || !s->plane[plane_index].fast_mc )
 352             mc_block(&s->plane[plane_index], dst, src, stride, b_w, b_h, dx, dy);
 353         else if(b_w==32){
 354             int y;
 355             for(y=0; y<b_h; y+=16){
 356                 s->h264qpel.put_h264_qpel_pixels_tab[0][dy+(dx>>2)](dst + y*stride, src + 3 + (y+3)*stride,stride);
 357                 s->h264qpel.put_h264_qpel_pixels_tab[0][dy+(dx>>2)](dst + 16 + y*stride, src + 19 + (y+3)*stride,stride);
 358             }
 359         }else if(b_w==b_h)
 360             s->h264qpel.put_h264_qpel_pixels_tab[tab_index  ][dy+(dx>>2)](dst,src + 3 + 3*stride,stride);
 361         else if(b_w==2*b_h){
 362             s->h264qpel.put_h264_qpel_pixels_tab[tab_index+1][dy+(dx>>2)](dst    ,src + 3       + 3*stride,stride);
 363             s->h264qpel.put_h264_qpel_pixels_tab[tab_index+1][dy+(dx>>2)](dst+b_h,src + 3 + b_h + 3*stride,stride);
 364         }else{
 365             av_assert2(2*b_w==b_h);
 366             s->h264qpel.put_h264_qpel_pixels_tab[tab_index  ][dy+(dx>>2)](dst           ,src + 3 + 3*stride           ,stride);
 367             s->h264qpel.put_h264_qpel_pixels_tab[tab_index  ][dy+(dx>>2)](dst+b_w*stride,src + 3 + 3*stride+b_w*stride,stride);
 368         }
 369     }
 370 }
 371
 372 #define mca(dx,dy,b_w)\
 373 static void mc_block_hpel ## dx ## dy ## b_w(uint8_t *dst, const uint8_t *src, ptrdiff_t stride, int h){\
 374     av_assert2(h==b_w);\
 375     mc_block(NULL, dst, src-(HTAPS_MAX/2-1)-(HTAPS_MAX/2-1)*stride, stride, b_w, b_w, dx, dy);\
 376 }
 377
 378 mca( 0, 0,16)
 379 mca( 8, 0,16)
 380 mca( 0, 8,16)
 381 mca( 8, 8,16)
 382 mca( 0, 0,8)
 383 mca( 8, 0,8)
 384 mca( 0, 8,8)
 385 mca( 8, 8,8)
 386
 387 static av_cold void snow_static_init(void)
 388 {
 389     for (int i = 0; i < MAX_REF_FRAMES; i++)
 390         for (int j = 0; j < MAX_REF_FRAMES; j++)
 391             ff_scale_mv_ref[i][j] = 256 * (i + 1) / (j + 1);
 392 }
 393
 394 av_cold int ff_snow_common_init(AVCodecContext *avctx){
 395     static AVOnce init_static_once = AV_ONCE_INIT;
 396     SnowContext *s = avctx->priv_data;
 397     int width, height;
 398     int i;
 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     s->spatial_decomposition_count = 1;
 403
 404     ff_videodsp_init(&s->vdsp, 8);
 405     ff_dwt_init(&s->dwt);
 406     ff_h264qpel_init(&s->h264qpel, 8);
 407
 408 #define mcfh(dx,dy)\
 409     s->hdsp.put_pixels_tab       [0][dy/4+dx/8]=\
 410     s->hdsp.put_no_rnd_pixels_tab[0][dy/4+dx/8]=\
 411         mc_block_hpel ## dx ## dy ## 16;\
 412     s->hdsp.put_pixels_tab       [1][dy/4+dx/8]=\
 413     s->hdsp.put_no_rnd_pixels_tab[1][dy/4+dx/8]=\
 414         mc_block_hpel ## dx ## dy ## 8;
 415
 416     mcfh(0, 0)
 417     mcfh(8, 0)
 418     mcfh(0, 8)
 419     mcfh(8, 8)
 420
 421 //    dec += FFMAX(s->chroma_h_shift, s->chroma_v_shift);
 422
 423     width= s->avctx->width;
 424     height= s->avctx->height;
 425
 426     if (!FF_ALLOCZ_TYPED_ARRAY(s->spatial_idwt_buffer, width * height) ||
 427         !FF_ALLOCZ_TYPED_ARRAY(s->spatial_dwt_buffer,  width * height) ||  //FIXME this does not belong here
 428         !FF_ALLOCZ_TYPED_ARRAY(s->temp_dwt_buffer,     width)          ||
 429         !FF_ALLOCZ_TYPED_ARRAY(s->temp_idwt_buffer,    width)          ||
 430         !FF_ALLOCZ_TYPED_ARRAY(s->run_buffer, ((width + 1) >> 1) * ((height + 1) >> 1)))
 431         return AVERROR(ENOMEM);
 432
 433     for(i=0; i<MAX_REF_FRAMES; i++) {
 434         s->last_picture[i] = av_frame_alloc();
 435         if (!s->last_picture[i])
 436             return AVERROR(ENOMEM);
 437     }
 438
 439     s->mconly_picture = av_frame_alloc();
 440     s->current_picture = av_frame_alloc();
 441     if (!s->mconly_picture || !s->current_picture)
 442         return AVERROR(ENOMEM);
 443
 444     ff_thread_once(&init_static_once, snow_static_init);
 445
 446     return 0;
 447 }
 448
 449 int ff_snow_common_init_after_header(AVCodecContext *avctx) {
 450     SnowContext *s = avctx->priv_data;
 451     int plane_index, level, orientation;
 452
 453     if(!s->scratchbuf) {
 454         int emu_buf_size;
 455         emu_buf_size = FFMAX(s->mconly_picture->linesize[0], 2*avctx->width+256) * (2 * MB_SIZE + HTAPS_MAX - 1);
 456         if (!FF_ALLOCZ_TYPED_ARRAY(s->scratchbuf,      FFMAX(s->mconly_picture->linesize[0], 2*avctx->width+256) * 7 * MB_SIZE) ||
 457             !FF_ALLOCZ_TYPED_ARRAY(s->emu_edge_buffer, emu_buf_size))
 458             return AVERROR(ENOMEM);
 459     }
 460
 461     for(plane_index=0; plane_index < s->nb_planes; plane_index++){
 462         int w= s->avctx->width;
 463         int h= s->avctx->height;
 464
 465         if(plane_index){
 466             w = AV_CEIL_RSHIFT(w, s->chroma_h_shift);
 467             h = AV_CEIL_RSHIFT(h, s->chroma_v_shift);
 468         }
 469         s->plane[plane_index].width = w;
 470         s->plane[plane_index].height= h;
 471
 472         for(level=s->spatial_decomposition_count-1; level>=0; level--){
 473             for(orientation=level ? 1 : 0; orientation<4; orientation++){
 474                 SubBand *b= &s->plane[plane_index].band[level][orientation];
 475
 476                 b->buf= s->spatial_dwt_buffer;
 477                 b->level= level;
 478                 b->stride= s->plane[plane_index].width << (s->spatial_decomposition_count - level);
 479                 b->width = (w + !(orientation&1))>>1;
 480                 b->height= (h + !(orientation>1))>>1;
 481
 482                 b->stride_line = 1 << (s->spatial_decomposition_count - level);
 483                 b->buf_x_offset = 0;
 484                 b->buf_y_offset = 0;
 485
 486                 if(orientation&1){
 487                     b->buf += (w+1)>>1;
 488                     b->buf_x_offset = (w+1)>>1;
 489                 }
 490                 if(orientation>1){
 491                     b->buf += b->stride>>1;
 492                     b->buf_y_offset = b->stride_line >> 1;
 493                 }
 494                 b->ibuf= s->spatial_idwt_buffer + (b->buf - s->spatial_dwt_buffer);
 495
 496                 if(level)
 497                     b->parent= &s->plane[plane_index].band[level-1][orientation];
 498                 //FIXME avoid this realloc
 499                 av_freep(&b->x_coeff);
 500                 b->x_coeff = av_calloc((b->width + 1) * b->height + 1,
 501                                        sizeof(*b->x_coeff));
 502                 if (!b->x_coeff)
 503                     return AVERROR(ENOMEM);
 504             }
 505             w= (w+1)>>1;
 506             h= (h+1)>>1;
 507         }
 508     }
 509
 510     return 0;
 511 }
 512
 513 void ff_snow_release_buffer(AVCodecContext *avctx)
 514 {
 515     SnowContext *s = avctx->priv_data;
 516
 517     if(s->last_picture[s->max_ref_frames-1]->data[0]){
 518         av_frame_unref(s->last_picture[s->max_ref_frames-1]);
 519     }
 520 }
 521
 522 int ff_snow_frames_prepare(SnowContext *s)
 523 {
 524    AVFrame *tmp;
 525
 526     ff_snow_release_buffer(s->avctx);
 527
 528     tmp= s->last_picture[s->max_ref_frames-1];
 529     for (int i = s->max_ref_frames - 1; i > 0; i--)
 530         s->last_picture[i] = s->last_picture[i-1];
 531     s->last_picture[0] = s->current_picture;
 532     s->current_picture = tmp;
 533
 534     if(s->keyframe){
 535         s->ref_frames= 0;
 536         s->current_picture->flags |= AV_FRAME_FLAG_KEY;
 537     }else{
 538         int i;
 539         for(i=0; i<s->max_ref_frames && s->last_picture[i]->data[0]; i++)
 540             if(i && (s->last_picture[i-1]->flags & AV_FRAME_FLAG_KEY))
 541                 break;
 542         s->ref_frames= i;
 543         if(s->ref_frames==0){
 544             av_log(s->avctx,AV_LOG_ERROR, "No reference frames\n");
 545             return AVERROR_INVALIDDATA;
 546         }
 547         s->current_picture->flags &= ~AV_FRAME_FLAG_KEY;
 548     }
 549
 550     return 0;
 551 }
 552
 553 av_cold void ff_snow_common_end(SnowContext *s)
 554 {
 555     int plane_index, level, orientation, i;
 556
 557     av_freep(&s->spatial_dwt_buffer);
 558     av_freep(&s->temp_dwt_buffer);
 559     av_freep(&s->spatial_idwt_buffer);
 560     av_freep(&s->temp_idwt_buffer);
 561     av_freep(&s->run_buffer);
 562
 563     av_freep(&s->block);
 564     av_freep(&s->scratchbuf);
 565     av_freep(&s->emu_edge_buffer);
 566
 567     for(i=0; i<MAX_REF_FRAMES; i++){
 568         if(s->last_picture[i] && s->last_picture[i]->data[0]) {
 569             av_assert0(s->last_picture[i]->data[0] != s->current_picture->data[0]);
 570         }
 571         av_frame_free(&s->last_picture[i]);
 572     }
 573
 574     for(plane_index=0; plane_index < MAX_PLANES; plane_index++){
 575         for(level=MAX_DECOMPOSITIONS-1; level>=0; level--){
 576             for(orientation=level ? 1 : 0; orientation<4; orientation++){
 577                 SubBand *b= &s->plane[plane_index].band[level][orientation];
 578
 579                 av_freep(&b->x_coeff);
 580             }
 581         }
 582     }
 583     av_frame_free(&s->mconly_picture);
 584     av_frame_free(&s->current_picture);
 585 }