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

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

Symbian

开发平台：

C/C++

edge.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. #include "hxtypes.h"
  37. #include "hxcom.h"
  38. #include "edge.h"
  40. #include "hlxclib/math.h"
  42. // Lookup tables to perform luma image enhancement
  43. int soft_core_2d[LUT_LENGTH];
  44. int clip_softcore_post[CLIP_TABLE_LENGTH];
  45. int soft_core_2d88[LUT_LENGTH];
  47. #define lut_soft_core_2d (soft_core_2d+OFFSET_SOFTCORE)
  48. #define lut_soft_core_2d88 (soft_core_2d88+OFFSET_SOFTCORE)
  49. #define lut_clip_softcore_post (clip_softcore_post+OFFSET_CLIP_SOFTCORE)
  51. float g_fCurrentSharpness = 0.0;
  52. INT16 g_nCurrentExpand = 0 ;
  54. void HXEXPORT
  55. ENTRYPOINT(SetSharpnessAdjustments)(float Sharpness, INT16 nExpand)
  56. {
  58.     //Initialize edge enhancemnt lookup table
  59.     //adjust the Sharpness parameter input range [-1,1] to output range [0,MAX_B]
  60.     g_fCurrentSharpness = Sharpness;
  61.     g_nCurrentExpand = nExpand;
  63.     Sharpness += 1.0;
  64.     
  65.     if(nExpand)
  66.     {
  67. Sharpness *= (ZOOM_BOOST*MAX_B/2.0);
  68.     }
  69.     else
  70.     {
  71. Sharpness *= (MAX_B/2.0);
  72.     }
  74.     Inittriangleluts(DEFT_C,DEFT_A,Sharpness);
  75.    
  77. }
  79. void HXEXPORT
  80. ENTRYPOINT(GetSharpnessAdjustments)(float* pSharpness, INT16* pnExpand)
  81. {
  82.     *pSharpness = g_fCurrentSharpness;
  83.     *pnExpand = g_nCurrentExpand;
  84. }
  86. void HXEXPORT
  87. ENTRYPOINT(Enhance)(UCHAR *yuv420in, INT32 inheight, INT32  inwidth, INT32 pitchSrc, float Sharpness)
  88. {
  89.     int     row, curBuf, prevBuf;
  90.     unsigned char  *pLuma;
  91.     static int  helper[2][2][HELPER_MAXLEN];    
  94.     static int first_fl=1;
  95.     float tolerance=(float)0.1;
  96.     int tmp1;
  98.     if ((inwidth > HELPER_MAXLEN) || (inheight <16))
  99. {
  100. return ;
  101. }
  103.     //if Sharpness is -1.0 (or close) do not do any edge enhancement
  104.     if(((Sharpness+1.0)<tolerance) && ((Sharpness+1.0)>-tolerance))
  105.     {
  106. return ;
  107.     }
  109.     if(first_fl==1)
  110.     {
  111. //Initialize constant edge enhancemnt lookup table to defaults for the first time
  112. /*Inittriangleluts(DEFT_C,DEFT_A,DEFT_B);*/
  113. Inittrianglelutsconst();
  114. //initialize clipping table
  115. Initcliplut();
  116. first_fl=0;
  117. }
  119.     curBuf = 0;         // Point to "current" line buffer
  120.     pLuma = yuv420in;    // Point to beginning of current line
  122.     DiffNonLin2Dconst( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  123.     DiffNonLin2Dconst( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  126.     for (row = 1; row < inheight-9; row=row+8) {
  128. //(1)
  129. prevBuf = curBuf;   // Point to previous line buffer
  130. curBuf ^= 1;        // Add 1 modulo 2
  131. pLuma +=pitchSrc;   // Advance pointer to next row
  132. DiffNonLin2D( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  133.         DiffNonLin2D( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  134. Add2DHelper( (int *)helper[curBuf], (int *)helper[prevBuf], &pLuma[1], inwidth-2 );
  136. //(2)
  137. prevBuf = curBuf;   
  138.         curBuf ^= 1;       
  139. pLuma +=pitchSrc;  
  140. DiffNonLin2D( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  141. DiffNonLin2D( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  142. Add2DHelper( (int *)helper[curBuf], (int *)helper[prevBuf], &pLuma[1], inwidth-2 );
  144. //(3)
  145. prevBuf = curBuf;   
  146.         curBuf ^= 1;        
  147. pLuma +=pitchSrc;  
  148. DiffNonLin2D( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  149. DiffNonLin2D( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  150. Add2DHelper( (int *)helper[curBuf], (int *)helper[prevBuf], &pLuma[1], inwidth-2 );
  152. //(4)
  153. prevBuf = curBuf;   
  154.         curBuf ^= 1;        
  155. pLuma +=pitchSrc;   
  156. DiffNonLin2D( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  157. DiffNonLin2D( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  158. Add2DHelper( (int *)helper[curBuf], (int *)helper[prevBuf], &pLuma[1], inwidth-2 );
  160. //(5)
  161. prevBuf = curBuf;   
  162.         curBuf ^= 1;        
  163. pLuma +=pitchSrc;   
  164. DiffNonLin2D( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  165. DiffNonLin2D( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  166. Add2DHelper( (int *)helper[curBuf], (int *)helper[prevBuf], &pLuma[1], inwidth-2 );
  168. //(6)
  169. prevBuf = curBuf;   
  170.         curBuf ^= 1;        
  171. pLuma +=pitchSrc; 
  172. DiffNonLin2D( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  173. DiffNonLin2D( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  174. Add2DHelper( (int *)helper[curBuf], (int *)helper[prevBuf], &pLuma[1], inwidth-2 );
  176. //2edge pixels------------------
  178. //(7)
  179.         prevBuf = curBuf;   
  180.         curBuf ^= 1;        
  181. pLuma +=pitchSrc;
  182. DiffNonLin2Dconst( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  183. DiffNonLin2Dconst( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  184.         Add2DHelper( (int *)helper[curBuf], (int *)helper[prevBuf], &pLuma[1], inwidth-2 );
  186. //(8)
  187.         prevBuf = curBuf;   
  188.         curBuf ^= 1;        
  189. pLuma +=pitchSrc;
  190. DiffNonLin2Dconst( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  191. DiffNonLin2Dconst( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  192.         Add2DHelper( (int *)helper[curBuf], (int *)helper[prevBuf], &pLuma[1], inwidth-2 );
  194.     }
  196.     tmp1=(inheight-((inheight>>3)<<3))-1;
  197.     switch(tmp1)
  198.     {
  199.     case 6:
  200.  //(1)
  201. prevBuf = curBuf;   
  202. curBuf ^= 1;        
  203. pLuma +=pitchSrc;
  204. DiffNonLin2D( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  205. DiffNonLin2D( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  206. Add2DHelper( (int *)helper[curBuf], (int *)helper[prevBuf], &pLuma[1], inwidth-2 );
  208.     case 5:
  209. //(2)
  210. prevBuf = curBuf;  
  211. curBuf ^= 1;        
  212. pLuma +=pitchSrc; 
  213. DiffNonLin2D( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  214. DiffNonLin2D( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  215. Add2DHelper( (int *)helper[curBuf], (int *)helper[prevBuf], &pLuma[1], inwidth-2 );
  217.     case 4:
  218. //(3)
  219. prevBuf = curBuf;  
  220. curBuf ^= 1;        
  221. pLuma +=pitchSrc; 
  222. DiffNonLin2D( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  223. DiffNonLin2D( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  224. Add2DHelper( (int *)helper[curBuf], (int *)helper[prevBuf], &pLuma[1], inwidth-2 );
  226.     case 3:
  227. //(4)
  228. prevBuf = curBuf;   
  229. curBuf ^= 1;        
  230. pLuma +=pitchSrc; 
  231. DiffNonLin2D( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  232. DiffNonLin2D( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  233. Add2DHelper( (int *)helper[curBuf], (int *)helper[prevBuf], &pLuma[1], inwidth-2 );
  234.     
  235.     case 2:
  236. //(5)
  237. prevBuf = curBuf;   
  238. curBuf ^= 1;        
  239. pLuma +=pitchSrc; 
  240. DiffNonLin2D( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  241. DiffNonLin2D( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  242. Add2DHelper( (int *)helper[curBuf], (int *)helper[prevBuf], &pLuma[1], inwidth-2 );
  244.     case 1:
  245. //(6)
  246. prevBuf = curBuf;   
  247. curBuf ^= 1;        
  248. pLuma +=pitchSrc; 
  249. DiffNonLin2D( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  250. DiffNonLin2D( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  251. Add2DHelper( (int *)helper[curBuf], (int *)helper[prevBuf], &pLuma[1], inwidth-2 );
  253.     case 0:
  254. break;
  255.     }
  257.     return ;
  258. }
  260. void HXEXPORT
  261. ENTRYPOINT(EnhanceUniform)(UCHAR *yuv420in, INT32 inheight, INT32  inwidth, INT32 pitchSrc, float Sharpness)
  262. {
  263.     int     row, curBuf, prevBuf;
  264.     unsigned char  *pLuma;
  265.     static int  helper[2][2][HELPER_MAXLEN];    
  267.     static int first_fl=1;
  268.     float tolerance=(float)0.1;
  269.     int tmp1;
  271.     
  272.     if ((inwidth > HELPER_MAXLEN) || (inheight <16))
  273.     {
  274. return ;
  275.     }
  277.     //if Sharpness is -1.0 (or close) don not do any edge enhancement
  278.     if(((Sharpness+1.0)<tolerance) && ((Sharpness+1.0)>-tolerance))
  279.     {
  280. return ;
  281.     }
  283.     if(first_fl==1)
  284.     {
  285. //Initialize edge enhancemnt lookup table to defaults for the first time
  286. Inittriangleluts(DEFT_C,DEFT_A,DEFT_B);
  287. //initialize clipping table
  288. Initcliplut();
  289. first_fl=0;
  290.     }
  292.     curBuf = 0;         // Point to "current" line buffer
  293.     pLuma = yuv420in;    // Point to beginning of current line
  295.     DiffNonLin2Duniform( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  296.     DiffNonLin2Duniform( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  299.     for (row = 1; row < inheight-9; row=row+8) {
  301. //(1)
  302. prevBuf = curBuf;   // Point to previous line buffer
  303.         curBuf ^= 1;        // Add 1 modulo 2
  304. pLuma +=pitchSrc;   // Advance pointer to next row
  305.         DiffNonLin2Duniform( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  306.         DiffNonLin2Duniform( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  307. Add2DHelper( (int *)helper[curBuf], (int *)helper[prevBuf], &pLuma[1], inwidth-2 );
  310. //(2)
  311. prevBuf = curBuf;   
  312. curBuf ^= 1;        
  313. pLuma +=pitchSrc; 
  314. DiffNonLin2Duniform( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  315. DiffNonLin2Duniform( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  316. Add2DHelper( (int *)helper[curBuf], (int *)helper[prevBuf], &pLuma[1], inwidth-2 );
  318. //(3)
  319. prevBuf = curBuf;   
  320.         curBuf ^= 1;        
  321. pLuma +=pitchSrc; 
  322. DiffNonLin2Duniform( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  323. DiffNonLin2Duniform( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  324. Add2DHelper( (int *)helper[curBuf], (int *)helper[prevBuf], &pLuma[1], inwidth-2 );
  327. //(4)
  328. prevBuf = curBuf;   
  329.         curBuf ^= 1;       
  330. pLuma +=pitchSrc; 
  331. DiffNonLin2Duniform( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  332. DiffNonLin2Duniform( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  333. Add2DHelper( (int *)helper[curBuf], (int *)helper[prevBuf], &pLuma[1], inwidth-2 );
  335. //(5)
  336. prevBuf = curBuf;   
  337.         curBuf ^= 1;        
  338. pLuma +=pitchSrc; 
  339. DiffNonLin2Duniform( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  340. DiffNonLin2Duniform( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  341. Add2DHelper( (int *)helper[curBuf], (int *)helper[prevBuf], &pLuma[1], inwidth-2 );
  343. //(6)
  344. prevBuf = curBuf;   
  345.         curBuf ^= 1;        
  346. pLuma +=pitchSrc; 
  347. DiffNonLin2Duniform( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  348. DiffNonLin2Duniform( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  349. Add2DHelper( (int *)helper[curBuf], (int *)helper[prevBuf], &pLuma[1], inwidth-2 );
  352. //2edge pixels------------------
  354. //(7)
  355.         prevBuf = curBuf;  
  356.         curBuf ^= 1;        
  357. pLuma +=pitchSrc;
  358. DiffNonLin2Duniform( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  359. DiffNonLin2Duniform( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  360.         Add2DHelper( (int *)helper[curBuf], (int *)helper[prevBuf], &pLuma[1], inwidth-2 );
  362. //(8)
  363.         prevBuf = curBuf;   
  364.         curBuf ^= 1;        
  365. pLuma +=pitchSrc;
  366. DiffNonLin2Duniform( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  367. DiffNonLin2Duniform( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  368.         Add2DHelper( (int *)helper[curBuf], (int *)helper[prevBuf], &pLuma[1], inwidth-2 );
  370. }
  372.     tmp1=(inheight-((inheight>>3)<<3))-1;
  373.     switch(tmp1)
  374.     {
  375.     case 6:
  376. //(1)
  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.     case 5:
  385. //(2)
  386. prevBuf = curBuf;   
  387.         curBuf ^= 1;        
  388. pLuma +=pitchSrc; 
  389. DiffNonLin2Duniform( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  390. DiffNonLin2Duniform( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  391. Add2DHelper( (int *)helper[curBuf], (int *)helper[prevBuf], &pLuma[1], inwidth-2 );
  393.     case 4:
  394. //(3)
  395. prevBuf = curBuf;   
  396.         curBuf ^= 1;        
  397. pLuma +=pitchSrc; 
  398. DiffNonLin2Duniform( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  399. DiffNonLin2Duniform( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  400. Add2DHelper( (int *)helper[curBuf], (int *)helper[prevBuf], &pLuma[1], inwidth-2 );
  402.     case 3:
  403. //(4)
  404. prevBuf = curBuf;   
  405.         curBuf ^= 1;        
  406. pLuma +=pitchSrc; 
  407. DiffNonLin2Duniform( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  408. DiffNonLin2Duniform( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  409. Add2DHelper( (int *)helper[curBuf], (int *)helper[prevBuf], &pLuma[1], inwidth-2 );
  411.     case 2:
  412. //(5)
  413. prevBuf = curBuf;   
  414.         curBuf ^= 1;       
  415. pLuma +=pitchSrc;
  416. DiffNonLin2Duniform( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  417. DiffNonLin2Duniform( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  418. Add2DHelper( (int *)helper[curBuf], (int *)helper[prevBuf], &pLuma[1], inwidth-2 );
  420.     case 1:
  421. //(6)
  422. prevBuf = curBuf;   
  423.         curBuf ^= 1;        
  424. pLuma +=pitchSrc; 
  425. DiffNonLin2Duniform( &pLuma[pitchSrc], &pLuma[1], helper[curBuf][0], inwidth-1 );
  426. DiffNonLin2Duniform( &pLuma[pitchSrc+1], &pLuma[0], helper[curBuf][1], inwidth-1 );
  427. Add2DHelper( (int *)helper[curBuf], (int *)helper[prevBuf], &pLuma[1], inwidth-2 );
  429.     case 0:
  430. break;
  431.     }
  433.     return ;
  434. }
  436. int Add2DHelper( int *cur, int *prev, unsigned char *pic, int n )
  437. {
  438.     int i;
  439.     int tmp=n>>1;
  440.     int tmp1=n-((n>>1)<<1);
  442.     if(n<2) 
  443.     {
  444. return 1;
  445.     }
  447.     for (i = 0; i < n-1; i=i+2)
  448.     {
  449. pic[i] = clip_softcore_post[OFFSET_CLIP_SOFTCORE + pic[i]
  450.                         + prev[i+1] 
  451. + prev[i + HELPER_MAXLEN] 
  452.                         - cur[i] 
  453. - cur[i+1 + HELPER_MAXLEN] ]; 
  454. pic[i+1] = clip_softcore_post[OFFSET_CLIP_SOFTCORE + pic[i+1]
  455.                         + prev[i+2] 
  456. + prev[i+1+ HELPER_MAXLEN] 
  457.                         - cur[i+1] 
  458. - cur[i+2 + HELPER_MAXLEN] ]; 
  459.     }
  461.     if(tmp1)
  462.     {
  463. pic[n-1] = clip_softcore_post[OFFSET_CLIP_SOFTCORE + pic[n-1]
  464.                       + prev[n] 
  465.       + prev[n-1+ HELPER_MAXLEN]
  466.       - cur[n-1] 
  467.       - cur[n + HELPER_MAXLEN] ];
  468.     }
  470.     return 1;
  471. }
  475. int DiffNonLin2D( unsigned char* pos, unsigned char* neg, int* out, int n )
  476. {
  477.     int i;
  478.     int tmpv;
  479.    
  480.     if(n<16)
  481.     {
  482. return 1;
  483.     }
  485.     out[0]=lut_soft_core_2d[pos[0] - neg[0]];
  486.     
  487.     for (i = 1; i < n-9; i=i+8)
  488.     {
  489. register int tmp0, tmp1;
  491. tmp0 = pos[i] - neg[i];
  492. tmp1 = pos[i+1] - neg[i+1];
  493. out[i]=lut_soft_core_2d[tmp0];
  494. out[i+1]=lut_soft_core_2d[tmp1];
  496. tmp0 = pos[i+2] - neg[i+2];
  497. tmp1 = pos[i+3] - neg[i+3];
  498. out[i+2]=lut_soft_core_2d[tmp0];
  499. out[i+3]=lut_soft_core_2d[tmp1];
  502. tmp0 = pos[i+4] - neg[i+4];
  503. tmp1 = pos[i+5] - neg[i+5];
  504. out[i+4]=lut_soft_core_2d[tmp0];
  505. out[i+5]=lut_soft_core_2d[tmp1];
  507. tmp0 = pos[i+6] - neg[i+6];
  508. tmp1 = pos[i+7] - neg[i+7];
  509. out[i+6]=lut_soft_core_2d88[tmp0];
  510. out[i+7]=lut_soft_core_2d88[tmp1];
  511.     }
  514.     tmpv=(n-((n>>3)<<3))-1;
  516.     switch(tmpv)
  517.     {
  518.     case 6:
  519. out[n-6]=lut_soft_core_2d[pos[n-6]-neg[n-6]];
  520.     case 5:
  521. out[n-5]=lut_soft_core_2d[pos[n-5]-neg[n-5]];
  522.     case 4:
  523. out[n-4]=lut_soft_core_2d[pos[n-4]-neg[n-4]];
  524.     case 3:
  525. out[n-3]=lut_soft_core_2d[pos[n-3]-neg[n-3]];
  526.     case 2:
  527. out[n-2]=lut_soft_core_2d[pos[n-2]-neg[n-2]];
  528.     case 1:
  529. out[n-1]=lut_soft_core_2d[pos[n-1]-neg[n-1]];
  530.     case 0:
  531. break;
  532.     }
  535.     return 1;
  536. }
  538. int DiffNonLin2Duniform( unsigned char* pos, unsigned char* neg, int* out, int n )
  539. {
  540.     int i;
  541.     int tmpv;
  543.     if(n<16)
  544.     {
  545. return 1;
  546.     }
  548.     out[0]=lut_soft_core_2d[pos[0] - neg[0]];
  550.     for (i = 1; i < n-9; i=i+8)
  551. {
  552.     register int tmp0, tmp1;
  554.     tmp0 = pos[i] - neg[i];
  555.     tmp1 = pos[i+1] - neg[i+1];
  556.     out[i]=lut_soft_core_2d[tmp0];
  557.     out[i+1]=lut_soft_core_2d[tmp1];
  559.     tmp0 = pos[i+2] - neg[i+2];
  560.     tmp1 = pos[i+3] - neg[i+3];
  561.     out[i+2]=lut_soft_core_2d[tmp0];
  562.     out[i+3]=lut_soft_core_2d[tmp1];
  565.     tmp0 = pos[i+4] - neg[i+4];
  566.     tmp1 = pos[i+5] - neg[i+5];
  567.     out[i+4]=lut_soft_core_2d[tmp0];
  568.     out[i+5]=lut_soft_core_2d[tmp1];
  570.     tmp0 = pos[i+6] - neg[i+6];
  571.     tmp1 = pos[i+7] - neg[i+7];
  572.     out[i+6]=lut_soft_core_2d[tmp0];
  573.     out[i+7]=lut_soft_core_2d[tmp1];
  574. }
  576.     tmpv=(n-((n>>3)<<3))-1;
  578.     switch(tmpv)
  579.     {
  580.     case 6:
  581. out[n-6]=lut_soft_core_2d[pos[n-6]-neg[n-6]];
  582.     case 5:
  583. out[n-5]=lut_soft_core_2d[pos[n-5]-neg[n-5]];
  584.     case 4:
  585. out[n-4]=lut_soft_core_2d[pos[n-4]-neg[n-4]];
  586.     case 3:
  587. out[n-3]=lut_soft_core_2d[pos[n-3]-neg[n-3]];
  588.     case 2:
  589. out[n-2]=lut_soft_core_2d[pos[n-2]-neg[n-2]];
  590.     case 1:
  591. out[n-1]=lut_soft_core_2d[pos[n-1]-neg[n-1]];
  592.     case 0:
  593. break;
  594.     }
  595.     
  596.     return 1;
  597. }
  599. int DiffNonLin2Dconst( unsigned char* pos, unsigned char* neg, int* out, int n )
  600. {
  601.     int i;
  602.     int tmpv;
  604.     if(n<16)
  605.     {
  606. return 1;
  607.     }
  609.     out[0]=lut_soft_core_2d88[pos[0] - neg[0]];
  612.     for (i = 1; i < n-9; i=i+8)
  613. {
  614.     register int tmp0, tmp1;
  616.     tmp0 = pos[i] - neg[i];
  617.     tmp1 = pos[i+1] - neg[i+1];
  618.     out[i]=lut_soft_core_2d88[tmp0];
  619.     out[i+1]=lut_soft_core_2d88[tmp1];
  621.     tmp0 = pos[i+2] - neg[i+2];
  622.     tmp1 = pos[i+3] - neg[i+3];
  623.     out[i+2]=lut_soft_core_2d88[tmp0];
  624.     out[i+3]=lut_soft_core_2d88[tmp1];
  627.     tmp0 = pos[i+4] - neg[i+4];
  628.     tmp1 = pos[i+5] - neg[i+5];
  629.     out[i+4]=lut_soft_core_2d88[tmp0];
  630.     out[i+5]=lut_soft_core_2d88[tmp1];
  632.     tmp0 = pos[i+6] - neg[i+6];
  633.     tmp1 = pos[i+7] - neg[i+7];
  634.     out[i+6]=lut_soft_core_2d88[tmp0];
  635.     out[i+7]=lut_soft_core_2d88[tmp1];
  636. }
  639.     tmpv=(n-((n>>3)<<3))-1;
  641.     switch(tmpv)
  642.     {
  643.     case 6:
  644. out[n-6]=lut_soft_core_2d88[pos[n-6]-neg[n-6]];
  645.     case 5:
  646. out[n-5]=lut_soft_core_2d88[pos[n-5]-neg[n-5]];
  647.     case 4:
  648. out[n-4]=lut_soft_core_2d88[pos[n-4]-neg[n-4]];
  649.     case 3:
  650. out[n-3]=lut_soft_core_2d88[pos[n-3]-neg[n-3]];
  651.     case 2:
  652. out[n-2]=lut_soft_core_2d88[pos[n-2]-neg[n-2]];
  653.     case 1:
  654. out[n-1]=lut_soft_core_2d88[pos[n-1]-neg[n-1]];
  655.     case 0:
  656. break;
  657.     }
  658.          
  660.     return 1;
  661. }
  665. int Inittriangleluts(float c, float a, float b)
  666. {
  667. int i;
  669. //nonlinearity triangle lut
  670.         for (i=1; i<256; i++)
  671.     soft_core_2d[i+255] = (int)soft_triangle_lut_2d((float)i,c,a,b);
  673. soft_core_2d[255+(int)(c/2)] =int(-a);
  674. soft_core_2d[511-int((255-c)/2)]=int(b);
  677.         for (i=0; i<255; i++)
  678.             soft_core_2d[i] = -soft_core_2d[510-i];
  680. soft_core_2d[255]=0;
  681. soft_core_2d[0]=0;
  682. soft_core_2d[510]=0;
  684. return 1;
  686. }
  688. int Inittrianglelutsconst(void)
  689. {
  691. int i;
  693. //initialize a second lut which has c=50,a=0,b=40 this will be used for 8x8 block boundaries always
  694.         for (i=1; i<256; i++)
  695.     soft_core_2d88[i+255] = (int)soft_triangle_lut_2d((float)i,(float)CONST_C,(float)CONST_A,(float)CONST_B);
  697. soft_core_2d88[255+(int)(CONST_C/2)] =-CONST_A;
  698. soft_core_2d88[511-int((255-CONST_C)/2)]=40;
  701.         for (i=0; i<255; i++)
  702.             soft_core_2d88[i] = -soft_core_2d88[510-i];
  704. soft_core_2d88[255]=0;
  705. soft_core_2d88[0]=0;
  706. soft_core_2d88[510]=0;
  708. return 1;
  710. }
  712. int soft_triangle_lut_2d(float input, float c, float a, float b)
  713. {
  714.     float y;
  715.     /*assumes the ranges of input,a,b,c are already clipped*/
  717.     if(input>=0 && input<(c/2))
  718. y=-(input*a)/(c/2);
  719.     else if(input>=c/2 && input<c)
  720. y=-((c-input)*a)/(c/2);
  721.     else if(input>=c && input<((255+c)/2))
  722. y=((input-c)*b)/((255-c)/2);
  723.     else if(input>=((255+c)/2) && input <=255)
  724. y=((255-input)*b)/((255-c)/2);
  727.     return((int)y);
  729. }
  733. void Initcliplut(void)
  734. {
  736. int i;
  737. //clipping lut
  738. //assumes a and b can have a max value 60
  740.     for (i=0; i<319; i++)
  741. clip_softcore_post[i] = 0;
  743. clip_softcore_post[319] = 0;
  744.     for (i=1; i<256; i++)
  745. clip_softcore_post[i+319] = i;     
  746.    
  747.     for (i=256; i<511; i++)
  748. clip_softcore_post[i+319] = 255;     
  750. }