quicktime/ffmpeg/libavcodec/mlib/dsputil_mlib.c

   1 /*
   2  * Sun mediaLib optimized DSP utils
   3  * Copyright (c) 2001 Fabrice Bellard.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18  */
  19
  20 #include "../dsputil.h"
  21 #include "../mpegvideo.h"
  22
  23 #include <mlib_types.h>
  24 #include <mlib_status.h>
  25 #include <mlib_sys.h>
  26 #include <mlib_algebra.h>
  27 #include <mlib_video.h>
  28
  29 /* misc */
  30
  31 static void get_pixels_mlib(DCTELEM *restrict block, const uint8_t *pixels, int line_size)
  32 {
  33   int i;
  34
  35   for (i=0;i<8;i++) {
  36     mlib_VectorConvert_S16_U8_Mod((mlib_s16 *)block, (mlib_u8 *)pixels, 8);
  37
  38     pixels += line_size;
  39     block += 8;
  40   }
  41 }
  42
  43 static void diff_pixels_mlib(DCTELEM *restrict block, const uint8_t *s1, const uint8_t *s2, int line_size)
  44 {
  45   int i;
  46
  47   for (i=0;i<8;i++) {
  48     mlib_VectorSub_S16_U8_Mod((mlib_s16 *)block, (mlib_u8 *)s1, (mlib_u8 *)s2, 8);
  49
  50     s1 += line_size;
  51     s2 += line_size;
  52     block += 8;
  53   }
  54 }
  55
  56 static void add_pixels_clamped_mlib(const DCTELEM *block, uint8_t *pixels, int line_size)
  57 {
  58     mlib_VideoAddBlock_U8_S16(pixels, (mlib_s16 *)block, line_size);
  59 }
  60
  61 /* put block, width 16 pixel, height 8/16 */
  62
  63 static void put_pixels16_mlib (uint8_t * dest, const uint8_t * ref,
  64                                int stride, int height)
  65 {
  66   switch (height) {
  67     case 8:
  68       mlib_VideoCopyRef_U8_U8_16x8(dest, (uint8_t *)ref, stride);
  69     break;
  70
  71     case 16:
  72       mlib_VideoCopyRef_U8_U8_16x16(dest, (uint8_t *)ref, stride);
  73     break;
  74
  75     default:
  76       assert(0);
  77   }
  78 }
  79
  80 static void put_pixels16_x2_mlib (uint8_t * dest, const uint8_t * ref,
  81                                   int stride, int height)
  82 {
  83   switch (height) {
  84     case 8:
  85       mlib_VideoInterpX_U8_U8_16x8(dest, (uint8_t *)ref, stride, stride);
  86     break;
  87
  88     case 16:
  89       mlib_VideoInterpX_U8_U8_16x16(dest, (uint8_t *)ref, stride, stride);
  90     break;
  91
  92     default:
  93       assert(0);
  94   }
  95 }
  96
  97 static void put_pixels16_y2_mlib (uint8_t * dest, const uint8_t * ref,
  98                                   int stride, int height)
  99 {
 100   switch (height) {
 101     case 8:
 102       mlib_VideoInterpY_U8_U8_16x8(dest, (uint8_t *)ref, stride, stride);
 103     break;
 104
 105     case 16:
 106       mlib_VideoInterpY_U8_U8_16x16(dest, (uint8_t *)ref, stride, stride);
 107     break;
 108
 109     default:
 110       assert(0);
 111   }
 112 }
 113
 114 static void put_pixels16_xy2_mlib(uint8_t * dest, const uint8_t * ref,
 115                                   int stride, int height)
 116 {
 117   switch (height) {
 118     case 8:
 119       mlib_VideoInterpXY_U8_U8_16x8(dest, (uint8_t *)ref, stride, stride);
 120     break;
 121
 122     case 16:
 123       mlib_VideoInterpXY_U8_U8_16x16(dest, (uint8_t *)ref, stride, stride);
 124     break;
 125
 126     default:
 127       assert(0);
 128   }
 129 }
 130
 131 /* put block, width 8 pixel, height 4/8/16 */
 132
 133 static void put_pixels8_mlib (uint8_t * dest, const uint8_t * ref,
 134                                int stride, int height)
 135 {
 136   switch (height) {
 137     case 4:
 138       mlib_VideoCopyRef_U8_U8_8x4(dest, (uint8_t *)ref, stride);
 139     break;
 140
 141     case 8:
 142       mlib_VideoCopyRef_U8_U8_8x8(dest, (uint8_t *)ref, stride);
 143     break;
 144
 145     case 16:
 146       mlib_VideoCopyRef_U8_U8_8x16(dest, (uint8_t *)ref, stride);
 147     break;
 148
 149     default:
 150       assert(0);
 151   }
 152 }
 153
 154 static void put_pixels8_x2_mlib (uint8_t * dest, const uint8_t * ref,
 155                                   int stride, int height)
 156 {
 157   switch (height) {
 158     case 4:
 159       mlib_VideoInterpX_U8_U8_8x4(dest, (uint8_t *)ref, stride, stride);
 160     break;
 161
 162     case 8:
 163       mlib_VideoInterpX_U8_U8_8x8(dest, (uint8_t *)ref, stride, stride);
 164     break;
 165
 166     case 16:
 167       mlib_VideoInterpX_U8_U8_8x16(dest, (uint8_t *)ref, stride, stride);
 168     break;
 169
 170     default:
 171       assert(0);
 172   }
 173 }
 174
 175 static void put_pixels8_y2_mlib (uint8_t * dest, const uint8_t * ref,
 176                                   int stride, int height)
 177 {
 178   switch (height) {
 179     case 4:
 180       mlib_VideoInterpY_U8_U8_8x4(dest, (uint8_t *)ref, stride, stride);
 181     break;
 182
 183     case 8:
 184       mlib_VideoInterpY_U8_U8_8x8(dest, (uint8_t *)ref, stride, stride);
 185     break;
 186
 187     case 16:
 188       mlib_VideoInterpY_U8_U8_8x16(dest, (uint8_t *)ref, stride, stride);
 189     break;
 190
 191     default:
 192       assert(0);
 193   }
 194 }
 195
 196 static void put_pixels8_xy2_mlib(uint8_t * dest, const uint8_t * ref,
 197                                   int stride, int height)
 198 {
 199   switch (height) {
 200     case 4:
 201       mlib_VideoInterpXY_U8_U8_8x4(dest, (uint8_t *)ref, stride, stride);
 202     break;
 203
 204     case 8:
 205       mlib_VideoInterpXY_U8_U8_8x8(dest, (uint8_t *)ref, stride, stride);
 206     break;
 207
 208     case 16:
 209       mlib_VideoInterpXY_U8_U8_8x16(dest, (uint8_t *)ref, stride, stride);
 210     break;
 211
 212     default:
 213       assert(0);
 214   }
 215 }
 216
 217 /* average block, width 16 pixel, height 8/16 */
 218
 219 static void avg_pixels16_mlib (uint8_t * dest, const uint8_t * ref,
 220                                int stride, int height)
 221 {
 222   switch (height) {
 223     case 8:
 224       mlib_VideoCopyRefAve_U8_U8_16x8(dest, (uint8_t *)ref, stride);
 225     break;
 226
 227     case 16:
 228       mlib_VideoCopyRefAve_U8_U8_16x16(dest, (uint8_t *)ref, stride);
 229     break;
 230
 231     default:
 232       assert(0);
 233   }
 234 }
 235
 236 static void avg_pixels16_x2_mlib (uint8_t * dest, const uint8_t * ref,
 237                                   int stride, int height)
 238 {
 239   switch (height) {
 240     case 8:
 241       mlib_VideoInterpAveX_U8_U8_16x8(dest, (uint8_t *)ref, stride, stride);
 242     break;
 243
 244     case 16:
 245       mlib_VideoInterpAveX_U8_U8_16x16(dest, (uint8_t *)ref, stride, stride);
 246     break;
 247
 248     default:
 249       assert(0);
 250   }
 251 }
 252
 253 static void avg_pixels16_y2_mlib (uint8_t * dest, const uint8_t * ref,
 254                                   int stride, int height)
 255 {
 256   switch (height) {
 257     case 8:
 258       mlib_VideoInterpAveY_U8_U8_16x8(dest, (uint8_t *)ref, stride, stride);
 259     break;
 260
 261     case 16:
 262       mlib_VideoInterpAveY_U8_U8_16x16(dest, (uint8_t *)ref, stride, stride);
 263     break;
 264
 265     default:
 266       assert(0);
 267   }
 268 }
 269
 270 static void avg_pixels16_xy2_mlib(uint8_t * dest, const uint8_t * ref,
 271                                   int stride, int height)
 272 {
 273   switch (height) {
 274     case 8:
 275       mlib_VideoInterpAveXY_U8_U8_16x8(dest, (uint8_t *)ref, stride, stride);
 276     break;
 277
 278     case 16:
 279       mlib_VideoInterpAveXY_U8_U8_16x16(dest, (uint8_t *)ref, stride, stride);
 280     break;
 281
 282     default:
 283       assert(0);
 284   }
 285 }
 286
 287 /* average block, width 8 pixel, height 4/8/16 */
 288
 289 static void avg_pixels8_mlib (uint8_t * dest, const uint8_t * ref,
 290                                int stride, int height)
 291 {
 292   switch (height) {
 293     case 4:
 294       mlib_VideoCopyRefAve_U8_U8_8x4(dest, (uint8_t *)ref, stride);
 295     break;
 296
 297     case 8:
 298       mlib_VideoCopyRefAve_U8_U8_8x8(dest, (uint8_t *)ref, stride);
 299     break;
 300
 301     case 16:
 302       mlib_VideoCopyRefAve_U8_U8_8x16(dest, (uint8_t *)ref, stride);
 303     break;
 304
 305     default:
 306       assert(0);
 307   }
 308 }
 309
 310 static void avg_pixels8_x2_mlib (uint8_t * dest, const uint8_t * ref,
 311                                   int stride, int height)
 312 {
 313   switch (height) {
 314     case 4:
 315       mlib_VideoInterpAveX_U8_U8_8x4(dest, (uint8_t *)ref, stride, stride);
 316     break;
 317
 318     case 8:
 319       mlib_VideoInterpAveX_U8_U8_8x8(dest, (uint8_t *)ref, stride, stride);
 320     break;
 321
 322     case 16:
 323       mlib_VideoInterpAveX_U8_U8_8x16(dest, (uint8_t *)ref, stride, stride);
 324     break;
 325
 326     default:
 327       assert(0);
 328   }
 329 }
 330
 331 static void avg_pixels8_y2_mlib (uint8_t * dest, const uint8_t * ref,
 332                                   int stride, int height)
 333 {
 334   switch (height) {
 335     case 4:
 336       mlib_VideoInterpAveY_U8_U8_8x4(dest, (uint8_t *)ref, stride, stride);
 337     break;
 338
 339     case 8:
 340       mlib_VideoInterpAveY_U8_U8_8x8(dest, (uint8_t *)ref, stride, stride);
 341     break;
 342
 343     case 16:
 344       mlib_VideoInterpAveY_U8_U8_8x16(dest, (uint8_t *)ref, stride, stride);
 345     break;
 346
 347     default:
 348       assert(0);
 349   }
 350 }
 351
 352 static void avg_pixels8_xy2_mlib(uint8_t * dest, const uint8_t * ref,
 353                                   int stride, int height)
 354 {
 355   switch (height) {
 356     case 4:
 357       mlib_VideoInterpAveXY_U8_U8_8x4(dest, (uint8_t *)ref, stride, stride);
 358     break;
 359
 360     case 8:
 361       mlib_VideoInterpAveXY_U8_U8_8x8(dest, (uint8_t *)ref, stride, stride);
 362     break;
 363
 364     case 16:
 365       mlib_VideoInterpAveXY_U8_U8_8x16(dest, (uint8_t *)ref, stride, stride);
 366     break;
 367
 368     default:
 369       assert(0);
 370   }
 371 }
 372
 373 /* swap byte order of a buffer */
 374
 375 static void bswap_buf_mlib(uint32_t *dst, uint32_t *src, int w)
 376 {
 377   mlib_VectorReverseByteOrder_U32_U32(dst, src, w);
 378 }
 379
 380 /* transformations */
 381
 382 static void ff_idct_put_mlib(uint8_t *dest, int line_size, DCTELEM *data)
 383 {
 384     int i;
 385     uint8_t *cm = cropTbl + MAX_NEG_CROP;
 386
 387     mlib_VideoIDCT8x8_S16_S16 (data, data);
 388
 389     for(i=0;i<8;i++) {
 390         dest[0] = cm[data[0]];
 391         dest[1] = cm[data[1]];
 392         dest[2] = cm[data[2]];
 393         dest[3] = cm[data[3]];
 394         dest[4] = cm[data[4]];
 395         dest[5] = cm[data[5]];
 396         dest[6] = cm[data[6]];
 397         dest[7] = cm[data[7]];
 398
 399         dest += line_size;
 400         data += 8;
 401     }
 402 }
 403
 404 static void ff_idct_add_mlib(uint8_t *dest, int line_size, DCTELEM *data)
 405 {
 406     mlib_VideoIDCT8x8_S16_S16 (data, data);
 407     mlib_VideoAddBlock_U8_S16(dest, (mlib_s16 *)data, line_size);
 408 }
 409
 410 static void ff_idct_mlib(DCTELEM *data)
 411 {
 412     mlib_VideoIDCT8x8_S16_S16 (data, data);
 413 }
 414
 415 static void ff_fdct_mlib(DCTELEM *data)
 416 {
 417     mlib_VideoDCT8x8_S16_S16 (data, data);
 418 }
 419
 420 void dsputil_init_mlib(DSPContext* c, AVCodecContext *avctx)
 421 {
 422     c->get_pixels  = get_pixels_mlib;
 423     c->diff_pixels = diff_pixels_mlib;
 424     c->add_pixels_clamped = add_pixels_clamped_mlib;
 425
 426     c->put_pixels_tab[0][0] = put_pixels16_mlib;
 427     c->put_pixels_tab[0][1] = put_pixels16_x2_mlib;
 428     c->put_pixels_tab[0][2] = put_pixels16_y2_mlib;
 429     c->put_pixels_tab[0][3] = put_pixels16_xy2_mlib;
 430     c->put_pixels_tab[1][0] = put_pixels8_mlib;
 431     c->put_pixels_tab[1][1] = put_pixels8_x2_mlib;
 432     c->put_pixels_tab[1][2] = put_pixels8_y2_mlib;
 433     c->put_pixels_tab[1][3] = put_pixels8_xy2_mlib;
 434
 435     c->avg_pixels_tab[0][0] = avg_pixels16_mlib;
 436     c->avg_pixels_tab[0][1] = avg_pixels16_x2_mlib;
 437     c->avg_pixels_tab[0][2] = avg_pixels16_y2_mlib;
 438     c->avg_pixels_tab[0][3] = avg_pixels16_xy2_mlib;
 439     c->avg_pixels_tab[1][0] = avg_pixels8_mlib;
 440     c->avg_pixels_tab[1][1] = avg_pixels8_x2_mlib;
 441     c->avg_pixels_tab[1][2] = avg_pixels8_y2_mlib;
 442     c->avg_pixels_tab[1][3] = avg_pixels8_xy2_mlib;
 443
 444     c->put_no_rnd_pixels_tab[0][0] = put_pixels16_mlib;
 445     c->put_no_rnd_pixels_tab[1][0] = put_pixels8_mlib;
 446
 447     c->bswap_buf = bswap_buf_mlib;
 448 }
 449
 450 void MPV_common_init_mlib(MpegEncContext *s)
 451 {
 452     if(s->avctx->dct_algo==FF_DCT_AUTO || s->avctx->dct_algo==FF_DCT_MLIB){
 453         s->dsp.fdct = ff_fdct_mlib;
 454     }
 455
 456     if(s->avctx->idct_algo==FF_IDCT_AUTO || s->avctx->idct_algo==FF_IDCT_MLIB){
 457         s->dsp.idct_put= ff_idct_put_mlib;
 458         s->dsp.idct_add= ff_idct_add_mlib;
 459         s->dsp.idct    = ff_idct_mlib;
 460         s->dsp.idct_permutation_type= FF_NO_IDCT_PERM;
 461     }
 462 }