libavcodec/vc1dsp.c

   1 /*
   2  * VC-1 and WMV3 decoder - DSP functions
   3  * Copyright (c) 2006 Konstantin Shishkov
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  *
  21  */
  22
  23 /**
  24 * @file vc1dsp.c
  25  * VC-1 and WMV3 decoder
  26  *
  27  */
  28
  29 #include "dsputil.h"
  30
  31
  32 /** Apply overlap transform to vertical edge
  33 */
  34 static void vc1_v_overlap_c(uint8_t* src, int stride, int rnd)
  35 {
  36     int i;
  37     int a, b, c, d;
  38     for(i = 0; i < 8; i++) {
  39         a = src[-2*stride];
  40         b = src[-stride];
  41         c = src[0];
  42         d = src[stride];
  43
  44         src[-2*stride] = clip_uint8((7*a + d + 4 - rnd) >> 3);
  45         src[-stride] = clip_uint8((-a + 7*b + c + d + 3 + rnd) >> 3);
  46         src[0] = clip_uint8((a + b + 7*c - d + 4 - rnd) >> 3);
  47         src[stride] = clip_uint8((a + 7*d + 3 + rnd) >> 3);
  48         src++;
  49     }
  50 }
  51
  52 /** Apply overlap transform to horizontal edge
  53 */
  54 static void vc1_h_overlap_c(uint8_t* src, int stride, int rnd)
  55 {
  56     int i;
  57     int a, b, c, d;
  58     for(i = 0; i < 8; i++) {
  59         a = src[-2];
  60         b = src[-1];
  61         c = src[0];
  62         d = src[1];
  63
  64         src[-2] = clip_uint8((7*a + d + 4 - rnd) >> 3);
  65         src[-1] = clip_uint8((-a + 7*b + c + d + 3 + rnd) >> 3);
  66         src[0] = clip_uint8((a + b + 7*c - d + 4 - rnd) >> 3);
  67         src[1] = clip_uint8((a + 7*d + 3 + rnd) >> 3);
  68         src += stride;
  69     }
  70 }
  71
  72
  73 /** Do inverse transform on 8x8 block
  74 */
  75 static void vc1_inv_trans_8x8_c(DCTELEM block[64])
  76 {
  77     int i;
  78     register int t1,t2,t3,t4,t5,t6,t7,t8;
  79     DCTELEM *src, *dst;
  80
  81     src = block;
  82     dst = block;
  83     for(i = 0; i < 8; i++){
  84         t1 = 12 * (src[0] + src[4]);
  85         t2 = 12 * (src[0] - src[4]);
  86         t3 = 16 * src[2] +  6 * src[6];
  87         t4 =  6 * src[2] - 16 * src[6];
  88
  89         t5 = t1 + t3;
  90         t6 = t2 + t4;
  91         t7 = t2 - t4;
  92         t8 = t1 - t3;
  93
  94         t1 = 16 * src[1] + 15 * src[3] +  9 * src[5] +  4 * src[7];
  95         t2 = 15 * src[1] -  4 * src[3] - 16 * src[5] -  9 * src[7];
  96         t3 =  9 * src[1] - 16 * src[3] +  4 * src[5] + 15 * src[7];
  97         t4 =  4 * src[1] -  9 * src[3] + 15 * src[5] - 16 * src[7];
  98
  99         dst[0] = (t5 + t1 + 4) >> 3;
 100         dst[1] = (t6 + t2 + 4) >> 3;
 101         dst[2] = (t7 + t3 + 4) >> 3;
 102         dst[3] = (t8 + t4 + 4) >> 3;
 103         dst[4] = (t8 - t4 + 4) >> 3;
 104         dst[5] = (t7 - t3 + 4) >> 3;
 105         dst[6] = (t6 - t2 + 4) >> 3;
 106         dst[7] = (t5 - t1 + 4) >> 3;
 107
 108         src += 8;
 109         dst += 8;
 110     }
 111
 112     src = block;
 113     dst = block;
 114     for(i = 0; i < 8; i++){
 115         t1 = 12 * (src[ 0] + src[32]);
 116         t2 = 12 * (src[ 0] - src[32]);
 117         t3 = 16 * src[16] +  6 * src[48];
 118         t4 =  6 * src[16] - 16 * src[48];
 119
 120         t5 = t1 + t3;
 121         t6 = t2 + t4;
 122         t7 = t2 - t4;
 123         t8 = t1 - t3;
 124
 125         t1 = 16 * src[ 8] + 15 * src[24] +  9 * src[40] +  4 * src[56];
 126         t2 = 15 * src[ 8] -  4 * src[24] - 16 * src[40] -  9 * src[56];
 127         t3 =  9 * src[ 8] - 16 * src[24] +  4 * src[40] + 15 * src[56];
 128         t4 =  4 * src[ 8] -  9 * src[24] + 15 * src[40] - 16 * src[56];
 129
 130         dst[ 0] = (t5 + t1 + 64) >> 7;
 131         dst[ 8] = (t6 + t2 + 64) >> 7;
 132         dst[16] = (t7 + t3 + 64) >> 7;
 133         dst[24] = (t8 + t4 + 64) >> 7;
 134         dst[32] = (t8 - t4 + 64 + 1) >> 7;
 135         dst[40] = (t7 - t3 + 64 + 1) >> 7;
 136         dst[48] = (t6 - t2 + 64 + 1) >> 7;
 137         dst[56] = (t5 - t1 + 64 + 1) >> 7;
 138
 139         src++;
 140         dst++;
 141     }
 142 }
 143
 144 /** Do inverse transform on 8x4 part of block
 145 */
 146 static void vc1_inv_trans_8x4_c(DCTELEM block[64], int n)
 147 {
 148     int i;
 149     register int t1,t2,t3,t4,t5,t6,t7,t8;
 150     DCTELEM *src, *dst;
 151     int off;
 152
 153     off = n * 32;
 154     src = block + off;
 155     dst = block + off;
 156     for(i = 0; i < 4; i++){
 157         t1 = 12 * (src[0] + src[4]);
 158         t2 = 12 * (src[0] - src[4]);
 159         t3 = 16 * src[2] +  6 * src[6];
 160         t4 =  6 * src[2] - 16 * src[6];
 161
 162         t5 = t1 + t3;
 163         t6 = t2 + t4;
 164         t7 = t2 - t4;
 165         t8 = t1 - t3;
 166
 167         t1 = 16 * src[1] + 15 * src[3] +  9 * src[5] +  4 * src[7];
 168         t2 = 15 * src[1] -  4 * src[3] - 16 * src[5] -  9 * src[7];
 169         t3 =  9 * src[1] - 16 * src[3] +  4 * src[5] + 15 * src[7];
 170         t4 =  4 * src[1] -  9 * src[3] + 15 * src[5] - 16 * src[7];
 171
 172         dst[0] = (t5 + t1 + 4) >> 3;
 173         dst[1] = (t6 + t2 + 4) >> 3;
 174         dst[2] = (t7 + t3 + 4) >> 3;
 175         dst[3] = (t8 + t4 + 4) >> 3;
 176         dst[4] = (t8 - t4 + 4) >> 3;
 177         dst[5] = (t7 - t3 + 4) >> 3;
 178         dst[6] = (t6 - t2 + 4) >> 3;
 179         dst[7] = (t5 - t1 + 4) >> 3;
 180
 181         src += 8;
 182         dst += 8;
 183     }
 184
 185     src = block + off;
 186     dst = block + off;
 187     for(i = 0; i < 8; i++){
 188         t1 = 17 * (src[ 0] + src[16]);
 189         t2 = 17 * (src[ 0] - src[16]);
 190         t3 = 22 * src[ 8];
 191         t4 = 22 * src[24];
 192         t5 = 10 * src[ 8];
 193         t6 = 10 * src[24];
 194
 195         dst[ 0] = (t1 + t3 + t6 + 64) >> 7;
 196         dst[ 8] = (t2 - t4 + t5 + 64) >> 7;
 197         dst[16] = (t2 + t4 - t5 + 64) >> 7;
 198         dst[24] = (t1 - t3 - t6 + 64) >> 7;
 199
 200         src ++;
 201         dst ++;
 202     }
 203 }
 204
 205 /** Do inverse transform on 4x8 parts of block
 206 */
 207 static void vc1_inv_trans_4x8_c(DCTELEM block[64], int n)
 208 {
 209     int i;
 210     register int t1,t2,t3,t4,t5,t6,t7,t8;
 211     DCTELEM *src, *dst;
 212     int off;
 213
 214     off = n * 4;
 215     src = block + off;
 216     dst = block + off;
 217     for(i = 0; i < 8; i++){
 218         t1 = 17 * (src[0] + src[2]);
 219         t2 = 17 * (src[0] - src[2]);
 220         t3 = 22 * src[1];
 221         t4 = 22 * src[3];
 222         t5 = 10 * src[1];
 223         t6 = 10 * src[3];
 224
 225         dst[0] = (t1 + t3 + t6 + 4) >> 3;
 226         dst[1] = (t2 - t4 + t5 + 4) >> 3;
 227         dst[2] = (t2 + t4 - t5 + 4) >> 3;
 228         dst[3] = (t1 - t3 - t6 + 4) >> 3;
 229
 230         src += 8;
 231         dst += 8;
 232     }
 233
 234     src = block + off;
 235     dst = block + off;
 236     for(i = 0; i < 4; i++){
 237         t1 = 12 * (src[ 0] + src[32]);
 238         t2 = 12 * (src[ 0] - src[32]);
 239         t3 = 16 * src[16] +  6 * src[48];
 240         t4 =  6 * src[16] - 16 * src[48];
 241
 242         t5 = t1 + t3;
 243         t6 = t2 + t4;
 244         t7 = t2 - t4;
 245         t8 = t1 - t3;
 246
 247         t1 = 16 * src[ 8] + 15 * src[24] +  9 * src[40] +  4 * src[56];
 248         t2 = 15 * src[ 8] -  4 * src[24] - 16 * src[40] -  9 * src[56];
 249         t3 =  9 * src[ 8] - 16 * src[24] +  4 * src[40] + 15 * src[56];
 250         t4 =  4 * src[ 8] -  9 * src[24] + 15 * src[40] - 16 * src[56];
 251
 252         dst[ 0] = (t5 + t1 + 64) >> 7;
 253         dst[ 8] = (t6 + t2 + 64) >> 7;
 254         dst[16] = (t7 + t3 + 64) >> 7;
 255         dst[24] = (t8 + t4 + 64) >> 7;
 256         dst[32] = (t8 - t4 + 64 + 1) >> 7;
 257         dst[40] = (t7 - t3 + 64 + 1) >> 7;
 258         dst[48] = (t6 - t2 + 64 + 1) >> 7;
 259         dst[56] = (t5 - t1 + 64 + 1) >> 7;
 260
 261         src++;
 262         dst++;
 263     }
 264 }
 265
 266 /** Do inverse transform on 4x4 part of block
 267 */
 268 static void vc1_inv_trans_4x4_c(DCTELEM block[64], int n)
 269 {
 270     int i;
 271     register int t1,t2,t3,t4,t5,t6;
 272     DCTELEM *src, *dst;
 273     int off;
 274
 275     off = (n&1) * 4 + (n&2) * 16;
 276     src = block + off;
 277     dst = block + off;
 278     for(i = 0; i < 4; i++){
 279         t1 = 17 * (src[0] + src[2]);
 280         t2 = 17 * (src[0] - src[2]);
 281         t3 = 22 * src[1];
 282         t4 = 22 * src[3];
 283         t5 = 10 * src[1];
 284         t6 = 10 * src[3];
 285
 286         dst[0] = (t1 + t3 + t6 + 4) >> 3;
 287         dst[1] = (t2 - t4 + t5 + 4) >> 3;
 288         dst[2] = (t2 + t4 - t5 + 4) >> 3;
 289         dst[3] = (t1 - t3 - t6 + 4) >> 3;
 290
 291         src += 8;
 292         dst += 8;
 293     }
 294
 295     src = block + off;
 296     dst = block + off;
 297     for(i = 0; i < 4; i++){
 298         t1 = 17 * (src[ 0] + src[16]);
 299         t2 = 17 * (src[ 0] - src[16]);
 300         t3 = 22 * src[ 8];
 301         t4 = 22 * src[24];
 302         t5 = 10 * src[ 8];
 303         t6 = 10 * src[24];
 304
 305         dst[ 0] = (t1 + t3 + t6 + 64) >> 7;
 306         dst[ 8] = (t2 - t4 + t5 + 64) >> 7;
 307         dst[16] = (t2 + t4 - t5 + 64) >> 7;
 308         dst[24] = (t1 - t3 - t6 + 64) >> 7;
 309
 310         src ++;
 311         dst ++;
 312     }
 313 }
 314
 315 /* motion compensation functions */
 316
 317 /** Filter used to interpolate fractional pel values
 318  */
 319 static always_inline int vc1_mspel_filter(const uint8_t *src, int stride, int mode, int r)
 320 {
 321     switch(mode){
 322     case 0: //no shift
 323         return src[0];
 324     case 1: // 1/4 shift
 325         return (-4*src[-stride] + 53*src[0] + 18*src[stride] - 3*src[stride*2] + 32 - r) >> 6;
 326     case 2: // 1/2 shift
 327         return (-src[-stride] + 9*src[0] + 9*src[stride] - src[stride*2] + 8 - r) >> 4;
 328     case 3: // 3/4 shift
 329         return (-3*src[-stride] + 18*src[0] + 53*src[stride] - 4*src[stride*2] + 32 - r) >> 6;
 330     }
 331     return 0; //should not occur
 332 }
 333
 334 /** Function used to do motion compensation with bicubic interpolation
 335  */
 336 static void vc1_mspel_mc(uint8_t *dst, const uint8_t *src, int stride, int mode, int rnd)
 337 {
 338     int i, j;
 339     uint8_t tmp[8*11], *tptr;
 340     int m, r;
 341
 342     m = (mode & 3);
 343     r = rnd;
 344     src -= stride;
 345     tptr = tmp;
 346     for(j = 0; j < 11; j++) {
 347         for(i = 0; i < 8; i++)
 348             tptr[i] = clip_uint8(vc1_mspel_filter(src + i, 1, m, r));
 349         src += stride;
 350         tptr += 8;
 351     }
 352     r = 1 - rnd;
 353     m = (mode >> 2) & 3;
 354
 355     tptr = tmp + 8;
 356     for(j = 0; j < 8; j++) {
 357         for(i = 0; i < 8; i++)
 358             dst[i] = clip_uint8(vc1_mspel_filter(tptr + i, 8, m, r));
 359         dst += stride;
 360         tptr += 8;
 361     }
 362 }
 363
 364 /* pixel functions - really are entry points to vc1_mspel_mc */
 365
 366 /* this one is defined in dsputil.c */
 367 void ff_put_vc1_mspel_mc00_c(uint8_t *dst, const uint8_t *src, int stride, int rnd);
 368
 369 static void ff_put_vc1_mspel_mc10_c(uint8_t *dst, const uint8_t *src, int stride, int rnd) {
 370     vc1_mspel_mc(dst, src, stride, 0x1, rnd);
 371 }
 372
 373 static void ff_put_vc1_mspel_mc20_c(uint8_t *dst, const uint8_t *src, int stride, int rnd) {
 374     vc1_mspel_mc(dst, src, stride, 0x2, rnd);
 375 }
 376
 377 static void ff_put_vc1_mspel_mc30_c(uint8_t *dst, const uint8_t *src, int stride, int rnd) {
 378     vc1_mspel_mc(dst, src, stride, 0x3, rnd);
 379 }
 380
 381 static void ff_put_vc1_mspel_mc01_c(uint8_t *dst, const uint8_t *src, int stride, int rnd) {
 382     vc1_mspel_mc(dst, src, stride, 0x4, rnd);
 383 }
 384
 385 static void ff_put_vc1_mspel_mc11_c(uint8_t *dst, const uint8_t *src, int stride, int rnd) {
 386     vc1_mspel_mc(dst, src, stride, 0x5, rnd);
 387 }
 388
 389 static void ff_put_vc1_mspel_mc21_c(uint8_t *dst, const uint8_t *src, int stride, int rnd) {
 390     vc1_mspel_mc(dst, src, stride, 0x6, rnd);
 391 }
 392
 393 static void ff_put_vc1_mspel_mc31_c(uint8_t *dst, const uint8_t *src, int stride, int rnd) {
 394     vc1_mspel_mc(dst, src, stride, 0x7, rnd);
 395 }
 396
 397 static void ff_put_vc1_mspel_mc02_c(uint8_t *dst, const uint8_t *src, int stride, int rnd) {
 398     vc1_mspel_mc(dst, src, stride, 0x8, rnd);
 399 }
 400
 401 static void ff_put_vc1_mspel_mc12_c(uint8_t *dst, const uint8_t *src, int stride, int rnd) {
 402     vc1_mspel_mc(dst, src, stride, 0x9, rnd);
 403 }
 404
 405 static void ff_put_vc1_mspel_mc22_c(uint8_t *dst, const uint8_t *src, int stride, int rnd) {
 406     vc1_mspel_mc(dst, src, stride, 0xA, rnd);
 407 }
 408
 409 static void ff_put_vc1_mspel_mc32_c(uint8_t *dst, const uint8_t *src, int stride, int rnd) {
 410     vc1_mspel_mc(dst, src, stride, 0xB, rnd);
 411 }
 412
 413 static void ff_put_vc1_mspel_mc03_c(uint8_t *dst, const uint8_t *src, int stride, int rnd) {
 414     vc1_mspel_mc(dst, src, stride, 0xC, rnd);
 415 }
 416
 417 static void ff_put_vc1_mspel_mc13_c(uint8_t *dst, const uint8_t *src, int stride, int rnd) {
 418     vc1_mspel_mc(dst, src, stride, 0xD, rnd);
 419 }
 420
 421 static void ff_put_vc1_mspel_mc23_c(uint8_t *dst, const uint8_t *src, int stride, int rnd) {
 422     vc1_mspel_mc(dst, src, stride, 0xE, rnd);
 423 }
 424
 425 static void ff_put_vc1_mspel_mc33_c(uint8_t *dst, const uint8_t *src, int stride, int rnd) {
 426     vc1_mspel_mc(dst, src, stride, 0xF, rnd);
 427 }
 428
 429 void ff_vc1dsp_init(DSPContext* dsp, AVCodecContext *avctx) {
 430     dsp->vc1_inv_trans_8x8 = vc1_inv_trans_8x8_c;
 431     dsp->vc1_inv_trans_4x8 = vc1_inv_trans_4x8_c;
 432     dsp->vc1_inv_trans_8x4 = vc1_inv_trans_8x4_c;
 433     dsp->vc1_inv_trans_4x4 = vc1_inv_trans_4x4_c;
 434     dsp->vc1_h_overlap = vc1_h_overlap_c;
 435     dsp->vc1_v_overlap = vc1_v_overlap_c;
 436
 437     dsp->put_vc1_mspel_pixels_tab[ 0] = ff_put_vc1_mspel_mc00_c;
 438     dsp->put_vc1_mspel_pixels_tab[ 1] = ff_put_vc1_mspel_mc10_c;
 439     dsp->put_vc1_mspel_pixels_tab[ 2] = ff_put_vc1_mspel_mc20_c;
 440     dsp->put_vc1_mspel_pixels_tab[ 3] = ff_put_vc1_mspel_mc30_c;
 441     dsp->put_vc1_mspel_pixels_tab[ 4] = ff_put_vc1_mspel_mc01_c;
 442     dsp->put_vc1_mspel_pixels_tab[ 5] = ff_put_vc1_mspel_mc11_c;
 443     dsp->put_vc1_mspel_pixels_tab[ 6] = ff_put_vc1_mspel_mc21_c;
 444     dsp->put_vc1_mspel_pixels_tab[ 7] = ff_put_vc1_mspel_mc31_c;
 445     dsp->put_vc1_mspel_pixels_tab[ 8] = ff_put_vc1_mspel_mc02_c;
 446     dsp->put_vc1_mspel_pixels_tab[ 9] = ff_put_vc1_mspel_mc12_c;
 447     dsp->put_vc1_mspel_pixels_tab[10] = ff_put_vc1_mspel_mc22_c;
 448     dsp->put_vc1_mspel_pixels_tab[11] = ff_put_vc1_mspel_mc32_c;
 449     dsp->put_vc1_mspel_pixels_tab[12] = ff_put_vc1_mspel_mc03_c;
 450     dsp->put_vc1_mspel_pixels_tab[13] = ff_put_vc1_mspel_mc13_c;
 451     dsp->put_vc1_mspel_pixels_tab[14] = ff_put_vc1_mspel_mc23_c;
 452     dsp->put_vc1_mspel_pixels_tab[15] = ff_put_vc1_mspel_mc33_c;
 453 }