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

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

流媒体/Mpeg4/MP4

开发平台：

Visual C++

yuvai.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. CVOPIntYUVBA::~CVOPIntYUVBA ()
  51. {
  52. delete m_piiY;
  53. delete m_piiU;
  54. delete m_piiV;
  55. delete m_piiBY;
  56. delete m_piiBUV;
  57. delete m_piiA;
  58. }
  60. Void CVOPIntYUVBA::constructFromVOPF (const CVOPIntYUVBA& vopi, const CRct& rc)
  61. {
  62. if (rc.valid ()) {
  63. CRct rY = (rc.valid ()) ? rc : vopi.whereY ();
  64. CRct rUV = rY / 2;
  65. m_piiY = new CIntImage (*vopi.getPlane (Y_PLANE), rY);
  66. m_piiU = new CIntImage (*vopi.getPlane (U_PLANE), rUV);
  67. m_piiV = new CIntImage (*vopi.getPlane (V_PLANE), rUV);
  68. m_piiBY = new CIntImage (*vopi.getPlane (BY_PLANE), rY);
  69. m_piiBUV = new CIntImage (*vopi.getPlane (BUV_PLANE), rUV);
  70. if (m_fAUsage == EIGHT_BIT) {
  71. m_piiA = new CIntImage (*vopi.getPlane (A_PLANE), rY);
  72. assert (m_piiA != NULL);
  73. }
  74. }
  75. else {
  76. m_piiY = new CIntImage (*vopi.getPlane (Y_PLANE));
  77. m_piiU = new CIntImage (*vopi.getPlane (U_PLANE));
  78. m_piiV = new CIntImage (*vopi.getPlane (V_PLANE));
  79. m_piiBY = new CIntImage (*vopi.getPlane (BY_PLANE));
  80. m_piiBUV = new CIntImage (*vopi.getPlane (BUV_PLANE));
  81. if (m_fAUsage == EIGHT_BIT) {
  82. m_piiA = new CIntImage (*vopi.getPlane (A_PLANE));
  83. assert (m_piiA != NULL);
  84. }
  85. }
  86. assert (m_piiY != NULL);
  87. assert (m_piiU != NULL);
  88. assert (m_piiV != NULL);
  89. assert (m_piiBY != NULL);
  90. assert (m_piiBUV != NULL);
  91. }
  93. CVOPIntYUVBA::CVOPIntYUVBA (const CVOPIntYUVBA& vopi, AlphaUsage fAUsage, const CRct& rc) : 
  94. m_fAUsage (fAUsage), m_piiY (NULL), m_piiU (NULL), m_piiV (NULL), m_piiBY (NULL), m_piiBUV (NULL), m_piiA (NULL)
  96. {
  97. constructFromVOPF (vopi, rc);
  98. }
  101. CVOPIntYUVBA::CVOPIntYUVBA (const CVOPIntYUVBA& vopi, const CRct& rc) : 
  102. m_piiY (NULL), m_piiU (NULL), m_piiV (NULL), m_piiBY (NULL), m_piiBUV (NULL), m_piiA (NULL)
  103. {
  104. m_fAUsage = vopi.fAUsage ();
  105. constructFromVOPF (vopi, rc);
  106. }
  108. CVOPIntYUVBA::CVOPIntYUVBA (const CVideoObjectPlane& vop, AlphaUsage fAUsage, const CRct& rc) : 
  109. m_fAUsage (fAUsage), m_piiY (NULL), m_piiU (NULL), m_piiV (NULL), m_piiBY (NULL), m_piiBUV (NULL), m_piiA (NULL)
  111. {
  112. CRct r = (rc.valid ()) ? rc : vop.where ();
  113. m_piiY = new CIntImage (r);
  114. CIntImage* piiU = new CIntImage (r);
  115. CIntImage* piiV = new CIntImage (r);
  116. m_piiBY = new CIntImage (r);
  117. if (m_fAUsage == EIGHT_BIT)
  118. m_piiA = new CIntImage (r);
  120. if (r == vop.where ()) { // faster operation if these two has the same rects
  121. PixelI* ppxlfY = (PixelI*) m_piiY -> pixels ();
  122. PixelI* ppxlfU = (PixelI*) piiU -> pixels ();
  123. PixelI* ppxlfV = (PixelI*) piiV -> pixels ();
  124. PixelI* ppxlfB = (PixelI*) m_piiBY -> pixels ();
  125. const CPixel* ppxl = vop.pixels ();
  126. UInt area = vop.where ().area ();
  127. UInt ip;
  128. for (ip = 0; ip < area; ip++, ppxl++, ppxlfY++, ppxlfU++, ppxlfV++, ppxlfB++) {
  129. *ppxlfY = ppxl -> pxlU.yuv.y;
  130. *ppxlfU = ppxl -> pxlU.yuv.u;
  131. *ppxlfV = ppxl -> pxlU.yuv.v;
  132. *ppxlfB = (ppxl -> pxlU.yuv.a == transpValue) ? 0 : 255;
  133. }
  134. if (m_fAUsage == EIGHT_BIT) {
  135. ppxl = vop.pixels ();
  136. PixelI* ppxlfA = (PixelI*) m_piiA -> pixels ();
  137. for (ip = 0; ip < area; ip++, ppxl++, ppxlfA++)
  138. *ppxlfA = ppxl -> pxlU.yuv.a;
  139. }
  140. }
  141. else {
  142. for (CoordI y = r.top; y < r.bottom; y++) {
  143. PixelI* ppxlfY = (PixelI*) m_piiY -> pixels (r.left, y);
  144. PixelI* ppxlfU = (PixelI*) piiU -> pixels (r.left, y);
  145. PixelI* ppxlfV = (PixelI*) piiV -> pixels (r.left, y);
  146. PixelI* ppxlfB = (PixelI*) m_piiBY -> pixels (r.left, y);
  147. const CPixel* ppxl = vop.pixels (r.left, y);
  148. for (CoordI x = r.left; x < r.right; x++, ppxl++, ppxlfY++, ppxlfU++, ppxlfV++, ppxlfB++) {
  149. *ppxlfY = ppxl -> pxlU.yuv.y;
  150. *ppxlfU = ppxl -> pxlU.yuv.u;
  151. *ppxlfV = ppxl -> pxlU.yuv.v;
  152. *ppxlfB++ = (ppxl -> pxlU.yuv.a == transpValue) ? 0 : 255;
  153. }
  154. if (m_fAUsage == EIGHT_BIT) {
  155. ppxl = vop.pixels ();
  156. PixelI* ppxlfA = (PixelI*) m_piiA -> pixels ();
  157. for (CoordI x = r.left; x < r.right; x++, ppxl++, ppxlfA++)
  158. *ppxlfA = ppxl -> pxlU.yuv.a;
  159. }
  160. }
  161. }
  162. CRct rctBoxY = m_piiBY -> whereVisible ();
  163. if (rctBoxY.left % 2 != 0)
  164. rctBoxY.left--;
  165. if (rctBoxY.top % 2 != 0)
  166. rctBoxY.top--;
  167. m_piiBY -> where (rctBoxY);
  168. m_piiY -> where (rctBoxY);
  169. if (m_fAUsage == EIGHT_BIT)
  170. m_piiA -> where (rctBoxY);
  171. piiU -> where (rctBoxY);
  172. piiV -> where (rctBoxY);
  173. m_piiU = piiU -> decimate (2, 2);
  174. delete piiU;
  175. m_piiV = piiV -> decimate (2, 2);
  176. delete piiV;
  177. m_piiBUV = m_piiBY -> decimateBinaryShape (2, 2); //conservative decimation
  178. }
  181. CVOPIntYUVBA::CVOPIntYUVBA (AlphaUsage fAUsage, const CRct& rc) :
  182. m_fAUsage (fAUsage), m_piiY (NULL), m_piiU (NULL), m_piiV (NULL), m_piiBY (NULL), m_piiBUV (NULL), m_piiA (NULL)
  183. {
  184. CRct rcY = rc;
  185. CRct rcUV = rc / 2;
  186. m_piiY = new CIntImage (rcY);
  187. assert (m_piiY != NULL);
  188. m_piiU = new CIntImage (rcUV);
  189. assert (m_piiU != NULL);
  190. m_piiV = new CIntImage (rcUV);
  191. assert (m_piiV != NULL);
  192. m_piiBY = new CIntImage (rcY);
  193. assert (m_piiBY != NULL);
  194. m_piiBUV = new CIntImage (rcUV);
  195. assert (m_piiBUV != NULL);
  196. if (m_fAUsage == EIGHT_BIT) {
  197. m_piiA = new CIntImage (rcY);
  198. assert (m_piiA != NULL);
  199. }
  200. }
  202. CVOPIntYUVBA::CVOPIntYUVBA (AlphaUsage fAUsage, const CRct& rcY, const CRct& rcUV) :
  203. m_fAUsage (fAUsage), m_piiY (NULL), m_piiU (NULL), m_piiV (NULL), m_piiBY (NULL), m_piiBUV (NULL), m_piiA (NULL)
  205. {
  206. m_piiY = new CIntImage (rcY);
  207. assert (m_piiY != NULL);
  208. m_piiU = new CIntImage (rcUV);
  209. assert (m_piiU != NULL);
  210. m_piiV = new CIntImage (rcUV);
  211. assert (m_piiV != NULL);
  212. m_piiBY = new CIntImage (rcY);
  213. assert (m_piiBY != NULL);
  214. m_piiBUV = new CIntImage (rcUV);
  215. assert (m_piiBUV != NULL);
  216. if (m_fAUsage == EIGHT_BIT) {
  217. m_piiA = new CIntImage (rcY);
  218. assert (m_piiA != NULL);
  219. }
  220. }
  222. CVOPIntYUVBA::CVOPIntYUVBA (AlphaUsage fAUsage) : 
  223. m_fAUsage (fAUsage), m_piiY (NULL), m_piiU (NULL), m_piiV (NULL), m_piiBY (NULL), m_piiBUV (NULL), m_piiA (NULL)
  225. {
  226. }
  228. const CIntImage* CVOPIntYUVBA::getPlane (PlaneType plnType) const
  229. {
  230. if (plnType == Y_PLANE) return m_piiY;
  231. else if (plnType == U_PLANE) return m_piiU;
  232. else if (plnType == V_PLANE) return m_piiV;
  233. else if (plnType == BY_PLANE) return m_piiBY;
  234. else if (plnType == BUV_PLANE) return m_piiBUV;
  235. else if (plnType == A_PLANE) return m_piiA;
  236. else return NULL;
  237. }
  239. Void CVOPIntYUVBA::where (const CRct& rct)
  240. {
  241. whereY (rct);
  242. CRct rctUV = rct / 2;
  243. whereUV (rctUV);
  244. }
  246. Void CVOPIntYUVBA::whereY (const CRct& rct)
  247. {
  248. m_piiY -> where (rct);
  249. m_piiBY -> where (rct);
  250. if (m_fAUsage == EIGHT_BIT)
  251. m_piiA -> where (rct);
  252. }
  254. Void CVOPIntYUVBA::whereUV (const CRct& rct)
  255. {
  256. m_piiU -> where (rct);
  257. m_piiV -> where (rct);
  258. m_piiBUV -> where (rct);
  259. }
  261. Void CVOPIntYUVBA::setPlane (const CIntImage* pii, PlaneType plnType, Bool bBUV)
  262. {
  263. if (pii == NULL)
  264. return;
  265. if (plnType == Y_PLANE) {
  266. delete m_piiY;
  267. m_piiY = new CIntImage (*pii);
  268. }
  269. else if (plnType == U_PLANE) {
  270. delete m_piiU;
  271. m_piiU = new CIntImage (*pii);
  272. }
  273. else if (plnType == V_PLANE) {
  274. delete m_piiV;
  275. m_piiV = new CIntImage (*pii);
  276. }
  277. else if (plnType == BY_PLANE) {
  278. delete m_piiBY;
  279. m_piiBY = new CIntImage (*pii);
  280. if (bBUV) {
  281. delete m_piiBUV;
  282. m_piiBUV = m_piiBY -> decimate (2, 2);
  283. m_piiBUV -> setRect (whereUV ());
  284. }
  285. }
  286. else if (plnType == BUV_PLANE) {
  287. delete m_piiBUV;
  288. m_piiBUV = new CIntImage (*pii);
  289. }
  290. else if (plnType == A_PLANE) {
  291. delete m_piiA;
  292. m_piiA = new CIntImage (*pii);
  293. }
  294. else assert (FALSE);
  295. }
  297. Void CVOPIntYUVBA::cropOnAlpha ()
  298. {
  299. m_piiBY -> cropOnAlpha ();
  300. m_piiBUV -> cropOnAlpha ();
  301. m_piiY -> where (m_piiBY -> where ());
  302. m_piiU -> where (m_piiBUV -> where ());
  303. m_piiV -> where (m_piiBUV -> where ());
  304. if (m_fAUsage == EIGHT_BIT)
  305. m_piiA -> where (m_piiBY -> where ());
  306. }
  308. Void overlayMB (CIntImage* piiBig, const CIntImage* piiSmall, const CIntImage* piiMskSmall)
  309. {
  310. if (piiSmall == NULL)
  311. return;
  312. PixelI* ppxlfBig = (PixelI*) piiBig -> pixels (piiSmall -> where ().left, piiSmall -> where ().top);
  313. Int unit = piiSmall -> where ().width;
  314. Int skipBig = piiBig -> where ().width - unit;
  315. const PixelI* ppxlfSmall = piiSmall -> pixels ();
  316. const PixelI* ppxlfMsk = piiMskSmall -> pixels ();
  317. for (Int i = 0; i < unit; i++) {
  318. for (Int j = 0; j < unit; j++) {
  319. *ppxlfBig = *ppxlfSmall;
  320. ppxlfBig++;
  321. ppxlfSmall++;
  322. ppxlfMsk++;
  323. }
  324. ppxlfBig += skipBig;
  325. }
  326. }
  328. Void CVOPIntYUVBA::overlay (const CVOPIntYUVBA& vopi)
  329. {
  330. if (!vopi.valid ()) return;
  331. m_piiBY -> overlay (*vopi.getPlane (BY_PLANE));
  332. m_piiBUV -> overlay (*vopi.getPlane (BUV_PLANE));
  333. overlayMB (m_piiY, vopi.getPlane (Y_PLANE), vopi.getPlane (BY_PLANE));
  334. overlayMB (m_piiU, vopi.getPlane (U_PLANE), vopi.getPlane (BUV_PLANE));
  335. overlayMB (m_piiV, vopi.getPlane (V_PLANE), vopi.getPlane (BUV_PLANE));
  336. if (m_fAUsage == EIGHT_BIT)
  337. overlayMB (m_piiA, vopi.getPlane (A_PLANE), vopi.getPlane (BY_PLANE));
  338. }
  340. Void CVOPIntYUVBA::overlayBY (const CIntImage& iiBY)
  341. {
  342. if (!iiBY.valid ()) return;
  343. m_piiBY -> overlay (iiBY);
  344. }
  346. /*
  347. own CVOPIntYUVBA* CVOPIntYUVBA::warp (const CAffine2D& aff) const
  348. {
  349. CVideoObjectPlane* pvop = pvopYUV ();
  350. CVideoObjectPlane* pvopWarp = pvop -> warp (aff);
  351. CVOPIntYUVBA* pvopfRet = new CVOPIntYUVBA (*pvopWarp, m_fAUsage);
  352. delete pvop;
  353. delete pvopWarp;
  354. return pvopfRet;
  355. }
  358. own CVOPIntYUVBA* CVOPIntYUVBA::warp (const CAffine2D& aff, const CRct& rctWarp) const
  359. {
  360. CVideoObjectPlane* pvop = pvopYUV ();
  361. CVideoObjectPlane* pvopWarp = pvop -> warp (aff, rctWarp);
  362. CVOPIntYUVBA* pvopfRet = new CVOPIntYUVBA (*pvopWarp, m_fAUsage);
  363. delete pvop;
  364. delete pvopWarp;
  365. return pvopfRet;
  366. }
  368. own CVOPIntYUVBA* CVOPIntYUVBA::warp (const CPerspective2D& persp) const
  369. {
  370. CVideoObjectPlane* pvop = pvopYUV ();
  371. CVideoObjectPlane* pvopWarp = pvop -> warp (persp);
  372. CVOPIntYUVBA* pvopfRet = new CVOPIntYUVBA (*pvopWarp, m_fAUsage);
  373. delete pvop;
  374. delete pvopWarp;
  375. return pvopfRet;
  376. }
  379. own CVOPIntYUVBA* CVOPIntYUVBA::warp (const CPerspective2D& persp, const CRct& rctWarp) const
  380. {
  381. CVideoObjectPlane* pvop = pvopYUV ();
  382. CVideoObjectPlane* pvopWarp = pvop -> warp (persp, rctWarp);
  383. CVOPIntYUVBA* pvopfRet = new CVOPIntYUVBA (*pvopWarp, m_fAUsage);
  384. delete pvop;
  385. delete pvopWarp;
  386. return pvopfRet;
  387. }
  389. own CVOPIntYUVBA* CVOPIntYUVBA::warp (const CPerspective2D& persp, const CRct& rctWarp, UInt accuracy) const
  390. {
  391. CVideoObjectPlane* pvop = pvopYUV ();
  392. CVideoObjectPlane* pvopWarp = pvop -> warp (persp, rctWarp, accuracy);
  393. CVOPIntYUVBA* pvopfRet = new CVOPIntYUVBA (*pvopWarp, m_fAUsage);
  394. delete pvop;
  395. delete pvopWarp;
  396. return pvopfRet;
  397. }
  398. */
  400. own CVOPIntYUVBA* CVOPIntYUVBA::warpYUV (const CPerspective2D& persp, const CRct& rctWarp, UInt accuracy) const
  401. {
  402. CVOPIntYUVBA* pvopfRet = new CVOPIntYUVBA (RECTANGLE, rctWarp);
  403. CIntImage* piiwarpedY = (CIntImage*) getPlane (Y_PLANE) -> warp (persp, rctWarp, accuracy);
  404. pvopfRet -> setPlane (piiwarpedY, Y_PLANE, FALSE);
  405. delete piiwarpedY;
  407. CIntImage* piiUZoom = (CIntImage*) getPlane (U_PLANE) -> zoomup (2, 2);
  408. CIntImage* piiUZoomWarp = piiUZoom -> warp (persp, rctWarp, accuracy);
  409. delete piiUZoom;
  410. CIntImage* piiUWarped = piiUZoomWarp -> decimate (2, 2);
  411. delete piiUZoomWarp;
  412. pvopfRet -> setPlane (piiUWarped, U_PLANE, FALSE);
  413. delete piiUWarped;
  415. CIntImage* piiVZoom = (CIntImage*) getPlane (V_PLANE) -> zoomup (2, 2);
  416. CIntImage* piiVZoomWarp = piiVZoom -> warp (persp, rctWarp, accuracy);
  417. delete piiVZoom;
  418. CIntImage* piiVWarp = piiVZoomWarp -> decimate (2, 2);
  419. delete piiVZoomWarp;
  420. pvopfRet -> setPlane (piiVWarp, V_PLANE, FALSE);
  421. delete piiVWarp;
  422. return pvopfRet;
  423. }
  425. own CVOPIntYUVBA* CVOPIntYUVBA::warpYUV (const CPerspective2D& persp, const CRct& rctWarp) const
  426. {
  427. CVOPIntYUVBA* pvopfRet = new CVOPIntYUVBA (RECTANGLE, rctWarp);
  428. CIntImage* piiwarpedY = getPlane (Y_PLANE) -> warp (persp, rctWarp);
  429. pvopfRet -> setPlane (piiwarpedY, Y_PLANE, FALSE);
  430. delete piiwarpedY;
  432. CIntImage* piiUZoom = getPlane (U_PLANE) -> zoomup (2, 2);
  433. CIntImage* piiUZoomWarp = piiUZoom -> warp (persp, rctWarp);
  434. delete piiUZoom;
  435. CIntImage* piiUWarped = piiUZoomWarp -> decimate (2, 2);
  436. delete piiUZoomWarp;
  437. pvopfRet -> setPlane (piiUWarped, U_PLANE, FALSE);
  438. delete piiUWarped;
  440. CIntImage* piiVZoom = getPlane (V_PLANE) -> zoomup (2, 2);
  441. CIntImage* piiVZoomWarp = piiVZoom -> warp (persp, rctWarp);
  442. delete piiVZoom;
  443. CIntImage* piiVWarp = piiVZoomWarp -> decimate (2, 2);
  444. delete piiVZoomWarp;
  445. pvopfRet -> setPlane (piiVWarp, V_PLANE, FALSE);
  446. delete piiVWarp;
  447. return pvopfRet;
  448. }
  450. own CVOPIntYUVBA* CVOPIntYUVBA::downsampleForSpatialScalability () const
  451. {
  452. //only handle CIF->QCIF for RECTANGULAR VOP
  453. assert (m_fAUsage == RECTANGLE);
  454. //CRct rctDown = whereY ();
  455. assert (whereY().left == 0 && whereY().top == 0);
  456. CVOPIntYUVBA* pvopfRet = new CVOPIntYUVBA (m_fAUsage);
  457. assert (pvopfRet != NULL);
  458. pvopfRet -> m_piiY = m_piiY->downsampleForSpatialScalability ();
  459. pvopfRet -> m_piiU = m_piiU->downsampleForSpatialScalability ();
  460. pvopfRet -> m_piiV = m_piiV->downsampleForSpatialScalability ();
  461. pvopfRet -> m_piiBY = new CIntImage (pvopfRet->whereY (), opaqueValue);
  462. pvopfRet -> m_piiBUV = new CIntImage (pvopfRet->whereUV (), opaqueValue);
  463. return pvopfRet;
  464. }
  465. own CVOPIntYUVBA* CVOPIntYUVBA::upsampleForSpatialScalability () const
  466. {
  467. //only handle QCIF->CIF for RECTANGULAR VOP
  468. assert (m_fAUsage == RECTANGLE);
  469. CVOPIntYUVBA* pvopfRet = new CVOPIntYUVBA (m_fAUsage);
  470. assert (pvopfRet != NULL);
  471. pvopfRet -> m_piiY = m_piiY->upsampleForSpatialScalability ();
  472. pvopfRet -> m_piiU = m_piiU->upsampleForSpatialScalability ();
  473. pvopfRet -> m_piiV = m_piiV->upsampleForSpatialScalability ();
  474. pvopfRet -> m_piiBY = new CIntImage (pvopfRet->whereY (), opaqueValue);
  475. pvopfRet -> m_piiBUV = new CIntImage (pvopfRet->whereUV (), opaqueValue);
  476. return pvopfRet;
  477. }
  479. /*
  480. Void CVOPIntYUVBA::vdlDump (const Char* fileName, CPixel ppxlFalse) const
  481. {
  482. CVideoObjectPlane* pvop = pvopYUV ();
  483. pvop -> vdlDump (fileName, ppxlFalse);
  484. delete pvop;
  485. }
  486. */
  488. own Double* CVOPIntYUVBA::mse (const CVOPIntYUVBA& vopi) const
  489. {
  490. assert (whereY () == vopi.whereY () && whereUV () == vopi.whereUV ());
  491. Double* rgdblMeanSquareError = new Double [4]; // mean square
  492. CIntImage* piiBOr = new CIntImage (*m_piiBY);
  493. piiBOr -> orIi (*vopi.getPlane (BY_PLANE));
  494. CIntImage* piiExp0 = new CIntImage (*m_piiY, piiBOr -> where ());
  495. CIntImage* piiExp1 = new CIntImage (*vopi.getPlane (Y_PLANE), piiBOr -> where ());
  496. rgdblMeanSquareError [0] = piiExp1 -> mse (*piiExp0, *piiBOr);
  497. delete piiExp0;
  498. delete piiExp1;
  499. if (fAUsage () == EIGHT_BIT) {
  500. piiExp0 = new CIntImage (*m_piiA, piiBOr -> where ());
  501. piiExp1 = new CIntImage (*vopi.getPlane (A_PLANE), piiBOr -> where ());
  502. rgdblMeanSquareError [3] = piiExp1 -> mse (*piiExp0, *piiBOr);
  503. delete piiExp0;
  504. delete piiExp1;
  505. }
  506. delete piiBOr;
  507. piiBOr = new CIntImage (*m_piiBUV);
  508. piiBOr -> orIi (*vopi.getPlane (BUV_PLANE));
  509. piiExp0 = new CIntImage (*m_piiU, piiBOr -> where ());
  510. piiExp1 = new CIntImage (*vopi.getPlane (U_PLANE), piiBOr -> where ());
  511. rgdblMeanSquareError [1] = piiExp1 -> mse (*piiExp0, *piiBOr);
  512. delete piiExp0;
  513. delete piiExp1;
  515. piiExp0 = new CIntImage (*m_piiV, piiBOr -> where ());
  516. piiExp1 = new CIntImage (*vopi.getPlane (V_PLANE), piiBOr -> where ());
  517. rgdblMeanSquareError [2] = piiExp1 -> mse (*piiExp0, *piiBOr);
  518. delete piiExp0;
  519. delete piiExp1;
  520. delete piiBOr;
  521. return rgdblMeanSquareError;
  522. }
  524. own Double* CVOPIntYUVBA::snr (const CVOPIntYUVBA& vopi) const
  525. {
  526. assert (whereY () == vopi.whereY () && whereUV () == vopi.whereUV ());
  527. Double* psnr = new Double [4]; // mean square
  528. CIntImage* piiBOr = new CIntImage (*m_piiBY);
  529. piiBOr -> orIi (*vopi.getPlane (BY_PLANE));
  530. CIntImage* piiExp0 = new CIntImage (*m_piiY, piiBOr -> where ());
  531. CIntImage* piiExp1 = new CIntImage (*vopi.getPlane (Y_PLANE), piiBOr -> where ());
  532. psnr [0] = piiExp1 -> snr (*piiExp0, *piiBOr);
  533. delete piiExp0;
  534. delete piiExp1;
  535. if (fAUsage () == EIGHT_BIT) {
  536. piiExp0 = new CIntImage (*m_piiA, piiBOr -> where ());
  537. piiExp1 = new CIntImage (*vopi.getPlane (A_PLANE), piiBOr -> where ());
  538. psnr [3] = piiExp1 -> snr (*piiExp0, *piiBOr);
  539. delete piiExp0;
  540. delete piiExp1;
  541. }
  542. delete piiBOr;
  543. piiBOr = new CIntImage (*m_piiBUV);
  544. piiBOr -> orIi (*vopi.getPlane (BUV_PLANE));
  545. piiExp0 = new CIntImage (*m_piiU, piiBOr -> where ());
  546. piiExp1 = new CIntImage (*vopi.getPlane (U_PLANE), piiBOr -> where ());
  547. psnr [1] = piiExp1 -> snr (*piiExp0, *piiBOr);
  548. delete piiExp0;
  549. delete piiExp1;
  551. piiExp0 = new CIntImage (*m_piiV, piiBOr -> where ());
  552. piiExp1 = new CIntImage (*vopi.getPlane (V_PLANE), piiBOr -> where ());
  553. psnr [2] = piiExp1 -> snr (*piiExp0, *piiBOr);
  554. delete piiExp0;
  555. delete piiExp1;
  556. delete piiBOr;
  557. return psnr;
  558. }
  560. own CVOPIntYUVBA* CVOPIntYUVBA::operator + (const CVOPIntYUVBA& vopi) const
  561. {
  562. assert (whereY () == vopi.whereY () && whereUV () == vopi.whereUV ());
  563. CVOPIntYUVBA* pvopfRet = new CVOPIntYUVBA (whereY (), m_fAUsage);
  564. assert (pvopfRet != NULL);
  565. delete pvopfRet -> m_piiY;
  566. pvopfRet -> m_piiY = *m_piiY + *vopi.getPlane (Y_PLANE);
  567. delete pvopfRet -> m_piiU;
  568. pvopfRet -> m_piiU = *m_piiU + *vopi.getPlane (U_PLANE);
  569. delete pvopfRet -> m_piiV;
  570. pvopfRet -> m_piiV = *m_piiV + *vopi.getPlane (V_PLANE);
  571. delete pvopfRet -> m_piiA;
  572. pvopfRet -> m_piiA = *m_piiA + *vopi.getPlane (A_PLANE);
  573. delete pvopfRet -> m_piiBY;
  574. pvopfRet -> m_piiBY = new CIntImage (*m_piiBY); // alpha is defined as the first one
  575. delete pvopfRet -> m_piiBUV;
  576. pvopfRet -> m_piiBUV = new CIntImage (*m_piiBUV); // alpha is defined as the first one
  577. return pvopfRet;
  578. }
  580. own CVOPIntYUVBA* CVOPIntYUVBA::operator - (const CVOPIntYUVBA& vopi) const
  581. {
  582. assert (whereY () == vopi.whereY () && whereUV () == vopi.whereUV ());
  583. // CVOPIntYUVBA* pvopfRet = new CVOPIntYUVBA (whereY (), m_fAUsage);
  584. CVOPIntYUVBA* pvopfRet = new CVOPIntYUVBA (m_fAUsage, whereY ());
  585. assert (pvopfRet != NULL);
  586. delete pvopfRet -> m_piiY;
  587. pvopfRet -> m_piiY = *m_piiY - *vopi.getPlane (Y_PLANE);
  588. delete pvopfRet -> m_piiU;
  589. pvopfRet -> m_piiU = *m_piiU - *vopi.getPlane (U_PLANE);
  590. delete pvopfRet -> m_piiV;
  591. pvopfRet -> m_piiV = *m_piiV - *vopi.getPlane (V_PLANE);
  592. delete pvopfRet -> m_piiA;
  593. pvopfRet -> m_piiA = *m_piiA - *vopi.getPlane (A_PLANE);
  594. delete pvopfRet -> m_piiBY;
  595. pvopfRet -> m_piiBY = new CIntImage (*m_piiBY); // alpha is defined as the first one
  596. delete pvopfRet -> m_piiBUV;
  597. pvopfRet -> m_piiBUV = new CIntImage (*m_piiBUV); // alpha is defined as the first one
  598. return pvopfRet;
  599. }
  601. own CVOPIntYUVBA* CVOPIntYUVBA::operator * (Int vl) const
  602. {
  603. CVOPIntYUVBA* pvopfRet = new CVOPIntYUVBA (*this);
  604. assert (pvopfRet != NULL);
  605. delete pvopfRet -> m_piiY;
  606. pvopfRet -> m_piiY = *m_piiY * vl;
  607. delete pvopfRet -> m_piiU;
  608. pvopfRet -> m_piiU = *m_piiU * vl;
  609. delete pvopfRet -> m_piiV;
  610. pvopfRet -> m_piiV = *m_piiV * vl;
  611. delete pvopfRet -> m_piiA;
  612. pvopfRet -> m_piiA = *m_piiA * vl;
  613. delete pvopfRet -> m_piiBY;
  614. pvopfRet -> m_piiBY = new CIntImage (*m_piiBY); // alpha is unchanged
  615. delete pvopfRet -> m_piiBUV;
  616. pvopfRet -> m_piiBUV = new CIntImage (*m_piiBUV); // alpha is unchanged
  617. return pvopfRet;
  618. }
  620. own CVOPIntYUVBA* CVOPIntYUVBA::operator / (Int vl) const
  621. {
  622. assert (vl != .0f);
  623. CVOPIntYUVBA* pvopfRet = new CVOPIntYUVBA (*this);
  624. assert (pvopfRet != NULL);
  625. delete pvopfRet -> m_piiY;
  626. pvopfRet -> m_piiY = *m_piiY / vl;
  627. delete pvopfRet -> m_piiU;
  628. pvopfRet -> m_piiU = *m_piiU / vl;
  629. delete pvopfRet -> m_piiV;
  630. pvopfRet -> m_piiV = *m_piiV / vl;
  631. delete pvopfRet -> m_piiA;
  632. pvopfRet -> m_piiA = *m_piiA / vl;
  633. delete pvopfRet -> m_piiBY;
  634. pvopfRet -> m_piiBY = new CIntImage (*m_piiBY); // alpha is unchanged
  635. delete pvopfRet -> m_piiBUV;
  636. pvopfRet -> m_piiBUV = new CIntImage (*m_piiBUV); // alpha is unchanged
  637. return pvopfRet;
  638. }
  640. own CVOPIntYUVBA* CVOPIntYUVBA::average (const CVOPIntYUVBA& vopi) const
  641. {
  642. assert (whereY () == vopi.whereY () && whereUV () == vopi.whereUV ());
  643. // CVOPIntYUVBA* pvopfRet = new CVOPIntYUVBA (whereY (), m_fAUsage);
  644. CVOPIntYUVBA* pvopfRet = new CVOPIntYUVBA (m_fAUsage, whereY ());
  645. assert (pvopfRet != NULL);
  646. delete pvopfRet -> m_piiY;
  647. pvopfRet -> m_piiY = m_piiY -> average (*vopi.getPlane (Y_PLANE));
  648. delete pvopfRet -> m_piiU;
  649. pvopfRet -> m_piiU = m_piiU -> average (*vopi.getPlane (U_PLANE));
  650. delete pvopfRet -> m_piiV;
  651. pvopfRet -> m_piiV = m_piiV -> average (*vopi.getPlane (V_PLANE));
  652. delete pvopfRet -> m_piiA;
  653. pvopfRet -> m_piiA = m_piiA -> average (*vopi.getPlane (A_PLANE));
  654. delete pvopfRet -> m_piiBY;
  655. pvopfRet -> m_piiBY = new CIntImage (*m_piiBY); // alpha is defined as the first one
  656. delete pvopfRet -> m_piiBUV;
  657. pvopfRet -> m_piiBUV = new CIntImage (*m_piiBUV); // alpha is defined as the first one
  658. return pvopfRet;
  659. }