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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
resize.cpp
资源名称：helix.src.0812.rar　[点击查看]
上传用户：zhongxx05
上传日期：2007-06-06
资源大小：33641k
文件大小：40k
源码类别：

Symbian

开发平台：

C/C++

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