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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
mvdec.cpp
资源名称：NETVIDEO.rar　[点击查看]
上传用户：sun1608
上传日期：2007-02-02
资源大小：6116k
文件大小：16k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

mvdec.cpp：源码内容
  1. /*************************************************************************
  3. This software module was originally developed by 
  5. Wei-ge Chen (wchen@microsoft.com), Microsoft Corporation
  6. Ming-Chieh Lee (mingcl@microsoft.com), Microsoft Corporation
  7. (date: July, 1997)
  9. and edited by Xuemin Chen (xchen@gi.com), General Instrument Corp.
  11. in the course of development of the MPEG-4 Video (ISO/IEC 14496-2). 
  12. This software module is an implementation of a part of one or more MPEG-4 Video tools 
  13. as specified by the MPEG-4 Video. 
  14. ISO/IEC gives users of the MPEG-4 Video free license to this software module or modifications 
  15. thereof for use in hardware or software products claiming conformance to the MPEG-4 Video. 
  16. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. 
  17. The original developer of this software module and his/her company, 
  18. the subsequent editors and their companies, 
  19. and ISO/IEC have no liability for use of this software module or modifications thereof in an implementation. 
  20. Copyright is not released for non MPEG-4 Video conforming products. 
  21. Microsoft retains full right to use the code for his/her own purpose, 
  22. assign or donate the code to a third party and to inhibit third parties from using the code for non <MPEG standard> conforming products. 
  23. This copyright notice must be included in all copies or derivative works. 
  25. Copyright (c) 1996, 1997.
  27. Module Name:
  29. mvDec.cpp
  31. Abstract:
  33. motion vector decoder
  35. Revision History:
  36. Dec 20, 1997: Interlaced tools added by General Instrument Corp.
  38. *************************************************************************/
  40. #include "typeapi.h"
  41. #include "codehead.h"
  42. #include "mode.hpp"
  43. #include "global.hpp"
  44. #include "entropy/bitstrm.hpp"
  45. #include "entropy/entropy.hpp"
  46. #include "entropy/huffman.hpp"
  47. #include "vopses.hpp"
  48. #include "vopsedec.hpp"
  50. #ifdef __MFC_
  51. #ifdef _DEBUG
  52. #undef THIS_FILE
  53. static char BASED_CODE THIS_FILE[] = __FILE__;
  54. #endif
  56. #define new DEBUG_NEW    
  57. #endif // __MFC_
  59. Void CVideoObjectDecoder::decodeMV (const CMBMode* pmbmd, CMotionVector* pmv, 
  60. Bool bLeftBndry, Bool bRightBndry, Bool bTopBndry, 
  61. Bool bZeroMV, Int iMBX, Int iMBY)
  62. {
  63. if (pmbmd->m_bSkip || pmbmd->m_dctMd == INTRA || pmbmd->m_dctMd == INTRAQ || bZeroMV) {
  64. memset (pmv, 0, PVOP_MV_PER_REF_PER_MB * sizeof (CMotionVector));
  65. return;
  66. }
  67. CVector vctDiff, vctDecode, vctPred;
  68. if (pmbmd->m_bhas4MVForward) {
  69. for (Int iBlk = Y_BLOCK1; iBlk <= Y_BLOCK4; iBlk++) {
  70. if (bLeftBndry || bRightBndry || bTopBndry)
  71. if(short_video_header)
  72. find8x8MVpredAtBoundary(vctPred, pmv, bLeftBndry, bRightBndry, bTopBndry, (BlockNum) iBlk);
  73. else
  74. findMVpredGeneric (vctPred, pmv, pmbmd, iBlk, iMBX, iMBY);
  75. else 
  76. find8x8MVpredInterior (vctPred, pmv, (BlockNum) iBlk);
  77. getDiffMV (vctDiff, m_vopmd.mvInfoForward);
  78. vctDecode = vctDiff + vctPred; //fit in range
  79. fitMvInRange (vctDecode, m_vopmd.mvInfoForward);
  80. pmv [iBlk] = CMotionVector (vctDecode); //convert to full pel now
  81. }
  82. }
  83. // INTERLACE
  84. else if ((m_vopmd.bInterlace)&&(pmbmd->m_bFieldMV)) {
  85. Int iTempX1, iTempY1, iTempX2, iTempY2;
  86. find16x16MVpred (vctPred, pmv, bLeftBndry, bRightBndry, bTopBndry);
  87. getDiffMV (vctDiff, m_vopmd.mvInfoForward);
  88. vctDiff.y *= 2;
  89. vctPred.y = 2*(vctPred.y / 2);
  90. vctDecode = vctDiff + vctPred; //fit in range
  91. fitMvInRange (vctDecode, m_vopmd.mvInfoForward);
  92. CMotionVector* pmv16x8 = pmv +5;
  93. if(pmbmd->m_bForwardTop) {
  94. pmv16x8++;
  95. *pmv16x8 = CMotionVector (vctDecode); //convert to full pel now
  96. iTempX1 = pmv16x8->m_vctTrueHalfPel.x;
  97. iTempY1 = pmv16x8->m_vctTrueHalfPel.y;
  98. pmv16x8++;
  99. } 
  100. else
  101. {
  102. *pmv16x8 = CMotionVector (vctDecode); //convert to full pel now
  103. iTempX1 = pmv16x8->m_vctTrueHalfPel.x;
  104. iTempY1 = pmv16x8->m_vctTrueHalfPel.y;
  105. pmv16x8++;
  106. pmv16x8++;
  107. }
  108. getDiffMV (vctDiff, m_vopmd.mvInfoForward);
  109. vctDiff.y *= 2;
  110. vctPred.y = 2*(vctPred.y / 2);
  111. vctDecode = vctDiff + vctPred; //fit in range
  112. fitMvInRange (vctDecode, m_vopmd.mvInfoForward);
  113. if(pmbmd->m_bForwardBottom) {
  114. pmv16x8++;
  115. *pmv16x8 = CMotionVector (vctDecode); //convert to full pel now
  116. iTempX2 = pmv16x8->m_vctTrueHalfPel.x;
  117. iTempY2 = pmv16x8->m_vctTrueHalfPel.y;
  118. }
  119. else
  120. {
  121. *pmv16x8 = CMotionVector (vctDecode); //convert to full pel now
  122. iTempX2 = pmv16x8->m_vctTrueHalfPel.x;
  123. iTempY2 = pmv16x8->m_vctTrueHalfPel.y;
  124. }
  126. Int iTemp;
  127. for (UInt i = 1; i < 5; i++) {
  128. iTemp = iTempX1 + iTempX2;
  129. pmv [i].m_vctTrueHalfPel.x = (iTemp & 3) ? ((iTemp>>1) | 1) : (iTemp>>1);
  130. iTemp = iTempY1 + iTempY2;
  131. pmv [i].m_vctTrueHalfPel.y = (iTemp & 3) ? ((iTemp>>1) | 1) : (iTemp>>1);
  132. }
  133. }
  134. // ~INTERLACE
  135. else { //1 mv
  136. if(short_video_header)
  137. find16x16MVpred(vctPred, pmv, bLeftBndry, bRightBndry, bTopBndry);
  138. else
  139. findMVpredGeneric (vctPred, pmv, pmbmd, ALL_Y_BLOCKS, iMBX, iMBY);
  140. getDiffMV (vctDiff, m_vopmd.mvInfoForward);
  141. vctDecode = vctDiff + vctPred; //fit in range
  142. fitMvInRange (vctDecode, m_vopmd.mvInfoForward);
  143. *pmv++ = CMotionVector (vctDecode); //convert to full pel now
  144. for (Int i = 0; i < 4; i++) {
  145. *pmv = *(pmv - 1);
  146. pmv++;
  147. }
  148. }
  149. }
  151. Void CVideoObjectDecoder::decodeMVofBVOP (CMotionVector* pmvForward, CMotionVector* pmvBackward, CMBMode* pmbmd, 
  152.   Int iMBX, Int iMBY, const CMotionVector* pmvRef, const CMBMode* pmbmdRef)
  153. {
  154. CVector vctDiff;
  155. //CVector vctPred;
  156. CVector vctDecode;
  157. //UInt nBits = 0;
  158. if(pmbmd->m_bSkip == TRUE && m_volmd.volType == ENHN_LAYER && m_vopmd.iRefSelectCode == 0)
  159. return;
  160. if (pmbmd->m_mbType == FORWARD || pmbmd->m_mbType == INTERPOLATE) {
  161. assert (pmbmd->m_bSkip != TRUE);
  162. assert (pmbmd->m_bhas4MVForward != TRUE);
  163. getDiffMV (vctDiff, m_vopmd.mvInfoForward);
  164. // TPS FIX
  165. if (pmbmd->m_bFieldMV && m_volmd.volType != ENHN_LAYER) {
  166. vctDecode.x = vctDiff.x + m_vctForwardMvPredBVOP[0].x;
  167. vctDecode.y = 2 * (vctDiff.y + m_vctForwardMvPredBVOP[0].y / 2);
  168. fitMvInRange (vctDecode, m_vopmd.mvInfoForward);
  169. m_vctForwardMvPredBVOP[0] = vctDecode;
  170. pmvForward[0] = CMotionVector(vctDecode);
  171. pmvForward[1] = pmvForward[0];
  172. pmvForward[2] = pmvForward[0];
  173. getDiffMV(vctDiff, m_vopmd.mvInfoForward);
  174. vctDecode.x = vctDiff.x + m_vctForwardMvPredBVOP[1].x;
  175. vctDecode.y = 2 * (vctDiff.y + m_vctForwardMvPredBVOP[1].y / 2);
  176. fitMvInRange (vctDecode, m_vopmd.mvInfoForward);
  177. m_vctForwardMvPredBVOP[1] = vctDecode;
  178. pmvForward[3] = CMotionVector(vctDecode);
  179. pmvForward[4] = pmvForward[3];
  180. } else {
  181. vctDecode = vctDiff + m_vctForwardMvPredBVOP[0];
  182. fitMvInRange (vctDecode, m_vopmd.mvInfoForward);
  183. m_vctForwardMvPredBVOP[0] = vctDecode;
  184. m_vctForwardMvPredBVOP[1] = vctDecode;
  185. *pmvForward++ = CMotionVector(vctDecode);
  186. for (Int i = 0; i < 4; i++) {
  187. *pmvForward = *(pmvForward - 1);
  188. pmvForward++;
  189. }
  190. }
  191. }
  192. // TPS FIX
  193. if ( (pmbmd->m_mbType == BACKWARD || pmbmd->m_mbType == INTERPOLATE)
  194. && (m_volmd.volType != ENHN_LAYER || m_vopmd.iRefSelectCode != 0) ){ // modified by Sharp (98/3/11)
  195. assert (pmbmd->m_bSkip != TRUE);
  196. assert (pmbmd->m_bhas4MVBackward != TRUE);
  197. getDiffMV (vctDiff, m_vopmd.mvInfoBackward);
  198. if (pmbmd->m_bFieldMV && m_volmd.volType != ENHN_LAYER) {
  199. vctDecode.x = vctDiff.x + m_vctBackwardMvPredBVOP[0].x;
  200. vctDecode.y = 2 * (vctDiff.y + m_vctBackwardMvPredBVOP[0].y / 2);
  201. fitMvInRange (vctDecode, m_vopmd.mvInfoBackward);
  202. m_vctBackwardMvPredBVOP[0] = vctDecode;
  203. pmvBackward[0] = CMotionVector(vctDecode);
  204. pmvBackward[1] = pmvBackward[0];
  205. pmvBackward[2] = pmvBackward[0];
  206. getDiffMV(vctDiff, m_vopmd.mvInfoBackward);
  207. vctDecode.x = vctDiff.x + m_vctBackwardMvPredBVOP[1].x;
  208. vctDecode.y = 2 * (vctDiff.y + m_vctBackwardMvPredBVOP[1].y / 2);
  209. fitMvInRange (vctDecode, m_vopmd.mvInfoBackward);
  210. m_vctBackwardMvPredBVOP[1] = vctDecode;
  211. pmvBackward[3] = CMotionVector(vctDecode);
  212. pmvBackward[4] = pmvBackward[3];
  213. } else {
  214. vctDecode = vctDiff + m_vctBackwardMvPredBVOP[0];
  215. fitMvInRange (vctDecode, m_vopmd.mvInfoBackward);
  216. m_vctBackwardMvPredBVOP[0] = vctDecode;
  217. m_vctBackwardMvPredBVOP[1] = vctDecode;
  218. *pmvBackward++ = CMotionVector(vctDecode);
  219. for (Int i = 0; i < 4; i++) {
  220. *pmvBackward = *(pmvBackward - 1);
  221. pmvBackward++;
  222. }
  223. }
  224. }
  225. if (pmbmd->m_mbType == DIRECT) {
  226. static MVInfo directInfo = { 32, 1, 1};
  227. assert (pmbmd->m_bhas4MVForward != TRUE);
  228. /* begin of new changes 02-19-99 
  229.      if (m_vopmd.bInterlace) {
  230.     memset (pmvForward, 0, BVOP_MV_PER_REF_PER_MB * sizeof (CMotionVector)); //set forward mv to zero
  231.     if (!pmbmd->m_bSkip)
  232.     getDiffMV (pmbmd->m_vctDirectDeltaMV, directInfo);
  233.     } else {
  234. end of new changes 02-19-99 */
  236. // begin of new changes 02-19-99
  237. if (m_vopmd.bInterlace) {
  238. if (!pmbmd->m_bSkip) {
  239. getDiffMV (pmbmd->m_vctDirectDeltaMV, directInfo);
  240. vctDiff.x = pmbmd->m_vctDirectDeltaMV.x;
  241. vctDiff.y = pmbmd->m_vctDirectDeltaMV.y;
  242. }
  243. else
  244. vctDiff.x = vctDiff.y = 0;
  245. }
  246. else {  
  247. //end of new changes 02-19-99
  249. if (pmbmd->m_bSkip)
  250. vctDiff.x = vctDiff.y = 0;
  251. else  {
  252. Long lSymbol = m_pentrdecSet->m_pentrdecMV->decodeSymbol ();
  253. vctDiff.x  = deScaleMV (lSymbol - 32, 0, 1);
  254. lSymbol = m_pentrdecSet->m_pentrdecMV->decodeSymbol ();
  255. vctDiff.y  = deScaleMV (lSymbol - 32, 0, 1);
  256. }
  257. }  // new change 02-19-99
  258.     computeDirectForwardMV (vctDiff, pmvForward, pmvRef, pmbmdRef); //compute forward mv from diff
  259.     if(pmbmdRef==NULL)
  260.     {
  261.     // transparent reference macroblock
  262.     pmbmd->m_bhas4MVBackward = pmbmd->m_bhas4MVForward = FALSE;
  263.     CMotionVector mvRef; // zero motion vector
  264.     backwardMVFromForwardMV (*pmvBackward, *pmvForward, mvRef, vctDiff);
  265.     }
  266.     else
  267.     {
  268.     pmbmd->m_bhas4MVBackward = pmbmd->m_bhas4MVForward = pmbmdRef->m_bhas4MVForward; //reset 4mv mode
  269.     if (pmbmd->m_bhas4MVBackward) {
  270.     for (Int i = 0; i < 4; i++) {
  271.     pmvForward++;
  272.     pmvBackward++;
  273.     pmvRef++;
  274.     backwardMVFromForwardMV (*pmvBackward, *pmvForward, *pmvRef,
  275.      vctDiff); //compute back mv from forward mv and ref mv for direct mode
  276.     }
  277.     }
  278.     else
  279.     backwardMVFromForwardMV (*pmvBackward, *pmvForward, *pmvRef,
  280.      vctDiff); //compute back mv from forward mv and ref mv for direct mode
  281. } 
  282. // }  new change 02-19-99
  283. }
  284. }
  286. Void CVideoObjectDecoder::computeDirectForwardMV (CVector vctDiff, CMotionVector* pmv,
  287.   const CMotionVector* pmvRef,
  288.   const CMBMode* pmbmdRef)
  289. {
  290. if(pmvRef==NULL)
  291. {
  292. // colocated macroblock is transparent, use zero reference MV
  293. *pmv++ = CMotionVector (vctDiff); //convert to full pel now
  294. for (Int i = 0; i < 4; i++) {
  295. *pmv = *(pmv - 1);
  296. pmv++;
  297. }
  298. }
  299. else
  300. {
  301. Int iPartInterval = m_t - m_tPastRef;
  302. Int iFullInterval = m_tFutureRef - m_tPastRef;
  303. if (pmbmdRef->m_bhas4MVForward == FALSE) {
  304. CVector vctRefScaled = pmvRef->trueMVHalfPel () * iPartInterval;
  305. vctRefScaled.x /= iFullInterval; //truncation as per vm
  306. vctRefScaled.y /= iFullInterval; //truncation as per vm
  307. CVector vctDecode = vctDiff + vctRefScaled;
  308. *pmv++ = CMotionVector (vctDecode); //convert to full pel now
  309. for (Int i = 0; i < 4; i++) {
  310. *pmv = *(pmv - 1);
  311. pmv++;
  312. }
  313. }
  314. else {
  315. for (Int i = 0; i < 4; i++) {
  316. pmv++;
  317. pmvRef++;
  318. CVector vctRefScaled = pmvRef->trueMVHalfPel () * iPartInterval;
  319. vctRefScaled.x /= iFullInterval; //truncation as per vm
  320. vctRefScaled.y /= iFullInterval; //truncation as per vm
  321. CVector vctDecode = vctDiff + vctRefScaled;
  322. *pmv = CMotionVector (vctDecode); //convert to full pel now
  323. }
  324. }
  325. }
  326. }
  328. Void CVideoObjectDecoder::decodeMVWithShape (const CMBMode* pmbmd, CoordI iMBX, CoordI iMBY, CMotionVector* pmv)
  329. {
  330. if (pmbmd->m_bSkip || pmbmd->m_dctMd == INTRA || pmbmd->m_dctMd == INTRAQ) {
  331. memset (pmv, 0, PVOP_MV_PER_REF_PER_MB * sizeof (CMotionVector));
  332. return;
  333. }
  334. CVector vctDiff, vctDecode, vctPred;
  335. if (pmbmd->m_bhas4MVForward) {
  336. for (Int iBlk = Y_BLOCK1; iBlk <= Y_BLOCK4; iBlk++) {
  337. if (pmbmd->m_rgTranspStatus [iBlk] == ALL)
  338. pmv [iBlk] = CMotionVector (NOT_MV, NOT_MV);
  339. else {
  340. findMVpredGeneric (vctPred, pmv, pmbmd, iBlk, iMBX, iMBY);
  341. getDiffMV (vctDiff, m_vopmd.mvInfoForward);
  342. vctDecode = vctDiff + vctPred; //fit in range
  343. fitMvInRange (vctDecode, m_vopmd.mvInfoForward);
  344. pmv [iBlk] = CMotionVector (vctDecode);
  345. }
  346. }
  347. }
  348. // INTERLACE
  349. //new changes
  350. else if ((m_vopmd.bInterlace)&&(pmbmd->m_bFieldMV)) {
  351. Int iTempX1, iTempY1, iTempX2, iTempY2;
  352. assert (pmbmd->m_rgTranspStatus [0] != ALL);
  353. findMVpredGeneric (vctPred, pmv, pmbmd, ALL_Y_BLOCKS, iMBX, iMBY);
  354. getDiffMV (vctDiff, m_vopmd.mvInfoForward);
  355. vctDiff.y *= 2;
  356. vctPred.y = 2*(vctPred.y / 2);
  357. vctDecode = vctDiff + vctPred; //fit in range
  358. fitMvInRange (vctDecode, m_vopmd.mvInfoForward);
  359. CMotionVector* pmv16x8 = pmv +5;
  360. if(pmbmd->m_bForwardTop) {
  361. pmv16x8++;
  362. *pmv16x8 = CMotionVector (vctDecode); //convert to full pel now
  363. iTempX1 = pmv16x8->m_vctTrueHalfPel.x;
  364. iTempY1 = pmv16x8->m_vctTrueHalfPel.y;
  365. pmv16x8++;
  366. } 
  367. else
  368. {
  369. *pmv16x8 = CMotionVector (vctDecode); //convert to full pel now
  370. iTempX1 = pmv16x8->m_vctTrueHalfPel.x;
  371. iTempY1 = pmv16x8->m_vctTrueHalfPel.y;
  372. pmv16x8++;
  373. pmv16x8++;
  374. }
  375. getDiffMV (vctDiff, m_vopmd.mvInfoForward);
  376. vctDiff.y *= 2;
  377. vctPred.y = 2*(vctPred.y / 2);
  378. vctDecode = vctDiff + vctPred; //fit in range
  379. fitMvInRange (vctDecode, m_vopmd.mvInfoForward);
  380. if(pmbmd->m_bForwardBottom) {
  381. pmv16x8++;
  382. *pmv16x8 = CMotionVector (vctDecode); //convert to full pel now
  383. iTempX2 = pmv16x8->m_vctTrueHalfPel.x;
  384. iTempY2 = pmv16x8->m_vctTrueHalfPel.y;
  385. }
  386. else
  387. {
  388. *pmv16x8 = CMotionVector (vctDecode); //convert to full pel now
  389. iTempX2 = pmv16x8->m_vctTrueHalfPel.x;
  390. iTempY2 = pmv16x8->m_vctTrueHalfPel.y;
  391. }
  393. Int iTemp;
  394. for (UInt i = 1; i < 5; i++) {
  395. iTemp = iTempX1 + iTempX2;
  396. pmv [i].m_vctTrueHalfPel.x = (iTemp & 3) ? ((iTemp>>1) | 1) : (iTemp>>1);
  397. iTemp = iTempY1 + iTempY2;
  398. pmv [i].m_vctTrueHalfPel.y = (iTemp & 3) ? ((iTemp>>1) | 1) : (iTemp>>1);
  399. }
  400. }
  401. //end of new changes
  402. // ~INTERLACE
  403. else { //1 mv
  404. assert (pmbmd->m_rgTranspStatus [0] != ALL);
  405. findMVpredGeneric (vctPred, pmv, pmbmd, ALL_Y_BLOCKS, iMBX, iMBY);
  406. getDiffMV (vctDiff, m_vopmd.mvInfoForward);
  407. vctDecode = vctDiff + vctPred; //fit in range
  408. fitMvInRange (vctDecode, m_vopmd.mvInfoForward);
  409. *pmv++ = CMotionVector (vctDecode);
  410. for (Int i = 0; i < 4; i++) {
  411. *pmv = *(pmv - 1);
  412. pmv++;
  413. }
  414. }
  415. }
  417. Void CVideoObjectDecoder::getDiffMV (CVector& vctDiffMV, MVInfo mvinfo) //get half pel
  418. {
  419. Int iResidual;
  420. Long lSymbol = m_pentrdecSet->m_pentrdecMV->decodeSymbol ();
  421. Int iVLC = lSymbol - 32;
  422. if (iVLC != 0)
  423. iResidual = m_pbitstrmIn->getBits (mvinfo.uiFCode - 1);
  424. else
  425. iResidual = 0;
  426. vctDiffMV.x  = deScaleMV (iVLC, iResidual, mvinfo.uiScaleFactor);
  428. lSymbol = m_pentrdecSet->m_pentrdecMV->decodeSymbol ();
  429. iVLC = lSymbol - 32;
  430. if (iVLC != 0)
  431. iResidual = m_pbitstrmIn->getBits (mvinfo.uiFCode - 1);
  432. else
  433. iResidual = 0;
  434. vctDiffMV.y  = deScaleMV (iVLC, iResidual, mvinfo.uiScaleFactor);
  435. }
  437. Int CVideoObjectDecoder::deScaleMV (Int iVLC, Int iResidual, Int iScaleFactor)
  438. {
  439. if (iVLC == 0 && iResidual == 0)
  440. return 0;
  441. else if (iScaleFactor == 1)
  442. return (iVLC);
  443. else {
  444. Int iAbsDiffMVcomponent = abs (iVLC) * iScaleFactor + iResidual - iScaleFactor + 1; //changed a'c to enc
  445. return (sign (iVLC) * iAbsDiffMVcomponent);
  446. }
  447. }
  449. Void CVideoObjectDecoder::fitMvInRange (CVector& vctSrc, MVInfo mvinfo)
  450. {
  451. Int iMvRange = mvinfo.uiRange; //in half pel unit
  452. if (vctSrc.x < -1 * iMvRange) //* 2 to get length of [-range, range]
  453. vctSrc.x += 2 * iMvRange;
  454. else if (vctSrc.x >= iMvRange)
  455. vctSrc.x  -= 2 * iMvRange;
  457. if (vctSrc.y < -1 * iMvRange)
  458. vctSrc.y += 2 * iMvRange;
  459. else if (vctSrc.y >= iMvRange)
  460. vctSrc.y  -= 2 * iMvRange;
  461. }