/******************************************************************************
 *    (c)2008 Broadcom Corporation
 * 
 * This program is the proprietary software of Broadcom Corporation and/or its licensors,
 * and may only be used, duplicated, modified or distributed pursuant to the terms and
 * conditions of a separate, written license agreement executed between you and Broadcom
 * (an "Authorized License").  Except as set forth in an Authorized License, Broadcom grants
 * no license (express or implied), right to use, or waiver of any kind with respect to the
 * Software, and Broadcom expressly reserves all rights in and to the Software and all
 * intellectual property rights therein.  IF YOU HAVE NO AUTHORIZED LICENSE, THEN YOU
 * HAVE NO RIGHT TO USE THIS SOFTWARE IN ANY WAY, AND SHOULD IMMEDIATELY
 * NOTIFY BROADCOM AND DISCONTINUE ALL USE OF THE SOFTWARE.  
 *  
 * Except as expressly set forth in the Authorized License,
 *  
 * 1.     This program, including its structure, sequence and organization, constitutes the valuable trade
 * secrets of Broadcom, and you shall use all reasonable efforts to protect the confidentiality thereof,
 * and to use this information only in connection with your use of Broadcom integrated circuit products.
 *  
 * 2.     TO THE MAXIMUM EXTENT PERMITTED BY LAW, THE SOFTWARE IS PROVIDED "AS IS" 
 * AND WITH ALL FAULTS AND BROADCOM MAKES NO PROMISES, REPRESENTATIONS OR 
 * WARRANTIES, EITHER EXPRESS, IMPLIED, STATUTORY, OR OTHERWISE, WITH RESPECT TO 
 * THE SOFTWARE.  BROADCOM SPECIFICALLY DISCLAIMS ANY AND ALL IMPLIED WARRANTIES 
 * OF TITLE, MERCHANTABILITY, NONINFRINGEMENT, FITNESS FOR A PARTICULAR PURPOSE, 
 * LACK OF VIRUSES, ACCURACY OR COMPLETENESS, QUIET ENJOYMENT, QUIET POSSESSION 
 * OR CORRESPONDENCE TO DESCRIPTION. YOU ASSUME THE ENTIRE RISK ARISING OUT OF 
 * USE OR PERFORMANCE OF THE SOFTWARE.
 * 
 * 3.     TO THE MAXIMUM EXTENT PERMITTED BY LAW, IN NO EVENT SHALL BROADCOM OR ITS 
 * LICENSORS BE LIABLE FOR (i) CONSEQUENTIAL, INCIDENTAL, SPECIAL, INDIRECT, OR 
 * EXEMPLARY DAMAGES WHATSOEVER ARISING OUT OF OR IN ANY WAY RELATING TO YOUR 
 * USE OF OR INABILITY TO USE THE SOFTWARE EVEN IF BROADCOM HAS BEEN ADVISED OF 
 * THE POSSIBILITY OF SUCH DAMAGES; OR (ii) ANY AMOUNT IN EXCESS OF THE AMOUNT 
 * ACTUALLY PAID FOR THE SOFTWARE ITSELF OR U.S. $1, WHICHEVER IS GREATER. THESE 
 * LIMITATIONS SHALL APPLY NOTWITHSTANDING ANY FAILURE OF ESSENTIAL PURPOSE OF 
 * ANY LIMITED REMEDY.
 *
 * $brcm_Workfile: boot.c $
 * $brcm_Revision: 2 $
 * $brcm_Date: 7/18/08 11:31a $
 * 
 * Module Description:
 * 
 * Revision History:
 * 
 * $brcm_Log: /nexus/examples/boot.c $
 * 
 * 2   7/18/08 11:31a jgarrett
 * PR 44953: Removing -Wstrict-prototypes warnings
 * 
 *****************************************************************************/
#include "ministd.h"
#include "nexus_types.h"
#include "nexus_platform.h"
#include "nexus_pid_channel.h"
#include "nexus_parser_band.h"
#include "nexus_video_decoder.h"
#include "nexus_stc_channel.h"
#include "nexus_display.h"
#include "nexus_video_window.h"
#include "nexus_video_input.h"
#include "nexus_audio_dac.h"
#include "nexus_audio_decoder.h"
#include "nexus_audio_output.h"
#include "nexus_audio_input.h"
#include "nexus_spdif_output.h"
#include "nexus_composite_output.h"
#include "nexus_component_output.h"
#include "nexus_hdmi_output_hdcp.h"

#include "nexus_security.h"
#include "nexus_msg.h"

BDBG_MODULE(boot_nexus);		/* Register software module with debug interface */

//RLQ
#ifdef DESCRABLER_TEST
void Descrmbler_Dvbcsa_SwKey(NEXUS_VideoDecoderStartSettings *pVideoProgram, NEXUS_AudioDecoderStartSettings *pAudioProgram );
#endif

#if 0
int main(void)
{
    NEXUS_Error errCode;

    while (1) {
        printf( "Ready to initialize\n");
    
        errCode = NEXUS_Platform_Init(NULL);
    
        if ( errCode )
        {
            printf( "Unable to initialize nexus, err %d\n", errCode);
            return -1;
        }
    
        printf( "Initialization complete, press enter to uninit\n");
        getchar();
    
        NEXUS_Platform_Uninit();
        
        printf( "Uninit complete, press enter to init again\n");
        getchar();
    }

    return 0;
}
#else
static void bapp_hdcp_callback(void *pParam, int iParam)
{
	NEXUS_HdmiOutputHandle hdmi = pParam;
	NEXUS_DisplayHandle display = (NEXUS_DisplayHandle)iParam;
    NEXUS_HdmiOutputHdcpStatus hdcpStatus;
    NEXUS_DisplaySettings displaySettings;
    NEXUS_HdmiOutputSettings hdmiOutputSettings;

    BDBG_ASSERT(pParam);
    BDBG_ASSERT(iParam);

    BDBG_MSG(("HDCP status change"));


    NEXUS_HdmiOutput_GetHdcpStatus(hdmi, &hdcpStatus);

    switch ( hdcpStatus.hdcpState )
    {
    case NEXUS_HdmiOutputHdcpState_eUnauthenticated:
        /* Display bluescreen and mute audio unless user disable this feature */
        if (1 /*!hdmi->desired.hdcp_disable_blue_screen */)
        {
            NEXUS_Display_GetSettings(display, &displaySettings);
            displaySettings.background = 0xff0000ff; /* blue */
            NEXUS_Display_SetSettings(display, &displaySettings);

            NEXUS_HdmiOutput_GetSettings(hdmi, &hdmiOutputSettings);
            hdmiOutputSettings.syncOnly = true;
            NEXUS_HdmiOutput_SetSettings(hdmi, &hdmiOutputSettings);

            //boutput_hdmi_audio_mute(hdmi, true);
        }
        break;

    case NEXUS_HdmiOutputHdcpState_eR0LinkFailure:
    case NEXUS_HdmiOutputHdcpState_ePjLinkIntegrityFailure:
    case NEXUS_HdmiOutputHdcpState_eRiLinkIntegrityFailure:
    case NEXUS_HdmiOutputHdcpState_eRepeaterAuthenticationFailure:

        /* Display bluescreen and mute audio unless user disable this feature */
        if (1 /*!hdmi->desired.hdcp_disable_blue_screen*/)
        {
            NEXUS_Display_GetSettings(display, &displaySettings);
            displaySettings.background = 0xff0000ff; /* blue */
            NEXUS_Display_SetSettings(display, &displaySettings);

            NEXUS_HdmiOutput_GetSettings(hdmi, &hdmiOutputSettings);
            hdmiOutputSettings.syncOnly = true;
            NEXUS_HdmiOutput_SetSettings(hdmi, &hdmiOutputSettings);

 //           boutput_hdmi_audio_mute(hdmi, true);
        }
#if 0
        /* Retry auth if requested */
        if ( hdmi->desired.hdcp_failure_retry_delay > 0 )
        {
            if ( NULL != hdmi->hdcpTimer )
            {
                b_timer_cancel(hdmi->hdcpTimer);
            }
            b_timer_schedule(hdmi->desired.hdcp_failure_retry_delay, bdisplay_p_hdcp_retry, hdmi);
        }
#endif
        break;

    case NEXUS_HdmiOutputHdcpState_eLinkAuthenticated:
    case NEXUS_HdmiOutputHdcpState_eEncryptionEnabled:
        /* clear bluescreen */
        if (1 /*!hdmi->desired.hdcp_disable_blue_screen*/)
        {
            NEXUS_Display_GetSettings(display, &displaySettings);
            displaySettings.background = 0xff000000; /* clear blue screen*/
            NEXUS_Display_SetSettings(display, &displaySettings);

            NEXUS_HdmiOutput_GetSettings(hdmi, &hdmiOutputSettings);
            hdmiOutputSettings.syncOnly = false;
            NEXUS_HdmiOutput_SetSettings(hdmi, &hdmiOutputSettings);

//            boutput_hdmi_audio_mute(hdmi, false);
        }
        break;

    default:
        break;
    }

}

void bapp_hdmi_hotplug_callback(void *pParam, int iParam)
{
	NEXUS_HdmiOutputStatus status;
	NEXUS_HdmiOutputHandle hdmi = pParam;
	NEXUS_DisplayHandle display = (NEXUS_DisplayHandle)iParam;

	NEXUS_HdmiOutput_GetStatus(hdmi, &status);
	printf("HDMI hotplug event: %s\n", status.connected?"connected":"not connected");

	/* the app can choose to switch to the preferred format, but it's not required. */
	if ( status.connected )
	{
		NEXUS_DisplaySettings displaySettings;
		NEXUS_Display_GetSettings(display, &displaySettings);
		if ( !status.videoFormatSupported[displaySettings.format] )
		{
			printf("\nCurrent format not supported by attached monitor. Switching to preferred format %d\n", status.preferredVideoFormat);
			displaySettings.format = status.preferredVideoFormat;
			NEXUS_Display_SetSettings(display, &displaySettings);
		}
		NEXUS_HdmiOutput_StartHdcpAuthentication(hdmi);
	}
} 


static void lock_callback(void *context, int param)
{
    NEXUS_FrontendHandle frontend = (NEXUS_FrontendHandle)context;
    NEXUS_FrontendQamStatus qamStatus;

    BSTD_UNUSED(param);

    printf("Lock callback, frontend 0x%08x\n", (unsigned)frontend);

    NEXUS_Frontend_GetQamStatus(frontend, &qamStatus);
    printf("QAM Lock callback, frontend 0x%08x - lock status %d, %d\n", (unsigned)frontend,
            qamStatus.fecLock, qamStatus.receiverLock);
}

static unsigned char ibuffer[0x100];

unsigned input_number(void)
{
    unsigned number;
    gets(ibuffer);
    if('0' ==ibuffer[0]){
        switch(ibuffer[1]){
        case 'x':
            sscanf(&ibuffer[2], "%x", &number);
            break;
        case 'X':
            sscanf(&ibuffer[2], "%x", &number);
            break;
        default:
            sscanf(ibuffer, "%d", &number);
            break;
        }
    }else{
        sscanf(ibuffer, "%d", &number);
    }
    printf(" %d %x", number, number);
    return number;
}

int console_main(void *data)
{
    NEXUS_PlatformSettings platformSettings;
    NEXUS_PlatformConfiguration platformConfig;
    NEXUS_ParserBand parserBand;
    NEXUS_ParserBandSettings parserBandSettings;
    NEXUS_StcChannelHandle stcChannel;
    NEXUS_StcChannelSettings stcSettings;
    NEXUS_PidChannelHandle videoPidChannel, audioPidChannel;
    NEXUS_DisplayHandle display;
    NEXUS_DisplaySettings displaySettings;
    NEXUS_VideoWindowHandle window;
    NEXUS_VideoDecoderHandle vdecode;
	NEXUS_AudioDecoderHandle pcmDecoder, compressedDecoder;
    NEXUS_VideoDecoderStartSettings videoProgram;
    NEXUS_AudioDecoderStartSettings audioProgram;
    NEXUS_HdmiOutputSettings hdmiSettings;
    NEXUS_FrontendUserParameters userParams;
    NEXUS_FrontendHandle frontend=NULL;
    NEXUS_FrontendQamSettings qamSettings;
	NEXUS_VideoWindowSettings windowSettings;
	NEXUS_CalculateVideoWindowPositionSettings calcSettings;
	NEXUS_HdmiOutputHdcpSettings hdcpSettings;
	NEXUS_VideoWindowSettings vwSettings;
	NEXUS_VideoDecoderSettings vdSettings;
	NEXUS_Error rc;

//    unsigned freq = 765; /* 777 qam256*/
    unsigned freq = 567; /* 777 qam256*/
    NEXUS_FrontendQamMode qamMode = NEXUS_FrontendQamMode_e256;
    //NEXUS_FrontendQamMode qamMode = NEXUS_FrontendQamMode_e64;
	int i;

    /* Bring up all modules for a platform in a default configuration for this platform */
    NEXUS_Platform_GetDefaultSettings(&platformSettings);
    platformSettings.openFrontend = true;
    NEXUS_Platform_Init(&platformSettings);

	//btnr_7550_utils,bads_7550_acquire
 #if 0
	BDBG_SetModuleLevel("bads_7550",BDBG_eTrace);
	BDBG_SetModuleLevel("btnr_7550_status",BDBG_eTrace);
	BDBG_SetModuleLevel("bads_75xx_priv",BDBG_eTrace);
	BDBG_SetModuleLevel("btnr_7550_utils",BDBG_eTrace);
	BDBG_SetModuleLevel("bads_7550_acquire",BDBG_eTrace);
	BDBG_SetModuleLevel("bads_7550_utils",BDBG_eTrace);
 #endif
#ifdef DESCRABLER_TEST
	BDBG_SetModuleLevel("BHSM",BDBG_eTrace);
	BDBG_SetModuleLevel("BHDM",BDBG_eTrace);
	BDBG_SetModuleLevel("BHDM_HDCP",BDBG_eTrace);
#endif

	NEXUS_Platform_GetConfiguration(&platformConfig);

    for ( i = 0; i < NEXUS_MAX_FRONTENDS; i++ )
    {
        NEXUS_FrontendCapabilities capabilities;
        frontend = platformConfig.frontend[i];
        if (frontend) {
            NEXUS_Frontend_GetCapabilities(frontend, &capabilities);
            /* Does this frontend support qam? */
            if ( capabilities.qam )
            {
                break;
            }
        }
    }

    if (NULL == frontend )
    {
        printf("Unable to find QAM-capable frontend\n");
        return 0;
    }

//RLQ, for TUNE only test, comment it if want to tune and start AV decoder
//#define	TUNE_ONLY

#ifdef	TUNE_ONLY
	while(1)
	{
		printf("Input frequency (MHz, e.g. 549 for 549MHz): ");
		freq = input_number();
		printf("\n");
		if (freq < 40 || freq > 999) {
			printf("Freq out of range, retry\n");
			continue;
		}
#endif
		NEXUS_Frontend_GetDefaultQamSettings(&qamSettings);
		qamSettings.frequency = freq * 1000000;
		qamSettings.mode = qamMode;
		qamSettings.symbolRate = 5056900;
		qamSettings.annex = NEXUS_FrontendQamAnnex_eB;
		qamSettings.bandwidth = NEXUS_FrontendQamBandwidth_e6Mhz;
		qamSettings.lockCallback.callback = lock_callback;
		qamSettings.lockCallback.context = frontend;
		NEXUS_Frontend_GetUserParameters(frontend, &userParams);

		parserBand = NEXUS_ParserBand_e0;
		NEXUS_ParserBand_GetSettings(parserBand, &parserBandSettings);
		parserBandSettings.sourceType = NEXUS_ParserBandSourceType_eInputBand;
		parserBandSettings.sourceTypeSettings.inputBand = userParams.param1;
		parserBandSettings.transportType = NEXUS_TransportType_eTs;
		NEXUS_ParserBand_SetSettings(parserBand, &parserBandSettings);

		// bos_sleep(5000);
		printf("Tune freq=%d\n",qamSettings.frequency);
		NEXUS_Frontend_TuneQam(frontend, &qamSettings);
		// bos_sleep(500);
#ifdef	TUNE_ONLY
		while (1)
		{
			NEXUS_FrontendQamStatus qamStatus;
			bos_sleep(1000);
			if (NEXUS_Frontend_GetQamStatus(frontend,&qamStatus) == NEXUS_SUCCESS)
			{
				printf("receiverLock = %d, fecLock = %d\n",qamStatus.receiverLock,qamStatus.fecLock);
			}
			printf("Input 9 to try new frequency ");
			freq = input_number();
			printf("\n");
			if (freq == 9)
				break;
		}
	}
#endif
	{
		NEXUS_FrontendQamStatus qamStatus;
		bos_sleep(1000);
		if (NEXUS_Frontend_GetQamStatus(frontend,&qamStatus) == NEXUS_SUCCESS)
		{
			printf("receiverLock = %d, fecLock = %d\n",qamStatus.receiverLock,qamStatus.fecLock);
		}
	}
	/* Open the audio and video pid channels */
	videoPidChannel = NEXUS_PidChannel_Open(parserBand, 49, NULL);
	audioPidChannel = NEXUS_PidChannel_Open(parserBand, 52, NULL);

	//nexus_msg_start(0);
	//nexus_msg_start(1);
	
	/* Open the StcChannel to do lipsync with the PCR */
	NEXUS_StcChannel_GetDefaultSettings(0, &stcSettings);
	stcSettings.timebase = NEXUS_Timebase_e0;
	stcSettings.mode = NEXUS_StcChannelMode_ePcr; /* live */
	stcSettings.modeSettings.pcr.pidChannel = videoPidChannel; /* PCR happens to be on video pid */
	stcChannel = NEXUS_StcChannel_Open(0, &stcSettings);

	/* Set up decoder Start structures now. We need to know the audio codec to properly set up
	   the audio outputs. */
	NEXUS_VideoDecoder_GetDefaultStartSettings(&videoProgram);
	videoProgram.codec = NEXUS_VideoCodec_eMpeg2;
	videoProgram.pidChannel = videoPidChannel;
	videoProgram.stcChannel = stcChannel;
	NEXUS_AudioDecoder_GetDefaultStartSettings(&audioProgram);
	audioProgram.codec = NEXUS_AudioCodec_eAc3;
	audioProgram.pidChannel = audioPidChannel;
	audioProgram.stcChannel = stcChannel;

	/* Bring up audio decoders and outputs */
	pcmDecoder = NEXUS_AudioDecoder_Open(0, NULL);
	compressedDecoder = NEXUS_AudioDecoder_Open(1, NULL);
	NEXUS_AudioOutput_AddInput(
			NEXUS_AudioDac_GetConnector(platformConfig.outputs.audioDacs[0]),
			NEXUS_AudioDecoder_GetConnector(pcmDecoder, NEXUS_AudioDecoderConnectorType_eStereo));
	if ( audioProgram.codec == NEXUS_AudioCodec_eAc3 )
	{
		/* Only pass through AC3 */
		NEXUS_AudioOutput_AddInput(
				NEXUS_SpdifOutput_GetConnector(platformConfig.outputs.spdif[0]),
				NEXUS_AudioDecoder_GetConnector(compressedDecoder, NEXUS_AudioDecoderConnectorType_eCompressed));
	}
	else
	{
		NEXUS_AudioOutput_AddInput(
				NEXUS_SpdifOutput_GetConnector(platformConfig.outputs.spdif[0]),
				NEXUS_AudioDecoder_GetConnector(pcmDecoder, NEXUS_AudioDecoderConnectorType_eStereo));
	}
	NEXUS_AudioOutput_AddInput(NEXUS_HdmiOutput_GetAudioConnector(platformConfig.outputs.hdmi[0]), 
			NEXUS_AudioDecoder_GetConnector(pcmDecoder, NEXUS_AudioDecoderConnectorType_eStereo));

	/* Bring up display and outputs */
	NEXUS_Display_GetDefaultSettings(&displaySettings);
	displaySettings.format = NEXUS_VideoFormat_e720p;
    displaySettings.displayType = NEXUS_DisplayType_eAuto;
	//displaySettings.background = 0xffff0000;
	display = NEXUS_Display_Open(0, &displaySettings);
	BDBG_ASSERT(display);
	NEXUS_Display_AddOutput(display, NEXUS_HdmiOutput_GetVideoConnector(platformConfig.outputs.hdmi[0]));
#if 0
	NEXUS_Display_AddOutput(display, NEXUS_CompositeOutput_GetConnector(platformConfig.outputs.composite[0]));
#endif

	window = NEXUS_VideoWindow_Open(display, 0);

	/* Install hotplug callback -- video only for now */
	NEXUS_HdmiOutput_GetSettings(platformConfig.outputs.hdmi[0], &hdmiSettings);
	hdmiSettings.hotplugCallback.callback = bapp_hdmi_hotplug_callback;
	hdmiSettings.hotplugCallback.context = platformConfig.outputs.hdmi[0];
	hdmiSettings.hotplugCallback.param = (int)display;
	NEXUS_HdmiOutput_SetSettings(platformConfig.outputs.hdmi[0], &hdmiSettings);
#if 0
	/* Initialize/install HDCP callback to notify app */
	NEXUS_HdmiOutput_GetHdcpSettings(platformConfig.outputs.hdmi[0], &hdcpSettings);
	hdcpSettings.stateChangedCallback.callback = bapp_hdcp_callback;
	hdcpSettings.stateChangedCallback.context = platformConfig.outputs.hdmi[0];
	hdcpSettings.stateChangedCallback.param = (int)display;
	hdcpSettings.failureCallback.callback = bapp_hdcp_callback;
	hdcpSettings.failureCallback.context = platformConfig.outputs.hdmi[0];
	hdcpSettings.failureCallback.param = (int)display;
	/* TO DO: Add successCallback */
	rc = NEXUS_HdmiOutput_SetHdcpSettings(platformConfig.outputs.hdmi[0], &hdcpSettings);
	if (rc != NEXUS_SUCCESS)
		BDBG_ERR(("Error initializing hdmi_output_hdcp settings"));
#endif
	NEXUS_HdmiOutput_StartHdcpAuthentication(platformConfig.outputs.hdmi[0]);

	/* bring up decoder and connect to display */
	vdecode = NEXUS_VideoDecoder_Open(0, NULL); /* take default capabilities */
	NEXUS_VideoDecoder_GetSettings(vdecode,&vdSettings);
	vdSettings.channelChangeMode = NEXUS_VideoDecoder_ChannelChangeMode_eHoldUntilFirstPicture;
	NEXUS_VideoDecoder_SetSettings(vdecode,&vdSettings);
	NEXUS_VideoWindow_AddInput(window, NEXUS_VideoDecoder_GetConnector(vdecode));

	NEXUS_VideoWindow_GetSettings(window,&vwSettings );
	vwSettings.visible = true;
	NEXUS_VideoWindow_SetSettings(window,&vwSettings );

	/* Start Decoders */
	NEXUS_VideoDecoder_Start(vdecode, &videoProgram);
	NEXUS_AudioDecoder_Start(pcmDecoder, &audioProgram);
	if ( audioProgram.codec == NEXUS_AudioCodec_eAc3 )
	{
		/* Only pass through AC3 */
		NEXUS_AudioDecoder_Start(compressedDecoder, &audioProgram);
	}
#if 0
	NEXUS_VideoWindow_GetSettings(window,&windowSettings);
	windowSettings.contentMode = NEXUS_VideoWindowContentMode_eBox;
#if 0
	NEXUS_GetDefaultCalculateVideoWindowPositionSettings(&calcSettings);
	calcSettings.manualAspectRatioCorrection = NEXUS_VideoWindowContentMode_eBox;

	NEXUS_CalculateVideoWindowPosition(&calcSettings,&windowSettings);
#endif
	NEXUS_VideoWindow_SetSettings(window,&windowSettings);
#endif

#ifdef DESCRABLER_TEST
	Descrmbler_Dvbcsa_SwKey(&videoProgram , &audioProgram);
#endif


#if 1
	/* Print status while decoding */
	for (;;) {
		NEXUS_VideoDecoderStatus status;
		NEXUS_AudioDecoderStatus audioStatus;
		uint32_t stc;
		b_cpu_load load;

		NEXUS_VideoDecoder_GetStatus(vdecode, &status);
		NEXUS_StcChannel_GetStc(videoProgram.stcChannel, &stc);
		printf("decode %.4dx%.4d, pts %#x, stc %#x (diff %d) fifo=%d%%\n",
				status.source.width, status.source.height, status.pts, stc, status.pts - stc, status.fifoSize?(status.fifoDepth*100)/status.fifoSize:0);
		NEXUS_AudioDecoder_GetStatus(pcmDecoder, &audioStatus);
		printf("audio0            pts %#x, stc %#x (diff %d) fifo=%d%%\n",
				audioStatus.pts, stc, audioStatus.pts - stc, audioStatus.fifoSize?(audioStatus.fifoDepth*100)/audioStatus.fifoSize:0);
		NEXUS_AudioDecoder_GetStatus(compressedDecoder, &audioStatus);
		if ( audioStatus.started )
		{
			printf("audio1            pts %#x, stc %#x (diff %d) fifo=%d%%\n",
					audioStatus.pts, stc, audioStatus.pts - stc, audioStatus.fifoSize?(audioStatus.fifoDepth*100)/audioStatus.fifoSize:0);
		}
#if 0
		printf("-------- TASKINFO --------\n");
		bos_print_taskinfo();
		bos_getload(&load);
		printf("LOAD: %u ms IDLE:%u ISR:%u:%u %u us CSW:%u\n", load.duration, load.idle, load.isr_rate, load.isr, load.isr_us, load.ctxsw_rate);
#endif
		BKNI_Sleep(1000);
	}
#else
	printf("Press ENTER to stop decode\n");
	getchar();

	/* example shutdown */
	NEXUS_AudioDecoder_Stop(pcmDecoder);
	if ( audioProgram.codec == NEXUS_AudioCodec_eAc3 )
	{
		NEXUS_AudioDecoder_Stop(compressedDecoder);
	}
	NEXUS_AudioOutput_RemoveAllInputs(NEXUS_AudioDac_GetConnector(platformConfig.outputs.audioDacs[0]));
	NEXUS_AudioOutput_RemoveAllInputs(NEXUS_SpdifOutput_GetConnector(platformConfig.outputs.spdif[0]));
	NEXUS_AudioInput_Shutdown(NEXUS_AudioDecoder_GetConnector(pcmDecoder, NEXUS_AudioDecoderConnectorType_eStereo));
	NEXUS_AudioInput_Shutdown(NEXUS_AudioDecoder_GetConnector(compressedDecoder, NEXUS_AudioDecoderConnectorType_eCompressed));
	NEXUS_AudioDecoder_Close(pcmDecoder);
	NEXUS_AudioDecoder_Close(compressedDecoder);
	NEXUS_VideoDecoder_Stop(vdecode);
	NEXUS_VideoWindow_RemoveAllInputs(window);
	NEXUS_VideoInput_Shutdown(NEXUS_VideoDecoder_GetConnector(vdecode));
	NEXUS_VideoWindow_Close(window);
	NEXUS_Display_Close(display);
	NEXUS_VideoDecoder_Close(vdecode);
	NEXUS_StcChannel_Close(stcChannel);
	NEXUS_PidChannel_Close(videoPidChannel);
	NEXUS_PidChannel_Close(audioPidChannel);
	NEXUS_Platform_Uninit();
#endif

	return 0;
}


void Descrmbler_Dvbcsa_SwKey(NEXUS_VideoDecoderStartSettings *pVideoProgram, NEXUS_AudioDecoderStartSettings *pAudioProgram )
{
	NEXUS_KeySlotHandle videoKeyHandle = NULL;
	NEXUS_KeySlotHandle audioKeyHandle = NULL;
	NEXUS_SecurityAlgorithmSettings AlgConfig;
	NEXUS_SecurityClearKey key;
	NEXUS_PidChannelStatus pidStatus;
	NEXUS_SecurityKeySlotSettings keySlotSettings;

	unsigned char cwAudioEven[8]      =  { 
		0xd3,0x94,0xdd,0x44,0x13,0xd5,0xd1,0xb9,
	};	

	unsigned char cwAudioOdd[8]      = { 
		0xd6,0x91,0xd8,0x3f,0x13,0xd0,0xd4,0xb7,

	};

	unsigned char cwVideoEven[8]      =  { 
		0xbe,0xf9,0xb0,0x67,0x13,0xb8,0xbc,0x87,
	};	

	unsigned char cwVideoOdd[8]      = { 
		0xbc,0xfb,0xb2,0x69,0x13,0xba,0xbe,0x8b,
	};


	/* Allocate CA video keyslot */
	printf("Allocate CA video keyslot\n");
	NEXUS_Security_GetDefaultKeySlotSettings(&keySlotSettings);
	keySlotSettings.keySlotEngine = NEXUS_SecurityEngine_eCa;
	videoKeyHandle = NEXUS_Security_AllocateKeySlot(&keySlotSettings);
	if ( !videoKeyHandle)
	{
		printf("\nAllocate CA video keyslot failed \n");
		return ;
	}

	/* Add video PID channel to keyslot */
	printf("Add video PID channel to keyslot \n");
	NEXUS_PidChannel_GetStatus (pVideoProgram->pidChannel, &pidStatus);  
	if ( NEXUS_Security_AddPidChannelToKeySlot(videoKeyHandle, pidStatus.pidChannelIndex)!= 0 )
	{
		printf("\nAdd video PID channel to keyslot failed \n");
		return ;
	}

	/* Config video CA Algorithm for both even and odd*/
	printf("Configure video CA Algorithm for both even and odd \n");
	NEXUS_Security_GetDefaultAlgorithmSettings(&AlgConfig);
	AlgConfig.algorithm = NEXUS_SecurityAlgorithm_eDvb;
	AlgConfig.algorithmVar = NEXUS_SecurityAlgorithmVariant_eXpt;

	if ( NEXUS_Security_ConfigAlgorithm (videoKeyHandle, &AlgConfig) != 0 )
	{
		printf("\nConfigure Video CA Algorithm Even failed \n");
		return ;
	}

	/* Load Video keys */
	printf("Load video Odd key \n");
	key.keySize = 8; 
	key.keyEntryType = NEXUS_SecurityKeyType_eOdd;
	BKNI_Memcpy(key.keyData,cwVideoOdd,sizeof(cwVideoOdd));
	if ( NEXUS_Security_LoadClearKey (videoKeyHandle, &key) != 0 )
	{
		printf("\nLoad Video Odd key failed \n");
		return ;
	}

	printf("Load video ODD key \n");
	key.keyEntryType = NEXUS_SecurityKeyType_eEven;
	BKNI_Memcpy(key.keyData,cwVideoEven,sizeof(cwVideoEven));
	if ( NEXUS_Security_LoadClearKey (videoKeyHandle, &key) != 0 )
	{
		printf("\nLoad Video Even key failed \n");
		return ;
	}

	/* Allocate CA Audio keyslot */
	printf("Allocate CA Audio keyslot\n");	
	NEXUS_Security_GetDefaultKeySlotSettings(&keySlotSettings);
	keySlotSettings.keySlotEngine = NEXUS_SecurityEngine_eCa;
	audioKeyHandle = NEXUS_Security_AllocateKeySlot(&keySlotSettings);
	if ( !audioKeyHandle)
	{
		printf("\nAllocate CA Audio Keyslot failed \n");
		return ;
	}

	/* Add Audio PID channel to keyslot */
	printf("Add Audio PID channel to keyslot \n");
	NEXUS_PidChannel_GetStatus (pAudioProgram->pidChannel, &pidStatus);

	if ( NEXUS_Security_AddPidChannelToKeySlot(audioKeyHandle, pidStatus.pidChannelIndex)!= 0 )   
	{
		printf("\nAdd Audio PID channel to keyslot failed \n");
		return ;
	}

	/* Configure Audio CA Algorithm for both even and odd */
	printf("Configure Audio CA Algorithm for both even and odd \n");
	NEXUS_Security_GetDefaultAlgorithmSettings(&AlgConfig);
	AlgConfig.algorithm = NEXUS_SecurityAlgorithm_eDvb;
	AlgConfig.algorithmVar = NEXUS_SecurityAlgorithmVariant_eXpt;

	if ( NEXUS_Security_ConfigAlgorithm (audioKeyHandle, &AlgConfig) != 0 )
	{
		printf("\nConfigure Audio CA Algorithm failed \n");
		return ;
	}

	/* Load AV keys */
	printf("Load Audio Odd key \n");
	key.keySize = 8; 
	key.keyEntryType = NEXUS_SecurityKeyType_eOdd;
	BKNI_Memcpy(key.keyData,cwAudioOdd,sizeof(cwAudioOdd));
	if ( NEXUS_Security_LoadClearKey (audioKeyHandle, &key) != 0 )
	{
		printf("\nLoad Audio Odd key failed \n");
		return ;
	}

	printf("Load Audio Even key \n");
	key.keyEntryType = NEXUS_SecurityKeyType_eEven;
	BKNI_Memcpy(key.keyData,cwAudioEven,sizeof(cwAudioEven));
	if ( NEXUS_Security_LoadClearKey (audioKeyHandle, &key) != 0 )
	{
		printf("\nLoad Audio Even Key failed \n");
		return ;
	}

	printf ("\nSecurity Configure OK\n");
#if 1
	return;

#endif
	printf("Press ENTER to stop decode\n");
	getchar();


	/* Remove Audio PID channel from keyslot */
	printf("Remove Audio PID channel from keyslot \n");
	NEXUS_PidChannel_GetStatus (pAudioProgram->pidChannel, &pidStatus);
	if ( NEXUS_Security_RemovePidChannelFromKeySlot(audioKeyHandle, pidStatus.pidChannelIndex)!= 0 )
	{
		printf("\nRemove video PID channel from keyslot failed \n");
		return ;
	}

	/* Free CA Audio keyslot */
	printf("Free CA Audio keyslot\n");	
	NEXUS_Security_FreeKeySlot(audioKeyHandle);

	/* Remove Video PID channel from keyslot */
	printf("Remove Video PID channel from keyslot \n");
	NEXUS_PidChannel_GetStatus (pVideoProgram->pidChannel, &pidStatus);  
	if ( NEXUS_Security_RemovePidChannelFromKeySlot(videoKeyHandle, pidStatus.pidChannelIndex)!= 0 )
	{
		printf("\nRemove Video PID channel from keyslot failed \n");
		return ;
	}

	/* Free CA Video keyslot */
	printf("Free CA Video keyslot\n");	
	NEXUS_Security_FreeKeySlot(videoKeyHandle);

	printf ("\nFree Keyslot OK\n");

}

#endif