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

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

流媒体/Mpeg4/MP4

开发平台：

Visual C++

spt.cpp：源码内容
  1. /*************************************************************************
  3. This software module was originally developed by 
  5. Chuang Gu (chuanggu@microsoft.com), Microsoft Corporation
  6. (date: Auguest, 1997)
  8. and also edited by
  10.     Yoshinori Suzuki (Hitachi, Ltd.)
  11.     Yuichiro Nakaya (Hitachi, Ltd.)
  13. in the course of development of the MPEG-4 Video (ISO/IEC 14496-2). 
  14. This software module is an implementation of a part of one or more MPEG-4 Video tools 
  15. as specified by the MPEG-4 Video. 
  16. ISO/IEC gives users of the MPEG-4 Video free license to this software module or modifications 
  17. thereof for use in hardware or software products claiming conformance to the MPEG-4 Video. 
  18. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. 
  19. The original developer of this software module and his/her company, 
  20. the subsequent editors and their companies, 
  21. and ISO/IEC have no liability for use of this software module or modifications thereof in an implementation. 
  22. Copyright is not released for non MPEG-4 Video conforming products. 
  23. Microsoft retains full right to use the code for his/her own purpose, 
  24. assign or donate the code to a third party and to inhibit third parties from using the code for non <MPEG standard> conforming products. 
  25. This copyright notice must be included in all copies or derivative works. 
  27. Copyright (c) 1996, 1997.
  30. Module Name:
  32. spt.cpp
  34. Abstract:
  36. Functions for sprite warping 
  38. Revision History:
  39. Nov. 14, 1997: Fast Affine Warping functions added by Hitachi, Ltd.
  40. Jan. 13, 1999: Code for disallowing zero demoninators in perspective
  41.                        warping added by Hitachi, Ltd.
  43. *************************************************************************/
  45. #include <stdio.h>
  46. #include <math.h>
  47. #include "typeapi.h"
  48. #include "mode.hpp"
  49. #include "vopses.hpp"
  50. #include "codehead.h"
  52. #ifdef __MFC_
  53. #ifdef _DEBUG
  54. #undef THIS_FILE
  55. static char BASED_CODE THIS_FILE[] = __FILE__;
  56. #endif
  58. #define new DEBUG_NEW    
  59. #endif // __MFC_
  61. #define _FOR_GSSP_
  63. Void CVideoObject::warpYA (const CPerspective2D& persp, const CRct& rctWarpedBound, UInt accuracy) 
  64. // warp m_pvopcSptQ's Y and A components to m_pvopcCurrQs
  65. {
  66. assert (m_pvopcCurrQ -> whereY ().includes (rctWarpedBound));
  67. const CU8Image* puciCurrY = m_pvopcCurrQ -> getPlane (Y_PLANE);
  68. #ifdef _FOR_GSSP_
  69. const CU8Image* puciCurrBY = m_pvopcCurrQ -> getPlane (BY_PLANE);
  70. #endif
  71. const CU8Image* puciCurrA = (m_pvopcSptQ -> fAUsage () == EIGHT_BIT)? m_pvopcCurrQ -> getPlane (A_PLANE) : m_pvopcCurrQ -> getPlane (BY_PLANE);
  72. const CU8Image* puciSptY = m_pvopcSptQ -> getPlane (Y_PLANE);
  73. #ifdef _FOR_GSSP_
  74. const CU8Image* puciSptBY = m_pvopcSptQ -> getPlane (BY_PLANE);
  75. #endif
  76. const CU8Image* puciSptA = (m_pvopcSptQ -> fAUsage () == EIGHT_BIT)? m_pvopcSptQ -> getPlane (A_PLANE) : m_pvopcSptQ -> getPlane (BY_PLANE);
  77. const CRct rctSptY = m_pvopcSptQ -> whereY ();
  78. const UInt offsetSlice = m_pvopcCurrQ -> whereY ().width * MB_SIZE;
  79. UInt accuracy1 = accuracy + 1;
  80. PixelC* ppxlcCurrQYSlice = (PixelC*) puciCurrY -> pixels ();
  81. #ifdef _FOR_GSSP_
  82. PixelC* ppxlcCurrQBYSlice = (PixelC*) puciCurrBY -> pixels ();
  83. #endif
  84. PixelC* ppxlcCurrQASlice = (PixelC*) puciCurrA -> pixels ();
  85. memset (ppxlcCurrQYSlice, 0, puciCurrY -> where ().area () * sizeof(PixelC));
  86. #ifdef _FOR_GSSP_
  87. memset (ppxlcCurrQBYSlice, 0, puciCurrBY -> where ().area () * sizeof(PixelC));
  88. #endif
  89. memset (ppxlcCurrQASlice, 0, puciCurrA -> where ().area () * sizeof(PixelC));
  90. ppxlcCurrQYSlice = (PixelC*) puciCurrY -> pixels (rctWarpedBound.left, rctWarpedBound.top);
  91. #ifdef _FOR_GSSP_
  92. ppxlcCurrQBYSlice = (PixelC*) puciCurrBY -> pixels (rctWarpedBound.left, rctWarpedBound.top);
  93. #endif
  94. ppxlcCurrQASlice = (PixelC*) puciCurrA -> pixels (rctWarpedBound.left, rctWarpedBound.top);
  95. for (Int topMB = rctWarpedBound.top; topMB < rctWarpedBound.bottom; topMB += MB_SIZE) {
  96. PixelC * ppxlcCurrQYBlock = ppxlcCurrQYSlice;
  97. PixelC * ppxlcCurrQABlock = ppxlcCurrQASlice;
  98. PixelC * ppxlcCurrQBYBlock = ppxlcCurrQBYSlice;
  99. for (Int leftMB = rctWarpedBound.left; leftMB < rctWarpedBound.right; leftMB += MB_SIZE) {
  100. UInt offsetLine = m_pvopcCurrQ -> whereY ().width - min(MB_SIZE, rctWarpedBound.right - leftMB);
  101. Bool existOpaguePixelMB = (m_pvopcSptQ -> fAUsage () == RECTANGLE);
  102. Bool existZeroDenomMB = FALSE; 
  103. PixelC * ppxlcCurrQY = ppxlcCurrQYBlock;
  104. PixelC * ppxlcCurrQBY = ppxlcCurrQBYBlock;
  105. PixelC * ppxlcCurrQA = ppxlcCurrQABlock;
  106. for (CoordI y = topMB; y < min(topMB + MB_SIZE, rctWarpedBound.bottom); y++) {
  107. for (CoordI x = leftMB; x < min(leftMB + MB_SIZE, rctWarpedBound.right); x++) {
  108. CSiteWFlag src = persp * (CSite (x, y)); 
  109. if (src.f) {
  110. existZeroDenomMB = TRUE;
  111. continue;
  112. }
  113. CoordD dx = (CoordD)src.s.x / (1 << accuracy1);
  114. CoordD dy = (CoordD)src.s.y / (1 << accuracy1);
  115. CoordI fx = (CoordI) floor (dx);
  116. CoordI fy = (CoordI) floor (dy); 
  117. CoordI cx = (CoordI) ceil (dx);
  118. CoordI cy = (CoordI) ceil (dy);
  119. if (rctSptY.includes (fx, fy) && rctSptY.includes (fx, cy) && rctSptY.includes (cx, fy) && rctSptY.includes (cx, cy)) {
  120. #ifdef _FOR_GSSP_
  121. PixelC pxlcWarpedBY = puciSptBY -> pixel (src.s, accuracy);
  122. if (pxlcWarpedBY >= 128) {
  123. *ppxlcCurrQBY = MPEG4_OPAQUE;
  124. #else
  125. PixelC pxlcWarpedA = puciSptA -> pixel (src.s, accuracy);
  126. if (pxlcWarpedA >= 128) {
  127. *ppxlcCurrQA = MPEG4_OPAQUE;
  128. #endif
  129. existOpaguePixelMB = TRUE;
  130. *ppxlcCurrQY = puciSptY -> pixel (src.s, accuracy);
  131. #ifdef _FOR_GSSP_
  132. if(m_pvopcSptQ -> fAUsage () == EIGHT_BIT)
  133. *ppxlcCurrQA = puciSptA -> pixel (src.s, accuracy);
  134. #endif
  135. }
  136. }
  137. ppxlcCurrQY++;
  138. #ifdef _FOR_GSSP_
  139. ppxlcCurrQBY++;
  140. #endif
  141. ppxlcCurrQA++;
  142. }
  143. ppxlcCurrQY += offsetLine;
  144. #ifdef _FOR_GSSP_
  145. ppxlcCurrQBY += offsetLine;
  146. #endif
  147. ppxlcCurrQA += offsetLine;
  148. }
  149. assert (!(existOpaguePixelMB && existZeroDenomMB));
  151. ppxlcCurrQYBlock += MB_SIZE;
  152. #ifdef _FOR_GSSP_
  153. ppxlcCurrQBYBlock += MB_SIZE;
  154. #endif
  155. ppxlcCurrQABlock += MB_SIZE;
  156. }
  157. ppxlcCurrQYSlice += offsetSlice;
  158. #ifdef _FOR_GSSP_
  159. ppxlcCurrQBYSlice += offsetSlice;
  160. #endif
  161. ppxlcCurrQASlice += offsetSlice;
  162. }
  163. } 
  165. Void CVideoObject::warpUV (const CPerspective2D& persp, const CRct& rctWarpedBound, UInt accuracy) 
  166. // warp m_pvopcSptQ's U and V components to m_pvopcCurrQs
  167. {
  168. assert (m_pvopcCurrQ -> whereUV ().includes (rctWarpedBound));
  169. const CU8Image* puciCurrU = m_pvopcCurrQ -> getPlane (U_PLANE);
  170. const CU8Image* puciCurrV = m_pvopcCurrQ -> getPlane (V_PLANE);
  171. const CU8Image* puciCurrBY = m_pvopcCurrQ -> getPlane (BY_PLANE);
  172. const CU8Image* puciSptU = m_pvopcSptQ -> getPlane (U_PLANE);
  173. const CU8Image* puciSptV = m_pvopcSptQ -> getPlane (V_PLANE);
  174. const CRct rctSptUV = m_pvopcSptQ -> whereUV ();
  175. const UInt offsetSliceUV = m_pvopcCurrQ -> whereUV ().width * BLOCK_SIZE;
  176. const UInt offsetSliceBY = m_pvopcCurrQ -> whereY ().width * MB_SIZE;
  177. const UInt nextRowBY = m_pvopcCurrQ -> whereY ().width;
  178. UInt accuracy1 = accuracy + 1;
  179. PixelC* ppxlcCurrQUSlice = (PixelC*) puciCurrU -> pixels ();
  180. PixelC* ppxlcCurrQVSlice = (PixelC*) puciCurrV -> pixels ();
  181. PixelC pxlcVal = 128;
  182. // not sure if this is needed swinder
  183. if(m_volmd.nBits>8)
  184. pxlcVal = 1<<(m_volmd.nBits - 1);
  185. pxlcmemset (ppxlcCurrQUSlice, pxlcVal, puciCurrU -> where ().area ());
  186. pxlcmemset (ppxlcCurrQVSlice, pxlcVal, puciCurrV -> where ().area ());
  187. ppxlcCurrQUSlice = (PixelC*) puciCurrU -> pixels (rctWarpedBound.left, rctWarpedBound.top);
  188. ppxlcCurrQVSlice = (PixelC*) puciCurrV -> pixels (rctWarpedBound.left, rctWarpedBound.top);
  189. PixelC* ppxlcCurrQBYSlice = (PixelC*) puciCurrBY -> pixels (2 * rctWarpedBound.left, 2 * rctWarpedBound.top);
  191. for (Int topMB = rctWarpedBound.top; topMB < rctWarpedBound.bottom; topMB += BLOCK_SIZE) {
  192. PixelC * ppxlcCurrQUBlock = ppxlcCurrQUSlice;
  193. PixelC * ppxlcCurrQVBlock = ppxlcCurrQVSlice;
  194. PixelC * ppxlcCurrQBYBlock = ppxlcCurrQBYSlice;
  196. for (Int leftMB = rctWarpedBound.left; leftMB < rctWarpedBound.right; leftMB += BLOCK_SIZE) {
  197. PixelC *ppxlcCurrQU = ppxlcCurrQUBlock;
  198. PixelC *ppxlcCurrQV = ppxlcCurrQVBlock;
  199. PixelC *ppxlcCurrQBY = ppxlcCurrQBYBlock;
  200. PixelC *ppxlcCurrQBYNextRow = ppxlcCurrQBYBlock + nextRowBY;
  201. UInt offsetLineUV = m_pvopcCurrQ -> whereUV ().width - min(BLOCK_SIZE, rctWarpedBound.right - leftMB);
  202. UInt offsetLineBY = 2 * (m_pvopcCurrQ -> whereY ().width - min(BLOCK_SIZE, rctWarpedBound.right - leftMB));
  203. Bool existOpaguePixelMBUV = (m_pvopcSptQ -> fAUsage () == RECTANGLE);
  204. Bool existZeroDenomMBUV = FALSE; 
  205. for (CoordI y = topMB; y < min(topMB + BLOCK_SIZE, rctWarpedBound.bottom); y++) {
  206. for (CoordI x = leftMB; x < min(leftMB + BLOCK_SIZE, rctWarpedBound.right); x++) {
  207. CSiteWFlag src = persp * (CSite (x, y)); 
  208. if (src.f) {
  209. existZeroDenomMBUV = TRUE;
  210. continue;
  211. }
  212. CoordD dx = (CoordD)src.s.x / (1 << accuracy1);
  213. CoordD dy = (CoordD)src.s.y / (1 << accuracy1);
  214. CoordI fx = (CoordI) floor (dx);
  215. CoordI fy = (CoordI) floor (dy); 
  216. CoordI cx = (CoordI) ceil (dx);
  217. CoordI cy = (CoordI) ceil (dy);
  218. if (rctSptUV.includes (fx, fy) && rctSptUV.includes (fx, cy) && rctSptUV.includes (cx, fy) && rctSptUV.includes (cx, cy)) {
  219. if (*ppxlcCurrQBY | *(ppxlcCurrQBY + 1) | *ppxlcCurrQBYNextRow | *(ppxlcCurrQBYNextRow+1)) {
  220. existOpaguePixelMBUV = TRUE;
  221. *ppxlcCurrQU = puciSptU -> pixel (src.s, accuracy);
  222. *ppxlcCurrQV = puciSptV -> pixel (src.s, accuracy);
  223. }
  224. }
  225. ppxlcCurrQBY += 2;
  226. ppxlcCurrQBYNextRow += 2;
  227. ppxlcCurrQU++;
  228. ppxlcCurrQV++;
  229. }
  230. ppxlcCurrQBY += offsetLineBY;
  231. ppxlcCurrQBYNextRow += offsetLineBY;
  232. ppxlcCurrQU += offsetLineUV;
  233. ppxlcCurrQV += offsetLineUV;
  234. }
  235. assert (!(existOpaguePixelMBUV && existZeroDenomMBUV));
  237. ppxlcCurrQBYBlock += MB_SIZE;
  238. ppxlcCurrQUBlock += BLOCK_SIZE;
  239. ppxlcCurrQVBlock += BLOCK_SIZE;
  240. }
  241. ppxlcCurrQBYSlice += offsetSliceBY;
  242. ppxlcCurrQUSlice += offsetSliceUV;
  243. ppxlcCurrQVSlice += offsetSliceUV;
  244. }
  245. }  
  247. Void CVideoObject::FastAffineWarp (const CRct& rctWarpedBound, 
  248.                    const CRct& rctWarpedBoundUV, UInt accuracy, UInt pntNum) 
  249. {
  250. assert (m_pvopcCurrQ -> whereY ().includes (rctWarpedBound));
  251. const CU8Image* puciCurrY = m_pvopcCurrQ -> getPlane (Y_PLANE);
  252. #ifdef _FOR_GSSP_
  253. const CU8Image* puciCurrBY = m_pvopcCurrQ -> getPlane (BY_PLANE);
  254. #endif
  255. const CU8Image* puciCurrA = (m_pvopcSptQ -> fAUsage () == EIGHT_BIT)? m_pvopcCurrQ -> getPlane (A_PLANE) : m_pvopcCurrQ -> getPlane (BY_PLANE);
  256. const CU8Image* puciSptY = m_pvopcSptQ -> getPlane (Y_PLANE);
  257. #ifdef _FOR_GSSP_
  258. const CU8Image* puciSptBY = m_pvopcSptQ -> getPlane (BY_PLANE);
  259. #endif
  260. const CU8Image* puciSptA = (m_pvopcSptQ -> fAUsage () == EIGHT_BIT)? m_pvopcSptQ -> getPlane (A_PLANE) : m_pvopcSptQ -> getPlane (BY_PLANE);
  261. const UInt offset = m_pvopcCurrQ -> whereY ().width - rctWarpedBound.width;
  262. PixelC* ppxlcCurrQY = (PixelC*) puciCurrY -> pixels ();
  263. #ifdef _FOR_GSSP_
  264. PixelC* ppxlcCurrQBY = (PixelC*) puciCurrBY -> pixels ();
  265. #endif
  266. PixelC* ppxlcCurrQA = (PixelC*) puciCurrA -> pixels ();
  267. memset (ppxlcCurrQY, 0, puciCurrY -> where ().area () * sizeof(PixelC));
  268. #ifdef _FOR_GSSP_
  269. memset (ppxlcCurrQBY, 0, puciCurrBY -> where ().area () * sizeof(PixelC));
  270. #endif
  271. memset (ppxlcCurrQA, 0, puciCurrA -> where ().area () * sizeof(PixelC));
  272. ppxlcCurrQY = (PixelC*) puciCurrY -> pixels (rctWarpedBound.left, rctWarpedBound.top);
  273. #ifdef _FOR_GSSP_
  274. ppxlcCurrQBY = (PixelC*) puciCurrBY -> pixels (rctWarpedBound.left, rctWarpedBound.top);
  275. #endif
  276. ppxlcCurrQA = (PixelC*) puciCurrA -> pixels (rctWarpedBound.left, rctWarpedBound.top);
  277. PixelC* ppxlcSptQY = (PixelC*) puciSptY -> pixels ();
  278. #ifdef _FOR_GSSP_
  279. PixelC* ppxlcSptQBY = (PixelC*) puciSptBY -> pixels ();
  280. #endif
  281. PixelC* ppxlcSptQA = (PixelC*) puciSptA -> pixels ();
  282.     Int sprite_left_edge = m_pvopcSptQ -> whereY ().left;
  283.     Int sprite_top_edge = m_pvopcSptQ -> whereY ().top;
  284. ppxlcSptQY = (PixelC*) puciSptY -> pixels (sprite_left_edge, sprite_top_edge);
  285. #ifdef _FOR_GSSP_
  286. ppxlcSptQBY = (PixelC*) puciSptBY -> pixels (sprite_left_edge, sprite_top_edge);
  287. #endif
  288. ppxlcSptQA = (PixelC*) puciSptA -> pixels (sprite_left_edge, sprite_top_edge);
  290. assert (m_pvopcCurrQ -> whereUV ().includes (rctWarpedBoundUV));
  291. const CU8Image* puciCurrU = m_pvopcCurrQ -> getPlane (U_PLANE);
  292. const CU8Image* puciCurrV = m_pvopcCurrQ -> getPlane (V_PLANE);
  293. #ifndef _FOR_GSSP_
  294. const CU8Image* puciCurrBY = m_pvopcCurrQ -> getPlane (BY_PLANE);
  295. #endif
  296. const CU8Image* puciSptU = m_pvopcSptQ -> getPlane (U_PLANE);
  297. const CU8Image* puciSptV = m_pvopcSptQ -> getPlane (V_PLANE);
  298. const UInt offsetUV = m_pvopcCurrQ -> whereUV ().width - rctWarpedBoundUV.width;
  299. const UInt offsetBY = 2 * (m_pvopcCurrQ -> whereY ().width -  rctWarpedBoundUV.width);
  300. PixelC* ppxlcCurrQU = (PixelC*) puciCurrU -> pixels ();
  301. PixelC* ppxlcCurrQV = (PixelC*) puciCurrV -> pixels ();
  302. PixelC pxlcVal = 128;
  303. // not sure if this is needed swinder
  304. if(m_volmd.nBits>8)
  305. pxlcVal = 1<<(m_volmd.nBits - 1);
  306. memset (ppxlcCurrQU, pxlcVal, puciCurrU -> where ().area () * sizeof(PixelC));
  307. memset (ppxlcCurrQV, pxlcVal, puciCurrV -> where ().area () * sizeof(PixelC));
  308. ppxlcCurrQU = (PixelC*) puciCurrU -> pixels (rctWarpedBoundUV.left, rctWarpedBoundUV.top);
  309. ppxlcCurrQV = (PixelC*) puciCurrV -> pixels (rctWarpedBoundUV.left, rctWarpedBoundUV.top);
  310. PixelC* ppxlcSptQU = (PixelC*) puciSptU -> pixels ();
  311. PixelC* ppxlcSptQV = (PixelC*) puciSptV -> pixels ();
  312. ppxlcSptQU = (PixelC*) puciSptU -> pixels (sprite_left_edge/2, sprite_top_edge/2);
  313. ppxlcSptQV = (PixelC*) puciSptV -> pixels (sprite_left_edge/2, sprite_top_edge/2);
  315. UInt accuracy1 = accuracy + 1;
  316.     UInt uiScale = 1 << accuracy1;
  317.     Int a = 0, b = 0, c, d = 0, e = 0, f;
  318.     Int cyy = 0, cxy = 0, dnm_pwr = 0; //wchen: get rid of unreferenced local variable cxx and cyx
  320.     Int width = rctWarpedBound.right - rctWarpedBound.left;
  321.     Int height = rctWarpedBound.bottom - rctWarpedBound.top;
  322.     Int W, H, VW, VH = 0, VWH = 0, vh_pwr, vw_pwr, vwh_pwr = 0;
  324.     Int r_pwr = 3 - accuracy;
  325.     Int r = 1 << r_pwr;
  327.     Int x0p =  (Int)(m_rgstDstQ [0].x * uiScale * r);
  328.     Int y0p =  (Int)(m_rgstDstQ [0].y * uiScale * r);
  329.     Int x1p =  (Int)(m_rgstDstQ [1].x * uiScale * r);
  330.     Int y1p =  (Int)(m_rgstDstQ [1].y * uiScale * r);
  332.     W = width;
  333.     VW = 1;
  334.     vw_pwr = 0;
  335.     while (VW < W) {
  336.         VW <<= 1;
  337.         vw_pwr++;
  338.     }
  339.     Int ex2p = 0, ey2p = 0;
  340.     Int x0 = 0;
  341.     Int y0 = 0;
  342.     Int x1 = W;
  343.     Int y1 = 0;
  344.     Int ex1p = LinearExtrapolation(x0, x1, x0p, x1p, W, VW) + ((x0+VW)<<4);
  345.     Int ey1p = LinearExtrapolation(y0, y1, y0p, y1p, W, VW) + (y0<<4);
  347.     if (pntNum==3) {
  348.          Int x2p =  (Int)(m_rgstDstQ [2].x * uiScale * r);
  349.          Int y2p =  (Int)(m_rgstDstQ [2].y * uiScale * r);
  351.          H = height;
  352.          VH = 1;
  353.          vh_pwr = 0;
  354.          while (VH < H) {
  355.              VH <<= 1;
  356.              vh_pwr++;
  357.          }
  358.          VWH = VW * VH;
  359.          vwh_pwr = vw_pwr + vh_pwr;
  360.          Int x2 = 0;
  361.          Int y2 = H;
  362.          ex2p = LinearExtrapolation(x0, x2, x0p, x2p, H, VH) + (x0<<4);
  363.          ey2p = LinearExtrapolation(y0, y2, y0p, y2p, H, VH) + ((y0+VH)<<4);
  364.          if (vw_pwr<=vh_pwr) {
  365.             VH /= VW;
  366.             VWH /= VW;
  367.             VW=1;
  368.             vh_pwr -= vw_pwr;
  369.             vwh_pwr -= vw_pwr;
  370.             vw_pwr=0;
  371.          }
  372.          else {
  373.             VW /= VH;
  374.             VWH /= VH;
  375.             VH=1;
  376.             vw_pwr -= vh_pwr;
  377.             vwh_pwr -= vh_pwr;
  378.             vh_pwr=0;
  379.          }
  380.          ex2p -= (sprite_left_edge * 16);
  381.          ey2p -= (sprite_top_edge * 16);
  382.      }
  384.      x0p -= (sprite_left_edge * 16);
  385.      y0p -= (sprite_top_edge * 16);
  386.      ex1p -= (sprite_left_edge * 16);
  387.      ey1p -= (sprite_top_edge * 16);
  389.      if (pntNum == 2) {
  390.         a = ex1p - x0p ;
  391.         b = y0p - ey1p ;
  392.         c = x0p * VW;
  393.         d = -b ;
  394.         e = a ;
  395.         f = y0p * VW;
  396.         dnm_pwr = r_pwr + vw_pwr;
  397.         cxy = c + r*VW/2;
  398.         cyy = f + r*VW/2;
  399.      } 
  400.  else if (pntNum == 3) {
  401. a = (ex1p - x0p) * VH;
  402. b = (ex2p - x0p) * VW;
  403. c = x0p * VWH;
  404. d = (ey1p - y0p) * VH;
  405. e = (ey2p - y0p) * VW;
  406. f = y0p * VWH;
  407. dnm_pwr = r_pwr + vwh_pwr;
  408. cxy = c + r*VWH/2;
  409. cyy = f + r*VWH/2;
  410.      }
  412.      Int sprite_width = m_pvopcSptQ -> whereY ().width;
  413.      Int sprite_height = m_pvopcSptQ -> whereY ().bottom
  414.                        - m_pvopcSptQ -> whereY ().top;
  416.      sprite_left_edge *= (1 << accuracy1);
  417.      sprite_top_edge *= (1 << accuracy1);
  419.      Int cxx_i, cxx_f, cyx_i, cyx_f, cxy_i, cxy_f, cyy_i, cyy_f;
  420.      Int a_i, a_f, b_i, b_f, d_i, d_f, e_i, e_f;
  421.      FourSlashes(cxy, 1<<dnm_pwr, &cxy_i, &cxy_f);
  422.      FourSlashes(cyy, 1<<dnm_pwr, &cyy_i, &cyy_f);
  423.      FourSlashes(a, 1<<dnm_pwr, &a_i, &a_f);
  424.      FourSlashes(b, 1<<dnm_pwr, &b_i, &b_f);
  425.      FourSlashes(d, 1<<dnm_pwr, &d_i, &d_f);
  426.      FourSlashes(e, 1<<dnm_pwr, &e_i, &e_f);
  427.      Int fracmask = (1 << dnm_pwr) - 1;
  429.      Int y,x;
  430.      UInt accuracy2 = accuracy1 << 1;
  431. #ifdef _FOR_GSSP_
  432.      PixelC pxlcWarpedBY;
  433. #else
  434.      PixelC pxlcWarpedA;
  435. #endif
  436.      Int rx,ry;
  437.      Int addr_offset;
  438.      Int warpmask = uiScale -1;
  439.      Int bias = 1<<(accuracy2-1);
  440.  for (y = 0; y < height; 
  441.           cxy_i += b_i, cxy_f += b_f, cyy_i += e_i, cyy_f += e_f, y++) {
  442. cxy_i += cxy_f >> dnm_pwr;
  443. cyy_i += cyy_f >> dnm_pwr;
  444. cxy_f &= fracmask;
  445. cyy_f &= fracmask;
  446. for (x = 0, cxx_i = cxy_i, cxx_f = cxy_f, 
  447. cyx_i = cyy_i, cyx_f = cyy_f;
  448. x < width; cxx_i += a_i, cxx_f += a_f, 
  449. cyx_i += d_i, cyx_f += d_f, x++) {
  450. cxx_i += cxx_f >> dnm_pwr;
  451. cyx_i += cyx_f >> dnm_pwr;
  452. cxx_f &= fracmask;
  453. cyx_f &= fracmask;
  454.             if (cxx_i >= EXPANDY_REFVOP && cyx_i >= EXPANDY_REFVOP 
  455.   && cxx_i <= ((sprite_width-1-EXPANDY_REFVOP)<<accuracy1)
  456.   && cyx_i <= ((sprite_height-1-EXPANDY_REFVOP)<<accuracy1)) {
  457. addr_offset = (cyx_i>>accuracy1) * sprite_width + (cxx_i>>accuracy1);
  458. rx = cxx_i & warpmask;
  459. ry = cyx_i & warpmask;
  460. #ifdef _FOR_GSSP_
  461. pxlcWarpedBY = CInterpolatePixelValue ( ppxlcSptQBY, 
  462. #else
  463. pxlcWarpedA = CInterpolatePixelValue ( ppxlcSptQA, 
  464. #endif
  465. addr_offset,sprite_width, rx, ry,
  466. uiScale, bias, accuracy2);
  467. #ifdef _FOR_GSSP_
  468.            if (pxlcWarpedBY >= 128) {
  469.   *ppxlcCurrQBY = MPEG4_OPAQUE;
  470. #else
  471.            if (pxlcWarpedA >= 128) {
  472.   *ppxlcCurrQA = MPEG4_OPAQUE;
  473. #endif
  474.                     *ppxlcCurrQY = CInterpolatePixelValue ( ppxlcSptQY, 
  475. addr_offset, sprite_width, rx, ry,
  476. uiScale, bias, accuracy2);
  477. #ifdef _FOR_GSSP_
  478.                         if(m_pvopcSptQ -> fAUsage () == EIGHT_BIT)
  479.                      *ppxlcCurrQA = CInterpolatePixelValue ( ppxlcSptQA, 
  480. addr_offset, sprite_width, rx, ry,
  481. uiScale, bias, accuracy2);
  482. #endif
  483. }
  484.     }
  485. ppxlcCurrQY++;
  486. #ifdef _FOR_GSSP_
  487. ppxlcCurrQBY++;
  488. #endif
  489. ppxlcCurrQA++;
  490. }
  491. ppxlcCurrQY += offset;
  492. #ifdef _FOR_GSSP_
  493. ppxlcCurrQBY += offset;
  494. #endif
  495. ppxlcCurrQA += offset;
  496.  }
  498. #ifdef _FOR_GSSP_
  499. ppxlcCurrQBY = (PixelC*) puciCurrBY -> pixels (rctWarpedBound.left, rctWarpedBound.top);
  500. PixelC* ppxlcCurrQBYNextRow = ppxlcCurrQBY + puciCurrBY -> where ().width;
  501. #else
  502. ppxlcCurrQA = (PixelC*) puciCurrA -> pixels (rctWarpedBound.left, rctWarpedBound.top);
  503. PixelC* ppxlcCurrQANextRow = ppxlcCurrQA + puciCurrA -> where ().width;
  504. #endif
  505. sprite_left_edge /= 2;
  506. sprite_top_edge /= 2;
  507. width /= 2;
  508. height /= 2;
  509. sprite_width /= 2;
  510. sprite_height /= 2;
  511. if (pntNum == 2) {
  512. c = 2 * x0p * VW - 16*VW ;
  513. f = 2 * y0p * VW - 16*VW ;
  514. cxy = a + b + c + 2*r*VW;
  515. cyy = d + e + f + 2*r*VW;
  516. } 
  517. else if (pntNum == 3) {
  518. c = 2 * x0p * VWH - 16*VWH ;
  519. f = 2 * y0p * VWH - 16*VWH ;
  520. cxy = a + b + c + 2*VWH*r;
  521. cyy = d + e + f + 2*VWH*r;
  522. }
  523. a_f *= 4;
  524. b_f *= 4;
  525. d_f *= 4;
  526. e_f *= 4;
  527. dnm_pwr += 2;
  529. FourSlashes(cxy, 1<<dnm_pwr, &cxy_i, &cxy_f);
  530. FourSlashes(cyy, 1<<dnm_pwr, &cyy_i, &cyy_f);
  531. fracmask = (1 << dnm_pwr) - 1;
  533. for (y = 0; y < height; 
  534. cxy_i+=b_i, cxy_f+=b_f, cyy_i+=e_i, cyy_f+=e_f, y++) {
  535. cxy_i += cxy_f >> dnm_pwr;
  536. cyy_i += cyy_f >> dnm_pwr;
  537. cxy_f &= fracmask;
  538. cyy_f &= fracmask;
  539. for (x = 0, cxx_i = cxy_i, cxx_f = cxy_f, 
  540.                     cyx_i = cyy_i, cyx_f = cyy_f;
  541.                     x < width; cxx_i += a_i, cxx_f += a_f, 
  542.                     cyx_i += d_i, cyx_f += d_f, x++) {
  543. cxx_i += cxx_f >> dnm_pwr;
  544. cyx_i += cyx_f >> dnm_pwr;
  545. cxx_f &= fracmask;
  546. cyx_f &= fracmask;
  547. if ( cxx_i >= EXPANDUV_REFVOP && cyx_i >= EXPANDUV_REFVOP 
  548.   && cxx_i <= ((sprite_width-1-EXPANDUV_REFVOP)<<accuracy1)
  549.   && cyx_i <= ((sprite_height-1-EXPANDUV_REFVOP)<<accuracy1)) {
  550. addr_offset = (cyx_i>>accuracy1) * sprite_width + (cxx_i>>accuracy1);
  551. rx = cxx_i & warpmask;
  552. ry = cyx_i & warpmask;
  553. #ifdef _FOR_GSSP_
  554. if (*ppxlcCurrQBY | *(ppxlcCurrQBY + 1) | *ppxlcCurrQBYNextRow | *(ppxlcCurrQBYNextRow+1)) {
  555. #else
  556. if (*ppxlcCurrQA | *(ppxlcCurrQA + 1) | *ppxlcCurrQANextRow | *(ppxlcCurrQANextRow+1)) {
  557. #endif
  558. *ppxlcCurrQU = CInterpolatePixelValue ( ppxlcSptQU, addr_offset,
  559. sprite_width, rx, ry, uiScale, 
  560. bias, accuracy2); 
  561. *ppxlcCurrQV = CInterpolatePixelValue ( ppxlcSptQV, addr_offset,
  562. sprite_width, rx, ry, uiScale, 
  563. bias, accuracy2); 
  564. }
  565.     }
  566. #ifdef _FOR_GSSP_
  567. ppxlcCurrQBY += 2;
  568. ppxlcCurrQBYNextRow += 2;
  569. #else
  570. ppxlcCurrQA += 2;
  571. ppxlcCurrQANextRow += 2;
  572. #endif
  573. ppxlcCurrQU++;
  574. ppxlcCurrQV++;
  575. }
  576. #ifdef _FOR_GSSP_
  577. ppxlcCurrQBY += offsetBY;
  578. ppxlcCurrQBYNextRow += offsetBY;
  579. #else
  580. ppxlcCurrQA += offsetBY;
  581. ppxlcCurrQANextRow += offsetBY;
  582. #endif
  583. ppxlcCurrQU += offsetUV;
  584. ppxlcCurrQV += offsetUV;
  585. }
  586. }
  588. PixelC CVideoObject:: CInterpolatePixelValue(PixelC* F, Int pos, Int width,
  589.                            Int rx, Int ry, Int wpc, Int bias, Int pow_denom)
  590. {
  591. PixelC* Fp;
  592. Int rxc, ryc;
  593. Int hstep, vstep;
  595. Fp = F + pos;
  596. rxc = wpc - rx;
  597. ryc = wpc - ry;
  598. hstep = rx ? 1 : 0;
  599. vstep = ry ? width : 0;
  601. return ((PixelC) (((ryc * (rxc * *Fp + rx * *(Fp+hstep))
  602.             + ry * (rxc * *(Fp+vstep) + rx * *(Fp+vstep+hstep))) + bias)
  603.             >> pow_denom));
  604. }
  606. Int CVideoObject:: LinearExtrapolation(Int x0, Int x1, Int x0p, Int x1p, Int W, Int VW)
  607. {
  608. Int quot, res, ressum, extrapolated;
  610. FourSlashes(x0p - (x0 << 4), W, &quot, &res);
  611. extrapolated = quot * (W - VW);
  613. FourSlashes(res * (W - VW), W, &quot, &res);
  614. extrapolated += quot;
  615. ressum = res;
  617. FourSlashes(x1p - (x1 << 4), W, &quot, &res);
  618. extrapolated += quot * VW + res;
  620. FourSlashes(res * (VW - W), W, &quot, &res);
  621. extrapolated += quot;
  622. ressum += res;
  624. FourSlashes(ressum, W, &quot, &res);
  625. extrapolated += quot;
  627. if(extrapolated >= 0) {
  628. if(res >= (W+1) / 2)
  629. extrapolated++;
  630. } 
  631. else
  632. if(res > W / 2)
  633. extrapolated++;
  635. return(extrapolated);
  636. }
  638. Void CVideoObject::FourSlashes(Int num, Int denom, Int *quot, Int *res)
  639. {
  640. *quot =  num / denom;
  641. if (*quot * denom == num)
  642. *res = 0;
  643. else 
  644. {
  645. if (num < 0) /* denom is larger than zero */
  646. *quot -= 1;
  647. *res = num - denom * *quot;
  648. }
  649. }
  651. Void CVideoObject::swapRefQ1toSpt ()
  652. {
  653. m_pvopcSptQ = m_pvopcRefQ1;
  654. m_pvopcSptQ -> shift (m_rctSpt.left, m_rctSpt.top); 
  655. #ifdef _FOR_GSSP_
  656. if(m_pvopcSptQ -> fAUsage () == EIGHT_BIT){
  657. CU8Image* puciSptBY = (CU8Image *) m_pvopcSptQ -> getPlane (BY_PLANE);
  658. puciSptBY -> shift (m_rctSpt.left, m_rctSpt.top);
  659. }
  660. #endif
  661. m_pvopcRefQ1 = NULL;
  662. }
  664. Void CVideoObject::changeSizeofCurrQ (CRct rctOrg)
  665. {
  666. delete m_pvopcCurrQ;
  667. rctOrg.expand (EXPANDY_REF_FRAME);
  668. m_pvopcCurrQ = new CVOPU8YUVBA (m_pvopcSptQ -> fAUsage (), rctOrg);
  669. }
  670.  
  671. Bool CVideoObject::SptPieceMB_NOT_HOLE(Int iMBXoffset, Int iMBYoffset, CMBMode* pmbmd) 
  672. //   In a given Sprite object piece, Check whether current macroblock is not a hole and should be coded ?
  673. {
  674. if (m_tPiece < 0)
  675. return TRUE;
  676. else 
  677. {
  678. CMBMode* pmbmdLeft = pmbmd - 1;
  679. Int iMBX =  iMBXoffset + m_iPieceXoffset;
  680. Int iMBY =  iMBYoffset + m_iPieceYoffset;
  681. Int iMBX1 = iMBX -1;
  683. // dshu: [v071] begin of modification
  684. Int iMod = m_rctSpt.width % MB_SIZE;
  685. Int iSptWidth = (iMod > 0) ? m_rctSpt.width + MB_SIZE - iMod : m_rctSpt.width;
  686. Int iNumMBX = iSptWidth / MB_SIZE;   
  687. // dshu: [v071] end of modification
  689. IntraPredDirection* Spreddir = m_rgmbmdSpt[iMBY][iMBX1].m_preddir;
  690. IntraPredDirection* preddir = (*pmbmdLeft).m_preddir;
  691. if (iMBXoffset >0 ) 
  692. if( m_ppPieceMBstatus[iMBY][iMBX1] == NOT_DONE)
  693. {
  694. m_ppPieceMBstatus[iMBY][iMBX1] = PIECE_DONE;
  695. m_rgmbmdSpt[iMBY][iMBX1] = CMBMode (*pmbmdLeft);
  696. m_rgmbmdSprite[iMBX1 + iNumMBX * iMBY] = CMBMode (*pmbmdLeft);  // dshu: [v071]  added to store mbmd array for sprite
  697. memcpy (Spreddir, preddir, 10  * sizeof (IntraPredDirection));
  698. }
  699. else {
  700. *pmbmdLeft = CMBMode (m_rgmbmdSpt[iMBY][iMBX1]);
  701. memcpy (preddir, Spreddir, 10  * sizeof (IntraPredDirection));
  702. }
  703. // dshu: begin of modification
  704. if ( iMBX < (m_rctSptQ.width / MB_SIZE))   
  705. // dshu: end of modification
  707. // if ( iMBX < (m_rctSptExp.width / MB_SIZE))
  708. return ( m_ppPieceMBstatus[iMBY][iMBX] == NOT_DONE) ;
  709. }
  710. return FALSE;
  711. }
  712.  
  713. Bool CVideoObject::SptUpdateMB_NOT_HOLE(Int iMBXoffset, Int iMBYoffset, CMBMode* pmbmd)
  714. //   In a given Sprite update piece, Check whether current macroblock is not a hole and should be coded ?
  715. {
  717. Int iMBX =  iMBXoffset + m_iPieceXoffset;
  718. Int iMBY =  iMBYoffset + m_iPieceYoffset;
  720. Int iMBX1 = iMBX -1;
  721. if ( (iMBXoffset >0 ) && ( m_ppUpdateMBstatus[iMBY][iMBX1] == NOT_DONE))
  722. m_ppUpdateMBstatus[iMBY][iMBX1] = UPDATE_DONE;
  723. *pmbmd = CMBMode (m_rgmbmdSpt[iMBY][iMBX]);
  724. return ( m_ppUpdateMBstatus[iMBY][iMBX] == NOT_DONE) ;
  725. } 
  727. Void CVideoObject::SaveMBmCurrRow (Int iMBYoffset, MacroBlockMemory** rgpmbmCurr)
  728. {
  729. Int iMBX;
  730. Int iMBY =  iMBYoffset + m_iPieceYoffset;
  731. Int iMB, iBlk;
  732. Int nBlk = (m_volmd.fAUsage == EIGHT_BIT) ? 10 : 6;
  733. Int *Dest;
  734. Int *Src;
  736.   for (iMB = 0; iMB < m_iNumMBX; iMB++) {
  737. iMBX = iMB + m_iPieceXoffset;
  738. for (iBlk = 0; iBlk < nBlk; iBlk++) {
  739. Dest = (m_rgpmbmCurr_Spt[iMBY][iMBX]->rgblkm) [iBlk];
  740. Src = (rgpmbmCurr[iMB]->rgblkm) [iBlk];
  741. memcpy (Dest, Src, ((BLOCK_SIZE << 1) - 1)  * sizeof (Int));
  742. }
  743. }
  744. }
  746.  Void CVideoObject::RestoreMBmCurrRow (Int iMBYoffset, MacroBlockMemory** rgpmbmCurr)
  747. {
  748. Int iMBX;
  749. Int iMBY =  iMBYoffset + m_iPieceYoffset;
  750. Int iMB, iBlk;
  751. Int nBlk = (m_volmd.fAUsage == EIGHT_BIT) ? 10 : 6;
  752. Int *Dest, *Src;
  754.   for (iMB = 0; iMB < m_iNumMBX; iMB++) {
  755. iMBX = iMB + m_iPieceXoffset;
  756. for (iBlk = 0; iBlk < nBlk; iBlk++) {
  757. Src = (m_rgpmbmCurr_Spt[iMBY][iMBX]->rgblkm) [iBlk];
  758. Dest = (rgpmbmCurr[iMB]->rgblkm) [iBlk];
  759. memcpy (Dest, Src, ((BLOCK_SIZE << 1) - 1)  * sizeof (Int));
  760. }
  761. }
  762. }
  764. Void CVideoObject::CopyCurrQToPred (
  765. PixelC* ppxlcQMBY, 
  766. PixelC* ppxlcQMBU, 
  767. PixelC* ppxlcQMBV
  768. )
  769. {
  770. CoordI ix, iy, ic = 0;
  771. for (iy = 0; iy < MB_SIZE; iy++) {
  772. for (ix = 0; ix < MB_SIZE; ix++, ic++) {
  773. m_ppxlcPredMBY [ic] = ppxlcQMBY [ix] ;
  774. }   
  775. ppxlcQMBY += m_iFrameWidthY;
  776. }
  778. ic = 0;
  779. for (iy = 0; iy < BLOCK_SIZE; iy++) {
  780. for (ix = 0; ix < BLOCK_SIZE; ix++, ic++) {
  781. m_ppxlcPredMBU [ic] =  ppxlcQMBU [ix];
  782. m_ppxlcPredMBV [ic] =  ppxlcQMBV [ix];
  783. }
  784. ppxlcQMBU += m_iFrameWidthUV;
  785. ppxlcQMBV += m_iFrameWidthUV;
  786. }
  787. }
  789. //low latency sprite stuff
  790. Void CVideoObject::VOPOverlay (CVOPU8YUVBA& pvopc1, CVOPU8YUVBA& pvopc2, Int iscale)
  791. {
  792. float fscaleY = (float) ((iscale == 0) ? 0.0 : 1.0);   //  check whether there is a EXPANDY_REF_FRAME
  793. float fscaleUV = (float) ((iscale == 0) ? 0.0 : 0.5);
  794. CU8Image* uci1 = const_cast<CU8Image*> (pvopc1.getPlane (Y_PLANE)); 
  795. CU8Image* uci2 = const_cast<CU8Image*> (pvopc2.getPlane (Y_PLANE));
  796. Overlay (*uci1, *uci2, fscaleY) ; 
  797. uci1 = const_cast<CU8Image*> (pvopc1.getPlane (U_PLANE)); 
  798. uci2 = const_cast<CU8Image*> (pvopc2.getPlane (U_PLANE));
  799. Overlay (*uci1, *uci2, fscaleUV) ; 
  800. uci1 = const_cast<CU8Image*> (pvopc1.getPlane (V_PLANE)); 
  801. uci2 = const_cast<CU8Image*> (pvopc2.getPlane (V_PLANE));
  802. Overlay (*uci1, *uci2, fscaleUV) ; 
  804. if (m_volmd.fAUsage != RECTANGLE) {
  805. uci1 = const_cast<CU8Image*> (pvopc1.getPlane (BY_PLANE)); 
  806. uci2 = const_cast<CU8Image*> (pvopc2.getPlane (BY_PLANE));
  807. Overlay (*uci1, *uci2, fscaleY) ; 
  809. uci1 = const_cast<CU8Image*> (pvopc1.getPlane (BUV_PLANE)); 
  810. uci2 = const_cast<CU8Image*> (pvopc2.getPlane (BUV_PLANE));
  811. Overlay (*uci1, *uci2, fscaleUV) ;
  813. if (m_volmd.fAUsage == EIGHT_BIT) { 
  814. uci1 = const_cast<CU8Image*> (pvopc1.getPlane (A_PLANE)); 
  815. uci2 = const_cast<CU8Image*> (pvopc2.getPlane (A_PLANE));
  816. Overlay (*uci1, *uci2, fscaleY) ; 
  817. }
  819. }
  820. }
  822. Void CVideoObject::Overlay (CU8Image& uci1, CU8Image& uci2, float fscale)
  823. {
  824. CRct r1 = uci1.where ();
  825. CRct r2 = uci2.where (); 
  826. CoordI x = r1.left + (CoordI) (EXPANDY_REF_FRAME * fscale); // copy pixels, skip the guard band
  827. CoordI y = r1.top + (CoordI) (EXPANDY_REF_FRAME * fscale);
  828. Int cbLine = (r1.width- 2 * (Int) (EXPANDY_REF_FRAME * fscale)) * sizeof (PixelC);
  829. PixelC* ppxl = (PixelC*) uci2.pixels (x, y);
  830. const PixelC* ppxlFi = uci1.pixels (x, y);
  831. Int widthCurr = r2.width;
  832. Int widthFi = r1.width;
  833. for (CoordI yi = y; yi < (r1.bottom - EXPANDY_REF_FRAME * fscale); yi++) {
  834. memcpy (ppxl, ppxlFi, cbLine);
  835. ppxl += widthCurr;
  836. ppxlFi += widthFi;
  837. }
  838. }
  840. // dshu: begin of modification
  841. // get from  pvopc2 at (rctPieceY.left,rctPieceY.right)
  842. Void CVideoObject::PieceGet (CVOPU8YUVBA& pvopc1, CVOPU8YUVBA& pvopc2, CRct rctPieceY)
  843. {
  844. CRct rctPieceUV = rctPieceY.downSampleBy2 ();
  845. CU8Image* uci1 = const_cast<CU8Image*> (pvopc1.getPlane (Y_PLANE)); 
  846. CU8Image* uci2 = const_cast<CU8Image*> (pvopc2.getPlane (Y_PLANE));
  847. U8iGet(*uci1, *uci2, rctPieceY) ; 
  848. uci1 = const_cast<CU8Image*> (pvopc1.getPlane (U_PLANE)); 
  849. uci2 = const_cast<CU8Image*> (pvopc2.getPlane (U_PLANE));
  850. U8iGet(*uci1, *uci2, rctPieceUV) ; 
  851. uci1 = const_cast<CU8Image*> (pvopc1.getPlane (V_PLANE)); 
  852. uci2 = const_cast<CU8Image*> (pvopc2.getPlane (V_PLANE));
  853. U8iGet(*uci1, *uci2, rctPieceUV) ; 
  855. if (m_volmd.fAUsage != RECTANGLE) {
  856. uci1 = const_cast<CU8Image*> (pvopc1.getPlane (BY_PLANE)); 
  857. uci2 = const_cast<CU8Image*> (pvopc2.getPlane (BY_PLANE));
  858. U8iGet(*uci1, *uci2, rctPieceY) ; 
  860. uci1 = const_cast<CU8Image*> (pvopc1.getPlane (BUV_PLANE)); 
  861. uci2 = const_cast<CU8Image*> (pvopc2.getPlane (BUV_PLANE));
  862. U8iGet(*uci1, *uci2, rctPieceUV) ;
  864. if (m_volmd.fAUsage == EIGHT_BIT) { 
  865. uci1 = const_cast<CU8Image*> (pvopc1.getPlane (A_PLANE)); 
  866. uci2 = const_cast<CU8Image*> (pvopc2.getPlane (A_PLANE));
  867. U8iGet(*uci1, *uci2, rctPieceY) ; 
  868. }
  869. }
  870. }
  871.  
  872. Void CVideoObject::U8iGet(CU8Image& uci1, CU8Image& uci2, CRct rctPiece)
  873. {
  874. CRct r1 = uci1.where ();
  875. CRct r2 = uci2.where (); 
  876. CoordI x = rctPiece.left ; 
  877. CoordI y = rctPiece.top ;
  878. Int cbLine = (rctPiece.width) * sizeof (PixelC);
  879. PixelC* ppxl = (PixelC*) uci1.pixels (0, 0);
  880. const PixelC* ppxlFi = uci2.pixels (x, y);
  881. Int widthCurr = r2.width;
  882. Int widthFi = r1.width;
  883. for (CoordI yi = y; yi < rctPiece.bottom; yi++) {
  884. memcpy (ppxl, ppxlFi, cbLine);
  885. ppxl += widthCurr;
  886. ppxlFi += widthFi;
  887. }
  888. }
  890. //  put into pvopc2 at (rctPieceY.left,rctPieceY.right)
  891. Void CVideoObject::PiecePut (CVOPU8YUVBA& pvopc1, CVOPU8YUVBA& pvopc2, CRct rctPieceY)
  892. {
  893. CRct rctPieceUV = rctPieceY.downSampleBy2 ();
  894. CU8Image* uci1 = const_cast<CU8Image*> (pvopc1.getPlane (Y_PLANE)); 
  895. CU8Image* uci2 = const_cast<CU8Image*> (pvopc2.getPlane (Y_PLANE));
  896. U8iPut(*uci1, *uci2, rctPieceY) ; 
  897. uci1 = const_cast<CU8Image*> (pvopc1.getPlane (U_PLANE)); 
  898. uci2 = const_cast<CU8Image*> (pvopc2.getPlane (U_PLANE));
  899. U8iPut(*uci1, *uci2, rctPieceUV) ; 
  900. uci1 = const_cast<CU8Image*> (pvopc1.getPlane (V_PLANE)); 
  901. uci2 = const_cast<CU8Image*> (pvopc2.getPlane (V_PLANE));
  902. U8iPut(*uci1, *uci2, rctPieceUV) ; 
  904. if (m_volmd.fAUsage != RECTANGLE) {
  905. uci1 = const_cast<CU8Image*> (pvopc1.getPlane (BY_PLANE)); 
  906. uci2 = const_cast<CU8Image*> (pvopc2.getPlane (BY_PLANE));
  907. U8iPut(*uci1, *uci2, rctPieceY) ; 
  909. uci1 = const_cast<CU8Image*> (pvopc1.getPlane (BUV_PLANE)); 
  910. uci2 = const_cast<CU8Image*> (pvopc2.getPlane (BUV_PLANE));
  911. U8iPut(*uci1, *uci2, rctPieceUV) ;
  913. if (m_volmd.fAUsage == EIGHT_BIT) { 
  914. uci1 = const_cast<CU8Image*> (pvopc1.getPlane (A_PLANE)); 
  915. uci2 = const_cast<CU8Image*> (pvopc2.getPlane (A_PLANE));
  916. U8iPut(*uci1, *uci2, rctPieceY) ; 
  917. }
  918. }
  919. }
  920.  
  921. Void CVideoObject::U8iPut(CU8Image& uci1, CU8Image& uci2, CRct rctPiece)
  922. {
  923. CRct r1 = uci1.where ();
  924. CRct r2 = uci2.where (); 
  925. CoordI x = rctPiece.left ; 
  926. CoordI y = rctPiece.top ;
  927. Int cbLine = (rctPiece.width) * sizeof (PixelC);
  928. PixelC* ppxl = (PixelC*) uci2.pixels (x, y);
  929. const PixelC* ppxlFi = uci1.pixels (0, 0);
  930. Int widthCurr = r2.width;
  931. Int widthFi = r1.width;
  932. for (CoordI yi = y; yi < rctPiece.bottom; yi++) {
  933. memcpy (ppxl, ppxlFi, cbLine);
  934. ppxl += widthCurr;
  935. ppxlFi += widthFi;
  936. }
  937. }
  938.  
  939. // dshu: end of modification
  941. // dshu: [v071]  Begin of modification
  942.  
  943. Void CVideoObject::padSprite()
  944. {
  945. m_iNumMBX = m_rctSptQ.width / MB_SIZE; 
  946. m_iNumMBY = m_rctSptQ.height () / MB_SIZE;
  947. Int iMBXleft, iMBXright; 
  948. Int iMBYup, iMBYdown;
  949. CMBMode* pmbmd = m_rgmbmdSprite;
  950. PixelC* ppxlcRefY  = (PixelC*) m_pvopcSptQ->pixelsY () + m_iStartInRefToCurrRctY;
  951. PixelC* ppxlcRefU  = (PixelC*) m_pvopcSptQ->pixelsU () + m_iStartInRefToCurrRctUV;
  952. PixelC* ppxlcRefV  = (PixelC*) m_pvopcSptQ->pixelsV () + m_iStartInRefToCurrRctUV;
  953. PixelC* ppxlcRefBY = (PixelC*) m_pvopcSptQ->pixelsBY () + m_iStartInRefToCurrRctY;
  954. PixelC* ppxlcRefA  = (PixelC*) m_pvopcSptQ->pixelsA () + m_iStartInRefToCurrRctY;
  955. PixelC* ppxlcRefBUV = (PixelC*) m_pvopcSptQ->pixelsBUV () + m_iStartInRefToCurrRctUV;
  957. for (Int iMBY = 0; iMBY < m_iNumMBY; iMBY++){
  958. PixelC* ppxlcRefMBY  = ppxlcRefY;
  959. PixelC* ppxlcRefMBU  = ppxlcRefU;
  960. PixelC* ppxlcRefMBV  = ppxlcRefV;
  961. PixelC* ppxlcRefMBBY = ppxlcRefBY;
  962. PixelC* ppxlcRefMBBUV = ppxlcRefBUV;
  963. PixelC* ppxlcRefMBA  = ppxlcRefA;
  965. iMBYup = iMBY -1;
  966. iMBYdown = iMBY +1;
  967. for (Int iMBX = 0; iMBX < m_iNumMBX; iMBX++)
  968. {
  969. iMBXleft = iMBX -1 ; 
  970. iMBXright = iMBX +1 ;
  971. if((m_volmd.bShapeOnly==FALSE) && (m_ppPieceMBstatus[iMBY][iMBX] == PIECE_DONE))
  972. {
  973. pmbmd->m_bPadded=FALSE;
  974. copySptQShapeYToMb (m_ppxlcCurrMBBY, ppxlcRefMBBY);
  975. downSampleBY (m_ppxlcCurrMBBY, m_ppxlcCurrMBBUV); // downsample original BY now for LPE padding (using original shape)
  977. if (pmbmd->m_rgTranspStatus [0] != ALL)
  978. {
  979. // MC padding
  980. if (pmbmd -> m_rgTranspStatus [0] == PARTIAL)
  981. mcPadCurrMB (ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV,
  982. ppxlcRefMBA);
  983. padNeighborTranspMBs (
  984. iMBX, iMBY,
  985. pmbmd,
  986. ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV, ppxlcRefMBA
  987. );
  988. }
  989. else
  990. {
  991. if (iMBX > 0)
  992. {
  993. if ((pmbmd - 1)->m_rgTranspStatus [0] != ALL &&
  994. m_ppPieceMBstatus[iMBY][iMBX-1] == PIECE_DONE)
  995. {
  996.     mcPadCurrMBFromLeft (ppxlcRefMBY, ppxlcRefMBU,
  997.                          ppxlcRefMBV, ppxlcRefMBA);
  998. pmbmd->m_bPadded = TRUE;
  999. }
  1000. }
  1001. if (iMBY > 0)
  1002. {
  1003. if ((pmbmd - m_iNumMBX)->m_rgTranspStatus [0] != ALL &&
  1004. m_ppPieceMBstatus[iMBY-1][iMBX] == PIECE_DONE)
  1005. {
  1006. if (!(pmbmd->m_bPadded))
  1007. {
  1008. mcPadCurrMBFromTop (ppxlcRefMBY, ppxlcRefMBU,
  1009.    ppxlcRefMBV, ppxlcRefMBA);
  1010. pmbmd->m_bPadded = TRUE;
  1011. }
  1012. }
  1013. else if (!(pmbmd - m_iNumMBX)->m_bPadded)
  1014. mcSetTopMBGray (ppxlcRefMBY, ppxlcRefMBU,
  1015.    ppxlcRefMBV, ppxlcRefMBA);
  1016. }
  1017. if(iMBY == m_iNumMBY-1)
  1018. {
  1019. if(iMBX > 0 && (pmbmd-1)->m_rgTranspStatus [0] == ALL &&
  1020. !((pmbmd-1)->m_bPadded))
  1021. mcSetLeftMBGray(ppxlcRefMBY, ppxlcRefMBU,
  1022. ppxlcRefMBV, ppxlcRefMBA);
  1023. if(iMBX == m_iNumMBX-1 && !(pmbmd->m_bPadded))
  1024. mcSetCurrMBGray(ppxlcRefMBY, ppxlcRefMBU,
  1025. ppxlcRefMBV, ppxlcRefMBA);
  1026. }
  1027. }
  1028. }
  1029. ppxlcRefMBA += MB_SIZE;
  1030. ppxlcRefMBBY += MB_SIZE;
  1031. ppxlcRefMBBUV += BLOCK_SIZE;
  1032. pmbmd++;
  1033. ppxlcRefMBY += MB_SIZE;
  1034. ppxlcRefMBU += BLOCK_SIZE;
  1035. ppxlcRefMBV += BLOCK_SIZE;
  1036. }
  1037. ppxlcRefY += m_iFrameWidthYxMBSize;
  1038. ppxlcRefU += m_iFrameWidthUVxBlkSize;
  1039. ppxlcRefV += m_iFrameWidthUVxBlkSize;
  1040. ppxlcRefBY += m_iFrameWidthYxMBSize;
  1041. ppxlcRefA += m_iFrameWidthYxMBSize;
  1042. ppxlcRefBUV += m_iFrameWidthUVxBlkSize;
  1043. }
  1044. m_rctPrevNoExpandY = m_rctSptQ;
  1045. m_rctPrevNoExpandUV = m_rctPrevNoExpandY.downSampleBy2 ();
  1046. repeatPadYOrA ((PixelC*) m_pvopcSptQ->pixelsY () + m_iOffsetForPadY, m_pvopcSptQ);
  1047. repeatPadUV (m_pvopcSptQ);
  1049. //reset by in RefQ1 so that no left-over from last frame
  1050. if (m_volmd.fAUsage != RECTANGLE)       {
  1051. if (m_volmd.fAUsage == EIGHT_BIT)
  1052. repeatPadYOrA ((PixelC*) m_pvopcSptQ->pixelsA () + m_iOffsetForPadY, m_pvopcSptQ);
  1053. }
  1054. }
  1056. Void CVideoObject::copySptQShapeYToMb (
  1057. PixelC* ppxlcDstMB, const PixelC* ppxlcSrc)
  1058. {
  1059. for (Int i = 0; i < MB_SIZE; i++) {
  1060. memcpy (ppxlcDstMB, ppxlcSrc, MB_SIZE*sizeof(PixelC));
  1061. ppxlcSrc += m_iFrameWidthY;
  1062. ppxlcDstMB  += MB_SIZE;
  1063. }
  1064. }
  1066. // dshu: [v071] end of modification