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.
38308 Commits
32 Branches
776MB
Tree: ce1e8045e0
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'ce1e8045e0'
${ noResults }
FFmpeg/libavcodec/hpeldsp_template.c

255 lines
9.5KB
Raw Blame History 

  1. /*

  2.  * Half-pel DSP functions.

  3.  * Copyright (c) 2000, 2001 Fabrice Bellard

  4.  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>

  5.  *

  6.  * gmc & q-pel & 32/64 bit based MC by Michael Niedermayer <michaelni@gmx.at>

  7.  *

  8.  * This file is part of Libav.

  9.  *

  10.  * Libav is free software; you can redistribute it and/or

  11.  * modify it under the terms of the GNU Lesser General Public

  12.  * License as published by the Free Software Foundation; either

  13.  * version 2.1 of the License, or (at your option) any later version.

  14.  *

  15.  * Libav is distributed in the hope that it will be useful,

  16.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  17.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  18.  * Lesser General Public License for more details.

  19.  *

  20.  * You should have received a copy of the GNU Lesser General Public

  21.  * License along with Libav; if not, write to the Free Software

  22.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

  23.  */

  24. 

  25. /**

  26.  * @file

  27.  * Half-pel DSP functions.

  28.  */

  29. 

  30. #include "bit_depth_template.c"

  31. 

  32. #include "hpel_template.c"

  33. 

  34. #define PIXOP2(OPNAME, OP) \

  35. static inline void FUNC(OPNAME ## _no_rnd_pixels8_l2)(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, \

  36.                                                 int src_stride1, int src_stride2, int h){\

  37.     int i;\

  38.     for(i=0; i<h; i++){\

  39.         pixel4 a,b;\

  40.         a= AV_RN4P(&src1[i*src_stride1  ]);\

  41.         b= AV_RN4P(&src2[i*src_stride2  ]);\

  42.         OP(*((pixel4*)&dst[i*dst_stride  ]), no_rnd_avg_pixel4(a, b));\

  43.         a= AV_RN4P(&src1[i*src_stride1+4*sizeof(pixel)]);\

  44.         b= AV_RN4P(&src2[i*src_stride2+4*sizeof(pixel)]);\

  45.         OP(*((pixel4*)&dst[i*dst_stride+4*sizeof(pixel)]), no_rnd_avg_pixel4(a, b));\

  46.     }\

  47. }\

  48. \

  49. static inline void FUNCC(OPNAME ## _no_rnd_pixels8_x2)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h){\

  50.     FUNC(OPNAME ## _no_rnd_pixels8_l2)(block, pixels, pixels+sizeof(pixel), line_size, line_size, line_size, h);\

  51. }\

  52. \

  53. static inline void FUNCC(OPNAME ## _pixels8_x2)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h){\

  54.     FUNC(OPNAME ## _pixels8_l2)(block, pixels, pixels+sizeof(pixel), line_size, line_size, line_size, h);\

  55. }\

  56. \

  57. static inline void FUNCC(OPNAME ## _no_rnd_pixels8_y2)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h){\

  58.     FUNC(OPNAME ## _no_rnd_pixels8_l2)(block, pixels, pixels+line_size, line_size, line_size, line_size, h);\

  59. }\

  60. \

  61. static inline void FUNCC(OPNAME ## _pixels8_y2)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h){\

  62.     FUNC(OPNAME ## _pixels8_l2)(block, pixels, pixels+line_size, line_size, line_size, line_size, h);\

  63. }\

  64. \

  65. static inline void FUNCC(OPNAME ## _pixels4_x2)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h){\

  66.     FUNC(OPNAME ## _pixels4_l2)(block, pixels, pixels+sizeof(pixel), line_size, line_size, line_size, h);\

  67. }\

  68. \

  69. static inline void FUNCC(OPNAME ## _pixels4_y2)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h){\

  70.     FUNC(OPNAME ## _pixels4_l2)(block, pixels, pixels+line_size, line_size, line_size, line_size, h);\

  71. }\

  72. \

  73. static inline void FUNCC(OPNAME ## _pixels2_x2)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h){\

  74.     FUNC(OPNAME ## _pixels2_l2)(block, pixels, pixels+sizeof(pixel), line_size, line_size, line_size, h);\

  75. }\

  76. \

  77. static inline void FUNCC(OPNAME ## _pixels2_y2)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h){\

  78.     FUNC(OPNAME ## _pixels2_l2)(block, pixels, pixels+line_size, line_size, line_size, line_size, h);\

  79. }\

  80. \

  81. static inline void FUNCC(OPNAME ## _pixels2_xy2)(uint8_t *_block, const uint8_t *_pixels, ptrdiff_t line_size, int h)\

  82. {\

  83.         int i, a0, b0, a1, b1;\

  84.         pixel *block = (pixel*)_block;\

  85.         const pixel *pixels = (const pixel*)_pixels;\

  86.         line_size /= sizeof(pixel);\

  87.         a0= pixels[0];\

  88.         b0= pixels[1] + 2;\

  89.         a0 += b0;\

  90.         b0 += pixels[2];\

  91. \

  92.         pixels+=line_size;\

  93.         for(i=0; i<h; i+=2){\

  94.             a1= pixels[0];\

  95.             b1= pixels[1];\

  96.             a1 += b1;\

  97.             b1 += pixels[2];\

  98. \

  99.             block[0]= (a1+a0)>>2; /* FIXME non put */\

  100.             block[1]= (b1+b0)>>2;\

  101. \

  102.             pixels+=line_size;\

  103.             block +=line_size;\

  104. \

  105.             a0= pixels[0];\

  106.             b0= pixels[1] + 2;\

  107.             a0 += b0;\

  108.             b0 += pixels[2];\

  109. \

  110.             block[0]= (a1+a0)>>2;\

  111.             block[1]= (b1+b0)>>2;\

  112.             pixels+=line_size;\

  113.             block +=line_size;\

  114.         }\

  115. }\

  116. \

  117. static inline void FUNCC(OPNAME ## _pixels4_xy2)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h)\

  118. {\

  119.         /* FIXME HIGH BIT DEPTH */\

  120.         int i;\

  121.         const uint32_t a= AV_RN32(pixels  );\

  122.         const uint32_t b= AV_RN32(pixels+1);\

  123.         uint32_t l0=  (a&0x03030303UL)\

  124.                     + (b&0x03030303UL)\

  125.                     + 0x02020202UL;\

  126.         uint32_t h0= ((a&0xFCFCFCFCUL)>>2)\

  127.                    + ((b&0xFCFCFCFCUL)>>2);\

  128.         uint32_t l1,h1;\

  129. \

  130.         pixels+=line_size;\

  131.         for(i=0; i<h; i+=2){\

  132.             uint32_t a= AV_RN32(pixels  );\

  133.             uint32_t b= AV_RN32(pixels+1);\

  134.             l1=  (a&0x03030303UL)\

  135.                + (b&0x03030303UL);\

  136.             h1= ((a&0xFCFCFCFCUL)>>2)\

  137.               + ((b&0xFCFCFCFCUL)>>2);\

  138.             OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\

  139.             pixels+=line_size;\

  140.             block +=line_size;\

  141.             a= AV_RN32(pixels  );\

  142.             b= AV_RN32(pixels+1);\

  143.             l0=  (a&0x03030303UL)\

  144.                + (b&0x03030303UL)\

  145.                + 0x02020202UL;\

  146.             h0= ((a&0xFCFCFCFCUL)>>2)\

  147.               + ((b&0xFCFCFCFCUL)>>2);\

  148.             OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\

  149.             pixels+=line_size;\

  150.             block +=line_size;\

  151.         }\

  152. }\

  153. \

  154. static inline void FUNCC(OPNAME ## _pixels8_xy2)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h)\

  155. {\

  156.     /* FIXME HIGH BIT DEPTH */\

  157.     int j;\

  158.     for(j=0; j<2; j++){\

  159.         int i;\

  160.         const uint32_t a= AV_RN32(pixels  );\

  161.         const uint32_t b= AV_RN32(pixels+1);\

  162.         uint32_t l0=  (a&0x03030303UL)\

  163.                     + (b&0x03030303UL)\

  164.                     + 0x02020202UL;\

  165.         uint32_t h0= ((a&0xFCFCFCFCUL)>>2)\

  166.                    + ((b&0xFCFCFCFCUL)>>2);\

  167.         uint32_t l1,h1;\

  168. \

  169.         pixels+=line_size;\

  170.         for(i=0; i<h; i+=2){\

  171.             uint32_t a= AV_RN32(pixels  );\

  172.             uint32_t b= AV_RN32(pixels+1);\

  173.             l1=  (a&0x03030303UL)\

  174.                + (b&0x03030303UL);\

  175.             h1= ((a&0xFCFCFCFCUL)>>2)\

  176.               + ((b&0xFCFCFCFCUL)>>2);\

  177.             OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\

  178.             pixels+=line_size;\

  179.             block +=line_size;\

  180.             a= AV_RN32(pixels  );\

  181.             b= AV_RN32(pixels+1);\

  182.             l0=  (a&0x03030303UL)\

  183.                + (b&0x03030303UL)\

  184.                + 0x02020202UL;\

  185.             h0= ((a&0xFCFCFCFCUL)>>2)\

  186.               + ((b&0xFCFCFCFCUL)>>2);\

  187.             OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\

  188.             pixels+=line_size;\

  189.             block +=line_size;\

  190.         }\

  191.         pixels+=4-line_size*(h+1);\

  192.         block +=4-line_size*h;\

  193.     }\

  194. }\

  195. \

  196. static inline void FUNCC(OPNAME ## _no_rnd_pixels8_xy2)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h)\

  197. {\

  198.     /* FIXME HIGH BIT DEPTH */\

  199.     int j;\

  200.     for(j=0; j<2; j++){\

  201.         int i;\

  202.         const uint32_t a= AV_RN32(pixels  );\

  203.         const uint32_t b= AV_RN32(pixels+1);\

  204.         uint32_t l0=  (a&0x03030303UL)\

  205.                     + (b&0x03030303UL)\

  206.                     + 0x01010101UL;\

  207.         uint32_t h0= ((a&0xFCFCFCFCUL)>>2)\

  208.                    + ((b&0xFCFCFCFCUL)>>2);\

  209.         uint32_t l1,h1;\

  210. \

  211.         pixels+=line_size;\

  212.         for(i=0; i<h; i+=2){\

  213.             uint32_t a= AV_RN32(pixels  );\

  214.             uint32_t b= AV_RN32(pixels+1);\

  215.             l1=  (a&0x03030303UL)\

  216.                + (b&0x03030303UL);\

  217.             h1= ((a&0xFCFCFCFCUL)>>2)\

  218.               + ((b&0xFCFCFCFCUL)>>2);\

  219.             OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\

  220.             pixels+=line_size;\

  221.             block +=line_size;\

  222.             a= AV_RN32(pixels  );\

  223.             b= AV_RN32(pixels+1);\

  224.             l0=  (a&0x03030303UL)\

  225.                + (b&0x03030303UL)\

  226.                + 0x01010101UL;\

  227.             h0= ((a&0xFCFCFCFCUL)>>2)\

  228.               + ((b&0xFCFCFCFCUL)>>2);\

  229.             OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\

  230.             pixels+=line_size;\

  231.             block +=line_size;\

  232.         }\

  233.         pixels+=4-line_size*(h+1);\

  234.         block +=4-line_size*h;\

  235.     }\

  236. }\

  237. \

  238. CALL_2X_PIXELS(FUNCC(OPNAME ## _pixels16_x2) , FUNCC(OPNAME ## _pixels8_x2) , 8*sizeof(pixel))\

  239. CALL_2X_PIXELS(FUNCC(OPNAME ## _pixels16_y2) , FUNCC(OPNAME ## _pixels8_y2) , 8*sizeof(pixel))\

  240. CALL_2X_PIXELS(FUNCC(OPNAME ## _pixels16_xy2), FUNCC(OPNAME ## _pixels8_xy2), 8*sizeof(pixel))\

  241. av_unused CALL_2X_PIXELS(FUNCC(OPNAME ## _no_rnd_pixels16)    , FUNCC(OPNAME ## _pixels8) , 8*sizeof(pixel))\

  242. CALL_2X_PIXELS(FUNCC(OPNAME ## _no_rnd_pixels16_x2) , FUNCC(OPNAME ## _no_rnd_pixels8_x2) , 8*sizeof(pixel))\

  243. CALL_2X_PIXELS(FUNCC(OPNAME ## _no_rnd_pixels16_y2) , FUNCC(OPNAME ## _no_rnd_pixels8_y2) , 8*sizeof(pixel))\

  244. CALL_2X_PIXELS(FUNCC(OPNAME ## _no_rnd_pixels16_xy2), FUNCC(OPNAME ## _no_rnd_pixels8_xy2), 8*sizeof(pixel))\

  245. 

  246. #define op_avg(a, b) a = rnd_avg_pixel4(a, b)

  247. #define op_put(a, b) a = b

  248. #if BIT_DEPTH == 8

  249. #define put_no_rnd_pixels8_8_c put_pixels8_8_c

  250. PIXOP2(avg, op_avg)

  251. PIXOP2(put, op_put)

  252. #endif

  253. #undef op_avg

  254. #undef op_put