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

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

流媒体/Mpeg4/MP4

开发平台：

Visual C++

decoder.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. and edited by
  13. Hiroyuki Katata (katata@imgsl.mkhar.sharp.co.jp), Sharp Corporation
  14. Norio Ito (norio@imgsl.mkhar.sharp.co.jp), Sharp Corporation
  15. Shuichi Watanabe (watanabe@imgsl.mkhar.sharp.co.jp), Sharp Corporation
  16. (date: October, 1997)
  18. and also edited by
  19. Dick van Smirren (D.vanSmirren@research.kpn.com), KPN Research
  20. Cor Quist (C.P.Quist@research.kpn.com), KPN Research
  21. (date: July, 1998)
  23. in the course of development of the MPEG-4 Video (ISO/IEC 14496-2). 
  24. This software module is an implementation of a part of one or more MPEG-4 Video tools 
  25. as specified by the MPEG-4 Video. 
  26. ISO/IEC gives users of the MPEG-4 Video free license to this software module or modifications 
  27. thereof for use in hardware or software products claiming conformance to the MPEG-4 Video. 
  28. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. 
  29. The original developer of this software module and his/her company, 
  30. the subsequent editors and their companies, 
  31. and ISO/IEC have no liability for use of this software module or modifications thereof in an implementation. 
  32. Copyright is not released for non MPEG-4 Video conforming products. 
  33. Sharp retains full right to use the code for his/her own purpose, 
  34. assign or donate the code to a third party and to inhibit third parties from using the code for non <MPEG standard> conforming products. 
  35. This copyright notice must be included in all copies or derivative works. 
  37. Copyright (c) 1997.
  39. Module Name:
  41. tps_decoder.cpp
  43. Abstract:
  45. caller for decoder for temporal scalability
  47. Revision History:
  49. *************************************************************************/
  51. #include <stdio.h>
  52. #include <stdlib.h>
  53. #include <iostream.h>
  54. #include <fstream.h>
  56. #ifdef __PC_COMPILER_
  57. #include <windows.h>
  58. #include <mmsystem.h>
  59. #endif // __PC_COMPILER_
  61. #include "typeapi.h"
  62. #include "mode.hpp"
  63. #include "vopses.hpp"
  64. #include "entropy/bitstrm.hpp"
  65. #include "tps_enhcbuf.hpp"
  66. #include "decoder/enhcbufdec.hpp"
  67. #include "decoder/vopsedec.hpp"
  69. #include "dataStruct.hpp"
  71. #ifndef __GLOBAL_VAR_
  72. #define __GLOBAL_VAR_
  73. #endif
  75. #include "global.hpp"
  77. #ifdef __MFC_
  78. #ifdef _DEBUG
  79. #undef THIS_FILE
  80. static char BASED_CODE THIS_FILE[] = __FILE__;
  81. #endif
  82. #define new DEBUG_NEW
  83. #endif // __MFC_
  85. Void dumpFrame (const CVOPU8YUVBA* pvopcQuant, FILE* pfYUV, FILE* pfSeg, AlphaUsage, CRct& rct, UInt nBits, Int iAlphaScale, Int DumpSkip);
  88. #define MAX_TIME 99999 // for bitstreams stopped at BVOP
  89. #define USAGE "Usage: tDECODER bitstream_file [enhn_layer_bitstream_file] output_file width heightn
  90. or:    tDECODER -vtc bitstream_file output_file target_spatial_layer target_snr_layern"
  92. // Main Routine
  93. int main(int argc, char* argv[])
  94. {
  95. Bool bScalability = 0;
  96. Bool bWavelet = 0;
  98. Bool main_short_video_header; // Added by KPN for short headers [FDS]
  100. main_short_video_header = FALSE; 
  102. if(argc>1 && strcmp(argv[1],"-vtc")==0)
  103. {
  104. bWavelet = 1;
  105. if(argc != 6)
  106. {
  107. fprintf(stderr,USAGE);
  108. exit(1);
  109. }
  110. }
  111. else
  112. {
  113. if (argc < 5 || argc > 6) {
  114. fprintf (stderr,USAGE);
  115. exit(1);
  116. }
  117. else if (argc == 6)
  118. bScalability = 1;
  119. }
  122. FILE *pfBits;
  123. if ((pfBits = fopen (argv [bWavelet + 1], "rb")) == NULL )
  124. fatal_error("Bitstream File Not Found");
  125. fclose (pfBits);
  126. if (bScalability) {
  127. if ((pfBits = fopen (argv [2], "rb")) == NULL )
  128. fatal_error("Bitstream File for Enhancement Layer Not Foundn");
  129. fclose (pfBits);
  130. }
  133. if(bWavelet)
  134. {
  135. /////  WAVELET VTC: begin   /////////////////////////
  136. CVTCDecoder vtcdec;
  138. // start VTC decoding 
  139. // argv[1]: "-vtc"
  140. // argv[2]: bitstream file
  141. // argv[3]: decoded image file
  142. // argv[4]: target spatial layer
  143. // argv[5]: target SNR layer
  144. vtcdec.decode(argv[2], argv[3], atoi(argv[4]), atoi(argv[5]) );
  146. return 0;
  147. /////// WAVELET VTC: end   /////////////////////////
  148. }
  150. CRct rctDisplay       (0, 0, atoi (argv [3 + bScalability]), atoi (argv [4 + bScalability]));
  151. /*Added */
  152. CRct rctDisplay_SSenh (0, 0, atoi (argv [3 + bScalability]), atoi (argv [4 + bScalability]));
  154. Bool bTemporalScalability = 0;
  156. if (bScalability){
  157. CVideoObjectDecoder* pvodec_tps[2];
  158. cout << "Checking scalability type...n";
  159. pvodec_tps[BASE_LAYER] = new CVideoObjectDecoder (argv[1], rctDisplay.width, rctDisplay.height (), NULL, &main_short_video_header);
  160. pvodec_tps[ENHN_LAYER] = new CVideoObjectDecoder (argv[2], rctDisplay.width, rctDisplay.height (), NULL, &main_short_video_header);
  161. pvodec_tps[BASE_LAYER]->setClockRateScale( pvodec_tps[ENHN_LAYER] ); // added by Sharp (98/6/26)
  162. Time FirstBase = pvodec_tps[BASE_LAYER] -> senseTime ();
  163. Time FirstEnhn = pvodec_tps[ENHN_LAYER] -> senseTime ();
  165. if ( FirstBase != FirstEnhn ){
  166. bTemporalScalability = 1;
  167. cout << "Starting temporal scalability decoding...nn";
  168. }
  169. else{
  170. bTemporalScalability = 0;
  171. cout << "Starting spatial scalability decoding...nn";
  172. }
  174. delete pvodec_tps[BASE_LAYER];
  175. delete pvodec_tps[ENHN_LAYER];
  176. }
  178. if ( !bScalability || !bTemporalScalability ){
  179. CVideoObjectDecoder* pvodec [2];
  180. Bool bSpatialScalable = FALSE;
  181. //CRct rctDisplayBackup = rctDisplay; // for recovery from sprite decoding
  183. pvodec [BASE_LAYER] = new CVideoObjectDecoder (argv [1], rctDisplay.width, rctDisplay.height(), &bSpatialScalable, &main_short_video_header);
  185. // NBIT: get nBits information
  186. UInt nBits = pvodec [BASE_LAYER]->volmd ().nBits;
  188. /* Added*/
  189. if (bScalability){
  190. pvodec [ENHN_LAYER] = new CVideoObjectDecoder (argv [2], rctDisplay.width, rctDisplay.height(), &bSpatialScalable, &main_short_video_header);
  191. /*Added*/
  192. if(bSpatialScalable)
  193. pvodec[ENHN_LAYER]->set_enh_display_size(rctDisplay, &rctDisplay_SSenh);
  194. }
  195. if (pvodec [BASE_LAYER] -> fSptUsage () == 1) {
  196. // decode the initial sprite: //wchen: instead of calling decode ()
  197. pvodec [BASE_LAYER] -> decodeInitSprite ();
  198. }
  200. FILE* pfReconYUV [2];
  201. Char pchTmp [100];
  202. sprintf (pchTmp, "%s.yuv", argv [2 + bScalability]);
  203. pfReconYUV [BASE_LAYER] = fopen (pchTmp, "wb");
  204. fatal_error("cant open output yuv file",pfReconYUV [BASE_LAYER] != NULL);
  205. if (bScalability) {
  206. sprintf (pchTmp, "%s_e.yuv", argv [2 + bScalability]);
  207. pfReconYUV [ENHN_LAYER]= fopen (pchTmp, "wb");
  208. fatal_error("cant open enhancement layer output yuv file",pfReconYUV [ENHN_LAYER] != NULL);
  209. }
  210. sprintf (pchTmp, "%s.seg", argv [2 + bScalability]);
  211. FILE* pfReconSeg = NULL;
  212. if (pvodec [BASE_LAYER]-> volmd ().fAUsage != RECTANGLE) {
  213. pfReconSeg = fopen (pchTmp, "wb");
  214. fatal_error("cant open output seg file",pfReconSeg != NULL);
  215. }
  217. Int iEof = 1;
  218. Int nFrames = 0;
  219. const CVOPU8YUVBA* pvopcQuant;
  220. #ifdef __PC_COMPILER_
  221. Int tickBegin = ::GetTickCount ();
  222. #endif // __PC_COMPILER_
  223. Bool bCachedRefFrame = FALSE;
  224. Bool bCachedRefFrameCoded = FALSE;
  225. while (iEof != EOF)
  226. {
  227. if (main_short_video_header) // Added by KPN for short headers
  228. {
  229. fprintf(stderr,"Frame number: %dn", nFrames);
  230. iEof = pvodec [BASE_LAYER] -> h263_decode ();
  231. }
  232. else
  233. iEof = pvodec [BASE_LAYER] -> decode ();  
  234. if (iEof != EOF)
  235. nFrames++;
  236. if(pvodec [BASE_LAYER] -> fSptUsage () == 1)
  237. {
  238. // sprite
  239. if(iEof != EOF)
  240. {
  241. pvopcQuant = pvodec [BASE_LAYER]->pvopcReconCurr();
  242. dumpFrame (pvopcQuant, pfReconYUV [BASE_LAYER], pfReconSeg, pvodec[BASE_LAYER]->volmd().fAUsage, rctDisplay,
  243. nBits, pvodec [BASE_LAYER]->vopmd().iVopConstantAlphaValue, 0);
  244. }
  245. }
  246. else
  247. {
  248. if(iEof == EOF)
  249. {
  250. // dump final cached frame if present
  251. if(bCachedRefFrame)
  252. {
  253. bCachedRefFrame = FALSE;
  254. if(bCachedRefFrameCoded)
  255. {
  256. pvopcQuant = pvodec [BASE_LAYER]->pvopcRefQLater(); // future reference
  257. dumpFrame (pvopcQuant, pfReconYUV [BASE_LAYER], pfReconSeg, pvodec[BASE_LAYER]->volmd().fAUsage, rctDisplay,
  258. nBits, pvodec [BASE_LAYER]->vopmd().iVopConstantAlphaValue, 0);
  259. }
  260. else // non coded
  261. dumpNonCodedFrame(pfReconYUV [BASE_LAYER], pfReconSeg, rctDisplay, nBits);
  262. }
  263. }
  264. else
  265. {
  266. // dump if bvop
  267. if(pvodec[BASE_LAYER]->vopmd().vopPredType == BVOP)
  268. {
  269. // BVOP
  270. if(iEof != FALSE)
  271. {
  272. pvopcQuant = pvodec [BASE_LAYER]->pvopcReconCurr(); // current vop
  273. dumpFrame (pvopcQuant, pfReconYUV [BASE_LAYER], pfReconSeg, pvodec[BASE_LAYER]->volmd().fAUsage, rctDisplay,
  274. nBits, pvodec [BASE_LAYER]->vopmd().iVopConstantAlphaValue, 0);
  275. }
  276. else // non coded BVOP
  277. dumpNonCodedFrame(pfReconYUV [BASE_LAYER], pfReconSeg, rctDisplay, nBits);
  278. }
  279. else
  280. {
  281. // not a BVOP, so dump any previous cached frame
  282. if(bCachedRefFrame)
  283. {
  284. bCachedRefFrame = FALSE;
  285. if(bCachedRefFrameCoded)
  286. {
  287. pvopcQuant = pvodec [BASE_LAYER]->pvopcRefQPrev(); // past reference
  288. dumpFrame (pvopcQuant, pfReconYUV [BASE_LAYER], pfReconSeg, pvodec[BASE_LAYER]->volmd().fAUsage, rctDisplay,
  289. nBits, pvodec [BASE_LAYER]->vopmd().iVopConstantAlphaValue, 0);
  290. }
  291. else // non coded
  292. dumpNonCodedFrame(pfReconYUV [BASE_LAYER], pfReconSeg, rctDisplay, nBits);
  293. }
  295. // cache current reference
  296. bCachedRefFrame = TRUE;
  297. bCachedRefFrameCoded = (iEof != FALSE);
  298. }
  299. }
  300. }
  302. if (bSpatialScalable == TRUE) {
  303. // if base layer is non coded, pvopcQuant=NULL, but enh layer should also be non coded.
  304. if(iEof == FALSE)
  305. pvopcQuant = NULL;
  306. else
  307. pvopcQuant = pvodec [BASE_LAYER]->pvopcReconCurr();
  308. iEof = pvodec [ENHN_LAYER] -> decode (pvopcQuant);
  309. if(iEof!=EOF)
  310. nFrames++; // include enhancement layer
  311. if(iEof==FALSE)
  312. dumpNonCodedFrame(pfReconYUV [ENHN_LAYER], NULL, rctDisplay_SSenh, nBits);
  313. /* dumpNonCodedFrame(pfReconYUV [ENHN_LAYER], NULL, rctDisplay * 2, nBits);*/
  315. if (iEof != EOF && iEof!=FALSE)
  316. /*Added*/
  317. dumpFrame (pvodec [ENHN_LAYER]->pvopcReconCurr (), pfReconYUV [ENHN_LAYER], NULL, RECTANGLE, rctDisplay_SSenh,
  318. nBits, pvodec [BASE_LAYER]->vopmd().iVopConstantAlphaValue, 0); // still base layer
  319. /*
  320. dumpFrame (pvodec [ENHN_LAYER]->pvopcReconCurr (), pfReconYUV [ENHN_LAYER], NULL, RECTANGLE, rctDisplay * 2,
  321. nBits, pvodec [BASE_LAYER]->vopmd().iVopConstantAlphaValue, 0); // still base layer
  322. */
  323. }
  324. }
  326. #ifdef __PC_COMPILER_
  327. Int tickAfter = ::GetTickCount ();
  328. printf ("Total time: %dn", tickAfter - tickBegin);
  329. Double dAverage = (Double) (tickAfter - tickBegin) / (Double) (nFrames);
  330. printf ("Total frames: %dtAverage time: %.6lfn", nFrames, dAverage);
  331. printf ("FPS %.6lfn", 1000.0 / dAverage);
  332. #endif // __PC_COMPILER_
  334. fclose (pfReconYUV [BASE_LAYER]);
  335. if (pvodec [BASE_LAYER]->volmd ().fAUsage != RECTANGLE)
  336. fclose (pfReconSeg);
  337. delete pvodec [BASE_LAYER];
  338. if (bScalability) {
  339. fclose (pfReconYUV [ENHN_LAYER]);
  340. delete pvodec [ENHN_LAYER];
  341. }
  343. }
  344. else { // loop for temporal scalability
  345. CVideoObjectDecoder* pvodec[2];
  346. pvodec[BASE_LAYER] = new CVideoObjectDecoder (argv[1], rctDisplay.width, rctDisplay.height (), NULL, &main_short_video_header); // modified by Sharp (98/7/16)
  348. UInt nBits = pvodec [BASE_LAYER]->volmd ().nBits; // added by Sharp (98/11/11)
  349. if(bScalability){
  350. pvodec[ENHN_LAYER] = new CVideoObjectDecoder (argv[2], rctDisplay.width, rctDisplay.height (), NULL, &main_short_video_header); // modified by Sharp (98/7/16)
  351. // for back/forward shape
  352. pvodec[ENHN_LAYER]->rgpbfShape[0] = new CVideoObjectDecoder (rctDisplay.width, rctDisplay.height ());
  353. pvodec[ENHN_LAYER]->rgpbfShape[1] = new CVideoObjectDecoder (rctDisplay.width, rctDisplay.height ());
  354. pvodec[BASE_LAYER]->setClockRateScale( pvodec[ENHN_LAYER] );
  355. // copy pointers
  356. pvodec[ENHN_LAYER]->copyTobfShape ();
  357. }
  359. Char pchTmp [100];
  360. FILE* pfReconYUV [2]; // following two lines are swapped by Sharp (98/10/26)
  361. #ifndef __OUT_ONE_FRAME_
  362. sprintf (pchTmp, "%s.yuv", argv [2 + bScalability]);
  363. pfReconYUV [BASE_LAYER] = fopen (pchTmp, "wb");
  364. fatal_error("cant open output yuv file",pfReconYUV [BASE_LAYER] != NULL);
  365. if (bScalability) {
  366. // sprintf (pchTmp, "%s_e.yuv", argv [2 + bScalability]); // deleted by Sharp (98/10/26)
  367. // pfReconYUV [ENHN_LAYER]= fopen (pchTmp, "wb"); // deleted by Sharp (98/10/26)
  368. pfReconYUV [ENHN_LAYER] = pfReconYUV [BASE_LAYER]; // added by Sharp (98/10/26)
  369. fatal_error("cant open enhancement layer output yuv file",pfReconYUV [ENHN_LAYER] != NULL);
  370. }
  371. sprintf (pchTmp, "%s.seg", argv [2 + bScalability]);
  372. FILE* pfReconSeg [2];
  373. if (pvodec [BASE_LAYER]-> volmd ().fAUsage != RECTANGLE) {
  374. pfReconSeg [BASE_LAYER] = fopen (pchTmp, "wb");
  375. fatal_error("cant open output seg file",pfReconSeg [BASE_LAYER] != NULL);
  376. }
  377. if (bScalability) {
  378. if (pvodec [ENHN_LAYER]-> volmd ().fAUsage != RECTANGLE) {
  379. if (pvodec [ENHN_LAYER]-> volmd ().iEnhnType == 1) { // added by Sharp (98/10/26)
  380. sprintf (pchTmp, "%s_e.seg", argv [2 + bScalability]);
  381. pfReconSeg [ENHN_LAYER]= fopen (pchTmp, "wb");
  382. } else // added by Sharp (98/10/26)
  383. pfReconSeg [ENHN_LAYER]= pfReconSeg [BASE_LAYER]; // added by Sharp (98/10/26)
  384. fatal_error("cant open output enhancement layer seg file",pfReconSeg [ENHN_LAYER] != NULL);
  385. }
  386. }
  388. // begin: deleted by Sharp (98/10/26)
  389. // if (bScalability) 
  390. // if (pvodec [ENHN_LAYER]-> volmd ().iEnhnType == 1) {
  391. // FILE *pfTemp;
  392. // sprintf (pchTmp, "%s_bgc.yuv", argv [2 + bScalability]);
  393. // pfTemp = fopen (pchTmp, "wb");  // clear file pointer for background composition
  394. // fclose(pfTemp);
  395. // }
  396. // end: delted by Sharp (98/10/26)
  397. #endif
  398. // for back/forward shape output 
  399. FILE* pfTestSeg = NULL;
  400. if (bScalability)
  401. if (pvodec [ENHN_LAYER]-> volmd ().iEnhnType == 1) {
  402. sprintf (pchTmp, "%s.bfseg", argv [2 + bScalability]);
  403. pfTestSeg = fopen (pchTmp, "wb"); //reconstructed Seg file(bfShape)
  404. fatal_error("cant open output bfseg file",pfTestSeg!=NULL);
  405. }
  407. int iEof = 1;
  408. #ifdef __PC_COMPILER_
  409. Int tickBegin = ::GetTickCount ();
  410. #endif // __PC_COMPILER_
  411. Time tPvopBase, tNextBase, tNextEnhc = 0;
  412. int nBaseFrames = 0;
  413. int nEnhcFrames = 0;
  414. Bool bCacheRefFrame = FALSE; // added by Sharp (98/11/18)
  415. Bool bCachedRefFrameCoded = FALSE; // added by Sharp (99/1/28)
  417. tNextBase = pvodec[BASE_LAYER] -> senseTime();
  418. while (iEof != EOF) {
  420. if (pvodec[BASE_LAYER] -> getPredType () != BVOP) { // for bitstreams stopped at BVOP
  421. iEof = pvodec[BASE_LAYER] -> decode ();
  422. if(iEof == EOF)
  423. break;
  424. if(bScalability)
  425. pvodec[BASE_LAYER] -> updateBuffVOPsBase (pvodec[ENHN_LAYER]);
  426. nBaseFrames ++;
  428. // Output BASE_LAYER
  429. #ifndef __OUT_ONE_FRAME_
  430. // begin: added by Sharp (98/11/11)
  431. if ( bCacheRefFrame ) {  // modified by by Sharp (98/11/18)
  432. if ( bCachedRefFrameCoded ) // added by Sharp (99/1/28)
  433. dumpFrame (pvodec[BASE_LAYER]->pvopcRefQPrev() , pfReconYUV [BASE_LAYER], pfReconSeg[BASE_LAYER], pvodec[BASE_LAYER]->volmd().fAUsage, rctDisplay,
  434. nBits, pvodec [BASE_LAYER]->vopmd().iVopConstantAlphaValue,  0 );
  435. else // added by Sharp (99/1/28)
  436. dumpNonCodedFrame( pfReconYUV[BASE_LAYER], pfReconSeg[BASE_LAYER], rctDisplay, nBits); // added by Sharp (99/1/28)
  437. }
  438. // begin: added by Sharp (98/11/18)
  439. else {
  440. bCacheRefFrame = TRUE;
  441. }
  442. // end: added by Sharp (98/11/18)
  443. // end: added by Sharp (98/11/11)
  444. // pvodec [BASE_LAYER]->dumpDataAllFrame (pfReconYUV [BASE_LAYER], pfReconSeg [BASE_LAYER], rctDisplay); // deleted by Sharp (98/11/11)
  445. #else
  446. pvodec [BASE_LAYER]->dumpDataOneFrame(argv, bScalability, rctDisplay);
  447. #endif
  449. bCachedRefFrameCoded = (iEof != FALSE); // added by Sharp(99/1/28)
  450. tPvopBase = pvodec[BASE_LAYER] -> getTime ();
  451. }
  452. else { // for bitstreams stopped at BVOP
  453. tPvopBase = MAX_TIME;
  454. pvodec[BASE_LAYER] -> copyRefQ1ToQ0 ();
  455. }
  457. tNextBase = pvodec[BASE_LAYER] -> senseTime ();
  458. while((tPvopBase > tNextBase) && (tNextBase != EOF)) {
  459. iEof = pvodec[BASE_LAYER] -> decode ();
  460. if(bScalability)
  461. pvodec[BASE_LAYER] -> updateBuffVOPsBase (pvodec[ENHN_LAYER]);
  463. // Output BASE_LAYER
  464. if (iEof != EOF) {
  465. nBaseFrames ++; 
  466. // begin: deleted by Sharp (98/11/11)
  467. // #ifndef __OUT_ONE_FRAME_
  468. //  pvodec [BASE_LAYER]->dumpDataAllFrame (pfReconYUV [BASE_LAYER], pfReconSeg [BASE_LAYER], rctDisplay); // deleted by Sharp (98/11/11)
  469. // #else
  470. // end: deleted by Sharp (98/11/11)
  472. #ifdef __OUT_ONE_FRAME_ // added by Sharp (98/11/11)
  473. pvodec [BASE_LAYER]->dumpDataOneFrame(argv, bScalability, rctDisplay);
  474. #endif
  475. }
  477. if(bScalability && tNextEnhc != EOF) {
  478. tNextEnhc = pvodec[ENHN_LAYER] -> senseTime ();
  479. while((tNextBase > tNextEnhc) && (tNextEnhc != EOF)) {
  480. iEof = pvodec[ENHN_LAYER] -> decode ();
  481. nEnhcFrames ++;
  482. if (pvodec [ENHN_LAYER] -> volmd ().fAUsage != RECTANGLE) {
  483. // for background composition
  484. if(pvodec [ENHN_LAYER] -> volmd ().iEnhnType == 1) { 
  485. // should be changed to background_composition flag later.
  486. printf("============== background composition (1)n");
  487. pvodec [ENHN_LAYER] -> BackgroundComposition(argv, bScalability, rctDisplay.width, rctDisplay.height (), pfReconYUV[ENHN_LAYER]); // modified by Sharp (98/10/26)
  488. }
  489. // for back/forward shape
  490. if(pvodec [ENHN_LAYER] -> vopmd ().iLoadBakShape) {
  491. printf("---------- output backward shapen");
  492. const CVOPU8YUVBA* pvopcQuant = pvodec [ENHN_LAYER]->rgpbfShape[0]->pvopcReconCurr ();
  493. pvopcQuant->getPlane (BY_PLANE)->dump (pfTestSeg, rctDisplay);
  494. }
  495. if(pvodec [ENHN_LAYER] -> vopmd ().iLoadForShape) {
  496. printf("---------- output forward shapen");
  497. const CVOPU8YUVBA* pvopcQuant = pvodec [ENHN_LAYER]->rgpbfShape[1]->pvopcReconCurr ();
  498. pvopcQuant->getPlane (BY_PLANE)->dump (pfTestSeg, rctDisplay);
  499. }
  500. }
  502. // Output ENHN_LAYER
  503. if (iEof != EOF) {
  504. // if ( pvodec [ENHN_LAYER] -> volmd ().iEnhnType != 1 ){ // added by Sharp (98/10/26) //deleted by Sharp (99/1/25)
  505. #ifndef __OUT_ONE_FRAME_
  506. // begin: added by Sharp (99/1/28)
  507. if ( iEof != FALSE ){
  508. dumpFrame (pvodec[ENHN_LAYER]->pvopcReconCurr(), pfReconYUV [ENHN_LAYER], pfReconSeg[ENHN_LAYER], pvodec[ENHN_LAYER]->volmd().fAUsage, rctDisplay,
  509. nBits, pvodec [ENHN_LAYER]->vopmd().iVopConstantAlphaValue,  pvodec[ENHN_LAYER]->volmd().iEnhnType );
  510. }
  511. else
  512. dumpNonCodedFrame(pfReconYUV[ENHN_LAYER], pfReconSeg[ENHN_LAYER], rctDisplay, nBits);
  513. // end: added by Sharp (99/1/28)
  514. // pvodec [ENHN_LAYER]->dumpDataAllFrame (pfReconYUV [ENHN_LAYER], pfReconSeg [ENHN_LAYER], rctDisplay); // deleted by Sharp (99/1/28)
  515. #else
  516. pvodec [ENHN_LAYER]->dumpDataOneFrame(argv, bScalability, rctDisplay);
  517. #endif
  518. // } // added by Sharp (98/10/26) // deleted by Sharp (99/1/25)
  519. }
  521. tNextEnhc = pvodec[ENHN_LAYER] -> senseTime ();
  522. }
  523. }
  524. // begin: added by Sharp (98/11/11)
  525. #ifndef __OUT_ONE_FRAME_
  526. if ( iEof != FALSE )
  527. dumpFrame (pvodec[BASE_LAYER]->pvopcReconCurr() , pfReconYUV [BASE_LAYER], pfReconSeg[BASE_LAYER], pvodec[BASE_LAYER]->volmd().fAUsage, rctDisplay,
  528. nBits, pvodec [BASE_LAYER]->vopmd().iVopConstantAlphaValue,  0 );
  529. else
  530. dumpNonCodedFrame(pfReconYUV[BASE_LAYER], pfReconSeg[BASE_LAYER], rctDisplay, nBits);
  531. #endif
  532. // end: added by Sharp (98/11/11)
  533. tNextBase = pvodec[BASE_LAYER] -> senseTime ();
  534. }
  537. if(bScalability && (tNextEnhc = pvodec[ENHN_LAYER] -> senseTime ()) != EOF) { // modified by Sharp (99/1/25)
  538. pvodec[ENHN_LAYER] -> bufferB2flush ();
  540. // tNextEnhc = pvodec[ENHN_LAYER] -> senseTime (); // deleted by Sharp (99/1/25)
  541. while((tPvopBase > tNextEnhc) && (tNextEnhc != EOF)) {
  542. iEof = pvodec[ENHN_LAYER] -> decode ();
  543. nEnhcFrames ++;
  544. if (pvodec [ENHN_LAYER] -> volmd ().fAUsage != RECTANGLE) {
  545. // for background composition
  546. if(pvodec [ENHN_LAYER] -> volmd ().iEnhnType == 1) {
  547. // should be changed to background_composition flag later.
  548. printf("============== background composition (2)n");
  549. pvodec [ENHN_LAYER] -> BackgroundComposition(argv, bScalability, rctDisplay.width, rctDisplay.height (), pfReconYUV [ENHN_LAYER]); // modified by Sharp (98/10/26)
  550. }
  551. // for back/forward shape
  552. if(pvodec [ENHN_LAYER] -> vopmd ().iLoadBakShape) {
  553. printf("---------- output backward shapen");
  554. const CVOPU8YUVBA* pvopcQuant = pvodec [ENHN_LAYER]->rgpbfShape[0]->pvopcReconCurr ();
  555. pvopcQuant->getPlane (BY_PLANE)->dump (pfTestSeg, rctDisplay);
  556. }
  557. if(pvodec [ENHN_LAYER] -> vopmd ().iLoadForShape) {
  558. printf("---------- output forward shapen");
  559. const CVOPU8YUVBA* pvopcQuant = pvodec [ENHN_LAYER]->rgpbfShape[1]->pvopcReconCurr ();
  560. pvopcQuant->getPlane (BY_PLANE)->dump (pfTestSeg, rctDisplay);
  561. }
  562. }
  564. // Output ENHN_LAYER
  565. if (iEof != EOF) {
  566. // if ( pvodec [ENHN_LAYER] -> volmd ().iEnhnType != 1 ){ // added by Sharp (98/11/18) // deleted by Sharp (99/1/25)
  567. #ifndef __OUT_ONE_FRAME_
  568. // begin: added by Sharp (99/1/28)
  569. if ( iEof != FALSE )
  570. dumpFrame (pvodec[ENHN_LAYER]->pvopcReconCurr(), pfReconYUV [ENHN_LAYER], pfReconSeg[ENHN_LAYER], pvodec[ENHN_LAYER]->volmd().fAUsage, rctDisplay,
  571. nBits, pvodec [ENHN_LAYER]->vopmd().iVopConstantAlphaValue,  pvodec[ENHN_LAYER]->volmd().iEnhnType );
  572. else
  573. dumpNonCodedFrame(pfReconYUV[ENHN_LAYER], pfReconSeg[ENHN_LAYER], rctDisplay, nBits);
  574. // end: added by Sharp (99/1/28)
  575. // pvodec [ENHN_LAYER]->dumpDataAllFrame (pfReconYUV [ENHN_LAYER], pfReconSeg [ENHN_LAYER], rctDisplay); // deleted by Sharp (99/1/28)
  576. #else
  577. pvodec [ENHN_LAYER]->dumpDataOneFrame(argv, bScalability, rctDisplay);
  578. #endif
  579. // }// added by Sharp (98/11/18) // deleted by Sharp (99/1/25)
  580. }
  581. tNextEnhc = pvodec[ENHN_LAYER] -> senseTime ();
  582. }
  584. // begin: deleted by Sharp (99/1/25)
  585. /*
  586. if((tPvopBase == tNextEnhc) && (tNextEnhc != EOF)) { // for Spatial Scalability
  587. pvodec[ENHN_LAYER] -> copyBufP2ToB1 ();
  588. iEof = pvodec[ENHN_LAYER] -> decode ();
  589. nEnhcFrames ++;
  590. }
  591. */
  592. // end: deleted by Sharp (99/1/25)
  594. // begin: added by Sharp (99/1/20)
  595.       iEof = tNextBase;
  596. #ifndef __OUT_ONE_FRAME_
  597. // begin: added by Sharp (99/1/28)
  598.       if ( iEof == EOF )
  599. if ( bCachedRefFrameCoded )
  600. // end: added by Sharp (99/1/28)
  601.         dumpFrame (pvodec[BASE_LAYER]->pvopcRefQLater() , pfReconYUV [BASE_LAYER], pfReconSeg[BASE_LAYER], pvodec[BASE_LAYER]->volmd().fAUsage, rctDisplay,
  602.           nBits, pvodec [BASE_LAYER]->vopmd().iVopConstantAlphaValue,  0 );
  603. // begin: added by Sharp (99/1/28)
  604. else
  605. dumpNonCodedFrame(pfReconYUV[BASE_LAYER], pfReconSeg[BASE_LAYER], rctDisplay, nBits);
  606. // end: added by Sharp (99/1/28)
  607. #endif
  608. // end: added by Sharp (99/1/20)
  611. pvodec[ENHN_LAYER] -> bufferB1flush ();
  613. // Enhancement Layer after Base BVOP
  614. if (tNextBase == EOF && tNextEnhc != EOF) {
  615. pvodec[ENHN_LAYER] -> copyBufP2ToB1 ();
  616. while(tNextEnhc != EOF) {
  617. iEof = pvodec[ENHN_LAYER] -> decode ();
  618. nEnhcFrames ++;
  620. if (pvodec [ENHN_LAYER] -> volmd ().fAUsage != RECTANGLE) {
  621. // for background composition
  622. if(pvodec [ENHN_LAYER] -> volmd ().iEnhnType == 1) {
  623. // should be changed to background_composition flag later.
  624. printf("============== background composition (2)n");
  625. pvodec [ENHN_LAYER] -> BackgroundComposition(argv, bScalability, rctDisplay.width, rctDisplay.height (), pfReconYUV [ENHN_LAYER]); // Modified after Sharp (98/10/26)
  626. }
  627. // for back/forward shape
  628. if(pvodec [ENHN_LAYER] -> vopmd ().iLoadBakShape) {
  629. printf("---------- output backward shapen");
  630. const CVOPU8YUVBA* pvopcQuant = pvodec [ENHN_LAYER]->rgpbfShape[0]->pvopcReconCurr ();
  631. pvopcQuant->getPlane (BY_PLANE)->dump (pfTestSeg, rctDisplay);
  632. }
  633. if(pvodec [ENHN_LAYER] -> vopmd ().iLoadForShape) {
  634. printf("---------- output forward shapen");
  635. const CVOPU8YUVBA* pvopcQuant = pvodec [ENHN_LAYER]->rgpbfShape[1]->pvopcReconCurr ();
  636. pvopcQuant->getPlane (BY_PLANE)->dump (pfTestSeg, rctDisplay);
  637. }
  638. }
  640. // Output ENHN_LAYER
  641. if (iEof != EOF) {
  642. // if ( pvodec [ENHN_LAYER] -> volmd ().iEnhnType != 1 ){ // added by Sharp (98/11/18) // deleted by Sharp (99/1/25)
  643. #ifndef __OUT_ONE_FRAME_
  644. if ( iEof != FALSE )
  645. dumpFrame (pvodec[ENHN_LAYER]->pvopcReconCurr(), pfReconYUV [ENHN_LAYER], pfReconSeg[ENHN_LAYER], pvodec[ENHN_LAYER]->volmd().fAUsage, rctDisplay,
  646. nBits, pvodec [ENHN_LAYER]->vopmd().iVopConstantAlphaValue,  pvodec[ENHN_LAYER]->volmd().iEnhnType );
  647. else
  648. dumpNonCodedFrame(pfReconYUV[ENHN_LAYER], pfReconSeg[ENHN_LAYER], rctDisplay, nBits);
  649. // pvodec [ENHN_LAYER]->dumpDataAllFrame (pfReconYUV [ENHN_LAYER], pfReconSeg [ENHN_LAYER], rctDisplay);
  650. #else
  651. pvodec [ENHN_LAYER]->dumpDataOneFrame(argv, bScalability, rctDisplay);
  652. #endif
  653. // }// added by Sharp (98/11/18) // deleted by Sharp (99/1/25)
  654. }
  655. tNextEnhc = pvodec[ENHN_LAYER] -> senseTime ();
  656. }
  657. pvodec[ENHN_LAYER] -> bufferB1flush ();
  658. }
  659. }
  661. // begin: deleted by Sharp (99/1/28)
  662. // if (bScalability) 
  663. // pvodec[ENHN_LAYER] -> bufferP1flush ();
  664. // end: deleted by Sharp (99/1/28)
  666. iEof = tNextBase;
  667. // begin: deleted by Sharp (99/1/25)
  668. /*
  669. // begin: added by Sharp (98/11/11)
  670. #ifndef __OUT_ONE_FRAME_
  671. if ( iEof == EOF )
  672. if ( iEof != FALSE )
  673. dumpFrame (pvodec[BASE_LAYER]->pvopcRefQLater() , pfReconYUV [BASE_LAYER], pfReconSeg[BASE_LAYER], pvodec[BASE_LAYER]->volmd().fAUsage, rctDisplay,
  674. nBits, pvodec [BASE_LAYER]->vopmd().iVopConstantAlphaValue,  0 );
  675. else
  676. dumpNonCodedFrame(pfReconYUV[ENHN_LAYER], pfReconSeg[ENHN_LAYER], rctDisplay, nBits);
  677. #endif
  678. // end: added by Sharp (98/11/11)
  679. */
  680. // end: deleted by Sharp (99/1/25)
  681. }
  683. #ifdef __PC_COMPILER_
  684. Int tickAfter = ::GetTickCount ();
  685. printf ("Total time: %dn", tickAfter - tickBegin);
  686. Double dAverage = (Double) (tickAfter - tickBegin) / (Double) (nBaseFrames + nEnhcFrames);
  687. printf ("Total frames: %dtAverage time: %.6lfn", nBaseFrames + nEnhcFrames, dAverage);
  688. printf ("FPS %.6lfn", 1000.0 / dAverage);
  689. #endif // __PC_COMPILER_
  691. #ifndef __OUT_ONE_FRAME_
  692. fclose (pfReconYUV[BASE_LAYER]);
  693. if (pvodec[BASE_LAYER]->volmd ().fAUsage != RECTANGLE)
  694. fclose (pfReconSeg [BASE_LAYER]);
  695. #endif
  696. delete pvodec[BASE_LAYER];
  697. if (bScalability) {
  698. #ifndef __OUT_ONE_FRAME_
  699. fclose (pfReconYUV[ENHN_LAYER]);
  700. if (pvodec[ENHN_LAYER]->volmd ().fAUsage != RECTANGLE)
  701. fclose (pfReconSeg [ENHN_LAYER]);
  702. #endif
  703. delete pvodec[ENHN_LAYER];
  704. }
  706. }
  708. return 0;
  709. }
  711. Void dumpFrame (const CVOPU8YUVBA* pvopcQuant, FILE* pfYUV, FILE* pfSeg, AlphaUsage fAUsage, CRct& rct, UInt nBits, Int iAlphaScale, Int DumpSkip)
  712. {
  713. if ( DumpSkip == 0 ){
  714. pvopcQuant->getPlane (Y_PLANE)->dump (pfYUV, rct);
  715. pvopcQuant->getPlane (U_PLANE)->dump (pfYUV, rct / 2);
  716. pvopcQuant->getPlane (V_PLANE)->dump (pfYUV, rct / 2);
  717. }
  718. if(pfSeg!=NULL)
  719. {
  720. if (fAUsage == ONE_BIT)
  721. pvopcQuant->getPlane (BY_PLANE)->dump (pfSeg, rct, iAlphaScale);
  722. else if (fAUsage == EIGHT_BIT)
  723. pvopcQuant->getPlane (A_PLANE)->dumpWithMask (pfSeg, pvopcQuant->getPlane (BY_PLANE),
  724. rct, iAlphaScale);
  725. }
  726. return;
  727. }