source: svn/newcon3bcm2_21bu/magnum/commonutils/xdm/bxdm_pp_callback.c @ 74

Last change on this file since 74 was 74, checked in by phkim, 10 years ago
  1. phkim
  2. zasc
  3. 변경 내용
    • CT_ChMapUpdatePMTAC3AudioDescriptor 메모리 leak 버그 수정
  • Property svn:executable set to *
File size: 57.4 KB
Line 
1/***************************************************************************
2 *     Copyright (c) 2003-2010, Broadcom Corporation
3 *     All Rights Reserved
4 *     Confidential Property of Broadcom Corporation
5 *
6 *  THIS SOFTWARE MAY ONLY BE USED SUBJECT TO AN EXECUTED SOFTWARE LICENSE
7 *  AGREEMENT  BETWEEN THE USER AND BROADCOM.  YOU HAVE NO RIGHT TO USE OR
8 *  EXPLOIT THIS MATERIAL EXCEPT SUBJECT TO THE TERMS OF SUCH AN AGREEMENT.
9 *
10 * $brcm_Workfile: bxdm_pp_callback.c $
11 * $brcm_Revision: Hydra_Software_Devel/18 $
12 * $brcm_Date: 12/21/10 4:24p $
13 *
14 * [File Description:]
15 *
16 * Revision History:
17 *
18 * $brcm_Log: /magnum/commonutils/xdm/bxdm_pp_callback.c $
19 *
20 * Hydra_Software_Devel/18   12/21/10 4:24p delkert
21 * SW7405-5043: Split STC stored in local state into two parts: STC from
22 * decoder and STC after JTI adjustment
23 *
24 * Hydra_Software_Devel/17   11/17/10 9:37a btosi
25 * SW7422-72: added new BXVD and XDM 3D API's
26 *
27 * Hydra_Software_Devel/16   10/27/10 10:30a btosi
28 * SW7422-72: merged 3D changes to mainline
29 *
30 * Hydra_Software_Devel/15   10/20/10 11:47a btosi
31 * SW7405-4804: deliver the SEI messages for pictures that are dropped
32 *
33 * Hydra_Software_Devel/13   9/23/10 3:09p btosi
34 * SW7405-4736: add support for a XDM instance ID to help debug multi-
35 * channel issues
36 *
37 * Hydra_Software_Devel/12   8/10/10 4:16p btosi
38 * SW7405-4736: added PPB index to debug messages
39 *
40 * Hydra_Software_Devel/11   8/2/10 10:17a btosi
41 * SW7400-2880: (Coverity) handle
42 * BXDM_Picture_ExtensionType_eSEIFramePacking in switch statement
43 *
44 * Hydra_Software_Devel/10   7/29/10 11:22a btosi
45 * SW7405-4560: added support for the SEI "new message" flag.
46 *
47 * Hydra_Software_Devel/9   6/29/10 11:25a btosi
48 * SW7405-4365: revamped the timer code to selectively enable the function
49 * and callback timing
50 *
51 * Hydra_Software_Devel/8   6/15/10 2:11p btosi
52 * SW7405-4500: fixed compiler warning when DEBUG=n
53 *
54 * Hydra_Software_Devel/7   5/18/10 9:16a btosi
55 * SW7405-4352: added break statement
56 *
57 * Hydra_Software_Devel/6   5/12/10 12:10p btosi
58 * SWBLURAY-20606: enhanced BXDM_PPCB_S_PrintExtensionData
59 *
60 * Hydra_Software_Devel/5   5/10/10 3:05p btosi
61 * SW7550-379: fixed issue with the change for SW7405-3774
62 *
63 * Hydra_Software_Devel/4   5/4/10 10:46a btosi
64 * SW7405-3996: added support for new SEI message format
65 *
66 * Hydra_Software_Devel/SW7405-3996/1   4/5/10 2:38p btosi
67 * SW7405-3996: added code to dump extension data
68 *
69 * Hydra_Software_Devel/3   3/18/10 3:46p btosi
70 * SW7405-3774: clear bExecutedPtsStcOffsetCB when the callback is
71 * actually executed
72 *
73 * Hydra_Software_Devel/2   3/18/10 10:54a btosi
74 * SW7405-3774: added bExecutedPtsStcOffsetCB flag.
75 *
76 * Hydra_Software_Devel/1   2/16/10 10:50a nilesh
77 * SW7405-2993: Initial XDM version
78 *
79 ***************************************************************************/
80
81#include "bstd.h"
82#include "bkni.h"
83#include "bdbg.h"                /* Dbglib */
84
85#include "bxdm_pp.h"
86#include "bxdm_pp_priv.h"
87#include "bxdm_pp_callback_priv.h"
88#include "bxdm_pp_qm.h"
89#include "bxdm_pp_dbg.h"
90
91BDBG_MODULE(BXDM_PPCB);         /* Register software module with debug interface */
92
93const char BXDM_PictureProvider_P_DISPMGR_CALLBACK_NODE[]="DMCB:\t""$brcm_Revision: Hydra_Software_Devel/18 $";
94
95/*******************************************************************************
96 *
97 *  Local function protoypes.
98 *
99 ******************************************************************************/
100
101static void BXDM_PPCB_S_EvaluateCriteria_PtsStcOffset(
102   BXDM_PictureProvider_Handle hXdmPP,
103   BXDM_PictureProvider_P_LocalState* pLocalState
104   );
105
106static void BXDM_PPCB_S_FirstPtsReady( BXDM_PictureProvider_Handle hXdmPP, BXDM_PictureProvider_P_LocalState* pLocalState );
107static void BXDM_PPCB_S_FirstCodedPtsReady( BXDM_PictureProvider_Handle hXdmPP, BXDM_PictureProvider_P_LocalState* pLocalState );
108static void BXDM_PPCB_S_FirstPtsPassed( BXDM_PictureProvider_Handle hXdmPP, BXDM_PictureProvider_P_LocalState* pLocalState );
109static void BXDM_PPCB_S_PtsError( BXDM_PictureProvider_Handle hXdmPP, BXDM_PictureProvider_P_LocalState* pLocalState );
110static void BXDM_PPCB_S_PtsStcOffset( BXDM_PictureProvider_Handle hXdmPP, BXDM_PictureProvider_P_LocalState* pLocalState );
111static void BXDM_PPCB_S_IFrame( BXDM_PictureProvider_Handle hXdmPP, BXDM_PictureProvider_P_LocalState* pLocalState );
112static void BXDM_PPCB_S_PictureParameters( BXDM_PictureProvider_Handle hXdmPP, BXDM_PictureProvider_P_LocalState* pLocalState );
113static void BXDM_PPCB_S_TsmPassInASTMMode( BXDM_PictureProvider_Handle hXdmPP, BXDM_PictureProvider_P_LocalState* pLocalState );
114static void BXDM_PPCB_S_PictureUnderEvaluation( BXDM_PictureProvider_Handle hXdmPP, BXDM_PictureProvider_P_LocalState* pLocalState );
115
116static void BXDM_PPCB_S_RequestSTC( BXDM_PictureProvider_Handle hXdmPP, BXDM_PictureProvider_P_LocalState* pLocalState );
117static void BXDM_PPCB_S_ClipStart( BXDM_PictureProvider_Handle hXdmPP, BXDM_PictureProvider_P_LocalState* pLocalState );
118static void BXDM_PPCB_S_ClipStop( BXDM_PictureProvider_Handle hXdmPP, BXDM_PictureProvider_P_LocalState* pLocalState );
119static void BXDM_PPCB_S_PictureMarker( BXDM_PictureProvider_Handle hXdmPP, BXDM_PictureProvider_P_LocalState* pLocalState );
120static void BXDM_PPCB_S_DecodeError( BXDM_PictureProvider_Handle hXdmPP, BXDM_PictureProvider_P_LocalState* pLocalState );
121static void BXDM_PPCB_S_TSMResult( BXDM_PictureProvider_Handle hXdmPP, BXDM_PictureProvider_P_LocalState* pLocalState );
122static void BXDM_PPCB_S_PictureExtensionData(
123                  BXDM_PictureProvider_Handle hXdmPP,
124                  BXDM_PictureProvider_P_LocalState* pLocalState,
125                  BXDM_PictureProvider_P_Picture_Context * pstPicture
126                  );
127static void BXDM_PPCB_S_PrintExtensionData(
128                  BXDM_PictureProvider_Handle hXdmPP,
129                  const BXDM_Picture_ExtensionInfo * pstExtensionInfo
130                  );
131
132/*******************************************************************************
133 *
134 *  Local functions.
135 *
136 ******************************************************************************/
137
138static void BXDM_PPCB_S_FirstPtsReady(
139   BXDM_PictureProvider_Handle hXdmPP,
140   BXDM_PictureProvider_P_LocalState* pLocalState
141   )
142{
143   bool bSignalFirstPPB;
144
145   BDBG_ENTER(BXDM_PPCB_S_FirstPtsReady);
146
147   BDBG_ASSERT( hXdmPP );
148   BDBG_ASSERT( pLocalState );
149
150   /* First check that a callback function has been registered */
151   bSignalFirstPPB = ( NULL != hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eFirstPTSReady].stFunction.fFirstPTSReady );
152
153   /* Then check that the callback mask bit is set. */
154   bSignalFirstPPB &= ( true == hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eFirstPTSReady].bEnable );
155
156   /* Finally check that the callback criteria has been met. */
157   bSignalFirstPPB &= ( true == pLocalState->bFirstPPBReceived );
158
159   /* If all the conditions have been met, execute the callback. */
160   if( bSignalFirstPPB )
161   {
162      /*
163       * By design, only execute the callback once per BXVD_StartDecode() call.
164       * So, clear the appropriate mask bit(s) when the callback is executed.
165       */
166         pLocalState->uiCallbackTriggered |= BXDM_PPDBG_Callback_FirstPtsReady;
167
168      hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eFirstPTSReady].bEnable = false;
169
170      /* PR52901: update with the STC for this vsync. */
171      hXdmPP->stDMState.stDecode.stFirstCodedPts.uiSTCSnapShot = pLocalState->uiAdjustedStc;
172
173      BXVD_DBG_MSG(hXdmPP, ("%x: BXDM_PictureProvider_Callback_eFirstPtsReady(%08x)",
174                                 hXdmPP->stDMState.stDecode.stDebug.uiVsyncCount,
175                                 hXdmPP->stDMState.stDecode.stFirstCodedPts.ui32RunningPTS ));
176
177
178      /* Snapshot the start time. */
179      BXDM_PPTMR_P_SnapshotCallbackStartTime( hXdmPP, BXDM_PictureProvider_Callback_eFirstPTSReady );
180
181      hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eFirstPTSReady].stFunction.fFirstPTSReady (
182                                 hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eFirstPTSReady].pPrivateContext,
183                                 hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eFirstPTSReady].iPrivateParam,
184                                 &hXdmPP->stDMState.stDecode.stFirstCodedPts
185                                 );
186
187      /* Snapshot the end time. */
188      BXDM_PPTMR_P_SnapshotCallbackEndTime( hXdmPP, BXDM_PictureProvider_Callback_eFirstPTSReady );
189   }
190
191   BDBG_LEAVE(BXDM_PPCB_S_FirstPtsReady );
192
193   return;
194
195}  /* end of BXDM_PPCB_S_FirstPtsReady() */
196
197static void BXDM_PPCB_S_FirstCodedPtsReady(
198   BXDM_PictureProvider_Handle hXdmPP,
199   BXDM_PictureProvider_P_LocalState* pLocalState
200   )
201{
202   bool bSignalFirstCodedPts;
203
204   BDBG_ENTER(BXDM_PPCB_S_FirstCodedPtsReady);
205
206   BDBG_ASSERT( hXdmPP );
207   BDBG_ASSERT( pLocalState );
208
209   /* First check that a callback function has been registered */
210   bSignalFirstCodedPts = ( NULL != hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eFirstCodedPTSReady].stFunction.fFirstCodedPTSReady );
211
212   /* Then check that the callback mask bit is set. */
213   bSignalFirstCodedPts &= ( true == hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eFirstCodedPTSReady].bEnable );
214
215   /* Finally check that the callback criteria has been met. */
216   bSignalFirstCodedPts &= ( true == pLocalState->bCodedPtsReceived );
217
218   /* If all the conditions have been met, execute the callback. */
219   if( bSignalFirstCodedPts )
220   {
221      pLocalState->uiCallbackTriggered |= BXDM_PPDBG_Callback_FirstCodedPtsReady;
222
223      hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eFirstCodedPTSReady].bEnable = false;
224
225      /* PR52901: update with the STC for this vsync. */
226      hXdmPP->stDMState.stDecode.stFirstCodedPts.uiSTCSnapShot = pLocalState->uiAdjustedStc;
227
228      BXVD_DBG_MSG(hXdmPP, ("%x: BXDM_PictureProvider_Callback_eFirstCodedPtsReady(%08x)",
229                                 hXdmPP->stDMState.stDecode.stDebug.uiVsyncCount,
230                                 hXdmPP->stDMState.stDecode.stFirstCodedPts.ui32RunningPTS ));
231
232
233      /* Snapshot the start time. */
234      BXDM_PPTMR_P_SnapshotCallbackStartTime( hXdmPP, BXDM_PictureProvider_Callback_eFirstCodedPTSReady );
235
236      hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eFirstCodedPTSReady].stFunction.fFirstCodedPTSReady (
237                                 hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eFirstCodedPTSReady].pPrivateContext,
238                                 hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eFirstCodedPTSReady].iPrivateParam,
239                                 &hXdmPP->stDMState.stDecode.stFirstCodedPts
240                                 );
241
242      /* Snapshot the end time. */
243      BXDM_PPTMR_P_SnapshotCallbackEndTime( hXdmPP, BXDM_PictureProvider_Callback_eFirstCodedPTSReady );
244   }
245
246   BDBG_LEAVE(BXDM_PPCB_S_FirstCodedPtsReady );
247
248   return;
249
250}  /* end of BXDM_PPCB_S_FirstCodedPtsReady() */
251
252static void BXDM_PPCB_S_FirstPtsPassed(
253   BXDM_PictureProvider_Handle hXdmPP,
254   BXDM_PictureProvider_P_LocalState* pLocalState
255   )
256{
257   bool bSignalTsmPass;
258
259   BDBG_ENTER(BXDM_PPCB_S_FirstPtsPassed);
260
261   BDBG_ASSERT( hXdmPP );
262   BDBG_ASSERT( pLocalState );
263
264   /* First check that a callback function has been registered */
265   bSignalTsmPass = ( NULL != hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eFirstPTSPassed].stFunction.fFirstPTSPassed );
266
267   /* Then check that the callback mask bit is set. */
268   bSignalTsmPass &= ( true == hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eFirstPTSPassed].bEnable );
269
270   /* Finally check that the callback criteria has been met. */
271   bSignalTsmPass &= ( true == pLocalState->bTSMPass );
272
273   /* If all the conditions have been met, execute the callback. */
274   if( bSignalTsmPass )
275   {
276      pLocalState->uiCallbackTriggered |= BXDM_PPDBG_Callback_FirstPtsPassed;
277
278      /*
279       * Clear the interrup mask bit so that the callback is only
280       * executed once per BXVD_StartDecode() call.
281       */
282      hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eFirstPTSPassed].bEnable = false;
283
284      /* TODO: is "stCurrentPTSInfo" the correct value to return? */
285
286      BXVD_DBG_MSG(hXdmPP, ("%x: BXDM_PictureProvider_Callback_eFirstPtsPassed(%08x)",
287                                 hXdmPP->stDMState.stDecode.stDebug.uiVsyncCount,
288                                 hXdmPP->stDMStatus.stCurrentPTS.ui32RunningPTS
289                           ));
290
291      /* Snapshot the start time. */
292      BXDM_PPTMR_P_SnapshotCallbackStartTime( hXdmPP, BXDM_PictureProvider_Callback_eFirstPTSPassed );
293
294      hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eFirstPTSPassed].stFunction.fFirstPTSPassed (
295                                 hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eFirstPTSPassed].pPrivateContext,
296                                 hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eFirstPTSPassed].iPrivateParam,
297                                 &hXdmPP->stDMStatus.stCurrentPTS
298                                 ) ;
299
300      /* Snapshot the end time. */
301      BXDM_PPTMR_P_SnapshotCallbackEndTime( hXdmPP, BXDM_PictureProvider_Callback_eFirstPTSPassed );
302
303      /* TODO: from DM V1, is the following logic still needed?
304       * If so, is this the appropriate place?
305       * PR 32432: Resetting the Count so that Pic on TSM Wait is not counted
306       */
307      hXdmPP->stDMStatus.stCounters.uiDisplayedCount = 0;
308      hXdmPP->stDMStatus.stCounters.uiDisplayedParityFailureCount = 0;
309   }
310
311   BDBG_LEAVE(BXDM_PPCB_S_FirstPtsPassed);
312
313   return;
314
315}  /* end of BXDM_PPCB_S_FirstPtsPassed() */
316
317static void BXDM_PPCB_S_PtsError(
318   BXDM_PictureProvider_Handle hXdmPP,
319   BXDM_PictureProvider_P_LocalState* pLocalState
320   )
321{
322   bool  bSignalPtsError;
323
324   BDBG_ENTER(BXDM_PPCB_S_PtsError);
325
326   BDBG_ASSERT( hXdmPP );
327   BDBG_ASSERT( pLocalState );
328
329   /* First check that a callback function has been registered */
330   bSignalPtsError = ( NULL != hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_ePTSError].stFunction.fPTSError );
331
332   /* Then check that the callback mask bit is set. */
333   bSignalPtsError &= ( hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_ePTSError].bEnable == true );
334
335   /* Finally check that the callback criteria has been met. */
336   bSignalPtsError &= ( (pLocalState->bPtsError == true) || (pLocalState->bForcePtsError == true));
337
338   if (pLocalState->bForcePtsError)
339   {
340      /* When we are forced to send a PTS Error, we always use the PTS
341       * of the currently selected picture */
342
343      BXVD_DBG_MSG(hXdmPP, ("Force PTS Error"));
344      /* Get PTS for current element */
345      BXDM_PPQM_P_GetPts(
346         &hXdmPP->stDMState.stChannel.stSelectedPicture,
347         BXDM_PictureProvider_P_PTSIndex_eActual,
348         hXdmPP->stDMState.stChannel.stSelectedPicture.stPicParms.stTSM.stDynamic.uiTSMSelectedElement,
349         &hXdmPP->stDMState.stDecode.stErrorPts.ui32RunningPTS);
350
351      BXDM_PPQM_P_GetPtsType(
352         &hXdmPP->stDMState.stChannel.stSelectedPicture,
353         &hXdmPP->stDMState.stDecode.stErrorPts.ePTSType);
354   }
355
356   /* If all the conditions have been met, execute the callback */
357   if( bSignalPtsError )
358   {
359      pLocalState->uiCallbackTriggered |= BXDM_PPDBG_Callback_PtsError;
360
361      BXVD_DBG_MSG(hXdmPP, ("%x: BXDM_PictureProvider_Callback_ePtsError(%08x)",
362                                 hXdmPP->stDMState.stDecode.stDebug.uiVsyncCount,
363                                 hXdmPP->stDMState.stDecode.stErrorPts.ui32RunningPTS ));
364
365      hXdmPP->stDMState.stDecode.stErrorPts.uiSTCSnapShot = pLocalState->uiAdjustedStc;
366      hXdmPP->stDMState.stDecode.stErrorPts.uiPicturesDecodedCount = hXdmPP->stDMStatus.stCounters.uiPicturesDecodedCount;
367      hXdmPP->stDMState.stDecode.stErrorPts.uiDisplayManagerDroppedCount = hXdmPP->stDMStatus.stCounters.uiDisplayManagerDroppedCount;
368
369
370      /* Snapshot the start time. */
371      BXDM_PPTMR_P_SnapshotCallbackStartTime( hXdmPP, BXDM_PictureProvider_Callback_ePTSError );
372
373      hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_ePTSError].stFunction.fPTSError (
374                                 hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_ePTSError].pPrivateContext,
375                                 hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_ePTSError].iPrivateParam,
376                                 &hXdmPP->stDMState.stDecode.stErrorPts
377                                 ) ;
378
379      /* Snapshot the end time. */
380      BXDM_PPTMR_P_SnapshotCallbackEndTime( hXdmPP, BXDM_PictureProvider_Callback_ePTSError );
381
382   }
383
384   BDBG_LEAVE(BXDM_PPCB_S_PtsError);
385
386   return;
387
388}  /* end of BXDM_PPCB_S_PtsError() */
389
390static void BXDM_PPCB_S_PtsStcOffset(
391   BXDM_PictureProvider_Handle hXdmPP,
392   BXDM_PictureProvider_P_LocalState* pLocalState
393   )
394{
395   bool bSignalPtsStcOffset;
396
397   BDBG_ENTER(BXDM_PPCB_S_PtsStcOffset);
398
399   BDBG_ASSERT( hXdmPP );
400   BDBG_ASSERT( pLocalState );
401
402   /* First check that a callback function has been registered */
403   bSignalPtsStcOffset = ( NULL != hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eStcPtsOffset].stFunction.fStcPtsOffset );
404
405   /* Then check that the callback mask bit is set. */
406   bSignalPtsStcOffset &= ( hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eStcPtsOffset].bEnable == true );
407
408   /* Finally check that the callback criteria has been met. */
409   bSignalPtsStcOffset &= (pLocalState->bPtsStcOffset == true );
410
411   /* If all the conditions have been met, execute the callback */
412
413   if ( bSignalPtsStcOffset )
414   {
415      /* SW7405-3774: indicate that the callback has been generated for this picture. */
416      hXdmPP->stDMState.stDecode.bExecutedInitialPtsStcOffsetCB = true;
417
418      pLocalState->uiCallbackTriggered |= BXDM_PPDBG_Callback_PtsStcOffset;
419
420      BXVD_DBG_MSG(hXdmPP, ("%x: BXDM_PictureProvider_Callback_eStcPtsOffset(%08x)",
421                hXdmPP->stDMState.stDecode.stDebug.uiVsyncCount,
422                hXdmPP->stDMState.stDecode.uiStcPtsDeltaSentToApp ));
423
424      /* Snapshot the start time. */
425      BXDM_PPTMR_P_SnapshotCallbackStartTime( hXdmPP, BXDM_PictureProvider_Callback_eStcPtsOffset );
426
427      hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eStcPtsOffset].stFunction.fStcPtsOffset (
428                                 hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eStcPtsOffset].pPrivateContext,
429                                 hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eStcPtsOffset].iPrivateParam,
430                                 &hXdmPP->stDMState.stDecode.uiStcPtsDeltaSentToApp
431                                 ) ;
432
433      /* Snapshot the end time. */
434      BXDM_PPTMR_P_SnapshotCallbackEndTime( hXdmPP, BXDM_PictureProvider_Callback_eStcPtsOffset );
435
436   }
437
438   BDBG_LEAVE(BXDM_PPCB_S_PtsStcOffset);
439
440   return;
441
442}   /* end of BXDM_PPCB_S_PtsStcOffset() */
443
444
445static void BXDM_PPCB_S_IFrame(
446   BXDM_PictureProvider_Handle hXdmPP,
447   BXDM_PictureProvider_P_LocalState* pLocalState
448   )
449{
450   bool bSignalIFrame;
451
452   BDBG_ENTER(BXDM_PPCB_S_IFrame);
453
454   BDBG_ASSERT( hXdmPP );
455   BDBG_ASSERT( pLocalState );
456
457   /* First check that a callback function has been registered */
458   bSignalIFrame = ( NULL != hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eIFrame].stFunction.fIFrame );
459
460   /* Then check that the callback mask bit is set. */
461   bSignalIFrame &= ( true == hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eIFrame].bEnable );
462
463   /* Finally check that the callback criteria has been met. */
464   bSignalIFrame &= ( true == pLocalState->bIFrameReceived );
465
466   /* If all the conditions have been met, execute the callback. */
467   if( bSignalIFrame )
468   {
469      pLocalState->uiCallbackTriggered |= BXDM_PPDBG_Callback_IFrame;
470
471      /* Clear the interrup mask bit so that the callback is only
472       * executed once per BXVD_StartDecode() call.
473       */
474      hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eIFrame].bEnable = false;
475
476      BXVD_DBG_MSG(hXdmPP, ("%x: BXDM_PictureProvider_Callback_eIFrame(%d)",
477                hXdmPP->stDMState.stDecode.stDebug.uiVsyncCount,
478                hXdmPP->stDMStatus.bIPictureFound ));
479
480      /* Snapshot the start time. */
481      BXDM_PPTMR_P_SnapshotCallbackStartTime( hXdmPP, BXDM_PictureProvider_Callback_eIFrame );
482
483      hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eIFrame].stFunction.fIFrame (
484                                 hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eIFrame].pPrivateContext,
485                                 hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eIFrame].iPrivateParam,
486                                 &hXdmPP->stDMStatus.bIPictureFound
487                                 ) ;
488
489      /* Snapshot the end time. */
490      BXDM_PPTMR_P_SnapshotCallbackEndTime( hXdmPP, BXDM_PictureProvider_Callback_eIFrame );
491   }
492
493
494   BDBG_LEAVE(BXDM_PPCB_S_IFrame);
495
496   return;
497
498}    /* end of BXDM_PPCB_S_IFrame() */
499
500static void BXDM_PPCB_S_PictureParameters(
501   BXDM_PictureProvider_Handle hXdmPP,
502   BXDM_PictureProvider_P_LocalState* pLocalState
503   )
504{
505   bool bSignalPictureParams;
506
507   BDBG_ENTER(BXDM_PPCB_S_PictureParameters);
508
509   BDBG_ASSERT( hXdmPP );
510   BDBG_ASSERT( pLocalState );
511
512   /* First check that a callback function has been registered */
513   bSignalPictureParams = ( NULL != hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_ePictureParameters].stFunction.fPictureParameters );
514
515   /* Then check that the callback mask bit is set. */
516   bSignalPictureParams &= ( true == hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_ePictureParameters].bEnable );
517
518   /* Always generate once the first picture has been seen  */
519   bSignalPictureParams &= ( true == hXdmPP->stDMState.stDecode.bFirstPPBSeen );
520
521   /* If all the conditions have been met, execute the callback. */
522   if ( bSignalPictureParams )
523   {
524      pLocalState->uiCallbackTriggered |= BXDM_PPDBG_Callback_PictureParameters;
525
526#if 0
527      BDBG_DISPMGR_MSG(("BXDM_PPCB_S_PictureParameters::"));
528
529      BKNI_Printf("%x: PPCB: %d x %d (%d)\n",
530                  hXdmPP->stDMState.stDecode.stDebug.uiVsyncCount,
531                  hXdmPP->stDMContextState.PictureParameterInfo.ulDisplayHorizontalSize,
532                  hXdmPP->stDMContextState.PictureParameterInfo.ulDisplayVerticalSize,
533                  hXdmPP->stDMContextState.PictureParameterInfo.eFrameRateCode);
534#endif
535
536      /* Snapshot the start time. */
537      BXDM_PPTMR_P_SnapshotCallbackStartTime( hXdmPP, BXDM_PictureProvider_Callback_ePictureParameters );
538
539      hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_ePictureParameters].stFunction.fPictureParameters (
540                                 hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_ePictureParameters].pPrivateContext,
541                                 hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_ePictureParameters].iPrivateParam,
542                                 &hXdmPP->stDMStatus.stPictureParameterInfo
543                                 ) ;
544
545      /* Snapshot the end time. */
546      BXDM_PPTMR_P_SnapshotCallbackEndTime( hXdmPP, BXDM_PictureProvider_Callback_ePictureParameters );
547   }
548
549   BDBG_LEAVE(BXDM_PPCB_S_PictureParameters);
550
551   return;
552
553}    /* end of BXDM_PPCB_S_PictureParameters() */
554
555static void BXDM_PPCB_S_TsmPassInASTMMode(
556   BXDM_PictureProvider_Handle hXdmPP,
557   BXDM_PictureProvider_P_LocalState* pLocalState
558   )
559{
560   bool bSignalASTMPass;
561
562   BDBG_ENTER(BXDM_PPCB_S_TsmPassInASTMMode);
563
564   BDBG_ASSERT( hXdmPP );
565   BDBG_ASSERT( pLocalState );
566
567   /* First check that a callback function has been registered */
568   bSignalASTMPass = ( NULL != hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eTSMPassInASTMMode].stFunction.fTSMPassInASTMMode );
569
570   /* Then check that the callback mask bit is set. */
571   bSignalASTMPass &= ( true == hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eTSMPassInASTMMode].bEnable );
572
573   /* Finally check that the callback criteria has been met. */
574   bSignalASTMPass &= ( true == pLocalState->bASTMModeTSMPass );
575
576   /* If all the conditions have been met, execute the callback. */
577   if( bSignalASTMPass )
578   {
579      pLocalState->uiCallbackTriggered |= BXDM_PPDBG_Callback_TsmPassInASTMMode;
580
581#if 0
582      BDBG_DISPMGR_MSG(("BXDM_PPCB_S_TsmPassInASTMMode::"));
583#endif
584      /* Snapshot the start time. */
585      BXDM_PPTMR_P_SnapshotCallbackStartTime( hXdmPP, BXDM_PictureProvider_Callback_eTSMPassInASTMMode );
586
587
588      hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eTSMPassInASTMMode].stFunction.fTSMPassInASTMMode (
589                                 hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eTSMPassInASTMMode].pPrivateContext,
590                                 hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eTSMPassInASTMMode].iPrivateParam,
591                                 &hXdmPP->stDMStatus.stCurrentPTS
592                                 ) ;
593
594      /* Snapshot the end time. */
595      BXDM_PPTMR_P_SnapshotCallbackEndTime( hXdmPP, BXDM_PictureProvider_Callback_eTSMPassInASTMMode );
596
597   }
598
599   BDBG_LEAVE(BXDM_PPCB_S_TsmPassInASTMMode);
600
601   return;
602
603}    /* end of BXDM_PPCB_S_TsmPassInASTMMode() */
604
605static void BXDM_PPCB_S_PictureUnderEvaluation(
606   BXDM_PictureProvider_Handle hXdmPP,
607   BXDM_PictureProvider_P_LocalState* pLocalState
608   )
609{
610   bool bSignalPictureUnderEvaluation;
611   BXDM_PictureProvider_P_Picture_Context *pstPictureUnderEvaluation = BXDM_PPQM_P_GetFirstPictureContext(hXdmPP);
612
613   BDBG_ENTER(BXDM_PPCB_S_PictureUnderEvaluation);
614
615   BDBG_ASSERT( hXdmPP );
616   BDBG_ASSERT( pLocalState );
617
618   /* First check that a callback function has been registered */
619   bSignalPictureUnderEvaluation = ( NULL != hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_ePictureUnderEvaluation].stFunction.fPictureUnderEvaluation );
620
621   /* Then check that the callback mask bit is set. */
622   bSignalPictureUnderEvaluation &= ( true == hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_ePictureUnderEvaluation].bEnable );
623
624   /* Finally check that the callback criteria has been met. */
625   bSignalPictureUnderEvaluation &= ( true == pLocalState->bPictureUnderEvaluation );
626
627   /* If all the conditions have been met, execute the callback. */
628   if( bSignalPictureUnderEvaluation )
629   {
630      pLocalState->uiCallbackTriggered |= BXDM_PPDBG_Callback_PictureUnderEvaluation;
631
632#if 0
633      BDBG_DISPMGR_MSG(("BXDM_PPCB_S_PictureUnderEvaluation::"));
634#endif
635      /* Snapshot the start time. */
636      BXDM_PPTMR_P_SnapshotCallbackStartTime( hXdmPP, BXDM_PictureProvider_Callback_ePictureUnderEvaluation );
637
638      hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_ePictureUnderEvaluation].stFunction.fPictureUnderEvaluation (
639                                 hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_ePictureUnderEvaluation].pPrivateContext,
640                                 hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_ePictureUnderEvaluation].iPrivateParam,
641                                 pstPictureUnderEvaluation->pstUnifiedPicture
642                                 ) ;
643
644      /* Snapshot the end time. */
645      BXDM_PPTMR_P_SnapshotCallbackEndTime( hXdmPP, BXDM_PictureProvider_Callback_ePictureUnderEvaluation );
646
647   }
648
649   BDBG_LEAVE(BXDM_PPCB_S_PictureUnderEvaluation);
650
651   return;
652
653}    /* end of BXDM_PPCB_S_PictureUnderEvaluation() */
654
655static void BXDM_PPCB_S_RequestSTC(
656   BXDM_PictureProvider_Handle hXdmPP,
657   BXDM_PictureProvider_P_LocalState* pLocalState
658   )
659{
660   bool bSignalRequestStc;
661   BXDM_PictureProvider_PTSInfo stPTSInfo;
662
663   BDBG_ENTER(BXDM_PPCB_S_RequestSTC);
664
665   BDBG_ASSERT( hXdmPP );
666   BDBG_ASSERT( pLocalState );
667
668   /* First check that a callback function has been registered */
669   bSignalRequestStc = ( NULL != hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eRequestSTC].stFunction.fRequestSTC );
670
671   /* Then check that the callback mask bit is set. */
672   bSignalRequestStc &= ( true == hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eRequestSTC].bEnable );
673
674   /* Finally check that the callback criteria has been met. */
675   if ( ( true == hXdmPP->stDMState.stChannel.stClipInfo.stCurrentClip.stTime.bValid )
676        && ( false == hXdmPP->stDMState.stChannel.stClipInfo.stCurrentClip.stDisplayEvent.bOccurred )
677        && ( false == hXdmPP->stDMState.stChannel.stClipInfo.stCurrentClip.stRequestEvent.bOccurred ) )
678
679   {
680      bSignalRequestStc &= ( true == hXdmPP->stDMState.stChannel.stClipInfo.stCurrentClip.stStartEvent.bOccurred );
681
682      BKNI_Memset( &stPTSInfo, 0, sizeof ( BXDM_PictureProvider_PTSInfo ) );
683      stPTSInfo.ui32RunningPTS = hXdmPP->stDMState.stChannel.stClipInfo.stCurrentClip.stStartEvent.uiTime;
684
685      if ( true == bSignalRequestStc )
686      {
687         hXdmPP->stDMState.stChannel.stClipInfo.stCurrentClip.stRequestEvent.bOccurred = true;
688         hXdmPP->stDMState.stChannel.stClipInfo.stCurrentClip.stRequestEvent.uiTime = stPTSInfo.ui32RunningPTS;
689      }
690   }
691   else
692   {
693      bSignalRequestStc &= ( ( BXDM_PictureProvider_PTSType_eCoded == hXdmPP->stDMStatus.stCurrentPTS.ePTSType )
694                             || ( BXDM_PictureProvider_PTSType_eInterpolatedFromValidPTS == hXdmPP->stDMStatus.stCurrentPTS.ePTSType ) );
695      stPTSInfo = hXdmPP->stDMStatus.stCurrentPTS;
696   }
697
698   /* If all the conditions have been met, execute the callback. */
699   if ( bSignalRequestStc )
700   {
701      pLocalState->uiCallbackTriggered |= BXDM_PPDBG_Callback_RequestSTC;
702
703      hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eRequestSTC].bEnable = false;
704
705      BXVD_DBG_MSG(hXdmPP, ("%x: BXDM_PictureProvider_Callback_eRequestSTC(%08x)",
706                hXdmPP->stDMState.stDecode.stDebug.uiVsyncCount,
707                stPTSInfo.ui32RunningPTS ));
708
709      /* Snapshot the start time. */
710      BXDM_PPTMR_P_SnapshotCallbackStartTime( hXdmPP, BXDM_PictureProvider_Callback_eRequestSTC );
711
712      hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eRequestSTC].stFunction.fRequestSTC (
713         hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eRequestSTC].pPrivateContext,
714         hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eRequestSTC].iPrivateParam,
715         &stPTSInfo
716         );
717
718      /* Snapshot the end time. */
719      BXDM_PPTMR_P_SnapshotCallbackEndTime( hXdmPP, BXDM_PictureProvider_Callback_eRequestSTC );
720
721   }
722
723   BDBG_LEAVE(BXDM_PPCB_S_RequestSTC);
724
725   return;
726
727}    /* end of BXDM_PPCB_S_RequestSTC() */
728
729static void BXDM_PPCB_S_ClipStart(
730   BXDM_PictureProvider_Handle hXdmPP,
731   BXDM_PictureProvider_P_LocalState* pLocalState
732   )
733{
734   bool bSignalClipStart;
735
736   BDBG_ENTER(BXDM_PPCB_S_ClipStart);
737
738   BDBG_ASSERT( hXdmPP );
739   BDBG_ASSERT( pLocalState );
740
741   /* First check that a callback function has been registered */
742   bSignalClipStart = ( NULL != hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eClipStart].stFunction.fClipStart );
743
744   /* Check that the callback was triggered. */
745   bSignalClipStart &= ( true == pLocalState->stCallbackInfo.stClipStart.bTriggered );
746
747   /* If all the conditions have been met, execute the callback. */
748   if ( bSignalClipStart )
749   {
750      pLocalState->uiCallbackTriggered |= BXDM_PPDBG_Callback_ClipStart;
751
752      BXVD_DBG_MSG(hXdmPP, ("%x: BXDM_PictureProvider_Callback_eClipStart(%08x)",
753                                 hXdmPP->stDMState.stDecode.stDebug.uiVsyncCount,
754                                 &pLocalState->stCallbackInfo.stClipStart.stClipEventInfo ));
755
756      /* Snapshot the start time. */
757      BXDM_PPTMR_P_SnapshotCallbackStartTime( hXdmPP, BXDM_PictureProvider_Callback_eClipStart );
758
759      hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eClipStart].stFunction.fClipStart (
760         hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eClipStart].pPrivateContext,
761         hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eClipStart].iPrivateParam,
762         &pLocalState->stCallbackInfo.stClipStart.stClipEventInfo
763         );
764
765      /* Snapshot the end time. */
766      BXDM_PPTMR_P_SnapshotCallbackEndTime( hXdmPP, BXDM_PictureProvider_Callback_eClipStart );
767
768   }
769
770   BDBG_LEAVE(BXDM_PPCB_S_ClipStart);
771
772   return;
773
774}    /* end of BXDM_PPCB_S_ClipStart() */
775
776static void BXDM_PPCB_S_ClipStop(
777   BXDM_PictureProvider_Handle hXdmPP,
778   BXDM_PictureProvider_P_LocalState* pLocalState
779   )
780{
781   bool bSignalClipStop;
782
783   BDBG_ENTER(BXDM_PPCB_S_ClipStop);
784
785   BDBG_ASSERT( hXdmPP );
786   BDBG_ASSERT( pLocalState );
787
788   /* First check that a callback function has been registered */
789   bSignalClipStop = ( NULL != hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eClipStop].stFunction.fClipStop );
790
791   /* Check that the callback was triggered. */
792   bSignalClipStop &= ( true == pLocalState->stCallbackInfo.stClipStop.bTriggered );
793
794   /* If all the conditions have been met, execute the callback. */
795   if ( bSignalClipStop )
796   {
797      pLocalState->uiCallbackTriggered |= BXDM_PPDBG_Callback_ClipStop;
798
799      BXVD_DBG_MSG(hXdmPP, ("%x: BXDM_PictureProvider_Callback_eClipStop(%08x)",
800                                 hXdmPP->stDMState.stDecode.stDebug.uiVsyncCount,
801                                 &pLocalState->stCallbackInfo.stClipStop.stClipEventInfo ));
802
803      /* Snapshot the start time. */
804      BXDM_PPTMR_P_SnapshotCallbackStartTime( hXdmPP, BXDM_PictureProvider_Callback_eClipStop );
805
806      hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eClipStop].stFunction.fClipStop (
807         hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eClipStop].pPrivateContext,
808         hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eClipStop].iPrivateParam,
809         &pLocalState->stCallbackInfo.stClipStop.stClipEventInfo
810         );
811
812      /* Snapshot the end time. */
813      BXDM_PPTMR_P_SnapshotCallbackEndTime( hXdmPP, BXDM_PictureProvider_Callback_eClipStop );
814
815   }
816
817   BDBG_LEAVE(BXDM_PPCB_S_ClipStop);
818
819   return;
820
821}    /* end of BXDM_PPCB_S_ClipStop() */
822
823static void BXDM_PPCB_S_PictureMarker(
824   BXDM_PictureProvider_Handle hXdmPP,
825   BXDM_PictureProvider_P_LocalState* pLocalState
826   )
827{
828   bool bSignalPictureMarker;
829
830   BDBG_ENTER(BXDM_PPCB_S_PictureMarker);
831
832   BDBG_ASSERT( hXdmPP );
833   BDBG_ASSERT( pLocalState );
834
835   /* First check that a callback function has been registered */
836   bSignalPictureMarker = ( NULL != hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_ePictureMarker].stFunction.fPictureMarker );
837
838   /* Check that the callback was triggered. */
839   bSignalPictureMarker &= ( true == pLocalState->stCallbackInfo.stPictureMarker.bTriggered );
840
841   /* If all the conditions have been met, execute the callback. */
842   if ( bSignalPictureMarker )
843   {
844      pLocalState->uiCallbackTriggered |= BXDM_PPDBG_Callback_PictureMarker;
845
846      BXVD_DBG_MSG(hXdmPP, ("%x: BXDM_PictureProvider_Callback_ePictureMarker(%08x)",
847                                 hXdmPP->stDMState.stDecode.stDebug.uiVsyncCount,
848                                 &pLocalState->stCallbackInfo.stPictureMarker.stClipEventInfo));
849
850      /* Snapshot the start time. */
851      BXDM_PPTMR_P_SnapshotCallbackStartTime( hXdmPP, BXDM_PictureProvider_Callback_ePictureMarker );
852
853      hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_ePictureMarker].stFunction.fPictureMarker (
854         hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_ePictureMarker].pPrivateContext,
855         hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_ePictureMarker].iPrivateParam,
856         &pLocalState->stCallbackInfo.stPictureMarker.stClipEventInfo
857         );
858
859      /* Snapshot the end time. */
860      BXDM_PPTMR_P_SnapshotCallbackEndTime( hXdmPP, BXDM_PictureProvider_Callback_ePictureMarker );
861
862   }
863
864   BDBG_LEAVE(BXDM_PPCB_S_PictureMarker);
865
866   return;
867
868}    /* end of BXDM_PPCB_S_PictureMarker() */
869
870
871static void BXDM_PPCB_S_DecodeError(
872   BXDM_PictureProvider_Handle hXdmPP,
873   BXDM_PictureProvider_P_LocalState* pLocalState
874   )
875{
876   bool bSignalDecodeError;
877   BXDM_PictureProvider_Callback_DecodeErrorInfo stDecodeErrorInfo;
878
879   BDBG_ENTER(BXDM_PPCB_S_DecodeError);
880
881   BDBG_ASSERT( hXdmPP );
882   BDBG_ASSERT( pLocalState );
883
884   /* First check that a callback function has been registered */
885   bSignalDecodeError = ( NULL != hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eDecodeError].stFunction.fDecodeError );
886
887   /* Then check that the callback mask bit is set. */
888   bSignalDecodeError &= ( true == hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eDecodeError].bEnable );
889
890   /* Finally check that the callback criteria has been met. */
891   bSignalDecodeError &= ( true == pLocalState->bDecodeError );
892
893   /* If all the conditions have been met, execute the callback. */
894   if( bSignalDecodeError )
895   {
896      BKNI_Memset( &stDecodeErrorInfo, 0, sizeof ( BXDM_PictureProvider_Callback_DecodeErrorInfo ) );
897
898      pLocalState->uiCallbackTriggered |= BXDM_PPDBG_Callback_DecodeError;
899
900      BXVD_DBG_MSG(hXdmPP, ("%x: BXDM_PPCB_S_DecodeError(%d)",
901                hXdmPP->stDMState.stDecode.stDebug.uiVsyncCount,
902                hXdmPP->stDMStatus.stCounters.uiDecodeErrorCount ));
903
904      /* Snapshot the start time. */
905      BXDM_PPTMR_P_SnapshotCallbackStartTime( hXdmPP, BXDM_PictureProvider_Callback_eDecodeError );
906
907      stDecodeErrorInfo.uiDecodeErrorCount = hXdmPP->stDMStatus.stCounters.uiDecodeErrorCount;
908
909      hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eDecodeError].stFunction.fDecodeError (
910                                 hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eDecodeError].pPrivateContext,
911                                 hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eDecodeError].iPrivateParam,
912                                 &stDecodeErrorInfo
913                                 ) ;
914
915      /* Snapshot the end time. */
916      BXDM_PPTMR_P_SnapshotCallbackEndTime( hXdmPP, BXDM_PictureProvider_Callback_eDecodeError );
917
918   }
919
920
921   BDBG_LEAVE(BXDM_PPCB_S_DecodeError);
922
923   return;
924
925}    /* end of BXDM_PPCB_S_DecodeError() */
926
927static void BXDM_PPCB_S_TSMResult(
928   BXDM_PictureProvider_Handle hXdmPP,
929   BXDM_PictureProvider_P_LocalState* pLocalState
930   )
931{
932   bool bSignalTSMResult;
933   BXDM_PictureProvider_P_Picture_Context *pstPictureUnderEvaluation = BXDM_PPQM_P_GetFirstPictureContext(hXdmPP);
934
935   BDBG_ENTER(BXDM_PPCB_S_TSMResult);
936
937   BDBG_ASSERT( hXdmPP );
938   BDBG_ASSERT( pLocalState );
939
940   /* First check that a callback function has been registered */
941   bSignalTSMResult = ( NULL != hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eTSMResult].stFunction.fTSMResult );
942
943   /* Then check that the callback mask bit is set. */
944   bSignalTSMResult &= ( true == hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eTSMResult].bEnable );
945
946   /* If all the conditions have been met, execute the callback. */
947   if( bSignalTSMResult )
948   {
949      BXDM_PictureProvider_TSMInfo stTSMInfo;
950
951      BKNI_Memset(&stTSMInfo, 0, sizeof(BXDM_PictureProvider_TSMInfo));
952
953      stTSMInfo.eTSMResult = pstPictureUnderEvaluation->stPicParms.stTSM.stDynamic.eTsmResult;
954      stTSMInfo.ePictureHandlingMode = pstPictureUnderEvaluation->stPicParms.stTSM.stDynamic.ePictureHandlingMode;
955
956      pLocalState->uiCallbackTriggered |= BXDM_PPDBG_Callback_TSMResult;
957
958#if 0
959      BDBG_DISPMGR_MSG(("BXDM_PPCB_S_TSMResult::"));
960#endif
961
962      /* Snapshot the start time. */
963      BXDM_PPTMR_P_SnapshotCallbackStartTime( hXdmPP, BXDM_PictureProvider_Callback_eTSMResult );
964
965      hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eTSMResult].stFunction.fTSMResult (
966                                 hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eTSMResult].pPrivateContext,
967                                 hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eTSMResult].iPrivateParam,
968                                 &stTSMInfo
969                                 ) ;
970
971      /* Snapshot the end time. */
972      BXDM_PPTMR_P_SnapshotCallbackEndTime( hXdmPP, BXDM_PictureProvider_Callback_eTSMResult );
973
974
975      /* Override this picture's picture handling mode based on the
976       * app's request */
977      pstPictureUnderEvaluation->stPicParms.stTSM.stDynamic.ePictureHandlingMode = stTSMInfo.ePictureHandlingMode;
978   }
979
980   BDBG_LEAVE(BXDM_PPCB_S_TSMResult);
981
982   return;
983
984}    /* end of BXDM_PPCB_S_TSMResult() */
985
986static void BXDM_PPCB_S_PrintExtensionData(
987   BXDM_PictureProvider_Handle hXdmPP,
988   const BXDM_Picture_ExtensionInfo * pstExtensionInfo
989   )
990{
991   uint32_t i;
992
993   for( i=0; i < pstExtensionInfo->uiCount; i++ )
994   {
995      switch( pstExtensionInfo->astExtensionData[i].eType )
996      {
997         case BXDM_Picture_ExtensionType_eBluRay3DGraphicsOffset:
998            if ( pstExtensionInfo->astExtensionData[i].data.stBluRay3DGraphicsOffset.uiCount )
999            {
1000               BXVD_DBG_MSG(hXdmPP, ("MVC graphics offset:: uiCount %d puiOffsetData 0x%x *puiOffsetData %d",
1001                     pstExtensionInfo->astExtensionData[i].data.stBluRay3DGraphicsOffset.uiCount,
1002                     pstExtensionInfo->astExtensionData[i].data.stBluRay3DGraphicsOffset.puiOffsetData,
1003                     *pstExtensionInfo->astExtensionData[i].data.stBluRay3DGraphicsOffset.puiOffsetData
1004                     ));
1005            }
1006            else
1007            {
1008               BXVD_DBG_MSG(hXdmPP, ("MVC graphics offset:: uiCount %d puiOffsetData 0x%x",
1009                     pstExtensionInfo->astExtensionData[i].data.stBluRay3DGraphicsOffset.uiCount,
1010                     pstExtensionInfo->astExtensionData[i].data.stBluRay3DGraphicsOffset.puiOffsetData
1011                     ));
1012            }
1013            break;
1014
1015         case BXDM_Picture_ExtensionType_eSEIMsg_FramePacking:
1016         {
1017            /* SW7405-4500: the following needs to be two lines to avoid a compiler warning when DEBUG=n */
1018
1019            BXDM_Picture_Extension_SEIFramePacking * pstSEIFramePacking;
1020            pstSEIFramePacking = pstExtensionInfo->astExtensionData[i].data.stSEIFramePacking.pstSeiData;
1021
1022            BXVD_DBG_MSG(hXdmPP, ("SEIFramePacking flag:0x%x msgFlag:0x%x msgData: %d %d %d %d %d %d %d %d %d",
1023                     pstExtensionInfo->astExtensionData[i].data.stSEIFramePacking.uiFlags,
1024                     pstSEIFramePacking->uiFlags,
1025                     pstSEIFramePacking->uiFramePackingArrangementId,
1026                     pstSEIFramePacking->uiFramePackingArrangementType,
1027                     pstSEIFramePacking->uiContentInterpretationType,
1028                     pstSEIFramePacking->uiFrame0GridPositionX,
1029                     pstSEIFramePacking->uiFrame0GridPositionY,
1030                     pstSEIFramePacking->uiFrame1GridPositionX,
1031                     pstSEIFramePacking->uiFrame1GridPositionY,
1032                     pstSEIFramePacking->uiFramePackingArrangementReservedByte,
1033                     pstSEIFramePacking->uiFramePackingArrangementRepetitionPeriod
1034                     ));
1035            break;
1036         }
1037
1038         case BXDM_Picture_ExtensionType_eSEIFramePacking:  /* DEPRECATED: SW7405-4560: use BXDM_Picture_ExtensionType_eSEIMsg_FramePacking */
1039         default:
1040            BXVD_DBG_MSG(hXdmPP, ("\t eType %d", pstExtensionInfo->astExtensionData[i].eType ));
1041            break;
1042
1043      }     /* end of switch( eType )*/
1044   }        /* end of for( pstExtensionInfo->uiCount ) */
1045
1046   if ( NULL != pstExtensionInfo->pNext )
1047   {
1048      BXDM_PPCB_S_PrintExtensionData( hXdmPP, pstExtensionInfo->pNext );
1049   }
1050
1051   return;
1052
1053}     /* end of BXDM_PPCB_S_PrintExtensionData */
1054
1055static void BXDM_PPCB_S_PictureExtensionData(
1056         BXDM_PictureProvider_Handle hXdmPP,
1057         BXDM_PictureProvider_P_LocalState* pLocalState,
1058         BXDM_PictureProvider_P_Picture_Context * pstPicture
1059   )
1060{
1061   bool bSignalExtensionData;
1062
1063   BDBG_ENTER(BXDM_PPCB_S_PictureExtensionData);
1064
1065   BDBG_ASSERT( hXdmPP );
1066   BDBG_ASSERT( pLocalState );
1067   BDBG_ASSERT( pstPicture );
1068
1069   /* SW7405-4804: Typically the extension data callback will be executed when a
1070    * picture is delivered to VDC via the "BXDM_PPCB_P_ExecuteCallbacks" function.
1071    * However this does not happen for pictures that are dropped.  This case is
1072    * now handled by calling "BXDM_PPCB_P_ExecuteSingleCallbackExt" whenever a
1073    * picture is released.  The flag "bExtensionDataDelivered" ensures that the
1074    * callback is only executed once per picture.
1075    */
1076
1077   /* First check that a callback function has been registered */
1078   bSignalExtensionData = ( NULL != hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_ePictureExtensionData].stFunction.fPictureExtensionData );
1079
1080   /* Then check that the callback mask bit is set. */
1081   bSignalExtensionData &= ( true == hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_ePictureExtensionData].bEnable );
1082
1083   bSignalExtensionData &= ( NULL != pstPicture->pstUnifiedPicture );
1084
1085   /* SW7405-4560: only deliver the data once per picture. */
1086   bSignalExtensionData &= ( false == pstPicture->stPicParms.stDisplay.stDynamic.bExtensionDataDelivered );
1087
1088   /* If all the conditions have been met, execute the callback. */
1089   if( bSignalExtensionData )
1090   {
1091      pLocalState->uiCallbackTriggered |= BXDM_PPDBG_Callback_ExtensionData;
1092
1093      pstPicture->stPicParms.stDisplay.stDynamic.bExtensionDataDelivered = true;
1094
1095      if ( 0 != pstPicture->pstUnifiedPicture->stExtensionInfo.uiCount
1096            || ( NULL != pstPicture->pstUnifiedPicture->stExtensionInfo.pNext
1097               && 0 != pstPicture->pstUnifiedPicture->stExtensionInfo.pNext->uiCount )
1098         )
1099      {
1100         BXVD_DBG_MSG(hXdmPP, ("%x: [%01x.%03x] BXDM_PPCB_S_PictureExtensionData uiCount %d",
1101                                    hXdmPP->stDMState.stDecode.stDebug.uiVsyncCount,
1102                                    hXdmPP->stDMConfig.uiInstanceID & 0xF,
1103                                    pstPicture->stPicParms.uiPPBIndex & 0xFFF,
1104                                    pstPicture->pstUnifiedPicture->stExtensionInfo.uiCount
1105                                    ));
1106
1107         BXDM_PPCB_S_PrintExtensionData( hXdmPP, (BXDM_Picture_ExtensionInfo *)&(pstPicture->pstUnifiedPicture->stExtensionInfo) );
1108      }
1109
1110      /* Snapshot the start time. */
1111      BXDM_PPTMR_P_SnapshotCallbackStartTime( hXdmPP, BXDM_PictureProvider_Callback_ePictureExtensionData );
1112
1113      hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_ePictureExtensionData].stFunction.fPictureExtensionData (
1114               hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_ePictureExtensionData].pPrivateContext,
1115               hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_ePictureExtensionData].iPrivateParam,
1116               &(pstPicture->pstUnifiedPicture->stExtensionInfo)
1117               );
1118
1119      /* Snapshot the end time. */
1120      BXDM_PPTMR_P_SnapshotCallbackEndTime( hXdmPP, BXDM_PictureProvider_Callback_ePictureExtensionData );
1121
1122   }
1123
1124
1125   BDBG_LEAVE(BXDM_PPCB_S_PictureExtensionData);
1126
1127   return;
1128
1129}    /* end of BXDM_PPCB_S_PictureExtensionData() */
1130
1131static void BXDM_PPCB_S_EvaluateCriteria_PtsStcOffset(
1132   BXDM_PictureProvider_Handle hXdmPP,
1133   BXDM_PictureProvider_P_LocalState* pLocalState
1134   )
1135{
1136   /*TODO: delete if not needed BXDM_PictureProvider_P_Queue_PtsStcDelta* pstStcPtsDelta;*/
1137   uint32_t    uiDeltaOfDeltas;
1138   uint32_t    uiCurrentStcPtsDelta;
1139   BXDM_PictureProvider_P_Picture_Context *  pstSelectedPicture;
1140
1141   BDBG_ENTER(BXDM_PPCB_S_EvaluateCriteria_PtsStcOffset);
1142
1143   BDBG_ASSERT( hXdmPP );
1144   BDBG_ASSERT( pLocalState );
1145
1146   /* initialize the local variables */
1147
1148   /*TODO: delete if not needed pstStcPtsDelta = &( hXdmPP->stDMState.stDecode.stStcPtsDeltas );   */
1149   pstSelectedPicture = &(hXdmPP->stDMState.stChannel.stSelectedPicture);
1150   uiCurrentStcPtsDelta = pstSelectedPicture->stPicParms.stTSM.stDynamic.iStcPtsDifferenceActual;
1151
1152   /* Only consider the STC/PTS delta if
1153    * - the TSM result is a "BXDM_PictureProvider_P_TSMState_ePass"
1154    * - AND the "selection" mode for this picture is TSM.
1155    *   (It could be overriden to "vsync" if auto vsync mode has kicked in.)
1156    * - AND the context has been validated
1157    * - AND either
1158    *   - the callback has NOT been called at least once (SW7405-3774/SW7550-379)
1159    *   - or this element is being displayed for the first time
1160    */
1161   if( BXDM_PictureProvider_TSMResult_ePass == pstSelectedPicture->stPicParms.stTSM.stDynamic.eTsmResult
1162         && BXDM_PictureProvider_DisplayMode_eTSM == pstSelectedPicture->stPicParms.stTSM.stDynamic.eSelectionMode
1163         && true == pstSelectedPicture->bValidated
1164         &&  ( false == hXdmPP->stDMState.stDecode.bExecutedInitialPtsStcOffsetCB
1165               || false == pstSelectedPicture->stPicParms.stDisplay.stDynamic.bElementRepeated )
1166      )
1167   {
1168
1169      /* "iStcPtsDifferenceActual" should always be a postive value.
1170       * Initially we had a bug where it was negative.
1171       * Keep this check for now in case an issue creeps back in.
1172       * TODO: eventually remove this check.
1173       */
1174      if ( pstSelectedPicture->stPicParms.stTSM.stDynamic.iStcPtsDifferenceActual < 0 )
1175      {
1176         uiCurrentStcPtsDelta = -pstSelectedPicture->stPicParms.stTSM.stDynamic.iStcPtsDifferenceActual;
1177         BXVD_DBG_ERR(hXdmPP, ("BXDM_PPCB_S_EvaluateCriteria_PtsStcOffset:: negative PTS/STC delta %d",
1178                     pstSelectedPicture->stPicParms.stTSM.stDynamic.iStcPtsDifferenceActual
1179                     ));
1180      }
1181
1182      if ( true == pLocalState->bFICChanged )
1183      {
1184         /* Do not generate a StcPtsOffset interrupt if the Field
1185          * Inversion Correction has changed this vsync */
1186         pLocalState->bPtsStcOffset =  false;
1187      }
1188      /*
1189       * The following will be true the first time through after "BXVD_StartDecode()" has been called.
1190       */
1191      else if ( hXdmPP->stDMState.stDecode.uiStcPtsDeltaSentToApp == (uint32_t)(-1) )
1192      {
1193         /*
1194          * Always want to send the first STC/PTS delta to the application.
1195          */
1196         pLocalState->bPtsStcOffset = true;
1197         hXdmPP->stDMState.stDecode.uiStcPtsDeltaSentToApp = uiCurrentStcPtsDelta;
1198      }
1199      else
1200      {
1201         /* Now generate the delta of the delta's, i.e. by how much do
1202          * the new delta and previous one differ?
1203          */
1204         if ( hXdmPP->stDMState.stDecode.uiStcPtsDeltaSentToApp > uiCurrentStcPtsDelta )
1205         {
1206            uiDeltaOfDeltas = hXdmPP->stDMState.stDecode.uiStcPtsDeltaSentToApp - uiCurrentStcPtsDelta;
1207         }
1208         else
1209         {
1210            uiDeltaOfDeltas = uiCurrentStcPtsDelta - hXdmPP->stDMState.stDecode.uiStcPtsDeltaSentToApp;
1211         }
1212
1213         /* TODO: in DM V1, "p_st_skip_pic->ui32NumLateOccurrence" factored
1214          * into the logic when generating the callback.  Is something similar still needed?
1215          */
1216         if ( uiDeltaOfDeltas > pstSelectedPicture->stPicParms.stTSM.stStatic.uiPtsVsyncDiffThreshold )
1217         {
1218            pLocalState->bPtsStcOffset =  true;
1219            hXdmPP->stDMState.stDecode.uiStcPtsDeltaSentToApp = uiCurrentStcPtsDelta;
1220         }
1221         else
1222         {
1223            /* TODO: is this really needed? */
1224            pLocalState->bPtsStcOffset =  false;
1225         }
1226
1227      }
1228
1229   }
1230
1231
1232   BDBG_LEAVE(BXDM_PPCB_S_EvaluateCriteria_PtsStcOffset);
1233
1234   return;
1235
1236}  /* end of BXDM_PPCB_P_EvaluateCriteria_PtsStcOffset() */
1237
1238
1239/*******************************************************************************
1240 *
1241 * Public routines.
1242 *
1243 ******************************************************************************/
1244
1245void BXDM_PPCB_P_EvaluateCriteria_IFrame(
1246   BXDM_PictureProvider_Handle hXdmPP,
1247   BXDM_PictureProvider_P_LocalState* pLocalState,
1248   BXDM_PictureProvider_P_Picture_Context * pstSelectedPic
1249   )
1250{
1251   BDBG_ENTER(BXDM_PPCB_P_EvaluateCriteria_IFrame);
1252
1253   BDBG_ASSERT( hXdmPP );
1254   BDBG_ASSERT( pLocalState );
1255   BDBG_ASSERT( pstSelectedPic );
1256
1257   if ( true == pstSelectedPic->bValidated
1258         && ( NULL != pstSelectedPic->pstUnifiedPicture )
1259         && ( BXDM_Picture_Coding_eI == pstSelectedPic->pstUnifiedPicture->stPictureType.eCoding )
1260       )
1261   {
1262      hXdmPP->stDMStatus.bIPictureFound = true;
1263      pLocalState->bIFrameReceived = true;
1264   }
1265
1266   BDBG_LEAVE(BXDM_PPCB_P_EvaluateCriteria_IFrame);
1267
1268   return;
1269
1270}    /* end of BXDM_PPCB_P_EvaluateCriteria_IFrame() */
1271
1272
1273void BXDM_PPCB_P_EnableAutomaticCallbacks(
1274   BXDM_PictureProvider_Handle hXdmPP
1275   )
1276{
1277   BDBG_ENTER(BXDM_PPCB_P_EnableAutomaticCallbacks );
1278
1279   BDBG_ASSERT( hXdmPP );
1280
1281   /* The following callbacks need to be enabled every time "BXVD_StartDecode"
1282    * or "BXVD_ProcessWatchdog" is called.
1283    */
1284   hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eStcPtsOffset].bEnable = true;
1285   hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eFirstPTSReady].bEnable = true;
1286   hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eFirstPTSPassed].bEnable = true;
1287   hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_ePTSError].bEnable = true;
1288   hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eIFrame].bEnable = true;
1289   hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_ePictureParameters].bEnable= true;
1290   hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eTSMPassInASTMMode].bEnable = true;
1291   hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eRequestSTC].bEnable = true;
1292   hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_ePictureUnderEvaluation].bEnable = true;
1293   hXdmPP->stCallbacks[BXDM_PictureProvider_Callback_eTSMResult].bEnable = true;
1294
1295   BDBG_LEAVE(BXDM_PPCB_P_EnableAutomaticCallbacks );
1296
1297   return;
1298
1299}  /* end of BXDM_PPCB_P_EnableAutomaticCallbacks() */
1300
1301
1302void BXDM_PPCB_P_ExecuteSingleCallbackExt(
1303   BXDM_PictureProvider_Handle hXdmPP,
1304   BXDM_PictureProvider_P_LocalState* pLocalState,
1305   BXDM_PictureProvider_P_Picture_Context * pstPicture,
1306   BXDM_PictureProvider_Callback eCallbackName
1307   )
1308{
1309   BDBG_ENTER(BXDM_PPCB_P_ExecuteSingleCallbackExt);
1310
1311   BDBG_ASSERT( hXdmPP );
1312   BDBG_ASSERT( pLocalState );
1313
1314   switch( eCallbackName )
1315   {
1316   case BXDM_PictureProvider_Callback_eFirstPTSReady:
1317      BXDM_PPCB_S_FirstPtsReady( hXdmPP, pLocalState );
1318      break;
1319
1320   case BXDM_PictureProvider_Callback_eFirstCodedPTSReady:
1321      BXDM_PPCB_S_FirstCodedPtsReady( hXdmPP, pLocalState );
1322      break;
1323
1324   case BXDM_PictureProvider_Callback_eFirstPTSPassed:
1325      BXDM_PPCB_S_FirstPtsPassed( hXdmPP, pLocalState );
1326      break;
1327
1328   case BXDM_PictureProvider_Callback_ePTSError:
1329      BXDM_PPCB_S_PtsError( hXdmPP, pLocalState );
1330      break;
1331
1332   case BXDM_PictureProvider_Callback_eStcPtsOffset:
1333      BXDM_PPCB_S_PtsStcOffset( hXdmPP, pLocalState );
1334      break;
1335
1336   case BXDM_PictureProvider_Callback_eIFrame:
1337      BXDM_PPCB_S_IFrame( hXdmPP, pLocalState );
1338      break;
1339
1340   case BXDM_PictureProvider_Callback_ePictureParameters:
1341      BXDM_PPCB_S_PictureParameters( hXdmPP, pLocalState );
1342      break;
1343
1344   case BXDM_PictureProvider_Callback_eTSMPassInASTMMode:
1345      BXDM_PPCB_S_TsmPassInASTMMode( hXdmPP, pLocalState );
1346      break;
1347
1348   case BXDM_PictureProvider_Callback_eRequestSTC:
1349      BXDM_PPCB_S_RequestSTC( hXdmPP, pLocalState );
1350      break;
1351
1352   case BXDM_PictureProvider_Callback_eClipStart:
1353      BXDM_PPCB_S_ClipStart( hXdmPP, pLocalState );
1354      break;
1355
1356   case BXDM_PictureProvider_Callback_eClipStop:
1357      BXDM_PPCB_S_ClipStop( hXdmPP, pLocalState );
1358      break;
1359
1360   case BXDM_PictureProvider_Callback_ePictureMarker:
1361      BXDM_PPCB_S_PictureMarker( hXdmPP, pLocalState );
1362      break;
1363   case BXDM_PictureProvider_Callback_ePictureUnderEvaluation:
1364      BXDM_PPCB_S_PictureUnderEvaluation( hXdmPP, pLocalState );
1365      break;
1366
1367   case BXDM_PictureProvider_Callback_eDecodeError:
1368      BXDM_PPCB_S_DecodeError( hXdmPP, pLocalState );
1369      break;
1370
1371   case BXDM_PictureProvider_Callback_eTSMResult:
1372      BXDM_PPCB_S_TSMResult( hXdmPP, pLocalState );
1373      break;
1374
1375   case BXDM_PictureProvider_Callback_ePictureExtensionData:
1376      BXDM_PPCB_S_PictureExtensionData( hXdmPP, pLocalState, pstPicture );
1377      break;
1378
1379   default:
1380      break;
1381
1382   }
1383
1384   BDBG_LEAVE(BXDM_PPCB_P_ExecuteSingleCallbackExt);
1385
1386   return;
1387
1388 }    /* end of BXDM_PPCB_P_ExecuteSingleCallbackExt() */
1389
1390
1391void BXDM_PPCB_P_ExecuteSingleCallback(
1392   BXDM_PictureProvider_Handle hXdmPP,
1393   BXDM_PictureProvider_P_LocalState* pLocalState,
1394   BXDM_PictureProvider_Callback eCallbackName
1395   )
1396{
1397   BDBG_ENTER(BXDM_PPCB_P_ExecuteSingleCallback);
1398
1399   BDBG_ASSERT( hXdmPP );
1400   BDBG_ASSERT( pLocalState );
1401
1402   BXDM_PPCB_P_ExecuteSingleCallbackExt( hXdmPP, pLocalState, NULL, eCallbackName );
1403
1404   BDBG_LEAVE(BXDM_PPCB_P_ExecuteSingleCallback);
1405
1406   return;
1407
1408 }    /* end of BXDM_PPCB_P_ExecuteSingleCallback() */
1409
1410void BXDM_PPCB_P_ExecuteCallbacks(
1411   BXDM_PictureProvider_Handle hXdmPP,
1412   BXDM_PictureProvider_P_LocalState* pLocalState
1413   )
1414{
1415   BDBG_ENTER(BXDM_PPCB_P_ExecuteCallbacks);
1416
1417   BDBG_ASSERT( hXdmPP );
1418   BDBG_ASSERT( pLocalState );
1419
1420   /* Has the STC/PTS delta changed enough that a callback is needed?
1421    * Note: This routine can be called anytime after the picture element has been selected.
1422    * Call it from here just to keep the routine local to this file.
1423    */
1424   BXDM_PPCB_S_EvaluateCriteria_PtsStcOffset( hXdmPP, pLocalState );
1425
1426   BXDM_PPCB_P_ExecuteSingleCallbackExt( hXdmPP, pLocalState, NULL, BXDM_PictureProvider_Callback_eClipStop );
1427   BXDM_PPCB_P_ExecuteSingleCallbackExt( hXdmPP, pLocalState, NULL, BXDM_PictureProvider_Callback_ePictureMarker );
1428   BXDM_PPCB_P_ExecuteSingleCallbackExt( hXdmPP, pLocalState, NULL, BXDM_PictureProvider_Callback_eClipStart );
1429   BXDM_PPCB_P_ExecuteSingleCallbackExt( hXdmPP, pLocalState, NULL, BXDM_PictureProvider_Callback_eRequestSTC );
1430   BXDM_PPCB_P_ExecuteSingleCallbackExt( hXdmPP, pLocalState, NULL, BXDM_PictureProvider_Callback_eFirstPTSReady );
1431   BXDM_PPCB_P_ExecuteSingleCallbackExt( hXdmPP, pLocalState, NULL, BXDM_PictureProvider_Callback_eFirstCodedPTSReady );
1432   BXDM_PPCB_P_ExecuteSingleCallbackExt( hXdmPP, pLocalState, NULL, BXDM_PictureProvider_Callback_eFirstPTSPassed );
1433   BXDM_PPCB_P_ExecuteSingleCallbackExt( hXdmPP, pLocalState, NULL, BXDM_PictureProvider_Callback_ePTSError );
1434   BXDM_PPCB_P_ExecuteSingleCallbackExt( hXdmPP, pLocalState, NULL, BXDM_PictureProvider_Callback_eStcPtsOffset );
1435   BXDM_PPCB_P_ExecuteSingleCallbackExt( hXdmPP, pLocalState, NULL, BXDM_PictureProvider_Callback_eIFrame );
1436   BXDM_PPCB_P_ExecuteSingleCallbackExt( hXdmPP, pLocalState, NULL, BXDM_PictureProvider_Callback_ePictureParameters );
1437   BXDM_PPCB_P_ExecuteSingleCallbackExt( hXdmPP, pLocalState, NULL, BXDM_PictureProvider_Callback_eTSMPassInASTMMode );
1438   BXDM_PPCB_P_ExecuteSingleCallbackExt( hXdmPP, pLocalState, NULL, BXDM_PictureProvider_Callback_eDecodeError );
1439
1440   /* SW7422-72: the "ePictureExtensionData" callback is now executed in BXDM_PPOUT_S_3DFixup.
1441    * This is to allow the middleware/application a chance to call BXDM_PictureProvider_Set3D_isr
1442    * before the MFD picture structure is filled in.
1443    */
1444#if 0
1445   BXDM_PPCB_P_ExecuteSingleCallbackExt(
1446               hXdmPP,
1447               pLocalState,
1448               &(hXdmPP->stDMState.stChannel.stSelectedPicture),
1449               BXDM_PictureProvider_Callback_ePictureExtensionData
1450               );
1451#endif
1452   BXDM_PPDBG_P_CallbackTriggeredLog(hXdmPP, pLocalState->uiCallbackTriggered);
1453
1454
1455   BDBG_LEAVE(BXDM_PPCB_P_ExecuteCallbacks);
1456
1457   return;
1458
1459}  /* end of BXDM_PPCB_P_ExecuteCallBacks() */
1460
1461
1462
Note: See TracBrowser for help on using the repository browser.