falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3964 Commits
32 Branches
570MB
Tree: 35ef76b51c
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '35ef76b51c'
${ noResults }
FFmpeg/libavcodec/mlib/dsputil_mlib.c

463 lines
11KB
Raw Blame History 

  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. }