Category

Development Platform
Home > SourceCode/Document > Multimedia program > DVD > View Code
Jpeg.c
Package: tb_i86_wr_1019_1102.　[view]
Upload User: super_houu
Upload Date: 2008-09-21
Package Size: 4099k
Code Size: 25k
Category:

DVD

Development Platform:

Others

Jpeg.c：Code Content
  2. /****************************************************************************************
  3.  *  Copyright (c) 2000 ZORAN Corporation, All Rights Reserved
  4.  *  THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF ZORAN CORPORATION
  5.  *
  6.  *  File: $Workfile: Jpeg.c $             
  7.  *
  8.  * Description:
  9.  * ============
  10.  * JPEG Navigator implementation.
  11.  *
  12.  * Log:
  13.  * ====
  14.  ****************************************************************************************
  15.  * Updates:
  16.  ****************************************************************************************
  17.  * $Log: /I76/I76_Common/I76_Reference/Playcore/Nav_Clips/Jpeg.c $
  18.  * 
  19.  ****************************************************************************************/
  20. #include "Config.h" // Global Configuration - do not remove!
  22. #ifdef CLIPS_JPEG_SUPPORT
  24. #ifdef _DEBUG
  25. #undef IFTRACE
  26. #define IFTRACE if (gTraceNavigator)
  27. #include "DebugDbgMain.h"
  28. #endif
  30. #include "Includemath-macro.h"
  31. #include "KernelEventDef.H"
  32. #include "DecoderDecoder.h"
  33. #include "Drivedrv_api.h"
  34. #include "LogoLogo.h"
  35. #include "PlaycoreCoremainCoreGDef.h"
  36. #include "PlaycoreExceptionException.h"
  37. #include "PlaycoreNav_ClipsJPEG.h"
  38. #include "PlaycoreNav_ClipsClip_Impl.h"
  39. #include "PlaycoreNav_ClipsGenericClip.h"
  40. #include "PlaycoreNav_ClipsPE_Clips.h"
  42. #ifdef SUPPORT_FLASH_CARD
  43. #include "drivefe_manager.h"
  44. #endif
  47. /////////////////////////////////////////////////////////////////////////////
  48. // Globals and Singletions
  50. #define CURRENT_DISPLAY_BUFFER (gns.clips.globals.jpegGlobals.eJPEGCurrentDisplayBuffer)
  51. #define CURRENT_DECODE_BUFFER (gns.clips.globals.jpegGlobals.eJPEGCurrentDecodeBuffer)
  53. #define IS_CURRENT_DISPLAY_BUFFER_FRONT_R1 (CURRENT_DISPLAY_BUFFER == FRONT_R1_BUFFER )
  54. #define IS_CURRENT_DISPLAY_BUFFER_BACK_R2 (CURRENT_DISPLAY_BUFFER == BACK_R2_BUFFER )
  56. #define TOGGLE_CURRENT_DISPLAY_BUFFER (CURRENT_DISPLAY_BUFFER=(CURRENT_DISPLAY_BUFFER==FRONT_R1_BUFFER) ? BACK_R2_BUFFER : FRONT_R1_BUFFER)
  57. #define TOGGLE_CURRENT_DECODE_BUFFER (CURRENT_DECODE_BUFFER=(CURRENT_DECODE_BUFFER==FRONT_R1_BUFFER) ? BACK_R2_BUFFER : FRONT_R1_BUFFER)
  59. #define JPEG_PLAYBACK_FINISHED_WATCHDOG 100 // 20 seconds timeout since it's called in 200ms tick, it's necessary for some progressive JPEGs
  60. #define STOP_WATCHDOG 0xff
  62. #define bStopRequested (gns.clips.globals.jpegGlobals.bStopRequested)
  64. static UINT8 g_uPresentationTime= 0;
  65. static BYTE ucWatchDog = JPEG_PLAYBACK_FINISHED_WATCHDOG;
  67. #ifdef I77_COMPANION_CHIP
  68. static BOOL bJpegDecodeDone = FALSE;
  69. #endif
  71. #define JPEG_TOLERANCE_BYTES (LOGICAL_BLOCK_SIZE / 2)
  72. #define JPEG_IMAGESTATE_MASK 0x0F
  73. #define JPEG_ERROR_MASK 0xF0
  76. /////////////////////////////////////////////////////////////////////////////
  77. // Macros
  79. #define GET_IMAGESTATE(ucUserData)
  80. (enImageState)((ucUserData) & JPEG_IMAGESTATE_MASK)
  82. #define SET_IMAGESTATE(ucUserData, eState)
  83. ucUserData= ((ucUserData) & ~JPEG_IMAGESTATE_MASK) | (UINT8)eState
  85. #define GET_ERROR(ucUserData)
  86. (((ucUserData) & JPEG_ERROR_MASK) >> 4)
  88. #define SET_ERROR(ucUserData, eError)
  89. ucUserData= ((ucUserData) & ~JPEG_ERROR_MASK) | ((UINT8)eError << 4)
  92. /////////////////////////////////////////////////////////////////////////////
  93. // Enumerations
  95. typedef enum {
  96. eImageState_Idle,
  97. eImageState_Caching,
  98. eImageState_Cached,
  99. eImageState_Decoding,
  100. eImageState_Transitioning,
  101. eImageState_Error
  102. } enImageState;
  105. /////////////////////////////////////////////////////////////////////////////
  106. // Forward Declarations of Virtual Methods
  108. BOOL JPEGClip_play(Clip *i_pThis, const ClipMarker *i_pResumeMarker, BOOL bCacheOnly);
  109. void JPEGClip_pause(Clip *i_pThis, BOOL bEnable);
  110. enClipStatus JPEGClip_getStatus(const Clip *i_pThis);
  111. void JPEGClip_abort(Clip *i_pThis, BOOL bMaintainStandby);
  112. void JPEGClip_refresh(Clip *i_pThis);
  113. UINT16 JPEGClip_getTime(const Clip *i_pThis);
  114. void JPEGClip_digest(Clip *i_pThis);
  117. /////////////////////////////////////////////////////////////////////////////
  118. // Const Factory
  120. // Valid Extenions List
  121. BEGIN_CLIP_VALID_EXTENSIONS_MAP(JPEG)
  122. CLIP_VALID_EXTENSIONS_ENTRY(L"JPEG")
  123. CLIP_VALID_EXTENSIONS_ENTRY(L"JPG")
  124. END_CLIP_VALID_EXTENSIONS_MAP()
  126. // Constant Attributes
  127. #ifndef D_ENABLE_JPEG_CACHE
  128. DECLARE_CLIP_CONST_ATTR(JPEG, 
  129. DECLARE_CLIP_VTABLE(GenericClip_getExtendedInfo,
  130. JPEGClip_play,
  131. JPEGClip_pause,
  132. JPEGClip_getStatus,
  133. JPEGClip_abort,
  134. GenericClip_recordMarker,
  135. JPEGClip_refresh,
  136. JPEGClip_getTime,
  137. JPEGClip_digest,
  138. GenericClip_scan
  139. ),
  140. eClipType_JPEG,
  141. DEC_ASID_JPEG, 0xFF, DEC_DISC_TYPE_JPG,
  142. (eCA_Zoomable | eCA_Digestable | eCA_StillImage ),
  143. &g_uPresentationTime
  144. )
  145. #else
  146. DECLARE_CLIP_CONST_ATTR(JPEG, 
  147. DECLARE_CLIP_VTABLE(GenericClip_getExtendedInfo,
  148. JPEGClip_play,
  149. JPEGClip_pause,
  150. JPEGClip_getStatus,
  151. JPEGClip_abort,
  152. GenericClip_recordMarker,
  153. JPEGClip_refresh,
  154. JPEGClip_getTime,
  155. JPEGClip_digest,
  156. GenericClip_scan
  157. ),
  158. eClipType_JPEG,
  159. DEC_ASID_JPEG, 0xFF, DEC_DISC_TYPE_JPG,
  160. (eCA_Zoomable | eCA_Digestable | eCA_StillImage | eCA_Cacheable ),
  161. &g_uPresentationTime
  162. )
  163. #endif
  165. /////////////////////////////////////////////////////////////////////////////
  166. // Public Services
  168. void JPEG_setPresentationTime(UINT8 uPresentationTime)
  169. {
  170. dbg_printf(("Set JPEG presentation time to %dn", uPresentationTime));
  171. g_uPresentationTime = uPresentationTime;
  172. }
  174. BOOL JPEGClip_isKindOf(LPCWSTR i_pszFilename)
  175. {
  176. return GenericClip_isKindOf(i_pszFilename, CLIP_VALID_EXTENSIONS(JPEG));
  177. }
  179. void JPEGClip_construct(struct Clip_TAG *o_pThis, const FindData *i_pFileInfo)
  180. {
  181. GenericClip_construct(o_pThis, i_pFileInfo);
  182. o_pThis->m_pConstAttr= &CLIP_CONST_ATTR(JPEG);
  183. }
  186. /////////////////////////////////////////////////////////////////////////////
  187. // Virtual Methods
  189. #pragma argsused
  190. BOOL JPEGClip_play(Clip *i_pThis, const ClipMarker *i_pResumeMarker,
  191.    BOOL bCacheOnly)
  192. {
  193. BOOL  bNoTransition;
  194. BOOL  bBtsChanged;
  195. ULONG ulBlocksCnt;
  196. ULONG cbFileSize;
  197. enImageState eState;   
  199. ucWatchDog = JPEG_PLAYBACK_FINISHED_WATCHDOG;
  201. dbg_printf(("JPEGClip_play(bCacheOnly=%x)n",bCacheOnly));
  203. bBtsChanged= (DEC_GetCurrentDiscType() != (DEC_DISC_TYPE)(i_pThis->m_pConstAttr)->m_eBitstreamType);
  204. bNoTransition= (eCTE_None == (enClipTransitionEffect)(i_pThis->m_presentationInfo).eTransitionEffect);
  206. #ifdef USE_STOP_EXCEPTION_WHEN_JPEG
  207. Exception_catch(EXCEPTION_STOP_REQUEST);
  208. #endif
  210. /* Sanity check - Is caching required while disc type has changed? */
  211. if (bCacheOnly && bBtsChanged)
  212. {
  213. return FALSE;
  214. }
  216. /* If transition effect is used - no caching is performed (no double buffering)! */
  217. if (bCacheOnly && !bNoTransition)
  218. {
  219. tr_printf(("Transition effect is required - disable cachingn"));
  220. return FALSE;
  221. }
  223. // Acquire the current image State
  224. eState= GET_IMAGESTATE((i_pThis->m_presentationInfo).ucUserData);
  226. // Check if the image is already in Error state;
  227. // This is only possible if this image was cached unsuccessfully.
  228. if (eImageState_Error == eState) 
  229. {
  230. // If this is a Caching request, do nothing
  231. if (bCacheOnly)
  232. return TRUE;
  234. // Clear the Front-Display Buffer and do nothing additional
  235. DEC_JPEG_clearDisplayBuffers(TRUE, FALSE, TRUE);
  237. return TRUE;
  238. }
  240. // display the picture if the image is already cached and in normal playback
  241. if( (!bCacheOnly)&&(eImageState_Cached == eState) )
  242. {
  243. tr_printf(("nJPEGClip_play: Display cached Imagen"));
  245. // If picutre already cached, switch to display it in decode buffer
  246. TOGGLE_CURRENT_DISPLAY_BUFFER;
  247. TOGGLE_CURRENT_DECODE_BUFFER;
  249. // clear previous display buffer to push DVP Video Task toggle the display buffer
  250. DEC_JPEG_clearDisplayBuffers(IS_CURRENT_DISPLAY_BUFFER_BACK_R2,
  251. IS_CURRENT_DISPLAY_BUFFER_FRONT_R1, bBtsChanged );
  253. DEC_JPEG_SetDisplayDecodeBuffer(CURRENT_DISPLAY_BUFFER,CURRENT_DECODE_BUFFER);
  255. if (!DEC_IsSystemIdle())
  256. {
  257. DEC_Stop_DVP_cmd((UINT8)0);
  258. delay_us(400000UL);
  259. }
  261. DEC_Start_DVP_cmd();
  262. delay_us(50000UL);//wait until picture is displayed
  263. TOGGLE_CURRENT_DECODE_BUFFER;
  265. // If this image is already Caching/Cached, then move to "Decoding" state;
  266. // the next Refresh will resume normal flow.
  267. SET_IMAGESTATE((i_pThis->m_presentationInfo).ucUserData, eImageState_Decoding);
  269. // Indicate that the data has been modified
  270. (i_pThis->m_presentationInfo).bModified= TRUE;
  272. return TRUE;
  273. }
  275. drv_abort_play();
  277. // Set the selected Orientation
  278. DEC_JPEG_setOrientation((UINT8)(i_pThis->m_presentationInfo).eImageOrientation);
  280. // Use no Transition-Effect for the Caching/Decoding phase
  281. DEC_JPEG_selectTransition((UINT8)eCTE_None, FALSE);
  283. // Set the Image State to "Caching" or "Decoding", as appropriate
  284. if (bCacheOnly)
  285. {
  286. dbg_printf(("JPEG_Play: Cache Imagen"));
  287. SET_IMAGESTATE((i_pThis->m_presentationInfo).ucUserData, eImageState_Caching);
  288. }
  289. else
  290. {
  291. dbg_printf(("JPEG_Play: Direct Play Imagen"));
  292. SET_IMAGESTATE((i_pThis->m_presentationInfo).ucUserData, eImageState_Decoding);
  293. #ifdef EXINO2 // ZKR GL040904 : Demo for Transition effect to S1
  294. DEC_JPEG_selectTransition((UINT8)eCTE_Random,TRUE);
  295. #else
  296. DEC_JPEG_selectTransition((enClipTransitionEffect)(i_pThis->m_presentationInfo).eTransitionEffect,TRUE);
  297. #endif
  298. }
  300. // Configure the Decoder to the appropriate Bitstream Type
  301. DEC_SetDiskType((DEC_DISC_TYPE)(i_pThis->m_pConstAttr)->m_eBitstreamType);
  303. DEC_EnableManualScaling(PROG_SCALER_MODE_CCRAM);
  305. //Set JPEG size
  306. DEC_set_coded_video_size((UINT16) JPEG_DISPLAY_HORZ_SIZE, (UINT16) JPEG_DISPLAY_VERT_SIZE);
  308. //caculate display SAR
  309. DEC_set_Display_AspectRatio(gps->tv_shape);
  311. //JPEG coded SAR is always 1000 to keep no distortion
  312. DEC_LL_SetCodedSAR(1000);
  314. // Set the scaler mode 
  315. DEC_SetViewMode(gps->view_mode);
  317. #ifdef D_ENABLE_SETUP_JPG_SIZE //JG_0803_2004
  318. //JPEG auto fit should do scaling later when get real pic size from ADP
  319. if(JPG_SIZE_AUTOFIT != PS_GET_JPEG_SIZE_SETTING())
  320. #endif
  321. gcst.mNeedScaling = TRUE;
  323. // Apply Auto-Fit, if required
  324. if (JPG_SIZE_AUTOFIT == PS_GET_JPEG_SIZE_SETTING()) 
  325. {
  326. DEC_JPEG_enableAutoFitToScreen(TRUE);
  327. }
  328. else 
  329. {
  330. DEC_JPEG_enableAutoFitToScreen(FALSE);
  331. }
  333. // Prepare for decoding
  334. DEC_prepare_to_decode();
  336. // Clear the Display Buffers
  337. if (!bCacheOnly) 
  338. {
  339. // no caching required, clear immediately if the bitstream type changed
  340. dbg_printf(("ndefault display/decode buffer as R2 when no cache playn"));
  341. CURRENT_DISPLAY_BUFFER = BACK_R2_BUFFER;
  342. CURRENT_DECODE_BUFFER = BACK_R2_BUFFER;
  343. DEC_JPEG_clearDisplayBuffers(IS_CURRENT_DISPLAY_BUFFER_FRONT_R1,
  344. IS_CURRENT_DISPLAY_BUFFER_BACK_R2, bBtsChanged);
  345. DEC_JPEG_SetDisplayDecodeBuffer(CURRENT_DISPLAY_BUFFER,CURRENT_DECODE_BUFFER);
  346. }
  347. else 
  348. {
  349. #ifdef D_ENABLE_JPEG_CACHE
  350. // Caching is required: clear only the Back Buffer
  351. DEC_JPEG_clearDisplayBuffers( IS_CURRENT_DISPLAY_BUFFER_BACK_R2,
  352. IS_CURRENT_DISPLAY_BUFFER_FRONT_R1, FALSE);
  353. // Continue display at current display buffer, while decoding the cached image into decoding buffer
  354. TOGGLE_CURRENT_DECODE_BUFFER;
  355. DEC_JPEG_SetDisplayDecodeBuffer(CURRENT_DISPLAY_BUFFER,CURRENT_DECODE_BUFFER);
  356. #endif
  357. }
  359. // Adjust the Zoom factor
  360. if (bNoTransition) 
  361. {
  362. #ifdef CLIPS_JPEG_KEEP_ZOOM_RATIO
  363. if (JPG_SIZE_ORIGINAL == PS_GET_JPEG_SIZE_SETTING())
  364. DEC_SetZoomScale(gcs.mZoomLevel);
  365. else
  366. #endif
  367. //JG_0407_2004:No need to kill zoom, using CPU scaling will not keep zoom ratio
  368. // Kill any existing Zoom
  369. //DEC_SetZoomScale(NO_ZOOM);
  370. }
  372. // Switch the Logo-Source to Frame
  373. if (!bCacheOnly && (eFrame != Logo_getCurrentSource())) 
  374. {
  375. Logo_selectSource(eFrame);
  376. Logo_display();
  377. }
  379. DEC_JPEG_ResetCopyDoneFlag();
  381. #ifdef I77_COMPANION_CHIP//jerry.ren 20050527
  382. #ifdef I77_BRAIN_STORM
  383. if( gcst.hd_jpeg_mode_preference != SD_JPEG_MODE )
  384. #else//I77_BRAIN_STORM
  385. if( gps->hd_jpeg_mode_preference != SD_JPEG_MODE )
  386. #endif//I77_BRAIN_STORM
  387. I77_SetBackground(TRUE);
  388. #endif
  390. Logo_selectSource(eBackground);
  391. Logo_display();
  393. //set HD JPEG resolution or SD JPEG display size
  394. DEC_JPEG_Init_Resolution();
  395.            
  396. //set file size
  397. #ifdef SUPPORT_FLASH_CARD
  398. if(IS_PLAYING_CARD)
  399. DEC_JPEG_SetFileSize( i_pThis->m_cfiInfo.cbFileSize + LOGICAL_BLOCK_SIZE - 1);
  400. else
  401. #endif
  402. DEC_JPEG_SetFileSize( i_pThis->m_cfiInfo.cbFileSize );
  404. DEC_SetSID(DEC_SID_TYPE_AUDIO, (i_pThis->m_pConstAttr)->m_eAudioSID);
  405. DEC_SetSID(DEC_SID_TYPE_VIDEO, (i_pThis->m_pConstAttr)->m_eVideoSID);
  407. // Select the appropriate Clock
  408. PE_Clips_SelectClock(eCT_Decoder);
  410. // Calculate the Playback Length, and add an extra Sector to accomodate for decoding tolerance in JPEG.
  411. ulBlocksCnt= ( ((i_pThis->m_cfiInfo).cbFileSize + LOGICAL_BLOCK_SIZE - 1) /LOGICAL_BLOCK_SIZE );
  413. // Calculate the effective File-Size to transfer, taking into account the JPEG Tolerance, required by the Decoder.
  414. cbFileSize= MIN((ulBlocksCnt * LOGICAL_BLOCK_SIZE),  ((i_pThis->m_cfiInfo).cbFileSize + JPEG_TOLERANCE_BYTES));
  416. // Inform the Decoder of the Playback-Range
  417. PE_Clips_SetPlaybackRange((i_pThis->m_cfiInfo).dwFileLocation, ulBlocksCnt, cbFileSize);//Leslie_0823_2003_A
  419. // Invoke playback of the Decoder & Drive
  420. // NOTE: The order of invocation is important, and must not be changed!
  421. DEC_PlaybackCommand(DEC_PLAYBACK_CMD_PLAY, NULL);
  423. Logo_selectSource(eFrame);
  424. //Freya Disable the next line to fix TD1609"Press Next key the picture flash once" at 050816
  425. //Logo_display();
  427. #ifdef I77_COMPANION_CHIP//jerry.ren 20050527
  428. #ifdef I77_BRAIN_STORM
  429. if( gcst.hd_jpeg_mode_preference != SD_JPEG_MODE )
  430. #else//I77_BRAIN_STORM
  431. if( gps->hd_jpeg_mode_preference != SD_JPEG_MODE )
  432. #endif//I77_BRAIN_STORM
  433. I77_SetBackground(FALSE);
  434. #endif
  436. if ( !PE_Clips_Playback_Sectors(DRVCF_CDSPEED_1X | DRVF_PLAY_CD_AV_DATA, (i_pThis->m_cfiInfo).dwFileLocation,//Leslie_0823_2003_A
  437. ulBlocksCnt))
  438. {
  439. dbg_printf(("WARNING: GenericClip_play() Failed [1]n"));
  440. return FALSE;
  441. }
  443. // Reset the Clock, without starting it
  444. PE_Clips_EnableClock(FALSE, TRUE, 0);
  446. // Indicate that the data has been modified
  447. (i_pThis->m_presentationInfo).bModified= TRUE;
  449. return TRUE;
  450. }
  453. #pragma argsused
  454. void JPEGClip_pause(Clip *i_pThis, BOOL bEnable)
  455. {
  456. // Nothing special to do for JPEG - just let the picture decode to
  457. // its end.
  458. dbg_printf(("JPEGClip_pause()n"));
  460. return;
  461. }
  463. #pragma argsused
  464. enClipStatus JPEGClip_getStatus(const Clip *i_pThis)
  465. {
  466. enImageState eState= GET_IMAGESTATE((i_pThis->m_presentationInfo).ucUserData);
  468. /* Check if an exception was thrown */
  469. #ifdef USE_STOP_EXCEPTION_WHEN_JPEG
  470. if (Exception_catchAndRethrow(EXCEPTION_STOP_REQUEST | EXCEPTION_MEDIUM_EJECTED | EXCEPTION_POWER_DOWN_REQUEST)) 
  471. #else
  472. if (Exception_catchAndRethrow(EXCEPTION_MEDIUM_EJECTED | EXCEPTION_POWER_DOWN_REQUEST)) 
  473. #endif
  474. {
  475. #ifdef I77_COMPANION_CHIP
  476. bJpegDecodeDone = FALSE;
  477. #endif
  478. return eCS_Busy;
  479. }
  481. if ((eImageState_Idle == eState) || (eImageState_Cached == eState))
  482. {
  483. #ifdef I77_COMPANION_CHIP
  484. #ifdef I77_BRAIN_STORM
  485. if( gcst.hd_jpeg_mode_preference != SD_JPEG_MODE )
  486. #else//I77_BRAIN_STORM
  487. if( gps->hd_jpeg_mode_preference != SD_JPEG_MODE )
  488. #endif//I77_BRAIN_STORM
  489. {
  490. bJpegDecodeDone = TRUE;
  491. return eCS_Finished;
  492. }
  493. else
  494. #endif
  495. {
  496. if ( DEC_JPEG_IsCopyDone() )
  497. return eCS_Finished;
  498. else
  499. return eCS_Busy;
  500. }
  501. }
  503. if (eImageState_Error == eState) {
  504. switch (GET_ERROR((i_pThis->m_presentationInfo).ucUserData))
  505. {
  506. case JPEG_STAT_ERR_FATAL:
  507. return eCS_Error_Decoding;
  509. case JPEG_STAT_ERR_UNSUPPORTED:
  510. return eCS_Error_UnsupportedFormat;
  511. }
  512. }
  514. if(!ucWatchDog)
  515. {
  516. ucWatchDog = JPEG_PLAYBACK_FINISHED_WATCHDOG;
  517. tr_printf(("Warnning: JPEG Watchdog time out!!!n"));
  518. return eCS_Finished;
  519. }  
  520. else
  521. if(STOP_WATCHDOG != ucWatchDog)
  522. ucWatchDog --;
  524. return eCS_Busy;
  525. }
  527. #pragma argsused
  528. void JPEGClip_abort(Clip *i_pThis, BOOL bMaintainStandby)
  529. {
  530. dbg_printf(("JPEGClip_abort(%d)n", bMaintainStandby));
  532. #ifdef USE_STOP_EXCEPTION_WHEN_JPEG
  533. /* Clear stop exception if it was thrown */
  534. Exception_catch(EXCEPTION_STOP_REQUEST);
  535. #endif
  537. DEC_JPEG_selectTransition((UINT8)eCTE_None, TRUE);
  539. // if (eImageState_Idle != GET_IMAGESTATE((i_pThis->m_presentationInfo).ucUserData)) {
  540. drv_abort_play();
  541. DEC_Stop_DVP_ADP_cmd((UINT8)0);
  542.   // }
  544. if (! bMaintainStandby)
  545. drv_spindown();
  547. SET_IMAGESTATE((i_pThis->m_presentationInfo).ucUserData, eImageState_Idle);
  548. (i_pThis->m_presentationInfo).bModified= TRUE;
  550. #ifdef I77_COMPANION_CHIP
  551.    if ( ( bJpegDecodeDone == FALSE ) && (PST_STOP != gcs.pstate) )
  552. {
  553. #ifdef I77_BRAIN_STORM
  554. if( gcst.hd_jpeg_mode_preference != SD_JPEG_MODE )
  555. #else//I77_BRAIN_STORM
  556. if( gps->hd_jpeg_mode_preference != SD_JPEG_MODE )
  557. #endif//I77_BRAIN_STORM
  558. DEC_JPEG_End_Resolution();
  559. }
  560. #endif
  561. return;
  562. }
  564. #ifdef I77_COMPANION_CHIP
  565. void JPEGClip_BeforeAbort(void)
  566. {
  567. bJpegDecodeDone = FALSE;
  568. }
  569. #endif // I77_COMPANION_CHIP
  570. void JPEGClip_beforeStop(struct Clip_TAG *o_pThis)
  571. {
  572. bStopRequested = TRUE;
  573. }
  575. #pragma argsused
  576. void JPEGClip_refresh(Clip *i_pThis)
  577. {
  578. UINT8 uDecodingStatus;
  579. enImageState eOriginalState;
  581. /* Check if an exception was thrown */
  582. #ifdef USE_STOP_EXCEPTION_WHEN_JPEG
  583. if (Exception_catchAndRethrow(EXCEPTION_STOP_REQUEST | EXCEPTION_MEDIUM_EJECTED | EXCEPTION_POWER_DOWN_REQUEST)) 
  584. #else
  585. if (Exception_catchAndRethrow(EXCEPTION_MEDIUM_EJECTED | EXCEPTION_POWER_DOWN_REQUEST)) 
  586. #endif
  587. {
  588. #ifdef I77_COMPANION_CHIP   
  589. bJpegDecodeDone = FALSE;
  590. #endif // I77_COMPANION_CHIP      
  591. return;
  592. }
  594. eOriginalState= GET_IMAGESTATE((i_pThis->m_presentationInfo).ucUserData);
  596. // Check if there is anything to refresh
  597. if ((eImageState_Cached == eOriginalState) || (eImageState_Idle == eOriginalState) ||
  598. (eImageState_Error == eOriginalState))
  599. {
  600. // If the Image is already Cached, Idle, or Erroneous, no point in doing anything.
  601. return;
  602. }
  604. #ifdef I77_COMPANION_CHIP
  605. #ifdef I77_BRAIN_STORM
  606. if( gcst.hd_jpeg_mode_preference == SD_JPEG_MODE )
  607. #else//I77_BRAIN_STORM
  608. if( gps->hd_jpeg_mode_preference == SD_JPEG_MODE )
  609. #endif//I77_BRAIN_STORM
  610. #endif
  611. {
  612. // notify to copy the new line to display buffer when ready
  613. if ( ( TRUE == DEC_JPEG_IsNewLineReady() ) && ( PST_STOP != gcs.pstate ) )
  614. DEC_JPEG_DecodeDoneCheck();
  615. }
  617. // Check if the current Phase has finished
  618. uDecodingStatus= DEC_JPEG_getStatus();
  620. #ifdef I77_COMPANION_CHIP//jerry.ren 20050527
  621. #ifdef I77_BRAIN_STORM
  622. if( gcst.hd_jpeg_mode_preference != SD_JPEG_MODE )
  623. #else//I77_BRAIN_STORM
  624. if( gps->hd_jpeg_mode_preference != SD_JPEG_MODE )
  625. #endif//I77_BRAIN_STORM
  626. I77_SetBackground(TRUE);
  627. #endif
  629. if (JPEG_STAT_DECODING == uDecodingStatus)
  630. {
  631. //no return if JPEG copy done even it still decoding (for SD JPEG mode only)
  632. if(!(DEC_JPEG_IsCopyDone()
  633. #ifdef I77_COMPANION_CHIP
  634. #ifdef I77_BRAIN_STORM
  635. &&(gcst.hd_jpeg_mode_preference == SD_JPEG_MODE)
  636. #else//I77_BRAIN_STORM
  637. &&(gps->hd_jpeg_mode_preference == SD_JPEG_MODE)
  638. #endif//I77_BRAIN_STORM
  639. #endif
  640. ) )
  641. return;
  642. }
  644. #ifdef I77_COMPANION_CHIP//jerry.ren 20050527
  645. #ifdef I77_BRAIN_STORM
  646. if( gcst.hd_jpeg_mode_preference != SD_JPEG_MODE )
  647. #else//I77_BRAIN_STORM
  648. if( gps->hd_jpeg_mode_preference != SD_JPEG_MODE )
  649. #endif//I77_BRAIN_STORM
  650. I77_SetBackground(FALSE);
  651. #endif
  653. // Check for Errors
  654. if ((JPEG_STAT_ERR_UNSUPPORTED == uDecodingStatus) ||
  655. (JPEG_STAT_ERR_FATAL == uDecodingStatus))
  656. {
  657. dbg_printf(("Error, unsupported format or error encountedn"));
  659. // If the current state is "Decoding", 
  660. if (eImageState_Decoding == eOriginalState){
  661. DEC_JPEG_clearDisplayBuffers(IS_CURRENT_DISPLAY_BUFFER_BACK_R2, IS_CURRENT_DISPLAY_BUFFER_FRONT_R1, TRUE);
  662. }
  665. // Move to "Error" state
  666. SET_IMAGESTATE((i_pThis->m_presentationInfo).ucUserData, eImageState_Error);
  667. SET_ERROR((i_pThis->m_presentationInfo).ucUserData, uDecodingStatus);
  669. (i_pThis->m_presentationInfo).bModified= TRUE;
  671. return;
  672. }
  674. // Check the current State
  675. if (eImageState_Caching == eOriginalState) {
  676. // Caching is finished -- move to "Cached" state
  677. SET_IMAGESTATE((i_pThis->m_presentationInfo).ucUserData, eImageState_Cached);
  678. }
  679. else if (eImageState_Decoding == eOriginalState) {
  681. // Check if a Transition-Phase is required
  682. if (eCTE_None == (enClipTransitionEffect)(i_pThis->m_presentationInfo).eTransitionEffect) {
  683. // No Transition required: move to "Idle" state
  684. SET_IMAGESTATE((i_pThis->m_presentationInfo).ucUserData, eImageState_Idle);
  685. }
  686. else {
  687. // Some Transition is required: select and apply the Transition
  688. enClipTransitionEffect eTransition;
  689. /* //no used now, will do it at dec_jpeg_selecttransition()
  690. if (eCTE_Random == (enClipTransitionEffect)(i_pThis->m_presentationInfo).eTransitionEffect)
  691. eTransition= (eCTE_TopToBottom + (rand() % (eCTE_TransitionEffectsCnt-1)));
  692. else*/
  693. eTransition= (enClipTransitionEffect)(i_pThis->m_presentationInfo).eTransitionEffect;
  695. // If no Auto-Fit was applied, cancel any Zoom
  696. #ifdef CLIPS_JPEG_KEEP_ZOOM_RATIO //DM021103 Keep Zoom level as required
  697. if (JPG_SIZE_ORIGINAL == PS_GET_JPEG_SIZE_SETTING())
  698. DEC_SetZoomScale(gcs.mZoomLevel);
  699. else
  700. #else
  701. if (JPG_SIZE_ORIGINAL == PS_GET_JPEG_SIZE_SETTING())
  702. #endif
  703. DEC_SetZoomScale(NO_ZOOM);
  705. DEC_JPEG_selectTransition((UINT8)eTransition, TRUE);
  707. // Move to "Transitioning" state
  708. SET_IMAGESTATE((i_pThis->m_presentationInfo).ucUserData, eImageState_Transitioning);
  709. }
  710. }
  711. else if (eImageState_Transitioning == eOriginalState) {
  712. // Since the Transition-Effect has finished, move to "Idle" state
  713. SET_IMAGESTATE((i_pThis->m_presentationInfo).ucUserData, eImageState_Idle);
  714. }
  716. // Check if there was some modification, and indicate that
  717. if (eOriginalState != GET_IMAGESTATE((i_pThis->m_presentationInfo).ucUserData))
  718. (i_pThis->m_presentationInfo).bModified= TRUE;
  719. }
  722. #pragma argsused
  723. UINT16 JPEGClip_getTime(const Clip *i_pThis)
  724. {
  725. // No Time dimension in a JPEG image - always return Zero
  726. return 0;
  727. }
  730. void JPEGClip_digest(Clip *i_pThis)
  731. {
  732. ULONG ulBlocksCnt;
  733. ULONG cbFileSize;
  735. ucWatchDog = STOP_WATCHDOG;
  737. dbg_printf(("JPEGClip_digest()n"));
  739. // Set the Image State to "Decoding"
  740. SET_IMAGESTATE((i_pThis->m_presentationInfo).ucUserData, eImageState_Decoding);
  742. // Set the selected Orientation
  743. #ifdef EXINO2
  744. DEC_JPEG_setOrientation((UINT8)(i_pThis->m_presentationInfo).eImageOrientation);
  745. #else
  746. DEC_JPEG_setOrientation(eCIO_Original);
  747. #endif
  748. // Use no Transition-Effect for the Caching/Decoding phase
  749. DEC_JPEG_selectTransition((UINT8)eCTE_None, FALSE);
  751. // Configure the Decoder to the appropriate Bitstream Type
  752. DEC_SetDiskType((DEC_DISC_TYPE)(i_pThis->m_pConstAttr)->m_eBitstreamType);
  754. //no auto fit for digest
  755. DEC_JPEG_enableAutoFitToScreen(FALSE);
  757. // Prepare for decoding
  758. DEC_prepare_to_decode();
  760. #ifndef D_ENABLE_JPEG_CACHE
  761. // tempory patch, current MPEG DVP Ucode is not able the clear background if no JPEG data is sent to DVP
  762. // need to figure it out later
  763. if ( IS_DVD_MEDIA ){
  764. if ( Digest_IsFirstDigestWindow())
  765. DEC_JPEG_clearDisplayBuffers(FALSE, TRUE, FALSE);
  766. else
  767. DEC_JPEG_clearDisplayBuffers(FALSE, FALSE, FALSE);
  768. }
  769. else
  770. #ifdef SUPPORT_FLASH_CARD
  771. if(!IS_PLAYING_CARD)
  772. #endif
  773. {
  774. DEC_JPEG_clearDisplayBuffers(TRUE, FALSE, FALSE);
  775. }
  776. #else
  777. dbg_printf(("ndefault display/decode buffer as R2 when digestn"));
  778. CURRENT_DISPLAY_BUFFER = BACK_R2_BUFFER;
  779. CURRENT_DECODE_BUFFER = BACK_R2_BUFFER;
  781. if ( Digest_IsFirstDigestWindow())
  782. DEC_JPEG_clearDisplayBuffers(IS_CURRENT_DISPLAY_BUFFER_FRONT_R1,IS_CURRENT_DISPLAY_BUFFER_BACK_R2, FALSE);
  783. else
  784. DEC_JPEG_clearDisplayBuffers(FALSE, FALSE, FALSE);
  785. #endif //D_ENABLE_JPEG_CACHE
  787. DEC_JPEG_SetDisplayDecodeBuffer(CURRENT_DISPLAY_BUFFER,CURRENT_DECODE_BUFFER);
  789. //clear the copy done Flag, it shoul be clear before next picture decoding
  790. DEC_JPEG_ResetCopyDoneFlag();
  792. //set HD JPEG resolution or SD JPEG display size
  793. DEC_JPEG_Init_Resolution();
  795. //set file size
  796. DEC_JPEG_SetFileSize( i_pThis->m_cfiInfo.cbFileSize );
  798. DEC_SetSID(DEC_SID_TYPE_AUDIO, (i_pThis->m_pConstAttr)->m_eAudioSID);
  799. DEC_SetSID(DEC_SID_TYPE_VIDEO, (i_pThis->m_pConstAttr)->m_eVideoSID);
  801. // Calculate the Playback Length, and add an extra Sector to accomodate for decoding tolerance in JPEG.
  802. ulBlocksCnt= ( ((i_pThis->m_cfiInfo).cbFileSize + LOGICAL_BLOCK_SIZE - 1) /LOGICAL_BLOCK_SIZE );
  804. // Calculate the effective File-Size to transfer, taking into account the JPEG Tolerance, required by the Decoder.
  805. cbFileSize= MIN((ulBlocksCnt * LOGICAL_BLOCK_SIZE), ((i_pThis->m_cfiInfo).cbFileSize + JPEG_TOLERANCE_BYTES));
  807. // Inform the Decoder of the Playback-Range
  808. PE_Clips_SetPlaybackRange((i_pThis->m_cfiInfo).dwFileLocation, ulBlocksCnt, cbFileSize);//Leslie_0823_2003_A
  810. // Invoke playback of the Decoder & Drive
  811. // NOTE: The order of invocation is important, and must not be changed!
  812. DEC_PlaybackCommand(DEC_PLAYBACK_CMD_PLAY, NULL);
  814. if ( !PE_Clips_Playback_Sectors(DRVCF_CDSPEED_1X | DRVF_PLAY_CD_AV_DATA, (i_pThis->m_cfiInfo).dwFileLocation,//Leslie_0823_2003_A
  815.  ulBlocksCnt)) 
  816. {
  817. dbg_printf(("WARNING: JPEGClip_digest() Failed [1]n"));
  818. return;
  819. }
  821. // Indicate that the data has been modified
  822. (i_pThis->m_presentationInfo).bModified= TRUE;
  824. return;
  825. }
  827. #endif //CLIPS_JPEG_SUPPORT