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