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

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

流媒体/Mpeg4/MP4

开发平台：

Visual C++

yuvac.cpp：源码内容
  1. /*************************************************************************
  3. This software module was originally developed by 
  5. Ming-Chieh Lee (mingcl@microsoft.com), Microsoft Corporation
  6. Wei-ge Chen (wchen@microsoft.com), Microsoft Corporation
  7. Bruce Lin (blin@microsoft.com), Microsoft Corporation
  8. Chuang Gu (chuanggu@microsoft.com), Microsoft Corporation
  9. (date: March, 1996)
  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. yuva.hpp
  31. Abstract:
  33. YUVA (4:2:0) VOP 
  35. Revision History:
  37. *************************************************************************/
  39. #include "typeapi.h"
  41. #ifdef __MFC_
  42. #ifdef _DEBUG
  43. #undef THIS_FILE
  44. static char BASED_CODE THIS_FILE[] = __FILE__;
  45. #endif
  47. #define new DEBUG_NEW    
  48. #endif // __MFC_
  50. CVOPU8YUVBA::~CVOPU8YUVBA ()
  51. {
  52. delete m_puciY;
  53. delete m_puciU;
  54. delete m_puciV;
  55. delete m_puciBY;
  56. delete m_puciBUV;
  57. delete m_puciA;
  58. }
  60. Void CVOPU8YUVBA::constructFromVOPU8 (const CVOPU8YUVBA& vopf, const CRct& rc)
  61. {
  62. if (rc.valid ()) {
  63. m_rctY = rc;
  64. m_rctUV = m_rctY.downSampleBy2 ();
  65. m_puciY = new CU8Image (*vopf.getPlane (Y_PLANE), m_rctY);
  66. m_puciU = new CU8Image (*vopf.getPlane (U_PLANE), m_rctUV);
  67. m_puciV = new CU8Image (*vopf.getPlane (V_PLANE), m_rctUV);
  68. m_ppxlcY = (PixelC*) m_puciY->pixels ();
  69. m_ppxlcU = (PixelC*) m_puciU->pixels ();
  70. m_ppxlcV = (PixelC*) m_puciV->pixels ();
  71. if (m_fAUsage != RECTANGLE) {
  72. m_puciBY = new CU8Image (*vopf.getPlane (BY_PLANE), m_rctY);
  73. m_ppxlcBY = (PixelC*) m_puciBY->pixels ();
  74. m_puciBUV = new CU8Image (*vopf.getPlane (BUV_PLANE), m_rctUV);
  75. m_ppxlcBUV = (PixelC*) m_puciBUV->pixels ();
  76. assert (m_puciBY != NULL);
  77. assert (m_puciBUV != NULL);
  78. if (m_fAUsage == EIGHT_BIT) {
  79. m_puciA = new CU8Image (*vopf.getPlane (A_PLANE), m_rctY);
  80. assert (m_puciA != NULL);
  81. m_ppxlcA = (PixelC*) m_puciA->pixels ();
  82. }
  83. }
  84. }
  85. else {
  86. m_rctY = vopf.whereY ();
  87. m_rctUV = vopf.whereUV ();
  88. m_puciY = new CU8Image (*vopf.getPlane (Y_PLANE));
  89. m_puciU = new CU8Image (*vopf.getPlane (U_PLANE));
  90. m_puciV = new CU8Image (*vopf.getPlane (V_PLANE));
  91. m_ppxlcY = (PixelC*) m_puciY->pixels ();
  92. m_ppxlcU = (PixelC*) m_puciU->pixels ();
  93. m_ppxlcV = (PixelC*) m_puciV->pixels ();
  94. if (m_fAUsage != RECTANGLE) {
  95. m_puciBY = new CU8Image (*vopf.getPlane (BY_PLANE));
  96. m_ppxlcBY = (PixelC*) m_puciBY->pixels ();
  97. m_puciBUV = new CU8Image (*vopf.getPlane (BUV_PLANE));
  98. m_ppxlcBUV = (PixelC*) m_puciBUV->pixels ();
  99. assert (m_puciBY != NULL);
  100. assert (m_puciBUV != NULL);
  101. if (m_fAUsage == EIGHT_BIT) {
  102. m_puciA = new CU8Image (*vopf.getPlane (A_PLANE));
  103. assert (m_puciA != NULL);
  104. m_ppxlcA = (PixelC*) m_puciA->pixels ();
  105. }
  106. }
  107. }
  108. assert (m_puciY != NULL);
  109. assert (m_puciU != NULL);
  110. assert (m_puciV != NULL);
  111. }
  113. CVOPU8YUVBA::CVOPU8YUVBA (const CVOPU8YUVBA& vopf, AlphaUsage fAUsage, const CRct& rc)
  114. {
  115.   m_fAUsage = fAUsage;
  116.   m_puciY = NULL;
  117.   m_puciU = NULL; 
  118.   m_puciV  = NULL; 
  119.   m_puciBY  = NULL; 
  120.   m_puciBUV = NULL; 
  121.   m_puciA = NULL;
  123.   constructFromVOPU8 (vopf, rc);
  124. }
  127. CVOPU8YUVBA::CVOPU8YUVBA (const CVOPU8YUVBA& vopf, const CRct& rc) : 
  128. m_puciY (NULL), m_puciU (NULL), m_puciV (NULL), m_puciBY (NULL), m_puciBUV (NULL), m_puciA (NULL)
  129. {
  130. m_fAUsage = vopf.fAUsage ();
  131. constructFromVOPU8 (vopf, rc);
  132. }
  134. CVOPU8YUVBA::CVOPU8YUVBA (const Char* sptFilename) :
  135. m_puciY (NULL), m_puciU (NULL), m_puciV (NULL), m_puciBY (NULL), m_puciBUV (NULL), m_puciA (NULL)
  136. {
  137. FILE* pf = fopen (sptFilename, "rb");
  138. // read overhead
  139. Int c0 = getc (pf);
  140. Int c1 = getc (pf);
  141. Int c2 = getc (pf);
  142. assert (c0 == 'S' && (c1 == 'P' || c2 == 'T') );
  143. fread (&m_rctY.left, sizeof (CoordI), 1, pf);
  144. fread (&m_rctY.top, sizeof (CoordI), 1, pf);
  145. fread (&m_rctY.right, sizeof (CoordI), 1, pf);
  146. fread (&m_rctY.bottom, sizeof (CoordI), 1, pf);
  147. fread (&m_fAUsage, sizeof (Int), 1, pf);
  148. m_rctY.width = m_rctY.right - m_rctY.left;
  149. m_rctUV = m_rctY.downSampleBy2 ();
  150. m_puciY = new CU8Image (m_rctY);
  151. assert (m_puciY != NULL);
  152. m_puciU = new CU8Image (m_rctUV);
  153. assert (m_puciU != NULL);
  154. m_puciV = new CU8Image (m_rctUV);
  155. assert (m_puciV != NULL);
  156. m_ppxlcY = (PixelC*) m_puciY->pixels ();
  157. m_ppxlcU = (PixelC*) m_puciU->pixels ();
  158. m_ppxlcV = (PixelC*) m_puciV->pixels ();
  159. if (m_fAUsage != RECTANGLE) {
  160. m_puciBY = new CU8Image (m_rctY, MPEG4_TRANSPARENT); //initialize so that outside VOP is transp
  161. assert (m_puciBY != NULL);
  162. m_puciBUV = new CU8Image (m_rctUV, MPEG4_TRANSPARENT); //initialize so that outside VOP is transp
  163. assert (m_puciBUV != NULL);
  164. m_ppxlcBY = (PixelC*) m_puciBY->pixels ();
  165. m_ppxlcBUV = (PixelC*) m_puciBUV->pixels ();
  166. if (m_fAUsage == EIGHT_BIT) {
  167. m_puciA = new CU8Image (m_rctY, MPEG4_TRANSPARENT); //initialize so that outside VOP is transp
  168. assert (m_puciA != NULL);
  169. m_ppxlcA = (PixelC*) m_puciA->pixels ();
  170. }
  171. }
  172. // read the actual data
  173. fread (m_ppxlcY, sizeof (U8), m_rctY.area (), pf);
  174. fread (m_ppxlcU, sizeof (U8), m_rctUV.area (), pf);
  175. fread (m_ppxlcV, sizeof (U8), m_rctUV.area (), pf);
  176. if (m_fAUsage != RECTANGLE) {
  177. if (m_fAUsage == EIGHT_BIT)
  178. fread ((PixelC*) m_ppxlcA, sizeof (U8), m_rctY.area (), pf);
  179. else
  180. fread ((PixelC*) m_ppxlcBY, sizeof (U8), m_rctY.area (), pf);
  181. }
  182. fclose (pf);
  183. }
  185. CVOPU8YUVBA::CVOPU8YUVBA (AlphaUsage fAUsage, const CRct& rc)
  186. {
  187. m_puciY = NULL;
  188. m_puciU = NULL;
  189. m_puciV = NULL;
  190. m_puciBY = NULL;
  191. m_puciBUV = NULL;
  192. m_puciA = NULL;
  193. m_fAUsage = fAUsage;
  195. m_rctY = rc;
  196. m_rctUV = m_rctY.downSampleBy2 ();
  197. m_puciY = new CU8Image (m_rctY);
  198. assert (m_puciY != NULL);
  199. m_puciU = new CU8Image (m_rctUV);
  200. assert (m_puciU != NULL);
  201. m_puciV = new CU8Image (m_rctUV);
  202. assert (m_puciV != NULL);
  203. m_ppxlcY = (PixelC*) m_puciY->pixels ();
  204. m_ppxlcU = (PixelC*) m_puciU->pixels ();
  205. m_ppxlcV = (PixelC*) m_puciV->pixels ();
  206. if (m_fAUsage != RECTANGLE) {
  207. m_puciBY = new CU8Image (m_rctY, MPEG4_TRANSPARENT); //initialize so that outside VOP is transp
  208. assert (m_puciBY != NULL);
  209. m_puciBUV = new CU8Image (m_rctUV, MPEG4_TRANSPARENT); //initialize so that outside VOP is transp
  210. assert (m_puciBUV != NULL);
  211. m_ppxlcBY = (PixelC*) m_puciBY->pixels ();
  212. m_ppxlcBUV = (PixelC*) m_puciBUV->pixels ();
  213. if (m_fAUsage == EIGHT_BIT) {
  214. m_puciA = new CU8Image (m_rctY, MPEG4_TRANSPARENT); //initialize so that outside VOP is transp
  215. assert (m_puciA != NULL);
  216. m_ppxlcA = (PixelC*) m_puciA->pixels ();
  217. }
  218. }
  219. }
  221. CVOPU8YUVBA::CVOPU8YUVBA (AlphaUsage fAUsage)
  222. {
  223. m_puciY = NULL;
  224. m_puciU = NULL;
  225. m_puciV = NULL;
  226. m_puciBY = NULL;
  227. m_puciBUV = NULL;
  228. m_puciA = NULL;
  229. m_fAUsage = fAUsage;
  230. }
  232. Void CVOPU8YUVBA::shift (CoordI left, CoordI top)
  233. {
  234. m_rctY.shift (left, top);
  235. m_rctUV.shift (left / 2, top / 2);
  236. m_puciY -> shift (left, top);
  237. m_puciU -> shift (left / 2, top / 2);
  238. m_puciV -> shift (left / 2, top / 2);
  239. if (m_fAUsage == EIGHT_BIT) 
  240. m_puciA -> shift (left, top);
  241. else if (m_fAUsage == ONE_BIT) {
  242. m_puciBY -> shift (left, top);
  243. m_puciBUV -> shift (left / 2, top / 2);
  244. }
  245. }
  247. Void CVOPU8YUVBA::setBoundRct (const CRct& rctBoundY)
  248. {
  249. assert (rctBoundY <= m_rctY);
  250. m_rctBoundY = rctBoundY;
  251. m_rctBoundUV = m_rctBoundY.downSampleBy2 ();
  252. Int iOffsetY = m_rctY.offset (m_rctBoundY.left, m_rctBoundY.top);
  253. Int iOffsetUV = m_rctUV.offset (m_rctBoundUV.left, m_rctBoundUV.top);
  254. m_ppxlcBoundY = (PixelC*) m_puciY->pixels () + iOffsetY;
  255. m_ppxlcBoundU = (PixelC*) m_puciU->pixels () + iOffsetUV;
  256. m_ppxlcBoundV = (PixelC*) m_puciV->pixels () + iOffsetUV;
  257. if (m_fAUsage != RECTANGLE) {
  258. m_ppxlcBoundBY = (PixelC*) m_puciBY->pixels () + iOffsetY;
  259. m_ppxlcBoundBUV = (PixelC*) m_puciBUV->pixels () + iOffsetUV;
  260. if (m_fAUsage == EIGHT_BIT)
  261. m_ppxlcBoundA = (PixelC*) m_puciA->pixels () + iOffsetY;
  262. }
  263. }
  265. Void CVOPU8YUVBA::setAndExpandBoundRctOnly (const CRct& rctBoundY, Int iExpand)
  266. {
  267. assert (rctBoundY <= m_rctY);
  268. m_rctBoundY = rctBoundY;
  269. m_rctBoundY.expand (iExpand);
  270. m_rctBoundUV = m_rctBoundY.downSampleBy2 ();
  271. }
  273. Void CVOPU8YUVBA::cropOnAlpha ()
  274. {
  275. m_puciBY -> cropOnAlpha ();
  276. m_puciBUV -> cropOnAlpha ();
  277. m_puciY -> where (m_puciBY -> where ());
  278. m_puciU -> where (m_puciBUV -> where ());
  279. m_puciV -> where (m_puciBUV -> where ());
  280. if (m_fAUsage == EIGHT_BIT)
  281. m_puciA -> where (m_puciBY -> where ());
  282. }
  284. Void CVOPU8YUVBA::overlay (const CVOPU8YUVBA& vopc)
  285. {
  286. if (!vopc.valid ()) return;
  287. if (m_puciBY) //sometime rectangular vops dont have by
  288. m_puciBY -> overlay (*vopc.getPlane (BY_PLANE));
  289. if (m_puciBUV)
  290. m_puciBUV -> overlay (*vopc.getPlane (BUV_PLANE));
  291. m_puciY -> overlay (*vopc.getPlane (Y_PLANE));
  292. m_puciU -> overlay (*vopc.getPlane (U_PLANE));
  293. m_puciV -> overlay (*vopc.getPlane (V_PLANE));
  294. if (m_fAUsage == EIGHT_BIT)
  295. m_puciA -> overlay (*vopc.getPlane (A_PLANE));
  296. }
  298. Void CVOPU8YUVBA::overlay (const CVOPU8YUVBA& vopc, const CRct& rctY)
  299. {
  300. if (!vopc.valid ()) return;
  301. if (!rctY.valid ()) return;
  302. CRct rctUV = rctY.downSampleBy2 ();
  303. m_puciBY -> overlay (*vopc.getPlane (BY_PLANE), rctY);
  304. m_puciBUV -> overlay (*vopc.getPlane (BUV_PLANE), rctUV);
  305. m_puciY -> overlay (*vopc.getPlane (Y_PLANE), rctY);
  306. m_puciU -> overlay (*vopc.getPlane (U_PLANE), rctUV);
  307. m_puciV -> overlay (*vopc.getPlane (V_PLANE), rctUV);
  308. if (m_fAUsage == EIGHT_BIT)
  309. m_puciA -> overlay (*vopc.getPlane (A_PLANE), rctY);
  310. }
  312. own CVOPU8YUVBA* CVOPU8YUVBA::downsampleForSpatialScalability () const
  313. {
  314. //only handle CIF->QCIF for RECTANGULAR VOP
  315. assert (m_fAUsage == RECTANGLE);
  316. //CRct rctDown = whereY ();
  317. assert (whereY().left == 0 && whereY().top == 0);
  318. CVOPU8YUVBA* pvopfRet = new CVOPU8YUVBA (m_fAUsage);
  319. assert (pvopfRet != NULL);
  320. pvopfRet -> m_puciY = m_puciY->downsampleForSpatialScalability ();
  321. pvopfRet -> m_puciU = m_puciU->downsampleForSpatialScalability ();
  322. pvopfRet -> m_puciV = m_puciV->downsampleForSpatialScalability ();
  323. pvopfRet -> m_puciBY = new CU8Image (pvopfRet->whereY (), opaqueValue);
  324. pvopfRet -> m_puciBUV = new CU8Image (pvopfRet->whereUV (), opaqueValue);
  325. return pvopfRet;
  326. }
  328. //wchen: maybe these upsampling functions should be in sys; do it later
  329. own CVOPU8YUVBA* CVOPU8YUVBA::upsampleForSpatialScalability (Int iVerticalSamplingFactorM,
  330.  Int iVerticalSamplingFactorN,
  331.  Int iHorizontalSamplingFactorM,
  332.  Int iHorizontalSamplingFactorN,
  333.  Int iExpandYRefFrame,
  334.  Int iExpandUVRefFrame) const
  335. {
  336. //only handle QCIF->CIF for RECTANGULAR VOP
  337. //assert (m_fAUsage == RECTANGLE);
  338. CVOPU8YUVBA* pvopfRet = new CVOPU8YUVBA (m_fAUsage);
  339. assert (pvopfRet != NULL);
  340. pvopfRet -> m_puciY = m_puciY->upsampleForSpatialScalability (iVerticalSamplingFactorM, iVerticalSamplingFactorN, iHorizontalSamplingFactorM, 
  341.   iHorizontalSamplingFactorN, 1, iExpandYRefFrame);
  342. pvopfRet -> m_puciU = m_puciU->upsampleForSpatialScalability (iVerticalSamplingFactorM, iVerticalSamplingFactorN, iHorizontalSamplingFactorM, 
  343.   iHorizontalSamplingFactorN, 2, iExpandYRefFrame);
  344. pvopfRet -> m_puciV = m_puciV->upsampleForSpatialScalability (iVerticalSamplingFactorM, iVerticalSamplingFactorN, iHorizontalSamplingFactorM, 
  345.   iHorizontalSamplingFactorN, 2, iExpandYRefFrame);
  346. pvopfRet -> m_puciBY = new CU8Image (pvopfRet->whereY (), opaqueValue);
  347. pvopfRet -> m_puciBUV = new CU8Image (pvopfRet->whereUV (), opaqueValue);
  348. pvopfRet->m_ppxlcY = (PixelC *) pvopfRet->m_puciY->pixels();
  349. pvopfRet->m_ppxlcU = (PixelC *) pvopfRet->m_puciU->pixels();
  350. pvopfRet->m_ppxlcV = (PixelC *) pvopfRet->m_puciV->pixels();
  351. pvopfRet->m_rctY   = pvopfRet->m_puciY->where();
  352. pvopfRet->m_rctUV  = pvopfRet->m_puciU->where();
  353. pvopfRet->m_rctBoundY.expand(-iExpandYRefFrame, -iExpandYRefFrame,-iExpandYRefFrame,-iExpandYRefFrame);
  354. pvopfRet->m_rctBoundUV.expand(-iExpandUVRefFrame,-iExpandUVRefFrame,-iExpandUVRefFrame,-iExpandUVRefFrame);
  356. pvopfRet->m_ppxlcBoundY=pvopfRet->m_ppxlcY+16+16*pvopfRet->m_rctY.width;
  357. pvopfRet->m_ppxlcBoundU=pvopfRet->m_ppxlcU +8 +8*pvopfRet->m_rctUV.width;
  358. pvopfRet->m_ppxlcBoundY=pvopfRet->m_ppxlcV +8 +8*pvopfRet->m_rctUV.width;
  359. return pvopfRet;
  360. }
  363. own Double* CVOPU8YUVBA::mse (const CVOPU8YUVBA& vopf) const
  364. {
  365. assert (whereY () == vopf.whereY () && whereUV () == vopf.whereUV ());
  366. Double* rgdblMeanSquareError = new Double [4]; // mean square
  367. CU8Image* puciBOr = new CU8Image (*m_puciBY);
  368. puciBOr -> CU8Image_or (*vopf.getPlane (BY_PLANE));
  369. CU8Image* puciExp0 = new CU8Image (*m_puciY, puciBOr -> where ());
  370. CU8Image* puciExp1 = new CU8Image (*vopf.getPlane (Y_PLANE), puciBOr -> where ());
  371. rgdblMeanSquareError [0] = puciExp1 -> mse (*puciExp0, *puciBOr);
  372. delete puciExp0;
  373. delete puciExp1;
  374. if (fAUsage () == EIGHT_BIT) {
  375. puciExp0 = new CU8Image (*m_puciA, puciBOr -> where ());
  376. puciExp1 = new CU8Image (*vopf.getPlane (A_PLANE), puciBOr -> where ());
  377. rgdblMeanSquareError [3] = puciExp1 -> mse (*puciExp0, *puciBOr);
  378. delete puciExp0;
  379. delete puciExp1;
  380. }
  381. delete puciBOr;
  382. puciBOr = new CU8Image (*m_puciBUV);
  383. puciBOr -> CU8Image_or (*vopf.getPlane (BUV_PLANE));
  384. puciExp0 = new CU8Image (*m_puciU, puciBOr -> where ());
  385. puciExp1 = new CU8Image (*vopf.getPlane (U_PLANE), puciBOr -> where ());
  386. rgdblMeanSquareError [1] = puciExp1 -> mse (*puciExp0, *puciBOr);
  387. delete puciExp0;
  388. delete puciExp1;
  390. puciExp0 = new CU8Image (*m_puciV, puciBOr -> where ());
  391. puciExp1 = new CU8Image (*vopf.getPlane (V_PLANE), puciBOr -> where ());
  392. rgdblMeanSquareError [2] = puciExp1 -> mse (*puciExp0, *puciBOr);
  393. delete puciExp0;
  394. delete puciExp1;
  395. delete puciBOr;
  396. return rgdblMeanSquareError;
  397. }
  399. own Double* CVOPU8YUVBA::snr (const CVOPU8YUVBA& vopf) const
  400. {
  401. assert (whereY () == vopf.whereY () && whereUV () == vopf.whereUV ());
  402. Double* psnr = new Double [4]; // mean square
  403. CU8Image* puciBOr = new CU8Image (*m_puciBY);
  404. puciBOr -> CU8Image_or (*vopf.getPlane (BY_PLANE));
  405. CU8Image* puciExp0 = new CU8Image (*m_puciY, puciBOr -> where ());
  406. CU8Image* puciExp1 = new CU8Image (*vopf.getPlane (Y_PLANE), puciBOr -> where ());
  407. psnr [0] = puciExp1 -> snr (*puciExp0, *puciBOr);
  408. delete puciExp0;
  409. delete puciExp1;
  410. if (fAUsage () == EIGHT_BIT) {
  411. puciExp0 = new CU8Image (*m_puciA, puciBOr -> where ());
  412. puciExp1 = new CU8Image (*vopf.getPlane (A_PLANE), puciBOr -> where ());
  413. psnr [3] = puciExp1 -> snr (*puciExp0, *puciBOr);
  414. delete puciExp0;
  415. delete puciExp1;
  416. }
  417. delete puciBOr;
  418. puciBOr = new CU8Image (*m_puciBUV);
  419. puciBOr -> CU8Image_or (*vopf.getPlane (BUV_PLANE));
  420. puciExp0 = new CU8Image (*m_puciU, puciBOr -> where ());
  421. puciExp1 = new CU8Image (*vopf.getPlane (U_PLANE), puciBOr -> where ());
  422. psnr [1] = puciExp1 -> snr (*puciExp0, *puciBOr);
  423. delete puciExp0;
  424. delete puciExp1;
  426. puciExp0 = new CU8Image (*m_puciV, puciBOr -> where ());
  427. puciExp1 = new CU8Image (*vopf.getPlane (V_PLANE), puciBOr -> where ());
  428. psnr [2] = puciExp1 -> snr (*puciExp0, *puciBOr);
  429. delete puciExp0;
  430. delete puciExp1;
  431. delete puciBOr;
  432. return psnr;
  433. }
  435. const CU8Image* CVOPU8YUVBA::getPlane (PlaneType plnType) const
  436. {
  437. if (plnType == Y_PLANE) return m_puciY;
  438. else if (plnType == U_PLANE) return m_puciU;
  439. else if (plnType == V_PLANE) return m_puciV;
  440. else if (plnType == BY_PLANE) return m_puciBY;
  441. else if (plnType == BUV_PLANE) return m_puciBUV;
  442. else if (plnType == A_PLANE) return m_puciA;
  443. else return NULL;
  444. }
  446. Void CVOPU8YUVBA::dump (FILE* pfFile) const
  447. {
  448. fwrite (m_ppxlcY, m_rctY .area(), 1, pfFile);
  449. fwrite (m_ppxlcU, m_rctUV.area(), 1, pfFile);
  450. fwrite (m_ppxlcV, m_rctUV.area(), 1, pfFile);
  451. }
  453. Void CVOPU8YUVBA::dump (const Char* pchFileName) const
  454. {
  455. FILE* pfOut = fopen (pchFileName, "wb");
  456. dump (pfOut);
  457. fclose (pfOut);
  458. }
  460. Void CVOPU8YUVBA::vdlDump (const Char* pchFileName, const CRct& rct) const
  461. {
  462. CRct rctROI = (!rct.valid ()) ? m_rctY : rct;
  463. assert (rctROI <= m_rctY);
  464. CVideoObjectPlane vop (rctROI, opaquePixel);
  465. Int offset = (rctROI == m_rctY)? 0 : m_rctY.width - rct.width;
  466. CU8Image* puciZoomedU = m_puciU -> zoomup (2, 2);
  467. CU8Image* puciZoomedV = m_puciV -> zoomup (2, 2);
  468. PixelC* ppxlucY = (PixelC*) m_puciY -> pixels ();
  469. PixelC* ppxlucU = (PixelC*) puciZoomedU -> pixels ();
  470. PixelC* ppxlucV = (PixelC*) puciZoomedV -> pixels ();
  471. PixelC* ppxlucA = NULL;
  472. if (m_fAUsage == EIGHT_BIT)
  473. ppxlucA = (PixelC*) m_puciA -> pixels ();
  474. else if (m_fAUsage == ONE_BIT)
  475. ppxlucA = (PixelC*) m_puciBY -> pixels ();
  476. CPixel* ppxl = (CPixel*) vop.pixels ();
  477. for (CoordI y = rctROI.top; y < rctROI.bottom; y++) {
  478. for (CoordI x = rctROI.left; x < rctROI.right; x++, ppxlucY++, ppxlucU++, ppxlucV++, ppxlucA++) {
  479. Double var = 1.164 * (*ppxlucY - 16);
  480. Int r = (Int) ((Double) (var + 1.596 * (*ppxlucV - 128)) + .5);
  481. Int g = (Int) ((Double) (var - 0.813 * (*ppxlucV - 128) - 0.391 * (*ppxlucU - 128)) + .5);
  482. Int b = (Int) ((Double) (var + 2.018 * (*ppxlucU - 128)) + .5);
  483. Int a = (m_fAUsage == RECTANGLE)? opaqueValue : *ppxlucA;
  484. ppxl -> pxlU.rgb.r = (U8) checkrange (r, 0, 255);
  485. ppxl -> pxlU.rgb.g = (U8) checkrange (g, 0, 255);
  486. ppxl -> pxlU.rgb.b = (U8) checkrange (b, 0, 255);
  487. ppxl -> pxlU.rgb.a = (U8) checkrange (a, 0, 255);
  488. ppxl++;
  489. }
  490. ppxlucY += offset; ppxlucU += offset; ppxlucV += offset; ppxlucA += offset;
  491. }
  492. delete puciZoomedU;
  493. delete puciZoomedV;
  494. vop.vdlDump (pchFileName);
  495. }
  497. Void CVOPU8YUVBA::addBYPlain ()
  498. {
  499. m_puciBY = new CU8Image (m_rctY, 255); //initialize so that outside VOP is transp
  500. assert (m_puciBY != NULL);
  501. m_puciBUV = new CU8Image (m_rctUV, 255); //initialize so that outside VOP is transp
  502. assert (m_puciBUV != NULL);
  503. m_ppxlcBY = (PixelC*) m_puciBY->pixels ();
  504. m_ppxlcBUV = (PixelC*) m_puciBUV->pixels ();
  505. if (m_fAUsage == EIGHT_BIT) {
  506. m_puciA = new CU8Image (m_rctY, 255); //initialize so that outside VOP is transp
  507. assert (m_puciA != NULL);
  508. m_ppxlcA = (PixelC*) m_puciA->pixels ();
  509. }
  510. }
  512. Void CVOPU8YUVBA::addBYPlain (const CRct& rct, const CRct& rctUV)
  513. {
  514. CU8Image* puciTemp = new CU8Image ( rct, MPEG4_OPAQUE );
  515. //m_puciBY = new CU8Image (m_rctY, 255); //initialize so that outside VOP is transp
  516. m_puciBY = new CU8Image (m_rctY, MPEG4_TRANSPARENT); //initialize so that outside VOP is transp
  517. m_puciBY->CU8Image_or( *puciTemp ); // for background composition, mask of whole image is generated here
  518. assert (m_puciBY != NULL);
  520. CU8Image* puciTempUV = new CU8Image ( rctUV, MPEG4_OPAQUE );
  521. //m_puciBUV = new CU8Image (m_rctUV, 255); //initialize so that outside VOP is transp
  522. m_puciBUV = new CU8Image (m_rctUV, MPEG4_TRANSPARENT); //initialize so that outside VOP is transp
  523. m_puciBUV->CU8Image_or( *puciTempUV ); // for background composition, mask of whole image is generated here
  524. assert (m_puciBUV != NULL);
  526. m_ppxlcBY = (PixelC*) m_puciBY->pixels ();
  527. m_ppxlcBUV = (PixelC*) m_puciBUV->pixels ();
  528. if (m_fAUsage == EIGHT_BIT) {
  529. //m_puciA = new CU8Image (m_rctY, 255); //initialize so that outside VOP is transp
  530. m_puciA = new CU8Image (m_rctY, MPEG4_TRANSPARENT); //initialize so that outside VOP is transp
  531. m_puciA->CU8Image_or( *puciTemp );
  532. assert (m_puciA != NULL);
  533. m_ppxlcA = (PixelC*) m_puciA->pixels ();
  534. }
  535. }