开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
resize.cpp
资源名称：142_61_thumb_advanced.rar　[点击查看]
上传用户：dangjiwu
上传日期：2013-07-19
资源大小：42019k
文件大小：40k
源码类别：

Symbian

开发平台：

Visual C++

resize.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: resize.cpp,v 1.9.32.1 2004/07/09 01:55:14 hubbe Exp $
  3.  * 
  4.  * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved.
  5.  * 
  6.  * The contents of this file, and the files included with this file,
  7.  * are subject to the current version of the RealNetworks Public
  8.  * Source License (the "RPSL") available at
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed
  10.  * the file under the current version of the RealNetworks Community
  11.  * Source License (the "RCSL") available at
  12.  * http://www.helixcommunity.org/content/rcsl, in which case the RCSL
  13.  * will apply. You may also obtain the license terms directly from
  14.  * RealNetworks.  You may not use this file except in compliance with
  15.  * the RPSL or, if you have a valid RCSL with RealNetworks applicable
  16.  * to this file, the RCSL.  Please see the applicable RPSL or RCSL for
  17.  * the rights, obligations and limitations governing use of the
  18.  * contents of the file.
  19.  * 
  20.  * Alternatively, the contents of this file may be used under the
  21.  * terms of the GNU General Public License Version 2 or later (the
  22.  * "GPL") in which case the provisions of the GPL are applicable
  23.  * instead of those above. If you wish to allow use of your version of
  24.  * this file only under the terms of the GPL, and not to allow others
  25.  * to use your version of this file under the terms of either the RPSL
  26.  * or RCSL, indicate your decision by deleting the provisions above
  27.  * and replace them with the notice and other provisions required by
  28.  * the GPL. If you do not delete the provisions above, a recipient may
  29.  * use your version of this file under the terms of any one of the
  30.  * RPSL, the RCSL or the GPL.
  31.  * 
  32.  * This file is part of the Helix DNA Technology. RealNetworks is the
  33.  * developer of the Original Code and owns the copyrights in the
  34.  * portions it created.
  35.  * 
  36.  * This file, and the files included with this file, is distributed
  37.  * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY
  38.  * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS
  39.  * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES
  40.  * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET
  41.  * ENJOYMENT OR NON-INFRINGEMENT.
  42.  * 
  43.  * Technology Compatibility Kit Test Suite(s) Location:
  44.  *    http://www.helixcommunity.org/content/tck
  45.  * 
  46.  * Contributor(s):
  47.  * 
  48.  * ***** END LICENSE BLOCK ***** */
  50. ////////////////////////////////////////////////////////
  51. // include files
  52. ////////////////////////////////////////////////////////
  54. #include "hlxclib/stdlib.h"
  55. #include "hlxclib/string.h"
  56. #include "mmx_util.h"
  57. #include "resize.h"
  60. ////////////////////////////////////////////////////////
  61. // internal prototypes
  62. ////////////////////////////////////////////////////////
  64. static void
  65. interpolate_ii (
  66.     unsigned char *dest, int dest_width, int dest_height, int dest_pitch,
  67.     unsigned char *src,  int src_width,  int src_height,  int src_pitch);
  69. static void
  70. decimate (
  71.     unsigned char *dest, int dest_width, int dest_height, int dest_pitch,
  72.     unsigned char *src,  int src_width,  int src_height,  int src_pitch, 
  73. RESIZE_BUFF_TYPE *buff);
  75. #ifdef _M_IX86
  77. static void
  78. decimate_half_horiz_MMX (
  79.     unsigned char *dest, int dest_width, int dest_height,
  80.     unsigned char *src,  int src_width,  int src_height);
  82. #endif
  84. static void 
  85. decimate_half_horiz_accurate(
  86.     unsigned char *dest, int dest_width, int dest_height, int dest_pitch,
  87.     unsigned char *src,  int src_width,  int src_height, int src_pitch);
  90. ////////////////////////////////////////////////////////
  91. // Select interpolation or decimation
  92. ////////////////////////////////////////////////////////
  94. void resize_plane(
  95.     unsigned char *dest, int dest_width, int dest_height, int dest_pitch,
  96.     unsigned char *src,  int src_width,  int src_height,  int src_pitch,
  97. RESIZE_BUFF_TYPE *buff, int accuracy)
  98. {
  100. if ((dest_width > src_width) || (dest_height > src_height) || 
  101. (accuracy == 0) || (buff == NULL))
  102. {
  103. // interpolation
  104. interpolate_ii (dest,dest_width, dest_height, dest_pitch,
  105. src, src_width, src_height, src_pitch);
  106. }
  107. else
  108. {
  109. // decimation -- check for special case functions
  110. #ifdef _M_IX86
  111. if (((dest_width) == (src_width >> 1)) &&
  112. ((dest_height) == (src_height)) &&
  113. ((dest_pitch) == (dest_width)) &&
  114. ((src_pitch) == (src_width)) &&
  115.             (checkMmxAvailablity()&CPU_HAS_MMX) && (accuracy == 0))
  116. {
  117. decimate_half_horiz_MMX (
  118. dest,dest_width, dest_height,
  119. src, src_width, src_height);
  120. }
  121. else
  122. #endif
  123. if (((dest_width) == (src_width >> 1)) &&
  124. ((dest_height) == (src_height)))
  125. {
  126. decimate_half_horiz_accurate(
  127. dest,dest_width, dest_height, dest_pitch,
  128. src, src_width, src_height, src_pitch);
  129. }
  130. else
  131. {
  132. decimate (dest,dest_width, dest_height, dest_pitch,
  133. src, src_width, src_height, src_pitch, buff);
  134. }
  135. }
  137. }
  139. #if 1 // simpler filter
  141. #define FULL_PEL_INC 256
  142. #define INT_FILT_SIZE 1025
  143. #define INT_FILT_CENTER 512
  145. static const int int_filt_tab[INT_FILT_SIZE] = 
  146. {
  147. 0,
  148. -3, -5, -8, -11, -13, -16, -19, -21, -24, -27, -29, -32, -35, -37, -40, -43, -45, -48, -50, -53,
  149. -56, -58, -61, -63, -66, -69, -71, -74, -76, -79, -81, -84, -87, -89, -92, -94, -97, -99, -102, -104,
  150. -107, -109, -111, -114, -116, -119, -121, -124, -126, -128, -131, -133, -135, -138, -140, -142, -144, -147, -149, -151,
  151. -153, -156, -158, -160, -162, -164, -166, -169, -171, -173, -175, -177, -179, -181, -183, -185, -187, -189, -191, -193,
  152. -194, -196, -198, -200, -202, -203, -205, -207, -209, -210, -212, -214, -215, -217, -218, -220, -222, -223, -225, -226,
  153. -227, -229, -230, -232, -233, -234, -235, -237, -238, -239, -240, -242, -243, -244, -245, -246, -247, -248, -249, -250,
  154. -251, -251, -252, -253, -254, -255, -255, -256, -257, -257, -258, -258, -259, -259, -260, -260, -261, -261, -261, -262,
  155. -262, -262, -262, -263, -263, -263, -263, -263, -263, -263, -263, -262, -262, -262, -262, -262, -261, -261, -260, -260,
  156. -260, -259, -258, -258, -257, -257, -256, -255, -254, -253, -253, -252, -251, -250, -249, -248, -246, -245, -244, -243,
  157. -241, -240, -239, -237, -236, -234, -233, -231, -229, -228, -226, -224, -222, -220, -218, -216, -214, -212, -210, -208,
  158. -206, -203, -201, -199, -196, -194, -191, -189, -186, -183, -180, -178, -175, -172, -169, -166, -163, -160, -157, -153,
  159. -150, -147, -143, -140, -137, -133, -129, -126, -122, -118, -114, -111, -107, -103, -99, -94, -90, -86, -82, -78,
  160. -73, -69, -64, -60, -55, -50, -45, -41, -36, -31, -26, -21, -16, -11, -5, 0, 16, 32, 48, 64,
  161. 81, 97, 113, 130, 146, 163, 180, 196, 213, 230, 247, 264, 280, 297, 314, 332, 349, 366, 383, 400,
  162. 418, 435, 452, 470, 487, 505, 522, 540, 558, 575, 593, 611, 629, 646, 664, 682, 700, 718, 736, 754,
  163. 772, 790, 808, 827, 845, 863, 881, 899, 918, 936, 954, 973, 991, 1009, 1028, 1046, 1065, 1083, 1102, 1120,
  164. 1139, 1157, 1176, 1194, 1213, 1231, 1250, 1268, 1287, 1306, 1324, 1343, 1362, 1380, 1399, 1418, 1436, 1455, 1473, 1492,
  165. 1511, 1529, 1548, 1567, 1585, 1604, 1623, 1641, 1660, 1679, 1697, 1716, 1735, 1753, 1772, 1790, 1809, 1828, 1846, 1865,
  166. 1883, 1902, 1920, 1939, 1957, 1976, 1994, 2013, 2031, 2049, 2068, 2086, 2104, 2123, 2141, 2159, 2177, 2195, 2214, 2232,
  167. 2250, 2268, 2286, 2304, 2322, 2340, 2358, 2376, 2394, 2411, 2429, 2447, 2465, 2482, 2500, 2518, 2535, 2553, 2570, 2588,
  168. 2605, 2622, 2640, 2657, 2674, 2691, 2708, 2725, 2742, 2759, 2776, 2793, 2810, 2827, 2843, 2860, 2877, 2893, 2910, 2926,
  169. 2942, 2959, 2975, 2991, 3007, 3023, 3039, 3055, 3071, 3087, 3103, 3119, 3134, 3150, 3165, 3181, 3196, 3211, 3226, 3242,
  170. 3257, 3272, 3287, 3301, 3316, 3331, 3345, 3360, 3374, 3389, 3403, 3417, 3432, 3446, 3460, 3473, 3487, 3501, 3515, 3528,
  171. 3542, 3555, 3568, 3582, 3595, 3608, 3621, 3633, 3646, 3659, 3671, 3684, 3696, 3708, 3721, 3733, 3745, 3757, 3768, 3780,
  172. 3792, 3803, 3814, 3826, 3837, 3848, 3859, 3870, 3880, 3891, 3902, 3912, 3922, 3932, 3943, 3953, 3962, 3972, 3982, 3991,
  173. 4001, 4010, 4019, 4028, 4037, 4046, 4054, 4063, 4071, 4080, 4088, 4096, 4088, 4080, 4071, 4063, 4054, 4046, 4037, 4028,
  174. 4019, 4010, 4001, 3991, 3982, 3972, 3962, 3953, 3943, 3932, 3922, 3912, 3902, 3891, 3880, 3870, 3859, 3848, 3837, 3826,
  175. 3814, 3803, 3792, 3780, 3768, 3757, 3745, 3733, 3721, 3708, 3696, 3684, 3671, 3659, 3646, 3633, 3621, 3608, 3595, 3582,
  176. 3568, 3555, 3542, 3528, 3515, 3501, 3487, 3473, 3460, 3446, 3432, 3417, 3403, 3389, 3374, 3360, 3345, 3331, 3316, 3301,
  177. 3287, 3272, 3257, 3242, 3226, 3211, 3196, 3181, 3165, 3150, 3134, 3119, 3103, 3087, 3071, 3055, 3039, 3023, 3007, 2991,
  178. 2975, 2959, 2942, 2926, 2910, 2893, 2877, 2860, 2843, 2827, 2810, 2793, 2776, 2759, 2742, 2725, 2708, 2691, 2674, 2657,
  179. 2640, 2622, 2605, 2588, 2570, 2553, 2535, 2518, 2500, 2482, 2465, 2447, 2429, 2411, 2394, 2376, 2358, 2340, 2322, 2304,
  180. 2286, 2268, 2250, 2232, 2214, 2195, 2177, 2159, 2141, 2123, 2104, 2086, 2068, 2049, 2031, 2013, 1994, 1976, 1957, 1939,
  181. 1920, 1902, 1883, 1865, 1846, 1828, 1809, 1790, 1772, 1753, 1735, 1716, 1697, 1679, 1660, 1641, 1623, 1604, 1585, 1567,
  182. 1548, 1529, 1511, 1492, 1473, 1455, 1436, 1418, 1399, 1380, 1362, 1343, 1324, 1306, 1287, 1268, 1250, 1231, 1213, 1194,
  183. 1176, 1157, 1139, 1120, 1102, 1083, 1065, 1046, 1028, 1009, 991, 973, 954, 936, 918, 899, 881, 863, 845, 827,
  184. 808, 790, 772, 754, 736, 718, 700, 682, 664, 646, 629, 611, 593, 575, 558, 540, 522, 505, 487, 470,
  185. 452, 435, 418, 400, 383, 366, 349, 332, 314, 297, 280, 264, 247, 230, 213, 196, 180, 163, 146, 130,
  186. 113, 97, 81, 64, 48, 32, 16, 0, -5, -11, -16, -21, -26, -31, -36, -41, -45, -50, -55, -60,
  187. -64, -69, -73, -78, -82, -86, -90, -94, -99, -103, -107, -111, -114, -118, -122, -126, -129, -133, -137, -140,
  188. -143, -147, -150, -153, -157, -160, -163, -166, -169, -172, -175, -178, -180, -183, -186, -189, -191, -194, -196, -199,
  189. -201, -203, -206, -208, -210, -212, -214, -216, -218, -220, -222, -224, -226, -228, -229, -231, -233, -234, -236, -237,
  190. -239, -240, -241, -243, -244, -245, -246, -248, -249, -250, -251, -252, -253, -253, -254, -255, -256, -257, -257, -258,
  191. -258, -259, -260, -260, -260, -261, -261, -262, -262, -262, -262, -262, -263, -263, -263, -263, -263, -263, -263, -263,
  192. -262, -262, -262, -262, -261, -261, -261, -260, -260, -259, -259, -258, -258, -257, -257, -256, -255, -255, -254, -253,
  193. -252, -251, -251, -250, -249, -248, -247, -246, -245, -244, -243, -242, -240, -239, -238, -237, -235, -234, -233, -232,
  194. -230, -229, -227, -226, -225, -223, -222, -220, -218, -217, -215, -214, -212, -210, -209, -207, -205, -203, -202, -200,
  195. -198, -196, -194, -193, -191, -189, -187, -185, -183, -181, -179, -177, -175, -173, -171, -169, -166, -164, -162, -160,
  196. -158, -156, -153, -151, -149, -147, -144, -142, -140, -138, -135, -133, -131, -128, -126, -124, -121, -119, -116, -114,
  197. -111, -109, -107, -104, -102, -99, -97, -94, -92, -89, -87, -84, -81, -79, -76, -74, -71, -69, -66, -63,
  198. -61, -58, -56, -53, -50, -48, -45, -43, -40, -37, -35, -32, -29, -27, -24, -21, -19, -16, -13, -11,
  199. -8, -5, -3, 0
  200. };
  202. #else  // complex filter
  204. #define FULL_PEL_INC 128
  205. #define INT_FILT_SIZE 1025
  206. #define INT_FILT_CENTER 512
  208. static const int int_filt_tab[INT_FILT_SIZE] = 
  209. {
  210. 0,
  211. 0, 0, -1, -1, -1, -1, -2, -2, -2, -2, -2, -3, -3, -3, -3, -4, -4, -4, -4, -4,
  212. -5, -5, -5, -5, -5, -6, -6, -6, -6, -6, -7, -7, -7, -7, -7, -7, -8, -8, -8, -8,
  213. -8, -8, -8, -8, -9, -9, -9, -9, -9, -9, -9, -9, -9, -10, -10, -10, -10, -10, -10, -10,
  214. -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10,
  215. -10, -9, -9, -9, -9, -9, -9, -9, -9, -9, -8, -8, -8, -8, -8, -8, -8, -7, -7, -7,
  216. -7, -7, -6, -6, -6, -6, -6, -5, -5, -5, -5, -4, -4, -4, -4, -3, -3, -3, -3, -2,
  217. -2, -2, -1, -1, -1, -1, 0, 0, 2, 4, 6, 9, 11, 13, 15, 17, 19, 21, 23, 25,
  218. 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 51, 53, 55, 57, 59, 61, 62, 64,
  219. 66, 67, 69, 70, 72, 74, 75, 76, 78, 79, 81, 82, 83, 84, 85, 87, 88, 89, 90, 91,
  220. 91, 92, 93, 94, 95, 95, 96, 96, 97, 97, 98, 98, 98, 99, 99, 99, 99, 99, 99, 99,
  221. 99, 98, 98, 98, 97, 97, 96, 96, 95, 94, 94, 93, 92, 91, 90, 89, 88, 87, 85, 84,
  222. 83, 81, 80, 78, 77, 75, 73, 71, 70, 68, 66, 64, 62, 60, 57, 55, 53, 51, 48, 46,
  223. 43, 41, 38, 35, 33, 30, 27, 24, 21, 18, 16, 12, 9, 6, 3, 0, -10, -19, -29, -39,
  224. -48, -58, -68, -78, -87, -97, -107, -117, -126, -136, -146, -155, -165, -175, -184, -194, -203, -212, -222, -231,
  225. -240, -249, -258, -267, -276, -285, -293, -302, -310, -318, -326, -335, -342, -350, -358, -365, -373, -380, -387, -394,
  226. -400, -407, -413, -420, -425, -431, -437, -442, -447, -452, -457, -462, -466, -470, -474, -478, -481, -484, -487, -490,
  227. -492, -495, -496, -498, -500, -501, -501, -502, -502, -502, -502, -501, -500, -499, -498, -496, -494, -491, -488, -485,
  228. -482, -478, -474, -470, -465, -460, -455, -449, -443, -436, -429, -422, -415, -407, -399, -390, -381, -372, -362, -352,
  229. -342, -331, -320, -309, -297, -285, -272, -259, -246, -232, -218, -203, -188, -173, -158, -142, -125, -108, -91, -74,
  230. -56, -38, -19, 0, 32, 65, 98, 131, 165, 198, 233, 267, 302, 338, 373, 409, 445, 481, 518, 555,
  231. 592, 629, 667, 705, 743, 781, 820, 858, 897, 936, 975, 1015, 1054, 1094, 1133, 1173, 1213, 1253, 1293, 1333,
  232. 1374, 1414, 1454, 1495, 1535, 1575, 1616, 1656, 1697, 1737, 1778, 1818, 1858, 1898, 1939, 1979, 2019, 2059, 2098, 2138,
  233. 2178, 2217, 2256, 2295, 2334, 2373, 2412, 2450, 2488, 2526, 2564, 2601, 2639, 2676, 2712, 2749, 2785, 2821, 2857, 2892,
  234. 2927, 2961, 2996, 3030, 3063, 3097, 3129, 3162, 3194, 3226, 3257, 3288, 3318, 3348, 3378, 3407, 3436, 3464, 3492, 3519,
  235. 3546, 3572, 3598, 3623, 3648, 3672, 3696, 3719, 3742, 3764, 3785, 3806, 3826, 3846, 3865, 3884, 3902, 3919, 3936, 3952,
  236. 3968, 3983, 3997, 4011, 4024, 4036, 4048, 4059, 4069, 4079, 4088, 4096, 4088, 4079, 4069, 4059, 4048, 4036, 4024, 4011,
  237. 3997, 3983, 3968, 3952, 3936, 3919, 3902, 3884, 3865, 3846, 3826, 3806, 3785, 3764, 3742, 3719, 3696, 3672, 3648, 3623,
  238. 3598, 3572, 3546, 3519, 3492, 3464, 3436, 3407, 3378, 3348, 3318, 3288, 3257, 3226, 3194, 3162, 3129, 3097, 3063, 3030,
  239. 2996, 2961, 2927, 2892, 2857, 2821, 2785, 2749, 2712, 2676, 2639, 2601, 2564, 2526, 2488, 2450, 2412, 2373, 2334, 2295,
  240. 2256, 2217, 2178, 2138, 2098, 2059, 2019, 1979, 1939, 1898, 1858, 1818, 1778, 1737, 1697, 1656, 1616, 1575, 1535, 1495,
  241. 1454, 1414, 1374, 1333, 1293, 1253, 1213, 1173, 1133, 1094, 1054, 1015, 975, 936, 897, 858, 820, 781, 743, 705,
  242. 667, 629, 592, 555, 518, 481, 445, 409, 373, 338, 302, 267, 233, 198, 165, 131, 98, 65, 32, 0,
  243. -19, -38, -56, -74, -91, -108, -125, -142, -158, -173, -188, -203, -218, -232, -246, -259, -272, -285, -297, -309,
  244. -320, -331, -342, -352, -362, -372, -381, -390, -399, -407, -415, -422, -429, -436, -443, -449, -455, -460, -465, -470,
  245. -474, -478, -482, -485, -488, -491, -494, -496, -498, -499, -500, -501, -502, -502, -502, -502, -501, -501, -500, -498,
  246. -496, -495, -492, -490, -487, -484, -481, -478, -474, -470, -466, -462, -457, -452, -447, -442, -437, -431, -425, -420,
  247. -413, -407, -400, -394, -387, -380, -373, -365, -358, -350, -342, -335, -326, -318, -310, -302, -293, -285, -276, -267,
  248. -258, -249, -240, -231, -222, -212, -203, -194, -184, -175, -165, -155, -146, -136, -126, -117, -107, -97, -87, -78,
  249. -68, -58, -48, -39, -29, -19, -10, 0, 3, 6, 9, 12, 16, 18, 21, 24, 27, 30, 33, 35,
  250. 38, 41, 43, 46, 48, 51, 53, 55, 57, 60, 62, 64, 66, 68, 70, 71, 73, 75, 77, 78,
  251. 80, 81, 83, 84, 85, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 96, 97, 97, 98,
  252. 98, 98, 99, 99, 99, 99, 99, 99, 99, 99, 98, 98, 98, 97, 97, 96, 96, 95, 95, 94,
  253. 93, 92, 91, 91, 90, 89, 88, 87, 85, 84, 83, 82, 81, 79, 78, 76, 75, 74, 72, 70,
  254. 69, 67, 66, 64, 62, 61, 59, 57, 55, 53, 51, 50, 48, 46, 44, 42, 40, 38, 36, 34,
  255. 32, 30, 28, 25, 23, 21, 19, 17, 15, 13, 11, 9, 6, 4, 2, 0, 0, -1, -1, -1,
  256. -1, -2, -2, -2, -3, -3, -3, -3, -4, -4, -4, -4, -5, -5, -5, -5, -6, -6, -6, -6,
  257. -6, -7, -7, -7, -7, -7, -8, -8, -8, -8, -8, -8, -8, -9, -9, -9, -9, -9, -9, -9,
  258. -9, -9, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10,
  259. -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -9, -9, -9, -9, -9, -9, -9, -9, -9, -8,
  260. -8, -8, -8, -8, -8, -8, -8, -7, -7, -7, -7, -7, -7, -6, -6, -6, -6, -6, -5, -5,
  261. -5, -5, -5, -4, -4, -4, -4, -4, -3, -3, -3, -3, -2, -2, -2, -2, -2, -1, -1, -1,
  262. -1, 0, 0, 0
  263. };
  265. #endif
  269. // Clipping table
  270. #define CLAMP_BIAS  128 // Bias in clamping table 
  271. #define CLIP_RANGE (CLAMP_BIAS + 256 + CLAMP_BIAS)
  273. const unsigned char ClampTbl[CLIP_RANGE] = { /* Flawfinder: ignore */
  274.              0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 
  275.             ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 
  276.             ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 
  277.             ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 
  278.             ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 
  279.             ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 
  280.             ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 
  281.             ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 
  282.             ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 
  283.             ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 
  284.             ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 
  285.             ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 
  286.             ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 
  287.             ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 
  288.             ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 
  289.             ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 
  290.             ,0x00 ,0x01 ,0x02 ,0x03 ,0x04 ,0x05 ,0x06 ,0x07 
  291.             ,0x08 ,0x09 ,0x0a ,0x0b ,0x0c ,0x0d ,0x0e ,0x0f 
  292.             ,0x10 ,0x11 ,0x12 ,0x13 ,0x14 ,0x15 ,0x16 ,0x17 
  293.             ,0x18 ,0x19 ,0x1a ,0x1b ,0x1c ,0x1d ,0x1e ,0x1f 
  294.             ,0x20 ,0x21 ,0x22 ,0x23 ,0x24 ,0x25 ,0x26 ,0x27 
  295.             ,0x28 ,0x29 ,0x2a ,0x2b ,0x2c ,0x2d ,0x2e ,0x2f 
  296.             ,0x30 ,0x31 ,0x32 ,0x33 ,0x34 ,0x35 ,0x36 ,0x37 
  297.             ,0x38 ,0x39 ,0x3a ,0x3b ,0x3c ,0x3d ,0x3e ,0x3f 
  298.             ,0x40 ,0x41 ,0x42 ,0x43 ,0x44 ,0x45 ,0x46 ,0x47 
  299.             ,0x48 ,0x49 ,0x4a ,0x4b ,0x4c ,0x4d ,0x4e ,0x4f 
  300.             ,0x50 ,0x51 ,0x52 ,0x53 ,0x54 ,0x55 ,0x56 ,0x57 
  301.             ,0x58 ,0x59 ,0x5a ,0x5b ,0x5c ,0x5d ,0x5e ,0x5f 
  302.             ,0x60 ,0x61 ,0x62 ,0x63 ,0x64 ,0x65 ,0x66 ,0x67 
  303.             ,0x68 ,0x69 ,0x6a ,0x6b ,0x6c ,0x6d ,0x6e ,0x6f 
  304.             ,0x70 ,0x71 ,0x72 ,0x73 ,0x74 ,0x75 ,0x76 ,0x77 
  305.             ,0x78 ,0x79 ,0x7a ,0x7b ,0x7c ,0x7d ,0x7e ,0x7f 
  306.             ,0x80 ,0x81 ,0x82 ,0x83 ,0x84 ,0x85 ,0x86 ,0x87 
  307.             ,0x88 ,0x89 ,0x8a ,0x8b ,0x8c ,0x8d ,0x8e ,0x8f 
  308.             ,0x90 ,0x91 ,0x92 ,0x93 ,0x94 ,0x95 ,0x96 ,0x97 
  309.             ,0x98 ,0x99 ,0x9a ,0x9b ,0x9c ,0x9d ,0x9e ,0x9f 
  310.             ,0xa0 ,0xa1 ,0xa2 ,0xa3 ,0xa4 ,0xa5 ,0xa6 ,0xa7 
  311.             ,0xa8 ,0xa9 ,0xaa ,0xab ,0xac ,0xad ,0xae ,0xaf 
  312.             ,0xb0 ,0xb1 ,0xb2 ,0xb3 ,0xb4 ,0xb5 ,0xb6 ,0xb7 
  313.             ,0xb8 ,0xb9 ,0xba ,0xbb ,0xbc ,0xbd ,0xbe ,0xbf 
  314.             ,0xc0 ,0xc1 ,0xc2 ,0xc3 ,0xc4 ,0xc5 ,0xc6 ,0xc7 
  315.             ,0xc8 ,0xc9 ,0xca ,0xcb ,0xcc ,0xcd ,0xce ,0xcf 
  316.             ,0xd0 ,0xd1 ,0xd2 ,0xd3 ,0xd4 ,0xd5 ,0xd6 ,0xd7 
  317.             ,0xd8 ,0xd9 ,0xda ,0xdb ,0xdc ,0xdd ,0xde ,0xdf 
  318.             ,0xe0 ,0xe1 ,0xe2 ,0xe3 ,0xe4 ,0xe5 ,0xe6 ,0xe7 
  319.             ,0xe8 ,0xe9 ,0xea ,0xeb ,0xec ,0xed ,0xee ,0xef 
  320.             ,0xf0 ,0xf1 ,0xf2 ,0xf3 ,0xf4 ,0xf5 ,0xf6 ,0xf7 
  321.             ,0xf8 ,0xf9 ,0xfa ,0xfb ,0xfc ,0xfd ,0xfe ,0xff 
  322.             ,0xff ,0xff ,0xff ,0xff ,0xff ,0xff ,0xff ,0xff 
  323.             ,0xff ,0xff ,0xff ,0xff ,0xff ,0xff ,0xff ,0xff 
  324.             ,0xff ,0xff ,0xff ,0xff ,0xff ,0xff ,0xff ,0xff 
  325.             ,0xff ,0xff ,0xff ,0xff ,0xff ,0xff ,0xff ,0xff 
  326.             ,0xff ,0xff ,0xff ,0xff ,0xff ,0xff ,0xff ,0xff 
  327.             ,0xff ,0xff ,0xff ,0xff ,0xff ,0xff ,0xff ,0xff 
  328.             ,0xff ,0xff ,0xff ,0xff ,0xff ,0xff ,0xff ,0xff 
  329.             ,0xff ,0xff ,0xff ,0xff ,0xff ,0xff ,0xff ,0xff 
  330.             ,0xff ,0xff ,0xff ,0xff ,0xff ,0xff ,0xff ,0xff 
  331.             ,0xff ,0xff ,0xff ,0xff ,0xff ,0xff ,0xff ,0xff 
  332.             ,0xff ,0xff ,0xff ,0xff ,0xff ,0xff ,0xff ,0xff 
  333.             ,0xff ,0xff ,0xff ,0xff ,0xff ,0xff ,0xff ,0xff 
  334.             ,0xff ,0xff ,0xff ,0xff ,0xff ,0xff ,0xff ,0xff 
  335.             ,0xff ,0xff ,0xff ,0xff ,0xff ,0xff ,0xff ,0xff 
  336.             ,0xff ,0xff ,0xff ,0xff ,0xff ,0xff ,0xff ,0xff 
  337.             ,0xff ,0xff ,0xff ,0xff ,0xff ,0xff ,0xff ,0xff 
  338.    };
  340. #ifdef CLIP_PEL
  341. #undef CLIP_PEL
  342. #endif
  344. #define CLIP_PEL(p) (ClampTbl[ (p) + CLAMP_BIAS ])
  347. #define POS_SCALE_BITS 16
  348. #define FILT_COEFF_BITS 12
  349. #define FILT_SCALE_BITS 8
  351. #define USE_SOURCE_LEVEL 1
  354. ////////////////////////////////////////////////////////
  355. //
  356. // Performs fast half horizontal w/ MMX
  357. // Greg Conklin - 9/21/99
  358. //
  359. ////////////////////////////////////////////////////////
  361. #ifdef _M_IX86
  363. static void
  364. decimate_half_horiz_MMX (
  365.     unsigned char *dest, int dest_width, int dest_height,
  366.     unsigned char *src,  int src_width,  int src_height)
  367. {
  368. unsigned char word_mask[8] = {0xFF,0x00,0xFF,0x00,0xFF,0x00,0xFF,0x00}; /* Flawfinder: ignore */
  369. int num_itrs;
  371. // must be doing half horizontal resolution
  372. if (((dest_width) != (src_width >> 1)) ||
  373. ((dest_height) != (src_height)))
  374. return;
  376. num_itrs = ((dest_height*dest_width) >> 3);
  378. __asm {
  380. mov ecx, num_itrs
  381. mov esi, src // esi -> source frame
  382. mov edi, dest // edi -> destination frame
  383. movq mm7, [word_mask] // mm7 holds the bytes->words mask
  385. ALIGN 16
  386. pel_loop:
  387. movq mm0, [esi]
  388. movq mm1, mm0
  389. psrlw mm1, 8
  390. pand mm0, mm7
  391. paddw mm0, mm1
  392. psrlw mm0, 1
  394. lea esi, [esi+8]
  396. movq mm1, [esi]
  397. movq mm2, mm1
  398. psrlw mm2, 8
  399. pand mm1, mm7
  400. paddw mm1, mm2
  401. psrlw mm1, 1
  403. lea esi, [esi+8]
  405. packuswb mm0, mm1
  406. movq [edi], mm0
  408. lea edi, [edi+8]
  410. dec ecx
  411. jnz pel_loop
  413. emms
  414. }
  415. }
  417. #endif
  419. ////////////////////////////////////////////////////////
  420. //
  421. // Performs fast and accurate half horizontal
  422. // Greg Conklin - 9/05/00
  423. //
  424. ////////////////////////////////////////////////////////
  426. static void 
  427. decimate_half_horiz_accurate(
  428.     unsigned char *dest, int dest_width, int dest_height, int dest_pitch,
  429.     unsigned char *src,  int src_width,  int src_height, int src_pitch)
  430. {
  431. unsigned char *dd;
  432. unsigned char *ss;
  433. unsigned char *src_end;
  434. unsigned char *line_end;
  435. int dest_skip;
  436. int src_skip;
  437. int a,b,c,d;
  439. dd = dest;
  440. ss = src;
  441. dest_skip = dest_pitch - dest_width + 1;
  442. src_skip = src_pitch - src_width + 2;
  443. src_end = src + src_width * src_height;
  445. while (ss < src_end)
  446. {
  447. line_end = ss + src_width - 2;
  449. a = ss[0];
  450. b = a;
  451. c = ss[1];
  452. d = ss[2];
  454. b += c;
  455. a += d;
  456. b *= 9;
  457. b -= a;
  458. b += 7;
  459. b >>= 4;
  461. dd[0] = CLIP_PEL(b);
  463. ss += 2;
  464. dd ++;
  466. while (ss < line_end)
  467. {
  468. a = c;
  469. b = d;
  470. c = ss[1];
  471. d = ss[2];
  473. b += c;
  474. a += d;
  475. b *= 9;
  476. b -= a;
  477. b += 7;
  478. b >>= 4;
  480. dd[0] = CLIP_PEL(b);
  482. ss += 2;
  483. dd ++;
  484. }
  486. a = c;
  487. b = d;
  488. c = ss[1];
  489. d = c;
  491. b += c;
  492. a += d;
  493. b *= 9;
  494. b -= a;
  495. b += 7;
  496. b >>= 4;
  498. dd[0] = CLIP_PEL(b);
  500. ss += src_skip;
  501. dd += dest_skip;
  502. }
  504. }
  506. ////////////////////////////////////////////////////////
  507. //
  508. // Performs accurate decimation
  509. // Greg Conklin - 9/21/99
  510. //
  511. ////////////////////////////////////////////////////////
  513. static void
  514. decimate (
  515.     unsigned char *dest, int dest_width, int dest_height, int dest_pitch,
  516.     unsigned char *src,  int src_width,  int src_height,  int src_pitch, 
  517. RESIZE_BUFF_TYPE *buff)
  518. {
  520. unsigned char *sp, *dp;
  521. RESIZE_BUFF_TYPE *tp;
  522. int pel; // destination x position
  523. int line; // destination y position
  524. int tmp; // temp storage for result pel
  525. int pos; // fractional position of source (x or y) location
  526. int pos_int; // integer position of source
  527. int pos_bgn; // the starting location of pos
  528. int pos_inc; // the increment of 'pos' to the next pel
  529. const int *filt_tab_ptr; // pointer to the current filter tap
  530. int filt_tab_inc; // spacing between tabs in the filter table
  531. int filt_tap_num; // number of filter taps
  532. int filt_scale; // filter gain 
  534. #if USE_SOURCE_LEVEL
  535. int source_level;
  536. #else
  537. #define source_level 0
  538. #endif
  540. if (dest_height == src_height)
  541. {
  542. // no vertical resizing
  543. for (line = 0; line < src_height; line++)
  544. {
  545. tp = buff + line * src_pitch;
  546. sp = src + line * src_pitch;
  548. for (pel = 0; pel < src_width - 3; pel += 4)
  549. {
  550. tp[0] = sp[0];
  551. tp[1] = sp[1];
  552. tp[2] = sp[2];
  553. tp[3] = sp[3];
  554. tp += 4;
  555. sp += 4;
  556. }
  557. for (; pel < dest_width; pel++)
  558. {
  559. *tp = *sp;
  560. tp ++;
  561. sp ++;
  562. }
  563. }
  565. }
  566. else if (dest_height == (src_height >> 1))
  567. {
  568. // decimate vertical by 2
  570. int src_skip = src_pitch - src_width;
  571. int a, b, c, d;
  573. tp = buff;
  574. sp = src;
  576. // top line
  577. for (pel = 0; pel < src_width; pel ++)
  578. {
  579. b = *sp;
  580. c = *(sp + src_pitch);
  581. d = *(sp + 2 * src_pitch);
  583. c += b;
  584. b += d;
  585. c *= 9;
  586. c -= b;
  587. c += 7;
  588. c >>= 4;
  590. *tp = CLIP_PEL(c);
  592. sp++;
  593. tp++;
  594. }
  595. tp += src_skip;
  596. sp += src_skip + src_pitch;
  598. // middle lines
  599. for (line = 2; line < dest_height; line ++)
  600. {
  601. for (pel = 0; pel < src_width; pel++)
  602. {
  603. a = *(sp - src_pitch);
  604. b = *sp;
  605. c = *(sp + src_pitch);
  606. d = *(sp + 2 * src_pitch);
  608. b += c;
  609. a += d;
  610. b *= 9;
  611. b -= a;
  612. b += 7;
  613. b >>= 4;
  615. *tp = CLIP_PEL(b);
  617. sp++;
  618. tp++;
  619. }
  620. tp += src_skip;
  621. sp += src_skip + src_pitch;
  622. }
  624. // bottom line
  625. for (pel = 0; pel < src_width; pel++)
  626. {
  627. a = *(sp - src_pitch);
  628. b = *sp;
  629. c = *(sp + src_pitch);
  631. b += c;
  632. a += c;
  633. b *= 9;
  634. b -= a;
  635. b += 7;
  636. b >>= 4;
  638. *tp = CLIP_PEL(b);
  640. sp++;
  641. tp++;
  642. }
  643. }
  644. else
  645. {
  646. // arbitrary vertical resize
  648. pos_inc = ((src_height << POS_SCALE_BITS) + (dest_height >> 1)) / (dest_height);
  649. pos_bgn = (pos_inc - (1 << POS_SCALE_BITS)) >> 1;
  650. filt_tab_inc = (FULL_PEL_INC * dest_height + (src_height >> 1)) / (src_height);
  651. if (filt_tab_inc > FULL_PEL_INC)
  652. filt_tab_inc = FULL_PEL_INC;
  653. filt_tap_num = (INT_FILT_SIZE - 1) / (filt_tab_inc << 1);
  654. filt_scale = ((dest_height << FILT_SCALE_BITS) + (src_height >> 1)) / (src_height);
  656. for (pel = 0; pel < src_width; pel++)
  657. {
  658. tp = buff + pel;
  660. line = 0;
  661. pos = pos_bgn;
  662. pos_int = pos >> POS_SCALE_BITS;
  664. // Top edge pels
  665. while (pos_int < filt_tap_num)
  666. {
  667. sp = src + (pos_int) * src_pitch + pel;
  668. #if USE_SOURCE_LEVEL
  669. source_level = *sp;
  670. #endif
  671. sp -= filt_tap_num * src_pitch;
  673. filt_tab_ptr = int_filt_tab;
  674. filt_tab_ptr -= (filt_tab_inc * (pos & ((1L << POS_SCALE_BITS) - 1))) >> POS_SCALE_BITS;
  675. filt_tab_ptr += INT_FILT_CENTER - (filt_tap_num * filt_tab_inc);
  676. if (filt_tab_ptr < int_filt_tab)
  677. {
  678. sp += src_pitch;
  679. filt_tab_ptr += filt_tab_inc;
  680. }
  682. tmp = 0;
  683. while (filt_tab_ptr < int_filt_tab + INT_FILT_SIZE)
  684. {
  685. if (sp < src)
  686. tmp += (*filt_tab_ptr) * (src[pel] - source_level);
  687. else
  688. tmp += (*filt_tab_ptr) * (*sp - source_level);
  689. sp += src_pitch;;
  690. filt_tab_ptr += filt_tab_inc;
  691. }
  692. tmp *= filt_scale;
  693. tmp += (source_level << (FILT_COEFF_BITS + FILT_SCALE_BITS));
  694. tmp += (1U << (FILT_COEFF_BITS + FILT_SCALE_BITS - 1));
  695. tmp >>= (FILT_COEFF_BITS + FILT_SCALE_BITS);
  696. *tp = tmp;
  698. tp += src_pitch;
  699. pos += pos_inc;
  700. pos_int = pos >> POS_SCALE_BITS;
  701. line++;
  702. }
  703. // Center pels
  704. while (pos_int < src_height - filt_tap_num - 1)
  705. {
  706. sp = src + (pos_int) * src_pitch + pel;
  707. #if USE_SOURCE_LEVEL
  708. source_level = *sp;
  709. #endif
  710. sp -= filt_tap_num * src_pitch;
  712. filt_tab_ptr = int_filt_tab;
  713. filt_tab_ptr -= (filt_tab_inc * (pos & ((1L << POS_SCALE_BITS) - 1))) >> POS_SCALE_BITS;
  714. filt_tab_ptr += INT_FILT_CENTER - (filt_tap_num * filt_tab_inc);
  715. if (filt_tab_ptr < int_filt_tab)
  716. {
  717. sp += src_pitch;
  718. filt_tab_ptr += filt_tab_inc;
  719. }
  721. // There are at least 4 taps...
  722. tmp = (*filt_tab_ptr) * (*sp - source_level);
  723. sp += src_pitch;
  724. filt_tab_ptr += filt_tab_inc;
  726. tmp += (*filt_tab_ptr) * (*sp - source_level);
  727. sp += src_pitch;
  728. filt_tab_ptr += filt_tab_inc;
  730. tmp += (*filt_tab_ptr) * (*sp - source_level);
  731. sp += src_pitch;
  732. filt_tab_ptr += filt_tab_inc;
  734. tmp += (*filt_tab_ptr) * (*sp - source_level);
  735. sp += src_pitch;
  736. filt_tab_ptr += filt_tab_inc;
  738. // Remaining taps...
  739. while (filt_tab_ptr < int_filt_tab + INT_FILT_SIZE)
  740. {
  741. tmp += (*filt_tab_ptr) * (*sp - source_level);
  742. sp += src_pitch;
  743. filt_tab_ptr += filt_tab_inc;
  744. }
  746. // scale and store result...
  747. tmp *= filt_scale;
  748. tmp += (source_level << (FILT_COEFF_BITS + FILT_SCALE_BITS));
  749. tmp += (1U << (FILT_COEFF_BITS + FILT_SCALE_BITS - 1));
  750. tmp >>= (FILT_COEFF_BITS + FILT_SCALE_BITS);
  751. *tp = tmp;
  753. tp += src_pitch;
  754. pos += pos_inc;
  755. pos_int = pos >> POS_SCALE_BITS;
  756. line++;
  757. }
  758. // Bottom edge pels
  759. while (line < dest_height)
  760. {
  761. sp = src + (pos_int) * src_pitch + pel;
  762. #if USE_SOURCE_LEVEL
  763. source_level = *sp;
  764. #endif
  765. sp -= filt_tap_num * src_pitch;
  767. filt_tab_ptr = int_filt_tab;
  768. filt_tab_ptr -= (filt_tab_inc * (pos & ((1L << POS_SCALE_BITS) - 1))) >> POS_SCALE_BITS;
  769. filt_tab_ptr += INT_FILT_CENTER - (filt_tap_num * filt_tab_inc);
  770. if (filt_tab_ptr < int_filt_tab)
  771. {
  772. sp += src_pitch;
  773. filt_tab_ptr += filt_tab_inc;
  774. }
  776. tmp = 0;
  777. while (filt_tab_ptr < int_filt_tab + INT_FILT_SIZE)
  778. {
  779. if (sp >= src + src_height*src_pitch)
  780. tmp += (*filt_tab_ptr) * (src[(src_height - 1) * src_pitch + pel] - source_level);
  781. else
  782. tmp += (*filt_tab_ptr) * (*sp - source_level);
  783. sp += src_pitch;
  784. filt_tab_ptr += filt_tab_inc;
  785. }
  786. tmp *= filt_scale;
  787. tmp += (source_level << (FILT_COEFF_BITS + FILT_SCALE_BITS));
  788. tmp += (1U << (FILT_COEFF_BITS + FILT_SCALE_BITS - 1));
  789. tmp >>= (FILT_COEFF_BITS + FILT_SCALE_BITS);
  790. *tp = tmp;
  792. tp += src_pitch;
  793. pos += pos_inc;
  794. pos_int = pos >> POS_SCALE_BITS;
  795. line++;
  796. }
  797. }
  798. }
  800. if (dest_width == src_width)
  801. {
  802. // no horizontal resizing
  803. for (line = 0; line < dest_height; line++)
  804. {
  805. tp = buff + line * src_pitch;
  806. dp = dest + line * dest_pitch;
  808. for (pel = 0; pel < dest_width - 3; pel += 4)
  809. {
  810. dp[0] = CLIP_PEL(tp[0]);
  811. dp[1] = CLIP_PEL(tp[1]);
  812. dp[2] = CLIP_PEL(tp[2]);
  813. dp[3] = CLIP_PEL(tp[3]);
  814. dp += 4;
  815. tp += 4;
  816. }
  817. for (; pel < dest_width; pel++)
  818. {
  819. *dp = CLIP_PEL(*tp);
  820. dp ++;
  821. tp ++;
  822. }
  823. }
  824. }
  825. else if (dest_width == (src_width >> 1))
  826. {
  827. // decimate horizontally by 2
  829. int src_skip = src_pitch - src_width + 2;
  830. int dest_skip = dest_pitch - dest_width + 1;
  831. int a, b, c, d;
  833. tp = buff;
  834. dp = dest;
  836. for (line = 0; line < dest_height; line ++)
  837. {
  838. a = tp[0];
  839. b = a;
  840. c = tp[1];
  841. d = tp[2];
  843. b += c;
  844. a += d;
  845. b *= 9;
  846. b -= a;
  847. b += 7;
  848. b >>= 4;
  850. *dp = CLIP_PEL(b);
  852. tp += 2;
  853. dp ++;
  855. for (pel = 1; pel < dest_width - 1; pel++)
  856. {
  857. a = c;
  858. b = d;
  859. c = tp[1];
  860. d = tp[2];
  862. b += c;
  863. a += d;
  864. b *= 9;
  865. b -= a;
  866. b += 7;
  867. b >>= 4;
  869. *dp = CLIP_PEL(b);
  871. tp += 2;
  872. dp ++;
  873. }
  874. a = c;
  875. b = d;
  876. c = tp[1];
  877. d = c;
  879. b += c;
  880. a += d;
  881. b *= 9;
  882. b -= a;
  883. b += 7;
  884. b >>= 4;
  886. *dp = CLIP_PEL(b);
  888. tp += src_skip;
  889. dp += dest_skip;
  890. }
  891. }
  892. else
  893. {
  894. // horizonal filtering
  895. pos_inc = ((src_width << POS_SCALE_BITS) + (dest_width >> 1)) / (dest_width);
  896. pos_bgn = (pos_inc - (1 << POS_SCALE_BITS)) >> 1;
  897. filt_tab_inc = (FULL_PEL_INC * dest_width + (src_width >> 1)) / (src_width);
  898. if (filt_tab_inc > FULL_PEL_INC)
  899. filt_tab_inc = FULL_PEL_INC;
  900. filt_tap_num = (INT_FILT_SIZE - 1) / (filt_tab_inc << 1);
  901. filt_scale = ((dest_width << FILT_SCALE_BITS) + (src_width >> 1)) / (src_width);
  903. for (line = 0; line < dest_height; line++)
  904. {
  905. dp = dest + line * dest_pitch;
  907. pel = 0;
  908. pos = pos_bgn;
  909. pos_int = pos >> POS_SCALE_BITS;
  911. // Left edge pels
  912. while (pos_int < filt_tap_num)
  913. {
  914. tp = buff + line * src_pitch + pos_int;
  916. #if USE_SOURCE_LEVEL
  917. source_level = *tp;
  918. #endif
  919. tp -= filt_tap_num;
  921. filt_tab_ptr = int_filt_tab;
  922. filt_tab_ptr -= (filt_tab_inc * (pos & ((1L << POS_SCALE_BITS) - 1))) >> POS_SCALE_BITS;
  923. filt_tab_ptr += INT_FILT_CENTER - (filt_tap_num * filt_tab_inc);
  924. if (filt_tab_ptr < int_filt_tab)
  925. {
  926. tp ++;
  927. filt_tab_ptr += filt_tab_inc;
  928. }
  930. tmp = 0;
  931. while (filt_tab_ptr < int_filt_tab + INT_FILT_SIZE)
  932. {
  933. if (tp < buff)
  934. tmp += (*filt_tab_ptr) * (buff[line * src_pitch] - source_level);
  935. else
  936. tmp += (*filt_tab_ptr) * (*tp - source_level);
  937. tp++;
  938. filt_tab_ptr += filt_tab_inc;
  939. }
  940. tmp *= filt_scale;
  941. tmp += (source_level << (FILT_COEFF_BITS + FILT_SCALE_BITS));
  942. tmp += (1U << (FILT_COEFF_BITS + FILT_SCALE_BITS - 1));
  943. tmp >>= (FILT_COEFF_BITS + FILT_SCALE_BITS);
  944. *dp = CLIP_PEL(tmp);
  946. dp++;
  947. pos += pos_inc;
  948. pos_int = pos >> POS_SCALE_BITS;
  949. pel++;
  950. }
  951. // Center pels
  952. while (pos_int < src_width - filt_tap_num - 1)
  953. {
  954. tp = buff + line * src_pitch + pos_int;
  956. #if USE_SOURCE_LEVEL
  957. source_level = *tp;
  958. #endif
  959. tp -= filt_tap_num;
  961. filt_tab_ptr = int_filt_tab;
  962. filt_tab_ptr -= (filt_tab_inc * (pos & ((1L << POS_SCALE_BITS) - 1))) >> POS_SCALE_BITS;
  963. filt_tab_ptr += INT_FILT_CENTER - (filt_tap_num * filt_tab_inc);
  964. if (filt_tab_ptr < int_filt_tab)
  965. {
  966. tp ++;
  967. filt_tab_ptr += filt_tab_inc;
  968. }
  970. // There are at least 4 taps...
  971. tmp = (*filt_tab_ptr) * (tp[0] - source_level);
  972. filt_tab_ptr += filt_tab_inc;
  973. tmp += (*filt_tab_ptr) * (tp[1] - source_level);
  974. filt_tab_ptr += filt_tab_inc;
  975. tmp += (*filt_tab_ptr) * (tp[2] - source_level);
  976. filt_tab_ptr += filt_tab_inc;
  977. tmp += (*filt_tab_ptr) * (tp[3] - source_level);
  978. filt_tab_ptr += filt_tab_inc;
  980. tp += 4;
  982. // Remaining taps...
  983. while (filt_tab_ptr < int_filt_tab + INT_FILT_SIZE)
  984. {
  985. tmp += (*filt_tab_ptr) * (*tp - source_level);
  986. tp++;
  987. filt_tab_ptr += filt_tab_inc;
  988. }
  989. tmp *= filt_scale;
  990. tmp += (source_level << (FILT_COEFF_BITS + FILT_SCALE_BITS));
  991. tmp += (1U << (FILT_COEFF_BITS + FILT_SCALE_BITS - 1));
  992. tmp >>= (FILT_COEFF_BITS + FILT_SCALE_BITS);
  994. *dp = CLIP_PEL(tmp);
  996. dp++;
  997. pos += pos_inc;
  998. pos_int = pos >> POS_SCALE_BITS;
  999. pel++;
  1000. }
  1001. // Right edge pels
  1002. while (pel < dest_width)
  1003. {
  1004. tp = buff + line * src_pitch + pos_int;
  1006. #if USE_SOURCE_LEVEL
  1007. source_level = *tp;
  1008. #endif
  1009. tp -= filt_tap_num;
  1011. filt_tab_ptr = int_filt_tab;
  1012. filt_tab_ptr -= (filt_tab_inc * (pos & ((1L << POS_SCALE_BITS) - 1))) >> POS_SCALE_BITS;
  1013. filt_tab_ptr += INT_FILT_CENTER - (filt_tap_num * filt_tab_inc);
  1014. if (filt_tab_ptr < int_filt_tab)
  1015. {
  1016. tp ++;
  1017. filt_tab_ptr += filt_tab_inc;
  1018. }
  1020. tmp = 0;
  1021. while (filt_tab_ptr < int_filt_tab + INT_FILT_SIZE)
  1022. {
  1023. if (tp >= buff + line * src_pitch + src_width)
  1024. tmp += (*filt_tab_ptr) * (buff[line * src_pitch + src_width - 1] - source_level);
  1025. else
  1026. tmp += (*filt_tab_ptr) * (*tp - source_level);
  1027. tp++;
  1028. filt_tab_ptr += filt_tab_inc;
  1029. }
  1030. tmp *= filt_scale;
  1031. tmp += (source_level << (FILT_COEFF_BITS + FILT_SCALE_BITS));
  1032. tmp += (1U << (FILT_COEFF_BITS + FILT_SCALE_BITS - 1));
  1033. tmp >>= (FILT_COEFF_BITS + FILT_SCALE_BITS);
  1034. *dp = CLIP_PEL(tmp);
  1036. dp++;
  1037. pos += pos_inc;
  1038. pos_int = pos >> POS_SCALE_BITS;
  1039. pel++;
  1040. }
  1041. }
  1042. }
  1043. }
  1046. /* 12-19-98 02:36am, written by Yuriy A. Reznik, yreznik@real.com */
  1048. #define TOTAL_SCALE_BITS    16  /* precision of inverse coordinate mapping */
  1049. #define COEF_SCALE_BITS     3   /* actual grid used to select scale coeffs */
  1051. /*
  1052.  * Interpolate image.
  1053.  * Use:
  1054.  *  void interpolate_x (
  1055.  *       unsigned char *dest, int dest_width, int dest_height, int dest_pitch,
  1056.  *       unsigned char *src,  int src_width,  int src_height,  int src_pitch);
  1057.  */
  1058. static void  /** G2H263Codec:: NEVER make this function a class method!!!! */
  1059. interpolate_ii (
  1060.     unsigned char *dest, int dest_width, int dest_height, int dest_pitch,
  1061.     unsigned char *src,  int src_width,  int src_height,  int src_pitch)
  1062. {
  1063.     /* scaled row/column counters, limits, & increment values: */
  1064.     int src_x, src_y;
  1065.     int src_x_inc = ((src_width << TOTAL_SCALE_BITS) + dest_width / 2) / dest_width;
  1066.     int src_y_inc = ((src_height << TOTAL_SCALE_BITS) + dest_height / 2) / dest_height;
  1067.     int src_x_max = (src_width - 1) << TOTAL_SCALE_BITS;
  1068.     int src_y_max = (src_height - 1) << TOTAL_SCALE_BITS;
  1069.     int src_x_end = src_x_inc * dest_width;
  1070.     int src_y_end = src_y_inc * dest_height;
  1071. int src_x_bgn = (src_width < dest_width)?(0):((src_x_inc  - (1 << TOTAL_SCALE_BITS)) >> 1);
  1072. int src_y_bgn = (src_height < dest_height)?(0):((src_y_inc - (1 << TOTAL_SCALE_BITS)) >> 1);
  1074. src_x_bgn = 0;
  1075. src_y_bgn = 0;
  1077.     /* source/destination pointers: */
  1078.     unsigned char *s1, *s2, *d1 = dest;
  1080.     /* perform interpolation by inverse mapping from destination to source: */
  1081.     for (src_y = src_y_bgn; src_y < src_y_max; src_y += src_y_inc) {
  1083.         /* map row: */
  1084.         int src_y_i = src_y >> TOTAL_SCALE_BITS;
  1085.         int q       = (src_y >> (TOTAL_SCALE_BITS - COEF_SCALE_BITS)) & ((1U << COEF_SCALE_BITS) - 1);
  1087.         /* get source row pointers: */
  1088.         s1 = src + src_y_i * src_pitch;
  1089.         s2 = s1 + src_pitch;
  1091.         src_x = src_x_bgn;
  1092.         do {
  1093.             register int src_x_i, p;
  1094.             register unsigned int a, b, c;
  1096.             /* get first pixel: */
  1097.             src_x_i = src_x >> TOTAL_SCALE_BITS;
  1098.             p = (src_x >> (TOTAL_SCALE_BITS - COEF_SCALE_BITS)) & ((1U << COEF_SCALE_BITS) - 1);
  1099.             /* load 4 pixels in 2 registers: */
  1100.             a = (s2 [src_x_i] << 16) + s1 [src_x_i]; 
  1101.             c = (s2 [src_x_i + 1] << 16) + s1 [src_x_i + 1]; 
  1102.             /* perform 1st horisontal projection: */
  1103.             a = (a << COEF_SCALE_BITS) + p * (c - a);
  1105.             src_x  += src_x_inc; /* 1! */
  1107.             /* get second pixel: */
  1108.             src_x_i = src_x >> TOTAL_SCALE_BITS;
  1109.             p = (src_x >> (TOTAL_SCALE_BITS - COEF_SCALE_BITS)) & ((1U << COEF_SCALE_BITS) - 1);
  1110.             /* load 4 pixels in 2 registers: */
  1111.             b = (s2 [src_x_i] << 16) + s1 [src_x_i]; 
  1112.             c = (s2 [src_x_i + 1] << 16) + s1 [src_x_i + 1]; 
  1113.             /* perform 2nd horisontal projection: */
  1114.             b = (b << COEF_SCALE_BITS) + p * (c - b);
  1116.             /* repack & perform vertical projection: */
  1117.             c = a;
  1118.             a = (a & 0xFFFF) + (b << 16);
  1119.             b = (b & 0xFFFF0000) + ((unsigned int)c >> 16);
  1120.             a = (a << COEF_SCALE_BITS) + q * (b - a);
  1121.             
  1122.             /* store pixels: */
  1123.             *d1++ = (unsigned int)a >> 2 * COEF_SCALE_BITS;
  1124.             *d1++ = (unsigned int)a >> (16 + 2 * COEF_SCALE_BITS);
  1126.             src_x  += src_x_inc; /* 2! */
  1128.         } while (src_x < src_x_max);
  1130.         /* last pixels: */
  1131.         {
  1132.             int a = s1 [src_width - 1];
  1133.             int c = s2 [src_width - 1];
  1134.             a = (unsigned int)((a << COEF_SCALE_BITS) + q * (c - a)) >> COEF_SCALE_BITS;
  1136.             for (; src_x < src_x_end; src_x += src_x_inc)
  1137.                 *d1++ = a;
  1138.         }
  1140.         d1 = (dest += dest_pitch);
  1141.     }
  1143.     /* last rows: */
  1144.     for (; src_y < src_y_end; src_y += src_y_inc) {
  1146.         s1 = src + (src_height-1) * src_pitch;
  1148.         for (src_x = 0; src_x < src_x_max; src_x += src_x_inc) {
  1150.             int src_x_i = src_x >> TOTAL_SCALE_BITS;
  1151.             int p       = (src_x >> (TOTAL_SCALE_BITS - COEF_SCALE_BITS)) & ((1U << COEF_SCALE_BITS) - 1);
  1153.             /* get four pixels: */
  1154.             int a = s1 [src_x_i];
  1155.             int b = s1 [src_x_i + 1];
  1157.             /* compute the interpolated pixel value: */
  1158.             a = (a << COEF_SCALE_BITS) + p * (b - a);
  1160.             *d1++ = (unsigned int)a >> COEF_SCALE_BITS;
  1161.         }
  1163.         /* last delta_x pixels: */
  1164.         for (; src_x < src_x_end; src_x += src_x_inc)
  1165.             *d1++ = s1 [src_width - 1];
  1167.         d1 = (dest += dest_pitch);
  1168.     }
  1169. }