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

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

Symbian

开发平台：

Visual C++

edge.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: edge.cpp,v 1.2.32.1 2004/07/09 02:00:18 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. #include "hxtypes.h"
  51. #include "hxcom.h"
  52. #include "edge.h"
  54. #include "hlxclib/math.h"
  56. // Lookup tables to perform luma image enhancement
  57. int soft_core_2d[LUT_LENGTH];
  58. int clip_softcore_post[CLIP_TABLE_LENGTH];
  59. int soft_core_2d88[LUT_LENGTH];
  61. #define lut_soft_core_2d (soft_core_2d+OFFSET_SOFTCORE)
  62. #define lut_soft_core_2d88 (soft_core_2d88+OFFSET_SOFTCORE)
  63. #define lut_clip_softcore_post (clip_softcore_post+OFFSET_CLIP_SOFTCORE)
  65. float g_fCurrentSharpness = 0.0;
  66. INT16 g_nCurrentExpand = 0 ;
  68. void HXEXPORT
  69. ENTRYPOINT(SetSharpnessAdjustments)(float Sharpness, INT16 nExpand)
  70. {
  72.     //Initialize edge enhancemnt lookup table
  73.     //adjust the Sharpness parameter input range [-1,1] to output range [0,MAX_B]
  74.     g_fCurrentSharpness = Sharpness;
  75.     g_nCurrentExpand = nExpand;
  77.     Sharpness += 1.0;
  78.     
  79.     if(nExpand)
  80.     {
  81. Sharpness *= (ZOOM_BOOST*MAX_B/2.0);
  82.     }
  83.     else
  84.     {
  85. Sharpness *= (MAX_B/2.0);
  86.     }
  88.     Inittriangleluts(DEFT_C,DEFT_A,Sharpness);
  89.    
  91. }
  93. void HXEXPORT
  94. ENTRYPOINT(GetSharpnessAdjustments)(float* pSharpness, INT16* pnExpand)
  95. {
  96.     *pSharpness = g_fCurrentSharpness;
  97.     *pnExpand = g_nCurrentExpand;
  98. }
  100. void HXEXPORT
  101. ENTRYPOINT(Enhance)(UCHAR *yuv420in, INT32 inheight, INT32  inwidth, INT32 pitchSrc, float Sharpness)
  102. {
  103.     int     row, curBuf, prevBuf;
  104.     unsigned char  *pLuma;
  105.     static int  helper[2][2][HELPER_MAXLEN];    
  108.     static int first_fl=1;
  109.     float tolerance=(float)0.1;
  110.     int tmp1;
  112.     if ((inwidth > HELPER_MAXLEN) || (inheight <16))
  113. {
  114. return ;
  115. }
  117.     //if Sharpness is -1.0 (or close) do not do any edge enhancement
  118.     if(((Sharpness+1.0)<tolerance) && ((Sharpness+1.0)>-tolerance))
  119.     {
  120. return ;
  121.     }
  123.     if(first_fl==1)
  124.     {
  125. //Initialize constant edge enhancemnt lookup table to defaults for the first time
  126. /*Inittriangleluts(DEFT_C,DEFT_A,DEFT_B);*/
  127. Inittrianglelutsconst();
  128. //initialize clipping table
  129. Initcliplut();
  130. first_fl=0;
  131. }
  133.     curBuf = 0;         // Point to "current" line buffer
  134.     pLuma = yuv420in;    // Point to beginning of current line
  136.     DiffNonLin2Dconst( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  137.     DiffNonLin2Dconst( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  140.     for (row = 1; row < inheight-9; row=row+8) {
  142. //(1)
  143. prevBuf = curBuf;   // Point to previous line buffer
  144. curBuf ^= 1;        // Add 1 modulo 2
  145. pLuma +=pitchSrc;   // Advance pointer to next row
  146. DiffNonLin2D( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  147.         DiffNonLin2D( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  148. Add2DHelper( (int *)helper[curBuf], (int *)helper[prevBuf], &pLuma[1], inwidth-2 );
  150. //(2)
  151. prevBuf = curBuf;   
  152.         curBuf ^= 1;       
  153. pLuma +=pitchSrc;  
  154. DiffNonLin2D( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  155. DiffNonLin2D( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  156. Add2DHelper( (int *)helper[curBuf], (int *)helper[prevBuf], &pLuma[1], inwidth-2 );
  158. //(3)
  159. prevBuf = curBuf;   
  160.         curBuf ^= 1;        
  161. pLuma +=pitchSrc;  
  162. DiffNonLin2D( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  163. DiffNonLin2D( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  164. Add2DHelper( (int *)helper[curBuf], (int *)helper[prevBuf], &pLuma[1], inwidth-2 );
  166. //(4)
  167. prevBuf = curBuf;   
  168.         curBuf ^= 1;        
  169. pLuma +=pitchSrc;   
  170. DiffNonLin2D( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  171. DiffNonLin2D( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  172. Add2DHelper( (int *)helper[curBuf], (int *)helper[prevBuf], &pLuma[1], inwidth-2 );
  174. //(5)
  175. prevBuf = curBuf;   
  176.         curBuf ^= 1;        
  177. pLuma +=pitchSrc;   
  178. DiffNonLin2D( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  179. DiffNonLin2D( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  180. Add2DHelper( (int *)helper[curBuf], (int *)helper[prevBuf], &pLuma[1], inwidth-2 );
  182. //(6)
  183. prevBuf = curBuf;   
  184.         curBuf ^= 1;        
  185. pLuma +=pitchSrc; 
  186. DiffNonLin2D( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  187. DiffNonLin2D( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  188. Add2DHelper( (int *)helper[curBuf], (int *)helper[prevBuf], &pLuma[1], inwidth-2 );
  190. //2edge pixels------------------
  192. //(7)
  193.         prevBuf = curBuf;   
  194.         curBuf ^= 1;        
  195. pLuma +=pitchSrc;
  196. DiffNonLin2Dconst( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  197. DiffNonLin2Dconst( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  198.         Add2DHelper( (int *)helper[curBuf], (int *)helper[prevBuf], &pLuma[1], inwidth-2 );
  200. //(8)
  201.         prevBuf = curBuf;   
  202.         curBuf ^= 1;        
  203. pLuma +=pitchSrc;
  204. DiffNonLin2Dconst( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  205. DiffNonLin2Dconst( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  206.         Add2DHelper( (int *)helper[curBuf], (int *)helper[prevBuf], &pLuma[1], inwidth-2 );
  208.     }
  210.     tmp1=(inheight-((inheight>>3)<<3))-1;
  211.     switch(tmp1)
  212.     {
  213.     case 6:
  214.  //(1)
  215. prevBuf = curBuf;   
  216. curBuf ^= 1;        
  217. pLuma +=pitchSrc;
  218. DiffNonLin2D( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  219. DiffNonLin2D( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  220. Add2DHelper( (int *)helper[curBuf], (int *)helper[prevBuf], &pLuma[1], inwidth-2 );
  222.     case 5:
  223. //(2)
  224. prevBuf = curBuf;  
  225. curBuf ^= 1;        
  226. pLuma +=pitchSrc; 
  227. DiffNonLin2D( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  228. DiffNonLin2D( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  229. Add2DHelper( (int *)helper[curBuf], (int *)helper[prevBuf], &pLuma[1], inwidth-2 );
  231.     case 4:
  232. //(3)
  233. prevBuf = curBuf;  
  234. curBuf ^= 1;        
  235. pLuma +=pitchSrc; 
  236. DiffNonLin2D( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  237. DiffNonLin2D( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  238. Add2DHelper( (int *)helper[curBuf], (int *)helper[prevBuf], &pLuma[1], inwidth-2 );
  240.     case 3:
  241. //(4)
  242. prevBuf = curBuf;   
  243. curBuf ^= 1;        
  244. pLuma +=pitchSrc; 
  245. DiffNonLin2D( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  246. DiffNonLin2D( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  247. Add2DHelper( (int *)helper[curBuf], (int *)helper[prevBuf], &pLuma[1], inwidth-2 );
  248.     
  249.     case 2:
  250. //(5)
  251. prevBuf = curBuf;   
  252. curBuf ^= 1;        
  253. pLuma +=pitchSrc; 
  254. DiffNonLin2D( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  255. DiffNonLin2D( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  256. Add2DHelper( (int *)helper[curBuf], (int *)helper[prevBuf], &pLuma[1], inwidth-2 );
  258.     case 1:
  259. //(6)
  260. prevBuf = curBuf;   
  261. curBuf ^= 1;        
  262. pLuma +=pitchSrc; 
  263. DiffNonLin2D( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  264. DiffNonLin2D( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  265. Add2DHelper( (int *)helper[curBuf], (int *)helper[prevBuf], &pLuma[1], inwidth-2 );
  267.     case 0:
  268. break;
  269.     }
  271.     return ;
  272. }
  274. void HXEXPORT
  275. ENTRYPOINT(EnhanceUniform)(UCHAR *yuv420in, INT32 inheight, INT32  inwidth, INT32 pitchSrc, float Sharpness)
  276. {
  277.     int     row, curBuf, prevBuf;
  278.     unsigned char  *pLuma;
  279.     static int  helper[2][2][HELPER_MAXLEN];    
  281.     static int first_fl=1;
  282.     float tolerance=(float)0.1;
  283.     int tmp1;
  285.     
  286.     if ((inwidth > HELPER_MAXLEN) || (inheight <16))
  287.     {
  288. return ;
  289.     }
  291.     //if Sharpness is -1.0 (or close) don not do any edge enhancement
  292.     if(((Sharpness+1.0)<tolerance) && ((Sharpness+1.0)>-tolerance))
  293.     {
  294. return ;
  295.     }
  297.     if(first_fl==1)
  298.     {
  299. //Initialize edge enhancemnt lookup table to defaults for the first time
  300. Inittriangleluts(DEFT_C,DEFT_A,DEFT_B);
  301. //initialize clipping table
  302. Initcliplut();
  303. first_fl=0;
  304.     }
  306.     curBuf = 0;         // Point to "current" line buffer
  307.     pLuma = yuv420in;    // Point to beginning of current line
  309.     DiffNonLin2Duniform( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  310.     DiffNonLin2Duniform( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  313.     for (row = 1; row < inheight-9; row=row+8) {
  315. //(1)
  316. prevBuf = curBuf;   // Point to previous line buffer
  317.         curBuf ^= 1;        // Add 1 modulo 2
  318. pLuma +=pitchSrc;   // Advance pointer to next row
  319.         DiffNonLin2Duniform( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  320.         DiffNonLin2Duniform( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  321. Add2DHelper( (int *)helper[curBuf], (int *)helper[prevBuf], &pLuma[1], inwidth-2 );
  324. //(2)
  325. prevBuf = curBuf;   
  326. curBuf ^= 1;        
  327. pLuma +=pitchSrc; 
  328. DiffNonLin2Duniform( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  329. DiffNonLin2Duniform( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  330. Add2DHelper( (int *)helper[curBuf], (int *)helper[prevBuf], &pLuma[1], inwidth-2 );
  332. //(3)
  333. prevBuf = curBuf;   
  334.         curBuf ^= 1;        
  335. pLuma +=pitchSrc; 
  336. DiffNonLin2Duniform( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  337. DiffNonLin2Duniform( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  338. Add2DHelper( (int *)helper[curBuf], (int *)helper[prevBuf], &pLuma[1], inwidth-2 );
  341. //(4)
  342. prevBuf = curBuf;   
  343.         curBuf ^= 1;       
  344. pLuma +=pitchSrc; 
  345. DiffNonLin2Duniform( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  346. DiffNonLin2Duniform( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  347. Add2DHelper( (int *)helper[curBuf], (int *)helper[prevBuf], &pLuma[1], inwidth-2 );
  349. //(5)
  350. prevBuf = curBuf;   
  351.         curBuf ^= 1;        
  352. pLuma +=pitchSrc; 
  353. DiffNonLin2Duniform( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  354. DiffNonLin2Duniform( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  355. Add2DHelper( (int *)helper[curBuf], (int *)helper[prevBuf], &pLuma[1], inwidth-2 );
  357. //(6)
  358. prevBuf = curBuf;   
  359.         curBuf ^= 1;        
  360. pLuma +=pitchSrc; 
  361. DiffNonLin2Duniform( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  362. DiffNonLin2Duniform( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  363. Add2DHelper( (int *)helper[curBuf], (int *)helper[prevBuf], &pLuma[1], inwidth-2 );
  366. //2edge pixels------------------
  368. //(7)
  369.         prevBuf = curBuf;  
  370.         curBuf ^= 1;        
  371. pLuma +=pitchSrc;
  372. DiffNonLin2Duniform( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  373. DiffNonLin2Duniform( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  374.         Add2DHelper( (int *)helper[curBuf], (int *)helper[prevBuf], &pLuma[1], inwidth-2 );
  376. //(8)
  377.         prevBuf = curBuf;   
  378.         curBuf ^= 1;        
  379. pLuma +=pitchSrc;
  380. DiffNonLin2Duniform( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  381. DiffNonLin2Duniform( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  382.         Add2DHelper( (int *)helper[curBuf], (int *)helper[prevBuf], &pLuma[1], inwidth-2 );
  384. }
  386.     tmp1=(inheight-((inheight>>3)<<3))-1;
  387.     switch(tmp1)
  388.     {
  389.     case 6:
  390. //(1)
  391.         prevBuf = curBuf;   
  392.         curBuf ^= 1;        
  393. pLuma +=pitchSrc;
  394. DiffNonLin2Duniform( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  395.         DiffNonLin2Duniform( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  396. Add2DHelper( (int *)helper[curBuf], (int *)helper[prevBuf], &pLuma[1], inwidth-2 );
  398.     case 5:
  399. //(2)
  400. prevBuf = curBuf;   
  401.         curBuf ^= 1;        
  402. pLuma +=pitchSrc; 
  403. DiffNonLin2Duniform( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  404. DiffNonLin2Duniform( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  405. Add2DHelper( (int *)helper[curBuf], (int *)helper[prevBuf], &pLuma[1], inwidth-2 );
  407.     case 4:
  408. //(3)
  409. prevBuf = curBuf;   
  410.         curBuf ^= 1;        
  411. pLuma +=pitchSrc; 
  412. DiffNonLin2Duniform( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  413. DiffNonLin2Duniform( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  414. Add2DHelper( (int *)helper[curBuf], (int *)helper[prevBuf], &pLuma[1], inwidth-2 );
  416.     case 3:
  417. //(4)
  418. prevBuf = curBuf;   
  419.         curBuf ^= 1;        
  420. pLuma +=pitchSrc; 
  421. DiffNonLin2Duniform( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  422. DiffNonLin2Duniform( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  423. Add2DHelper( (int *)helper[curBuf], (int *)helper[prevBuf], &pLuma[1], inwidth-2 );
  425.     case 2:
  426. //(5)
  427. prevBuf = curBuf;   
  428.         curBuf ^= 1;       
  429. pLuma +=pitchSrc;
  430. DiffNonLin2Duniform( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  431. DiffNonLin2Duniform( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  432. Add2DHelper( (int *)helper[curBuf], (int *)helper[prevBuf], &pLuma[1], inwidth-2 );
  434.     case 1:
  435. //(6)
  436. prevBuf = curBuf;   
  437.         curBuf ^= 1;        
  438. pLuma +=pitchSrc; 
  439. DiffNonLin2Duniform( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  440. DiffNonLin2Duniform( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  441. Add2DHelper( (int *)helper[curBuf], (int *)helper[prevBuf], &pLuma[1], inwidth-2 );
  443.     case 0:
  444. break;
  445.     }
  447.     return ;
  448. }
  450. int Add2DHelper( int *cur, int *prev, unsigned char *pic, int n )
  451. {
  452.     int i;
  453.     int tmp=n>>1;
  454.     int tmp1=n-((n>>1)<<1);
  456.     if(n<2) 
  457.     {
  458. return 1;
  459.     }
  461.     for (i = 0; i < n-1; i=i+2)
  462.     {
  463. pic[i] = clip_softcore_post[OFFSET_CLIP_SOFTCORE + pic[i]
  464.                         + prev[i+1] 
  465. + prev[i + HELPER_MAXLEN] 
  466.                         - cur[i] 
  467. - cur[i+1 + HELPER_MAXLEN] ]; 
  468. pic[i+1] = clip_softcore_post[OFFSET_CLIP_SOFTCORE + pic[i+1]
  469.                         + prev[i+2] 
  470. + prev[i+1+ HELPER_MAXLEN] 
  471.                         - cur[i+1] 
  472. - cur[i+2 + HELPER_MAXLEN] ]; 
  473.     }
  475.     if(tmp1)
  476.     {
  477. pic[n-1] = clip_softcore_post[OFFSET_CLIP_SOFTCORE + pic[n-1]
  478.                       + prev[n] 
  479.       + prev[n-1+ HELPER_MAXLEN]
  480.       - cur[n-1] 
  481.       - cur[n + HELPER_MAXLEN] ];
  482.     }
  484.     return 1;
  485. }
  489. int DiffNonLin2D( unsigned char* pos, unsigned char* neg, int* out, int n )
  490. {
  491.     int i;
  492.     int tmpv;
  493.    
  494.     if(n<16)
  495.     {
  496. return 1;
  497.     }
  499.     out[0]=lut_soft_core_2d[pos[0] - neg[0]];
  500.     
  501.     for (i = 1; i < n-9; i=i+8)
  502.     {
  503. register int tmp0, tmp1;
  505. tmp0 = pos[i] - neg[i];
  506. tmp1 = pos[i+1] - neg[i+1];
  507. out[i]=lut_soft_core_2d[tmp0];
  508. out[i+1]=lut_soft_core_2d[tmp1];
  510. tmp0 = pos[i+2] - neg[i+2];
  511. tmp1 = pos[i+3] - neg[i+3];
  512. out[i+2]=lut_soft_core_2d[tmp0];
  513. out[i+3]=lut_soft_core_2d[tmp1];
  516. tmp0 = pos[i+4] - neg[i+4];
  517. tmp1 = pos[i+5] - neg[i+5];
  518. out[i+4]=lut_soft_core_2d[tmp0];
  519. out[i+5]=lut_soft_core_2d[tmp1];
  521. tmp0 = pos[i+6] - neg[i+6];
  522. tmp1 = pos[i+7] - neg[i+7];
  523. out[i+6]=lut_soft_core_2d88[tmp0];
  524. out[i+7]=lut_soft_core_2d88[tmp1];
  525.     }
  528.     tmpv=(n-((n>>3)<<3))-1;
  530.     switch(tmpv)
  531.     {
  532.     case 6:
  533. out[n-6]=lut_soft_core_2d[pos[n-6]-neg[n-6]];
  534.     case 5:
  535. out[n-5]=lut_soft_core_2d[pos[n-5]-neg[n-5]];
  536.     case 4:
  537. out[n-4]=lut_soft_core_2d[pos[n-4]-neg[n-4]];
  538.     case 3:
  539. out[n-3]=lut_soft_core_2d[pos[n-3]-neg[n-3]];
  540.     case 2:
  541. out[n-2]=lut_soft_core_2d[pos[n-2]-neg[n-2]];
  542.     case 1:
  543. out[n-1]=lut_soft_core_2d[pos[n-1]-neg[n-1]];
  544.     case 0:
  545. break;
  546.     }
  549.     return 1;
  550. }
  552. int DiffNonLin2Duniform( unsigned char* pos, unsigned char* neg, int* out, int n )
  553. {
  554.     int i;
  555.     int tmpv;
  557.     if(n<16)
  558.     {
  559. return 1;
  560.     }
  562.     out[0]=lut_soft_core_2d[pos[0] - neg[0]];
  564.     for (i = 1; i < n-9; i=i+8)
  565. {
  566.     register int tmp0, tmp1;
  568.     tmp0 = pos[i] - neg[i];
  569.     tmp1 = pos[i+1] - neg[i+1];
  570.     out[i]=lut_soft_core_2d[tmp0];
  571.     out[i+1]=lut_soft_core_2d[tmp1];
  573.     tmp0 = pos[i+2] - neg[i+2];
  574.     tmp1 = pos[i+3] - neg[i+3];
  575.     out[i+2]=lut_soft_core_2d[tmp0];
  576.     out[i+3]=lut_soft_core_2d[tmp1];
  579.     tmp0 = pos[i+4] - neg[i+4];
  580.     tmp1 = pos[i+5] - neg[i+5];
  581.     out[i+4]=lut_soft_core_2d[tmp0];
  582.     out[i+5]=lut_soft_core_2d[tmp1];
  584.     tmp0 = pos[i+6] - neg[i+6];
  585.     tmp1 = pos[i+7] - neg[i+7];
  586.     out[i+6]=lut_soft_core_2d[tmp0];
  587.     out[i+7]=lut_soft_core_2d[tmp1];
  588. }
  590.     tmpv=(n-((n>>3)<<3))-1;
  592.     switch(tmpv)
  593.     {
  594.     case 6:
  595. out[n-6]=lut_soft_core_2d[pos[n-6]-neg[n-6]];
  596.     case 5:
  597. out[n-5]=lut_soft_core_2d[pos[n-5]-neg[n-5]];
  598.     case 4:
  599. out[n-4]=lut_soft_core_2d[pos[n-4]-neg[n-4]];
  600.     case 3:
  601. out[n-3]=lut_soft_core_2d[pos[n-3]-neg[n-3]];
  602.     case 2:
  603. out[n-2]=lut_soft_core_2d[pos[n-2]-neg[n-2]];
  604.     case 1:
  605. out[n-1]=lut_soft_core_2d[pos[n-1]-neg[n-1]];
  606.     case 0:
  607. break;
  608.     }
  609.     
  610.     return 1;
  611. }
  613. int DiffNonLin2Dconst( unsigned char* pos, unsigned char* neg, int* out, int n )
  614. {
  615.     int i;
  616.     int tmpv;
  618.     if(n<16)
  619.     {
  620. return 1;
  621.     }
  623.     out[0]=lut_soft_core_2d88[pos[0] - neg[0]];
  626.     for (i = 1; i < n-9; i=i+8)
  627. {
  628.     register int tmp0, tmp1;
  630.     tmp0 = pos[i] - neg[i];
  631.     tmp1 = pos[i+1] - neg[i+1];
  632.     out[i]=lut_soft_core_2d88[tmp0];
  633.     out[i+1]=lut_soft_core_2d88[tmp1];
  635.     tmp0 = pos[i+2] - neg[i+2];
  636.     tmp1 = pos[i+3] - neg[i+3];
  637.     out[i+2]=lut_soft_core_2d88[tmp0];
  638.     out[i+3]=lut_soft_core_2d88[tmp1];
  641.     tmp0 = pos[i+4] - neg[i+4];
  642.     tmp1 = pos[i+5] - neg[i+5];
  643.     out[i+4]=lut_soft_core_2d88[tmp0];
  644.     out[i+5]=lut_soft_core_2d88[tmp1];
  646.     tmp0 = pos[i+6] - neg[i+6];
  647.     tmp1 = pos[i+7] - neg[i+7];
  648.     out[i+6]=lut_soft_core_2d88[tmp0];
  649.     out[i+7]=lut_soft_core_2d88[tmp1];
  650. }
  653.     tmpv=(n-((n>>3)<<3))-1;
  655.     switch(tmpv)
  656.     {
  657.     case 6:
  658. out[n-6]=lut_soft_core_2d88[pos[n-6]-neg[n-6]];
  659.     case 5:
  660. out[n-5]=lut_soft_core_2d88[pos[n-5]-neg[n-5]];
  661.     case 4:
  662. out[n-4]=lut_soft_core_2d88[pos[n-4]-neg[n-4]];
  663.     case 3:
  664. out[n-3]=lut_soft_core_2d88[pos[n-3]-neg[n-3]];
  665.     case 2:
  666. out[n-2]=lut_soft_core_2d88[pos[n-2]-neg[n-2]];
  667.     case 1:
  668. out[n-1]=lut_soft_core_2d88[pos[n-1]-neg[n-1]];
  669.     case 0:
  670. break;
  671.     }
  672.          
  674.     return 1;
  675. }
  679. int Inittriangleluts(float c, float a, float b)
  680. {
  681. int i;
  683. //nonlinearity triangle lut
  684.         for (i=1; i<256; i++)
  685.     soft_core_2d[i+255] = (int)soft_triangle_lut_2d((float)i,c,a,b);
  687. soft_core_2d[255+(int)(c/2)] =int(-a);
  688. soft_core_2d[511-int((255-c)/2)]=int(b);
  691.         for (i=0; i<255; i++)
  692.             soft_core_2d[i] = -soft_core_2d[510-i];
  694. soft_core_2d[255]=0;
  695. soft_core_2d[0]=0;
  696. soft_core_2d[510]=0;
  698. return 1;
  700. }
  702. int Inittrianglelutsconst(void)
  703. {
  705. int i;
  707. //initialize a second lut which has c=50,a=0,b=40 this will be used for 8x8 block boundaries always
  708.         for (i=1; i<256; i++)
  709.     soft_core_2d88[i+255] = (int)soft_triangle_lut_2d((float)i,(float)CONST_C,(float)CONST_A,(float)CONST_B);
  711. soft_core_2d88[255+(int)(CONST_C/2)] =-CONST_A;
  712. soft_core_2d88[511-int((255-CONST_C)/2)]=40;
  715.         for (i=0; i<255; i++)
  716.             soft_core_2d88[i] = -soft_core_2d88[510-i];
  718. soft_core_2d88[255]=0;
  719. soft_core_2d88[0]=0;
  720. soft_core_2d88[510]=0;
  722. return 1;
  724. }
  726. int soft_triangle_lut_2d(float input, float c, float a, float b)
  727. {
  728.     float y;
  729.     /*assumes the ranges of input,a,b,c are already clipped*/
  731.     if(input>=0 && input<(c/2))
  732. y=-(input*a)/(c/2);
  733.     else if(input>=c/2 && input<c)
  734. y=-((c-input)*a)/(c/2);
  735.     else if(input>=c && input<((255+c)/2))
  736. y=((input-c)*b)/((255-c)/2);
  737.     else if(input>=((255+c)/2) && input <=255)
  738. y=((255-input)*b)/((255-c)/2);
  741.     return((int)y);
  743. }
  747. void Initcliplut(void)
  748. {
  750. int i;
  751. //clipping lut
  752. //assumes a and b can have a max value 60
  754.     for (i=0; i<319; i++)
  755. clip_softcore_post[i] = 0;
  757. clip_softcore_post[319] = 0;
  758.     for (i=1; i<256; i++)
  759. clip_softcore_post[i+319] = i;     
  760.    
  761.     for (i=256; i<511; i++)
  762. clip_softcore_post[i+319] = 255;     
  764. }