source: svn/trunk/newcon3bcm2_21bu/dta/src/dcc/src/bdccengine.c @ 2

/***************************************************************************         
 *     Copyright (c) 2002-2006, Broadcom Corporation     
 *     All Rights Reserved                  
 *     Confidential Property of Broadcom Corporation         
 *  
 *  THIS SOFTWARE MAY ONLY BE USED SUBJECT TO AN EXECUTED SOFTWARE LICENSE  
 *  AGREEMENT  BETWEEN THE USER AND BROADCOM.  YOU HAVE NO RIGHT TO USE OR      
 *  EXPLOIT THIS MATERIAL EXCEPT SUBJECT TO THE TERMS OF SUCH AN AGREEMENT.       
 *      
 * $brcm_Workfile: bdccengine.c $
 * $brcm_Revision: 14 $
 * $brcm_Date: 10/4/06 1:58p $
 *      
 * Module Description:               
 *         
 * Revision History:         
 *     
 * $brcm_Log: /BSEAV/lib/ccgfx/source/bdccengine.c $
 * 
 * 14   10/4/06 1:58p btosi
 * PR22275: fixed issues with the selection of the 608 service (CC 1-4)
 * need to pass"Field" and "Channel" to BDCC_608_TranscodeReset, treat
 * "Field" as a zero-based index.
 * 
 * 13   9/22/06 1:33p btosi
 * PR22275: added support for clearing the screen if the CC data stream
 * stops for an extended period (30 seconds)
 * 
 * 12   9/15/06 12:07p btosi
 * PR22275: added support for font edges
 * 
 * 11   8/23/06 9:00a btosi
 * PR22275: added support for specifying the "Safe Title" area
 * 
 * 10   8/17/06 1:13p btosi
 * PR22275: reworked the API to support loading/unloading fonts files
 * 
 * 9   8/4/06 4:03p btosi
 * PR22275: cleaned up the processing of the DELAY command.
 * 
 * 8   8/3/06 12:07p btosi
 * PR22275: cleaned up the flashing implementation which uses two
 * surfaces, i.e. FLASH_BY_2SURFACES
 * 
 * 7   7/28/06 1:27p btosi
 * PR22275: cleaned up build warnings
 * 
 * 6   7/17/06 1:35p btosi
 * PR22275: added wrapper routine BDCC_ENG_Process, support for resetting
 * the library and logic to update the time counter
 * 
 * 5   7/7/06 12:31p btosi
 * PR22275: added logic to redraw the framebuffer less frequently
 * 
 * 4   5/10/06 6:49p shyam
 * PR 8365 : Make it comiler warning free and ANSI C compliant
 * 
 * 3   4/6/06 2:51p btosi
 * PR3541: adding use of the BDBG_MODULE macro for integration with the
 * RNG200 build
 * 
 * 2   5/17/05 7:44p shyam
 * PR 8365 : Making it work at runtime
 * 
 * 1   5/9/05 3:49p shyam
 * PR 8365 : Add other sub-modules of ccgfx
 * 
 ***************************************************************************/    
  





/***************************************************************************
 *                         708 Rendering Engine
 *                         --------------------
 * 
 * This Rendering Engine API is a wrapper around several lower-level 708
 * libraries.  In most cases, it is expected that this API will be used
 * instead of the lower-level APIs.  In those cases in which the customer/
 * system integrator has a need that isn't covered here, this code then 
 * serves as example code.
 * 
 * Scope
 * 
 * This API wraps the 708 DTVCC rendering and 608 Transcoding libraries
 * but does not wrap the APIs used to extract Closed Captioning streams
 * from MPEG User Data or from analog Line 21.  Furthermore, it does not
 * wrap the API for inserting 608 back into Line 21 on analog output.
 * 
 * 608 and 708
 * 
 * The Rendering Engine has two main entry points, one each for 708 rendering
 * and 608 transcoding.  Higher level system/driver code is expected to call the
 * appropriate API to extract the Closed Captioning data from the input, be it
 * the MPEG API (ie., bcmMPIReadClosedCaptionStatus) or the CCDecoder API
 * (bCCDProcess), and then call one of these two entry points in this API:
 * BDCC_ENG_Process608 or DccEngine_Process708.
 * 
 * This API has these features:
 * 
 * 1.  manages the circular buffers
 * 2.  sequences the calls to the lower-level APIs
 * 3.  allows caller control over field and service numbers
 * 4.  allows caller ability to override various DTVCC attributes
 * 5.  provides reset
 * 6.  context-less:  all processing done on _ProcessXxx and _Periodic calls
 * 
 ***************************************************************************/    


                                /*********************
                                 *
                                 * Includes
                                 *
                                 *********************/


#include "bdcc_cfg.h"
#include "bdcc_kernel.h"
#include "bdcc.h"
#include "bdcc_cbuf.h"
#include "bdcc_coding.h"
#include "bdccpacket.h"
#include "bdcc608transcoder.h"

#include "bdccengine.h"
#include "bdccservice.h"
#include "bdccintgfx.h"

BDBG_MODULE(bdccengine);
                                /*********************
                                 *
                                 * Defines
                                 *
                                 *********************/
#define BDCC_ENG_P_ASPECT_4_3_COLUMN_SIZE       32
#define BDCC_ENG_P_ASPECT_16_9_COLUMN_SIZE      42
#define BDCC_ENG_P_DEF_CHARCELL_WIDTH           15
#define BDCC_ENG_P_DEF_CHARCELL_HEIGHT          25

#define BDCC_ENG_P_CBUF_SIZE                            512

#define BDCC_ENG_P_CBUF_RESERVE                 32
#define BDCC_ENG_P_SILIMIT_608                          (BDCC_ENG_P_CBUF_SIZE - BDCC_ENG_P_CBUF_RESERVE)
/*
** BDCC_ENG_P_SILIMIT_708 was originally defined to be 128.
** I don't see any reason that this can't be the entire buffer minus "a bit".  7/7/06
*/
#define BDCC_ENG_P_SILIMIT_708                          (BDCC_ENG_P_CBUF_SIZE - (2 * BDCC_ENG_P_CBUF_RESERVE))

/*
** How much the CC window needs to be indented to insure
** that it is visible.
** These really should be set by the application based on the
** screen resolution and display type.
*/
#define BDCC_ENG_P_SafeTitle_X    36 /* TODO: originally this was 40, what should it be?*/
#define BDCC_ENG_P_SafeTitle_Y    24 /* TODO: originally this was 30, what should it be?*/


                                /*********************
                                 *
                                 * Types
                                 *
                                 *********************/
typedef struct BDCC_ENG_P_Object
{
        /*
         * Circular Buffer:  Triplets
         *
         * This buffer holds either 608 or 708 byte
         * triplets:  (field,cc1,cc2) or (cc_type,cc1,cc2)
         */
        BDCC_CBUF               cbTriplets ;
        unsigned char   BufTriplets[BDCC_ENG_P_CBUF_SIZE*3] ;
        
        /*
         * Circular Buffer:  Packet
         *
         * This buffer holds 708 packets, used only for
         * DTVCC processing, not for 608 transcoding
         */
        BDCC_CBUF               cbPacket ;
        unsigned char   BufPacket[BDCC_ENG_P_CBUF_SIZE] ;
        
        /*
         * Circular Buffer:  Service
         *
         * This buffer holds 708 service blocks.
         */
        BDCC_CBUF               cbService ;
        unsigned char   BufService[BDCC_ENG_P_CBUF_SIZE] ;
        
        /*
         * Circular Buffer:  Coding
         *
         * This buffer feeds the coding and interpretation
         * library.  This also serves as the Service Input 
         * Buffer, per the 708 spec.
         */
        BDCC_CBUF               cbCoding ;
        unsigned char   BufCoding[BDCC_ENG_P_CBUF_SIZE] ;

        /*
         * associated object data
         */
        BDCC_608_hTranscoder    h608Transcoder ;
        BDCC_INT_P_Handle               hCodingInt ;
        BDCC_PKT_P_Object               PacketObject ;
        /* The CCGFX Winlib module handle */
        BCCGFX_WINLIB_P_Handle  hWinLibHandle ;
        /* The CCGFX module handle */
        BCCGFX_P_GfxHandle              hCCGfxHandle ;

        /*
         * object attributes
         */
        BDCC_ENG_Type   Type ;
        int                             iCcService ;
        
        BDCC_ENG_Settings engineSettings;
        unsigned int    SILimit ;
        
        unsigned int    uiCurTimeMilliSecs;     /* roughtly the current system                                      */
        unsigned int    uiLastDataMilliSecs;    /* the last time CC data was received                           */
        bool                bDataReceived;          /* data has been received since the last screen clear   */
        
        //RLQ
        int                             iCcService708;                  /* track the 708 CS user selected */
        unsigned int    uiLastCSMilliSecs;              /* the last time CC data was received                           */
        uint32_t                iPktSequenceNumErr;             /* track packet sequence number error */
} BDCC_ENG_P_Object ;
                                 



                                /*********************
                                 *
                                 * Prototypes
                                 *
                                 *********************/
                                 
BDCC_Error CheckForBufferOverflow(BDCC_ENG_Handle hEngine) ;
void ResetDownstreamOfPacket(BDCC_ENG_Handle hEngine);


BDCC_Error BDCC_ENG_P_Init(
        bool bResetOnly,
        BDCC_ENG_Handle hEngine, 
        BDCC_ENG_Type Type,
        BCCGFX_WINLIB_P_Handle hWinLibHandle,
        int iCcService
        )
{
        unsigned int SILimit ;
    BDCC_608_hTranscoder h608Transcoder = NULL  ;
    BCCGFX_P_GfxHandle hCCGfxHandle = NULL ;
    BDCC_INT_P_Handle hCodingInt = NULL ;

        /*
    ** save the current parameters
         */
        hEngine->hWinLibHandle = hWinLibHandle ;
        hEngine->Type = Type ;
    hEngine->iCcService = iCcService ;
    hEngine->bDataReceived = false ;

    /*
    ** TODO: is the following code block really needed?
    */
        if(bResetOnly)
        {
                h608Transcoder  = hEngine->h608Transcoder ;
                hCCGfxHandle = hEngine->hCCGfxHandle ;
                hCodingInt = hEngine->hCodingInt ;
        }
        
        /*
    ** init the circular buffers
         */
        BDCC_CBUF_Init(&hEngine->cbTriplets, hEngine->BufTriplets, sizeof(hEngine->BufTriplets), BDCC_ENG_P_CBUF_RESERVE) ;
        BDCC_CBUF_Init(&hEngine->cbPacket, hEngine->BufPacket, sizeof(hEngine->BufPacket), BDCC_ENG_P_CBUF_RESERVE) ;
        BDCC_CBUF_Init(&hEngine->cbService, hEngine->BufService, sizeof(hEngine->BufService), BDCC_ENG_P_CBUF_RESERVE) ;
        BDCC_CBUF_Init(&hEngine->cbCoding, hEngine->BufCoding, sizeof(hEngine->BufCoding), BDCC_ENG_P_CBUF_RESERVE) ;

        /*
    ** if we're doing 608 transcoding init its object structure
         */
        if ( Type == BDCC_ENG_Type_e608 )
        {
                int Field608, Chan608 ;
        switch ( iCcService )
        {       
                        case 1:
                                Field608 = 1 ;
                                Chan608 = 1 ;
                                break ;
                        case 2:
                                Field608 = 1 ;
                                Chan608 = 2 ;
                                break ;
                        case 3:
                                Field608 = 2 ;
                                Chan608 = 1 ;
                                break ;
                        case 4:
                                Field608 = 2 ;
                                Chan608 = 2 ;
                                break ;
                        default:
                                return(BDCC_Error_eArgOutOfRange) ;
                                break ;
                }

        /*
        ** If the library is being reset and the transcode engine has previously been
        ** opened, simply reset the transcode logic.  Otherwise allocate it.
        **
        ** TODO: can't we simply look at  "hEngine->h608Transcoder" to determine if we
        ** need to reset or allocate?
        */
        if ( bResetOnly && h608Transcoder )
        {
                        hEngine->h608Transcoder = h608Transcoder ;
            BDCC_608_TranscodeReset(hEngine->h608Transcoder, Field608, Chan608);
        }
        else
        {
            BDCC_608_TranscodeOpen(&hEngine->h608Transcoder, Field608, Chan608) ;       
        }

                SILimit = BDCC_ENG_P_SILIMIT_608 ;

    }
        else if ( Type == BDCC_ENG_Type_e708 )
        {
                SILimit = BDCC_ENG_P_SILIMIT_708 ;
        hEngine->iCcService708 = iCcService ;
        hEngine->uiLastCSMilliSecs = hEngine->uiCurTimeMilliSecs;
        }
        else
        {
                BKNI_Free(hEngine);
                return(BDCC_Error_eArgOutOfRange) ;
        }

        /*
    * * init the pkt, coding and interpretation objects
    ** TODO: wrap in "bResetOnly"?
         */
        BDCC_PKT_P_Init(&hEngine->PacketObject) ;
        hEngine->SILimit = SILimit ;

        if(bResetOnly)
        {
                hEngine->hCCGfxHandle = hCCGfxHandle ;
                hEngine->hCodingInt = hCodingInt ;
        /*
        ** TODO: are the following in the correct order?
        */
                BDCC_Coding_P_Reset(hEngine->hCodingInt) ;
        BCCGFX_P_Reset( hEngine->hCCGfxHandle, &hEngine->engineSettings );
    }
        else
        {
                /*
        ** init the ccgfx layer
                 */

        BCCGFX_P_Init( hEngine->hCCGfxHandle, &hEngine->engineSettings );

                BDCC_Coding_P_Open(&hEngine->hCodingInt, 
                        hEngine->hWinLibHandle, 
                        hEngine->hCCGfxHandle, 
                        hEngine->SILimit, 
                    hEngine->engineSettings.Columns );
    }

    /*
    ** Resample the system clock.
    */
    BCCGFX_P_TimeReset( hEngine->hCCGfxHandle );

        //RLQ
        hEngine->iPktSequenceNumErr = 0;

        return(BDCC_Error_eSuccess) ;

}

                                /*********************
                                 *
                                 * API Entry Points
                                 *
                                 *********************/

/**************************************************************************                
 *  
 * Function:            BDCC_ENG_GetDefaultSettings    
 *     
 * Inputs:                        
 *                                      Type                            - BDCC_ENG_Type_e608 or 
 *                                                                      BDCC_ENG_Type_e708
 *                                      pEngineSettings         - BDCC_ENG_Settings structure 
 *    
 * Outputs:                           
 *                                      hEngine                         - init'ed by this function
 *  
 * Returns:                     BDCC_Error_eSuccess or standard BDCC_Error error code     
 *    
 * Description:                
 *         
 * This function return the default and recommended values for various engine settings. 
 *
 * See Also:
 *    BDCC_ENG_Open
 *                
 **************************************************************************/  
BDCC_Error BDCC_ENG_GetDefaultSettings(
        BDCC_ENG_Settings *pEngineSettings)
{
        BDCC_ASSERT(pEngineSettings);
        
        pEngineSettings->Columns = BDCC_ENG_P_ASPECT_4_3_COLUMN_SIZE ;
        pEngineSettings->iCharCellWidth           = BDCC_ENG_P_DEF_CHARCELL_WIDTH ;
        pEngineSettings->iCharCellHeight          = BDCC_ENG_P_DEF_CHARCELL_HEIGHT ;
        pEngineSettings->iSafeTitleX                 = BDCC_ENG_P_SafeTitle_X;
        pEngineSettings->iSafeTitleY                 = BDCC_ENG_P_SafeTitle_Y;
        pEngineSettings->iEdgeWidth                 = BDCC_Edge_Width;
        pEngineSettings->uiTimeOutMilliSecs      = BDCC_Data_Timeout_MSecs;

        return BDCC_Error_eSuccess ;
}

BDCC_Error BDCC_ENG_GetSettings(
        BDCC_ENG_Handle hEngine, 
        BDCC_ENG_Settings *pEngineSettings
        )
{
        BDCC_ASSERT(hEngine);
        BDCC_ASSERT(pEngineSettings);

        *pEngineSettings = hEngine->engineSettings;

        return BDCC_Error_eSuccess ;
}


BDCC_Error BDCC_ENG_SetSettings(
        BDCC_ENG_Handle hEngine, 
        BDCC_ENG_Settings *pEngineSettings
        )
{
        BDCC_ASSERT(hEngine);
        BDCC_ASSERT(pEngineSettings);

        hEngine->engineSettings = *pEngineSettings;

        return BDCC_Error_eSuccess ;
}


/**************************************************************************                
 *  
 * Function:            BDCC_ENG_Open    
 *     
 * Inputs:                        
 *                                      Type                            - BDCC_ENG_Type_e608 or BDCC_ENG_Type_e708
 *                                      iCcService                              - CCx for 608 (1 to 4)
 *                                                                                Service Number for 708 (0 to 63)
 *                                      Columns                         - number of columns for DTVCC grid
 *                                                                                use 32 for 4:3 and 42 for 16:9
 *                                      iCharCellWidth          - pixel width for char cell, must be
 *                                                                                compatible with font/glyph design
 *                                      iCharCellHeight         - pixel height for char cell, must be
 *                                                                                compatible with font/glyph design
 *    
 * Outputs:                           
 *                                      hEngine                         - init'ed by this function    
 *  
 * Returns:                     BDCC_Error_eSuccess or standard BDCC_Error error code     
 *    
 * Description:                
 *         
 * This function inits the buffers used for 708 DTVCC Closed     
 * Captioning processing.  The 'Type' argument, in effect, is announcing
 * which processing entry point will be called during normal processing.
 * To switch between 608 and 708 (or to switch any of the init args), 
 * BDCC_ENG_Close and DccEngine_Init must be called again -- or 
 * alternatively, DccEngine_Reset.
 *
 * See Also:
 *    BDCC_ENG_Close
 *    DccEngine_Reset
 *                
 **************************************************************************/  
BDCC_Error BDCC_ENG_Open(
        BDCC_ENG_Handle *phEngine, 
        BCCGFX_WINLIB_P_Handle hWinLibHandle 
        )
{
    int iError;

        BDCC_ENG_Handle hEngine;

        BDCC_ASSERT(hWinLibHandle);
        
        *phEngine = hEngine = (BDCC_ENG_Handle)BKNI_Malloc( sizeof(BDCC_ENG_P_Object));

        if(hEngine == NULL)
        {
                return BDCC_Error_eNoMemory;
        }

    BKNI_Memset(hEngine, 0, sizeof(BDCC_ENG_P_Object)) ;

    hEngine->hWinLibHandle = hWinLibHandle ;

    iError = BCCGFX_P_Open(&hEngine->hCCGfxHandle, hEngine->hWinLibHandle );

    return iError;

} /* BDCC_ENG_Open */


BDCC_Error BDCC_ENG_Init(
        BDCC_ENG_Handle hEngine, 
        int iCcService,
        BDCC_ENG_Type Type
        )
{
        return BDCC_ENG_P_Init(
                        0, 
                        hEngine, 
                        Type, 
                        hEngine->hWinLibHandle, 
                        iCcService
                        );

} /* BDCC_ENG_Init */


/**************************************************************************                
 *  
 * Function:            BDCC_ENG_Close   
 *     
 * Inputs:                        
 *                                      hEngine                         - init'ed previously by DccEngine_Init   
 *    
 * Outputs:                           
 *  
 * Returns:                     BDCC_Error_eSuccess or standard BDCC_Error error code     
 *    
 * Description:                
 *         
 * This function undoes the initialization of DccEngine_Init().
 *
 * See Also:
 *    DccEngine_Reset
 *    DccEngine_Init
 *                
 **************************************************************************/  
BDCC_Error BDCC_ENG_Close(BDCC_ENG_Handle hEngine)
{
        BDCC_ASSERT(hEngine);
        if ( hEngine->Type == BDCC_ENG_Type_e608 )
        {
                BDCC_608_TranscodeClose(hEngine->h608Transcoder);
        }
        BDCC_Coding_P_Close(hEngine->hCodingInt);
        BCCGFX_P_Close(hEngine->hCCGfxHandle) ;

        BKNI_Free(hEngine);

        return(BDCC_Error_eSuccess) ;
        
} /* BDCC_ENG_Close */


/**************************************************************************                
 *  
 * Function:            BDCC_ENG_Reset    
 *     
 * Inputs:                        
 *                                      hEngine                         - init'ed previously by BDCC_ENG_Open   
 *                                      iCcService                              - CCx for 608 (1 to 4)
 *                                                                                Service Number for 708 (0 to 63)
 *                                      Type                            - 608, 708 or "NoChange"
 *                                      Columns                         - number of columns for DTVCC grid
 *                                                                                use 32 for 4:3 and 42 for 16:9
 *                                      iCharCellWidth          - pixel width for char cell, must be
 *                                                                                compatible with font/glyph design
 *                                      iCharCellHeight         - pixel height for char cell, must be
 *                                                                                compatible with font/glyph design
 *    
 * Outputs:                           
 *  
 * Returns:                     BDCC_Error_eSuccess or standard BDCC_Error error code     
 *    
 * Description:                
 *         
 * BDCC_ENG_Reset is logically equivalent to the sequence BDCC_ENG_Close() 
 * followed by BDCC_ENG_Open().  
 * 
 * Note:  This function is provided in case some advantage can be gained by
 * consolidating _Fini and _Init.  For example, memory need not be free and
 * re-aquired which has an effect on memory fragmentation.  Treat this function
 * as a soft reset and the sequence _Fini and _Init as a hard reset.
 * 
 * If Type is BDCC_ENG_Type_NoChange, then the reset is performed using the current
 * parameters and Type, iCcService, Columns, iCharCellXxx are ignored.
 *
 * See Also:
 *    BDCC_ENG_Close
 *    BDCC_ENG_Open
 *                
 **************************************************************************/  
BDCC_Error BDCC_ENG_Reset(
        BDCC_ENG_Handle hEngine, 
        bool bNoChange,
        BDCC_ENG_Type ccMode,
        int ccService
        )
{
    BDCC_Error bdccErr;
    unsigned int OverrideMask ;
    BDCC_ENG_OverRides Overrides ;

    BSTD_UNUSED( bNoChange );

    /* 
    ** Save the overrides.
    */
    OverrideMask = hEngine->hCodingInt->OverrideMask ;
    Overrides = hEngine->hCodingInt->Overrides ;

    /* 
    ** For now, only allow the CC service and mode to be reapplied.
    */
    bdccErr = BDCC_ENG_P_Init(
                        true,                                   /* bResetOnly */
                        hEngine, 
                        ccMode,                             /* 608 or 708 */
                        hEngine->hWinLibHandle,
                        ccService
                        );
    /* 
    ** re-apply the overrides
    */
    BDCC_ENG_Override(hEngine, OverrideMask, &Overrides) ;

    return( bdccErr );
        
}

extern unsigned int ProcessCmd_GetTextCount(void);

/**************************************************************************                
 *  
 * Function:            BDCC_ENG_Process    
 *     
 * Inputs:                        
 *                                      hEngine                 - init'ed previously by DccEngine_Init  
 *                                      pTriplets                       - ptr to buf of triplets (field,cc1,cc2)
 *                                      NumTriplets             - count = num_bytes / 3
 *    
 * Outputs:                           
 *  
 * Returns:                     BDCC_Error_eSuccess or standard BDCC_Error error code     
 *    
 * Description:                
 *         
 * Primarily a wrapper routine around the other BDCC functions.  Provides a single
 * entry point to simplify the interface for the application.
 *
 * If this function returns BDCC_Error_eBufferOverflow, it is expected that the
 * caller will call again to DccEngine_Reset.
 *
 **************************************************************************/  
BDCC_Error BDCC_ENG_Process(
    BDCC_ENG_Handle hEngine,
    unsigned char * pTriplets,
    int NumTriplets )
{
    static unsigned int text_count;
    unsigned int tmp;
    BDCC_Error bdccErr = BDCC_Error_eSuccess;

    bool bTimedOut;

    /*
     ** TODO: similar checks are performed in BDCC_ENG_Process708() 
     ** and BDCC_ENG_Process608.  If this routine becomes the only entry point,
     ** remove those checks.
     */

    if ( NULL == hEngine || NULL == pTriplets )
    {
        return( BDCC_Error_eNullPointer ) ;
    }

    /*
     ** Bump the clock and drive the time dependent events.
     ** ( flashing, scrolling, erasing windows, DELAY, FADE and WIPE )
     */

    BDCC_ENG_Periodic( hEngine );

    /*
     ** If data is availabe, call the appropriate processing rouinte.
     */
    if ( NumTriplets > 0 )
        {
                /*
                 ** Keep track of when data was last received.
                 ** If a "timeout", we'll need to clear the screen.
                 */
                tmp = ProcessCmd_GetTextCount();        /* just update time if we got text to draw */
                if (text_count != tmp) {
                        hEngine->uiLastDataMilliSecs = hEngine->uiCurTimeMilliSecs;
                        hEngine->bDataReceived = true;
                        text_count = tmp;
                }

                /*
                 ** Based on the CC mode, direct the data to the appropriate pipe.
                 */
                if ( BDCC_ENG_Type_e708 == hEngine->Type )
                {
#if 0
                        //RLQ
                        unsigned int cs_count = BDCC_SRV_Get_CS_Block_Count(hEngine->iCcService708);
#endif
                        /*
                         ** TODO: should we validate the data being passed by the application?
                         */
                        bdccErr = BDCC_ENG_Process708( hEngine, pTriplets, NumTriplets );
#if 0
                        if (cs_count != BDCC_SRV_Get_CS_Block_Count(hEngine->iCcService708)) {
                                /* CS selected by the user has DCC data, switch back to it and update timeout value */
                                hEngine->iCcService = hEngine->iCcService708;
                                hEngine->uiLastCSMilliSecs = hEngine->uiCurTimeMilliSecs;
                                BDCC_DBG_MSG(("CS%d service found, use it", hEngine->iCcService708)) ;
                        }
                        else {
                                if ( ((hEngine->uiCurTimeMilliSecs - hEngine->uiLastCSMilliSecs) > BDCC_CS_Timeout_MSecs) && (1 != hEngine->iCcService)) {
                                        hEngine->iCcService = 1;                /* if no CSx data for given timeout, switch to CS1 */
                                        BDCC_DBG_MSG(("No CS%d data for given %d ms, swich to CS1", hEngine->iCcService708, BDCC_CS_Timeout_MSecs)) ;
                                }
                        }
#endif
                }
                else if ( BDCC_ENG_Type_e608 == hEngine->Type )
                {
                        /*
                         ** TODO: should we validate the data being passed by the application?
                         */
                        bdccErr = BDCC_ENG_Process608( hEngine, pTriplets, NumTriplets );

                }
                else
                {
                        return( BDCC_Error_eBadOutputType ) ;
                }
        }
        else {
                /*RLQ*/
                /* handle DELAY command case */
                if ( BDCC_ENG_Type_e708 == hEngine->Type ) {
                        bdccErr = BDCC_ENG_Process708( hEngine, pTriplets, NumTriplets );
                }
        }

        /*
         ** Clear the screen if:
         ** - "engineSettings.uiTimeOutMilliSecs" milliseconds have passed since CC data was received
         ** - data has been received after the last time the screen was cleared
         */

        bTimedOut = ( hEngine->uiCurTimeMilliSecs - hEngine->uiLastDataMilliSecs > hEngine->engineSettings.uiTimeOutMilliSecs  );

        if ( bTimedOut && hEngine->bDataReceived)
        {
                BDCC_DBG_MSG(("+++CC timeout, clear screen")) ;
                BDCC_Coding_P_ScreenClear( hEngine->hCodingInt );
                hEngine->bDataReceived = false;
        }

        return( bdccErr );

} /* BDCC_ENG_Process608 */
/**************************************************************************                
 *  
 * Function:            BDCC_ENG_Process608    
 *     
 * Inputs:                        
 *                                      hEngine                         - init'ed previously by DccEngine_Init  
 *                                      pTriplets                       - ptr to buf of triplets (field,cc1,cc2)
 *                                      NumTriplets                     - count = num_bytes / 3
 *    
 * Outputs:                           
 *  
 * Returns:                     BDCC_Error_eSuccess or standard BDCC_Error error code     
 *    
 * Description:                
 *         
 * This function sends the CC pairs matching the supplied Field through
 * the required processing for rendering.  This includes the 608 Transcoder.
 *
 * If this function returns BDCC_Error_eBufferOverflow, it is expected that the
 * caller will call again to DccEngine_Reset.
 *
 **************************************************************************/  
BDCC_Error BDCC_ENG_Process608(
                BDCC_ENG_Handle hEngine,
                unsigned char * pTriplets,
                int NumTriplets)
{
        BDCC_Error err ;

        /*
         * first do some validation
         */
        if ( NULL == hEngine   ||   pTriplets == NULL )
        {
                return(BDCC_Error_eNullPointer) ;
        }

        if ( NumTriplets < 0 )
        {
                return(BDCC_Error_eArgOutOfRange) ;
        }

        if ( hEngine->Type != BDCC_ENG_Type_e608 )
        {
                return(BDCC_Error_eBadOutputType) ;
        }

        /*
         * do one pass 
         */
        BDCC_CBUF_WritePtr(&hEngine->cbTriplets, pTriplets, NumTriplets * 3) ;
        BDCC_608_TranscodeProcess(hEngine->h608Transcoder,&hEngine->cbTriplets, &hEngine->cbService) ;
        BDCC_SIBuf_P_Process(hEngine->hCodingInt, &hEngine->cbService, &hEngine->cbCoding) ; 
        BDCC_Coding_P_Process(hEngine->hCodingInt, &hEngine->cbCoding) ;

        /*
         * Now check for buffer overflow.
         * This should never happen -- if it does
         * either it will happen very often because
         * the buffer sizes are not provisioned correctly
         * or we have an errant stream.  In the first case
         * the BDCC_ENG_P_CBUF_SIZE and BDCC_ENG_P_CBUF_RESERVE need to be
         * corrected.  In the second case, it is appropriate to
         * reset.  The caller of this function is expected to
         * call again to DccEngine_Reset if this function returns
         * BDCC_Error_eBufferOverflow.
         */
        err = CheckForBufferOverflow(hEngine) ;
        return(err) ;

} /* BDCC_ENG_Process608 */


BDCC_Error WriteTripletsToCBuf(BDCC_CBUF * pCBuf, unsigned char ** ppTriplets, unsigned int * pNumTriplets)
{
        int TripletsThisTime = min(*pNumTriplets,pCBuf->FreeBytes/3) ;
        int TripletsLeftover = *pNumTriplets - TripletsThisTime ;

        BDCC_CBUF_WritePtr(pCBuf, *ppTriplets, TripletsThisTime * 3) ;
        *ppTriplets += TripletsThisTime * 3 ;
        *pNumTriplets -= TripletsThisTime ;

        BDCC_DBG_MSG(("WrTToCBuf:  Trip %d  LO %d\n", TripletsThisTime, TripletsLeftover)) ;

        if ( TripletsLeftover )
                return(BDCC_Error_eWrnPause) ;
        else
                return(BDCC_Error_eSuccess) ;
}


/**************************************************************************                
 *  
 * Function:            BDCC_ENG_Process708   
 *     
 * Inputs:                        
 *                                      hEngine                         - init'ed previously by DccEngine_Init  
 *                                      pTriplets                       - ptr to buf of triplets (cc_type,cc1,cc2)
 *                                      NumTriplets                     - count = num_bytes / 3
 *    
 * Outputs:                           
 *  
 * Returns:                     BDCC_Error_eSuccess or standard BDCC_Error error code     
 *    
 * Description:                
 *         
 * This function does the packet/service/coding/interpretation layers
 * of the 708 DTVCC spec.  It filters on the Service Number provided in the
 * previous _Init or _Reset call, as the iCcService argument.
 * 
 * If this function returns BDCC_Error_eBufferOverflow, it is expected that the
 * caller will call again to DccEngine_Reset.
 *
 **************************************************************************/  
#define MAX_ITER_CODING                         20
BDCC_Error BDCC_ENG_Process708(
                BDCC_ENG_Handle hEngine,
                unsigned char * pTriplets,
                int NumTriplets)
{
        BDCC_Error err ;
        BDCC_Error rcA, rcB, rcC, rcD ;
        int InnerTimes = 0 ;
        bool newActivity;

        BDCC_DBG_MSG(("%s: NumTriplets = %d", __FUNCTION__,NumTriplets));

        /*
         * first do some validation
         */
        if ( NULL == hEngine   ||   pTriplets == NULL )
        {
                return(BDCC_Error_eNullPointer) ;
        }

        if ( NumTriplets < 0 )
        {
                return(BDCC_Error_eArgOutOfRange) ;
        }
        else {
                /* handle DELAY command case */
                if (0 == NumTriplets) {
                        BDCC_Update_Delay(hEngine->hCodingInt, &hEngine->cbCoding);
                }
        }

        if ( hEngine->Type != BDCC_ENG_Type_e708 )
        {
                return(BDCC_Error_eBadOutputType) ;
        }

        /*
         * do one pass 
         *
         * The idea here is to push the input triplets all the way
         * through the processing pipe.
         *
         * The obvious approach is to call each of the processing handlers
         * once in succession, each completely consuming its input before
         * returning.  This works fine in most of the cases, but fails for
         * 'bursty' streams.
         *
         * The approach used here degenerates down to the simple approach for
         * the normal streams (so there's really no processing overhead for
         * most cases), but allows a processing handler to declare that its not
         * done with its input and should be called back after its downstream
         * handlers have gotten a chance to consume their inputs.
         *
         * The basic pattern used here is ...
         *     do
         *     {
         *         rcA = DccAAA_Process() ;
         *         ... other code ...
         *     } while ( rcA == BDCC_Error_eWrnPause ) ;
         *
         * Stamping this pattern several times, once for each processing
         * level, yields...
         *     do
         *     {
         *         rcA = DccAAA_Process() ;
         *         do
         *         {
         *             rcB = DccBBB_Process() ;
         *             do
         *             {
         *                 rcC = DccCCC_Process() ;
         *             } while ( rcC == BDCC_Error_eWrnPause ) ;
         *         } while ( rcB == BDCC_Error_eWrnPause ) ;
         *     } while ( rcA == BDCC_Error_eWrnPause ) ;
         *
         * The code below is essentially this algorithm, with an additional
         * sanity check that we don't get stuck forever.
         */
        do
        {
                rcA = WriteTripletsToCBuf(&hEngine->cbTriplets, &pTriplets, (unsigned int *)&NumTriplets) ;
                BDCC_DBG_MSG(("%s: NumTriplets = %d", __FUNCTION__,NumTriplets));
                do
                {
                        rcB = BDCC_PKT_P_Process(&hEngine->PacketObject, &hEngine->cbTriplets, &hEngine->cbPacket) ;
                        BDCC_DBG_MSG(("%s: hEngine->cbPacket.NumBytes = %d", __FUNCTION__,hEngine->cbPacket.NumBytes));
                        if ( rcB == BDCC_Error_eSequence )
                        {
                                BDCC_DBG_MSG(("%s: Error Sequence Resetting Down Stream", __FUNCTION__));
                                ResetDownstreamOfPacket(hEngine) ;
                                /* track Pkt sequence number errors */
                                hEngine->iPktSequenceNumErr++;
                        }

                        do
                        {
                                rcC = BDCC_SRV_P_Process(&hEngine->cbPacket, hEngine->iCcService, BDCC_SRV_SERVICE_ILLEGAL, &hEngine->cbService, NULL, &newActivity) ;
                                BDCC_DBG_MSG(("%s: hEngine->cbService.NumBytes = %d, hEngine->iCcService = %d", __FUNCTION__,hEngine->cbService.NumBytes,hEngine->iCcService));
                                /*
                                 ** Keep track of when caption data for the selected caption channel was last received.
                                 ** If a "timeout" (i.e. captions have been left dangling), we'll need to clear the screen.
                                 */
                                if(newActivity)
                                {
                                        hEngine->uiLastDataMilliSecs = hEngine->uiCurTimeMilliSecs;
                                        hEngine->bDataReceived = true;
                                }

                                do
                                {
                                        rcD = BDCC_SIBuf_P_Process(hEngine->hCodingInt, &hEngine->cbService, &hEngine->cbCoding) ; 
#if 1
                                        BDCC_Coding_P_Process(hEngine->hCodingInt, &hEngine->cbCoding) ;
#else
                                        /* consume without really doing anything, useful for debug */
                                        hEngine->hCodingInt.SIBuf_NumCmdsWritten = 0 ;
                                        hEngine->hCodingInt.SIBuf_StreamBytesWritten = 0 ;
                                        BDCC_CBUF_Clear(&hEngine->cbCoding) ;
#endif
                                        if ( (++InnerTimes) > MAX_ITER_CODING )
                                        {
                                                BDCC_DBG_WRN(("DccEngine_Process708:  max'ed out on iterations: %d\n", InnerTimes)) ;
                                                /*
                                                 * I know, GOTOs are bad, but this seems
                                                 * cleaner than adding extra conditions in
                                                 * each of the while clauses below to do a
                                                 * multi-level break.
                                                 */
                                                goto StopProcessing708 ;
                                        }
                                } while ( rcD == BDCC_Error_eWrnPause ) ;
                        } while ( rcC == BDCC_Error_eWrnPause ) ;
                } while ( rcB == BDCC_Error_eWrnPause ) ;
        } while ( rcA == BDCC_Error_eWrnPause ) ;
StopProcessing708 :     

        /*
         * Now check for buffer overflow.
         * This should never happen -- if it does
         * either it will happen very often because
         * the buffer sizes are not provisioned correctly
         * or we have an errant stream.  In the first case
         * the BDCC_ENG_P_CBUF_SIZE and BDCC_ENG_P_CBUF_RESERVE need to be
         * corrected.  In the second case, it is appropriate to
         * reset.  The caller of this function is expected to
         * call again to DccEngine_Reset if this function returns
         * BDCC_Error_eBufferOverflow.
         */
        err = CheckForBufferOverflow(hEngine) ;
        return(err) ;

} /* DccEngine_Process708 */


/**************************************************************************                
 *  
 * Function:            BDCC_ENG_Override   
 *     
 * Inputs:                        
 *                                      hEngine                         - init'ed previously by DccEngine_Init  
 *                                      OverrideMask            - bitmask of overridden attributes
 *                                      pOverrides                      - structure of overrides
 *    
 * Outputs:                           
 *  
 * Returns:                     BDCC_Error_eSuccess or standard BDCC_Error error code     
 *    
 * Description:                
 *         
 * This function allows the caller to override some of the 708 DTVCC
 * interpretation attributes, such as pen size, font style and colors.
 *
 * The OverrideMask argument is a bitmask that identifies which of 
 * structure members of *pOverrides are valid and hence overridden.  The
 * mask is absolute, not relative, meaning that overrides from a previous
 * call will be 'forgotten' if not also included in the present call.  To
 * undo all overrides and revert to the stream-supplied attributes, set
 * the OverrideMask arg to 0.
 *
 * The supported overrides are (as defined in bcmDccCoding.h):
 *
 *    UPM_PENSIZE
 *    UPM_FONTSTYLE
 *    UPM_PENFG
 *    UPM_PENBG
 *    UPM_EDGECOLOR
 *    UPM_EDGETYPE
 *
 **************************************************************************/  
BDCC_Error BDCC_ENG_Override(
                BDCC_ENG_Handle hEngine,
                unsigned int OverrideMask, 
                BDCC_ENG_OverRides * pOverrides)
{
        BDCC_Error err ;

        if ( hEngine == NULL   ||   pOverrides == NULL )
        {
                return(BDCC_Error_eNullPointer) ;
        }

        err = BDCC_Coding_P_Override(hEngine->hCodingInt, OverrideMask, pOverrides) ;

        return(err) ;

} /* BDCC_ENG_Override */


/**************************************************************************                
 *  
 * Function:            BDCC_ENG_Periodic   
 *     
 * Inputs:                        
 *                                      hEngine         - init'ed previously by DccEngine_Init  
 *                                      usPeriod                - average us from previous call
 *    
 * Outputs:                           
 *  
 * Returns:                     BDCC_Error_eSuccess or standard BDCC_Error error code     
 *    
 * Description:                
 *    
 * This function provides the Engine API a mechanism to do sequenced
 * effects.  This is used for flashing and smooth scrolling.  The usPeriod
 * arg is set to an average value.  For example, if this is driven from a
 * field interrupt, it can be set to 16683 for a 59.94 Hz field rate.
 *
 **************************************************************************/  
BDCC_Error BDCC_ENG_Periodic( BDCC_ENG_Handle hEngine )
{
        /*
         ** Call down to the interpretation layer to sample/update the time.
         */
        BCCGFX_P_TimeUpdate( hEngine->hCCGfxHandle, &(hEngine->uiCurTimeMilliSecs) );

        /*
         ** call to the ccgfx library for scrolling and flashing by 2 surfaces
         */
        BCCGFX_P_Periodic(hEngine->hCCGfxHandle) ;

        /*
         ** call to the interpreter for flashing by re-rendering
         */
#if FLASH_BY_RERENDER
        BCCGFX_INT_P_Periodic(hEngine->hCodingInt) ;
#endif

        return(BDCC_Error_eSuccess) ;

} /* BDCC_ENG_Periodic */




/*********************
 *
 * Support Routines
 *
 *********************/

/**************************************************************************                
 *  
 * Function:            CheckForBufferOverflow   
 *     
 * Inputs:                        
 *                                      hEngine                         - init'ed previously by DccEngine_Init  
 *    
 * Outputs:                           
 *  
 * Returns:                     BDCC_Error_eSuccess or BDCC_Error_eBufferOverflow     
 *    
 * Description:                
 *    
 * This function checks the ErrorCount of each of the circular buffers.
 *
 **************************************************************************/  
BDCC_Error CheckForBufferOverflow(BDCC_ENG_Handle hEngine)
{
        BDCC_DBG_MSG(("cbBufs (%4d,%4d,%4d,%4d))\n",
                                hEngine->cbTriplets.NumBytes,
                                hEngine->cbPacket.NumBytes,
                                hEngine->cbService.NumBytes,
                                hEngine->cbCoding.NumBytes)) ;

        if ( hEngine->cbTriplets.ErrorCount )
        {
                BDCC_DBG_ERR(("ENGINE: cbTriplets overflow\n")) ;
                return(BDCC_Error_eBufferOverflow) ;
        }

        if ( hEngine->cbPacket.ErrorCount )
        {
                BDCC_DBG_ERR(("ENGINE: cbPacket overflow\n")) ;
                return(BDCC_Error_eBufferOverflow) ;
        }

        if ( hEngine->cbService.ErrorCount )
        {
                BDCC_DBG_ERR(("ENGINE: cbService overflow\n")) ;
                return(BDCC_Error_eBufferOverflow) ;
        }

        if ( hEngine->cbCoding.ErrorCount )
        {
                BDCC_DBG_ERR(("ENGINE: cbCoding overflow\n")) ;
                return(BDCC_Error_eBufferOverflow) ;
        }

        return(BDCC_Error_eSuccess) ;

} /* CheckForBufferOverflow */


void ResetDownstreamOfPacket(BDCC_ENG_Handle hEngine)
{
        unsigned int OverrideMask ;
        BDCC_ENG_OverRides Overrides ;

        BDCC_DBG_WRN(("ResetDownstreamOfPacket:  resetting\n")) ;

        /* first save the overrides */
        OverrideMask = hEngine->hCodingInt->OverrideMask ;
        Overrides = hEngine->hCodingInt->Overrides ;

        /*
         * relevant parts of BDCC_ENG_Close
         */
        BDCC_CBUF_Init(&hEngine->cbService, hEngine->BufService, sizeof(hEngine->BufService), BDCC_ENG_P_CBUF_RESERVE) ;
        BDCC_CBUF_Init(&hEngine->cbCoding, hEngine->BufCoding, sizeof(hEngine->BufCoding), BDCC_ENG_P_CBUF_RESERVE) ;
        BDCC_Coding_P_Reset(hEngine->hCodingInt) ;
        BCCGFX_P_Reset( hEngine->hCCGfxHandle, &hEngine->engineSettings );

        /* re-apply the overrides */
        BDCC_ENG_Override(hEngine, OverrideMask, &Overrides) ;

        BDCC_DBG_WRN(("ResetDownstreamOfPacket:  resetting - DONE\n")) ;
} /* ResetDownstreamOfPacket */

BDCC_Error BDCC_ENG_LoadFont( 
                BDCC_ENG_Handle hEngine, 
                BDCC_FONT_DESCRIPTOR * pFontDesc,     
                int iNumToMeasure, 
                char * pszCharsToMeasure 
                )
{
        BDCC_Error iError;

        iError = BCCGFX_P_LoadFont( hEngine->hCCGfxHandle, pFontDesc, iNumToMeasure, pszCharsToMeasure );

        return iError;
}

BDCC_Error BDCC_ENG_UnloadFont( BDCC_ENG_Handle hEngine,  BDCC_FONT_DESCRIPTOR * pFontDesc )
{
        BDCC_Error iError;

        iError = BCCGFX_P_UnloadFont( hEngine->hCCGfxHandle, pFontDesc );

        return iError;
}

BDCC_Error BDCC_ENG_AssignFont( BDCC_ENG_Handle hEngine,  BDCC_FONT_DESCRIPTOR * pFontDesc,  BDCC_PenStyle penStyle, BDCC_FontStyle fontStyle )
{
        BDCC_Error iError;

        iError = BCCGFX_P_AssignFont( hEngine->hCCGfxHandle, pFontDesc,  penStyle, fontStyle );

        return iError;
}

uint32_t BDCC_ENG_GetPktSeqNumErrorCount(BDCC_ENG_Handle hEngine)
{
        if (hEngine)
                return hEngine->iPktSequenceNumErr;
        else
                return 0;
}

void BDCC_ENG_ResetPktSeqNumErrorCount(BDCC_ENG_Handle hEngine)
{
        if (hEngine) {
                hEngine->iPktSequenceNumErr = 0;
        }
}