filter.c

ST5100 driver files for ST chipset

/*****************************************************************************
                                                                              
File name  : filter.c

Description: Private Section filter for download.

COPYRIGHT (C) STMicroelectronics 2004.

*****************************************************************************/

/* Includes --------------------------------------------------------------- */

#include <stdio.h>
#include <string.h>
#include <debug.h>

#include "stddefs.h"
#include "stlite.h"
#include "stdevice.h"
#include "sttbx.h"
#include "stpti.h"
#include "stvid.h"
#include "testtool.h"

#include "errors.h"
#include "st_pti.h"
#include "sections.h"

#include "service.h"
#include "filter.h"

#include "dvb_si.h"
#include "lists.h"


/* Defines ----------------------------------------------------------------- */

/* DSS Fixed Scids */
#define APG_SCID    SCID_APG_BOOT_STREAM
#define MPG_SCID    9                       /* tr01.bts */

/* Global Variables -------------------------------------------------------- */

Filter_t 		Filter[NUM_FILTERS];
STPTI_Handle_t  PTI_Handle;
STPTI_Slot_t    PTI_SlotHandle_DSMCC;

U16 NumPrograms, NumChannels;

/* Local Variables -------------------------------------------------------- */

extern SERVICE_Mode_t    SERVICE_Mode;


extern void DVB_GetPids( U8 *Buffer_p, LISTS_Channel_t *Channel_p );

/* Functions -------------------------------------------------------------- */

/*-------------------------------------------------------------------------
 * Function : FilterSetup
 * Input    : 
 * Output   :
 * Return   : Error code
 * ----------------------------------------------------------------------*/
ST_ErrorCode_t FilterSetup( Filter_t *Filter_p )
{
    ST_ErrorCode_t         ErrCode = ST_NO_ERROR;

    if (ErrCode == ST_NO_ERROR)    /* Allocate buffer for Filter */
        ErrCode = STPTI_BufferAllocate(PTI_Handle, BUFFER_SIZE, 1, &Filter_p->BufferHandle);
    if (ErrCode == ST_NO_ERROR)    /* Allocate signal for the filter */
        ErrCode = STPTI_SignalAllocate(PTI_Handle, &Filter_p->SignalHandle);
    if (ErrCode == ST_NO_ERROR)    /* link signal with buffer */
        ErrCode = STPTI_SignalAssociateBuffer(Filter_p->SignalHandle, Filter_p->BufferHandle);
    if (ErrCode == ST_NO_ERROR)    /* Link allocated slot to buffer */
        ErrCode = STPTI_SlotLinkToBuffer(Filter_p->SlotHandle, Filter_p->BufferHandle);

    STTBX_Print(("FilterSetup() = %s\n", GetErrorText(ErrCode) ));
    return( ErrCode );
}

/*-------------------------------------------------------------------------
 * Function : FilterInit
 * Input    : 
 * Output   :
 * Return   : Error code
 * ----------------------------------------------------------------------*/
ST_ErrorCode_t FilterInit( void )
{
	ST_ErrorCode_t 		ErrCode = ST_NO_ERROR;
	STPTI_SlotData_t    STPTI_SlotData;

	PTI_Handle = PTI_GET_HANDLE(PTI_1,PTI_PS_AV1);

	memset((void *)&STPTI_SlotData, 0, sizeof(STPTI_SlotData_t));
	STPTI_SlotData.SlotType = STPTI_SLOT_TYPE_SECTION;
	STPTI_SlotData.SlotFlags.SignalOnEveryTransportPacket = FALSE;
	STPTI_SlotData.SlotFlags.CollectForAlternateOutputOnly = FALSE;
	STPTI_SlotData.SlotFlags.AlternateOutputInjectCarouselPacket = FALSE;
	STPTI_SlotData.SlotFlags.StoreLastTSHeader = FALSE;
	STPTI_SlotData.SlotFlags.InsertSequenceError = FALSE;
	STPTI_SlotData.SlotFlags.OutPesWithoutMetadata = FALSE;
	STPTI_SlotData.SlotFlags.ForcePesLengthToZero = FALSE;
	STPTI_SlotData.SlotFlags.AppendSyncBytePrefixToRawData = FALSE;

	STTBX_Print(("Slot Section DSMCC\n"));

	/* Allocates free slots */
	ErrCode = STPTI_SlotAllocate(PTI_Handle, &PTI_SlotHandle_DSMCC, &STPTI_SlotData);
	if (ErrCode != ST_NO_ERROR)
	{
		STTBX_Print((" ***PTI_SlotAllocate(DSMCC)=%s*** ", GetErrorText(ErrCode) ));
		return( ErrCode );
	}

	/* Clears slot PID */
	ErrCode = STPTI_SlotClearPid(PTI_SlotHandle_DSMCC);
	if (ErrCode != ST_NO_ERROR)
	{
		STTBX_Print((" ***PTI_SlotClearPid(DSMCC)=%s*** ", GetErrorText(ErrCode) ));
		return( ErrCode );
	}

	Filter[SECTION].SlotHandle = PTI_SlotHandle_DSMCC;
	Filter[SECTION].FilterData.FilterType = STPTI_FILTER_TYPE_SECTION_FILTER_SHORT_MODE; /*STPTI_FILTER_TYPE_SECTION_FILTER;*/
	return ( FilterSetup( &Filter[SECTION] ) );
}

/*-------------------------------------------------------------------------
 * Function : FilterStart
 * Input    : 
 * Output   :
 * Return   : Error code
 * ----------------------------------------------------------------------*/
ST_ErrorCode_t FilterStart( Filter_t *Filter_p, STPTI_Pid_t Pid, U8 TableId )
{
	ST_ErrorCode_t ErrCode = ST_NO_ERROR;
	STPTI_Buffer_t WhichBufferGotSignal;
	U32 DataSize = 0;

	Filter_p->FilterData.FilterRepeatMode     = STPTI_FILTER_REPEAT_MODE_STPTI_FILTER_REPEATED;
	Filter_p->FilterData.InitialStateEnabled  = TRUE;
	Filter_p->FilterData.FilterBytes_p        = &Filter_p->FilterBytes[0];
	Filter_p->FilterData.FilterMasks_p        = &Filter_p->FilterMasks[0];
	Filter_p->FilterData.u.SectionFilter.DiscardOnCrcError = TRUE;
	Filter_p->FilterData.u.SectionFilter.ModePattern_p     = NULL;
	Filter_p->FilterData.u.SectionFilter.NotMatchMode      = FALSE;

	if (ErrCode == ST_NO_ERROR)    /* Allocate filter for the private sections */
		ErrCode = STPTI_FilterAllocate(PTI_Handle, Filter_p->FilterData.FilterType, &Filter_p->Filter);
	if (ErrCode == ST_NO_ERROR)    /* Set Filter Data */
		ErrCode = STPTI_FilterSet(Filter_p->Filter, &Filter_p->FilterData);
	if (ErrCode == ST_NO_ERROR)    /* Associate Filter with Slot */
		ErrCode = STPTI_FilterAssociate(Filter_p->Filter, Filter_p->SlotHandle);
	if (ErrCode == ST_NO_ERROR)    /* Flush buffer */
		ErrCode = STPTI_BufferFlush(Filter_p->BufferHandle);
	if (ErrCode == ST_NO_ERROR)    /* Start Slot data from Pid */
		ErrCode = STPTI_SlotSetPid(Filter_p->SlotHandle, Pid);

	if (ErrCode != ST_NO_ERROR)
	{
		STTBX_Print(("Filter(PID = %d)=%s\n", Pid, GetErrorText(ErrCode) ));
		return( ErrCode );
	}
	else
	{
		STTBX_Print(("\nFilter(PID = %d)=Starting\n", Pid));		
	}

	memset( Filter_p->Buffer, 0, BUFFER_SIZE );
	while(1)
	{
        ErrCode = STPTI_SignalWaitBuffer(Filter_p->SignalHandle, &WhichBufferGotSignal, 2000);
		/* STPTI_SignalWaitBuffer() generated an error */
		if (ErrCode == ST_ERROR_TIMEOUT)
		{
			/* its timeout so nothing else to do apart from report it */
            STTBX_Print(("FILTER: ST_ERROR_TIMEOUT\n" ));
			break;
		}
		/* if not a harmless timeout then get rid of anything in the STPTI internal buffer */
		else if (ErrCode != ST_NO_ERROR)
		{
			ErrCode = STPTI_BufferFlush(WhichBufferGotSignal);
			STTBX_Print(("FILTER: STPTI_BufferFlush()=%s\n", GetErrorText(ErrCode) ));
		}

		/* We got a private section message */
		if (Filter_p->BufferHandle == WhichBufferGotSignal)
		{
			U32 NumFilterMatches = 0;
			BOOL CRCValid;

			if ( Filter_p == &Filter[SECTION] )
			{
				/* STPTI_SignalWaitBuffer() indicated a message
				** so now read it from the internal STPTI to our local buffer
				*/
				ErrCode = STPTI_BufferReadSection( Filter_p->BufferHandle, NULL, 0, &NumFilterMatches, &CRCValid, 
					&Filter_p->Buffer[0], BUFFER_SIZE, NULL, 0, 
					&DataSize, STPTI_COPY_TRANSFER_BY_MEMCPY );
				if (ErrCode != ST_NO_ERROR)    /* unexpected fault reading data */
				{
					STTBX_Print(("FILTER: STPTI_BufferReadSection()=%s\n", GetErrorText(ErrCode) ));
					return ErrCode;
				}
				break; /* filtered all sections */
			}
			else if ( Filter_p == &Filter[APG] )
			{
				ErrCode = STPTI_BufferReadSection( Filter_p->BufferHandle, NULL, 0, &NumFilterMatches, &CRCValid,
				&Filter_p->Buffer[0], BUFFER_SIZE, NULL, 0, 
				&DataSize, STPTI_COPY_TRANSFER_BY_MEMCPY );
				if (ErrCode != ST_NO_ERROR)    /* unexpected fault reading data */
				{
				STTBX_Print(("FILTER: STPTI_BufferRead()=%s\n", GetErrorText(ErrCode) ));
				return ErrCode;
				}
				break;
			}
			else if ( Filter_p == &Filter[MPG] )
			{
				ErrCode = STPTI_BufferRead( Filter_p->BufferHandle, /*NULL, 0, &NumFilterMatches, &CRCValid,*/
					&Filter_p->Buffer[0], BUFFER_SIZE, NULL, 0, 
					&DataSize, STPTI_COPY_TRANSFER_BY_MEMCPY );
				if (ErrCode != ST_NO_ERROR)    /* unexpected fault reading data */
				{
				STTBX_Print(("FILTER: STPTI_BufferRead()=%s\n", GetErrorText(ErrCode) ));
				return ErrCode;
				}
				break;
			}
		}
		else
		{
			/* Should not happen. Not our buffer but flush it anyway */
			STTBX_Print(("UNEXPECTED: SECTION_BufferHandle: 0x%08x, BufferFlush(0x%08x)=",
			Filter_p->BufferHandle, WhichBufferGotSignal ));
			ErrCode = STPTI_BufferFlush(WhichBufferGotSignal);
			STTBX_Print(("%s\n", GetErrorText(ErrCode) ));
		}
	}   /* while(1) */

	{
		ST_ErrorCode_t ErrCode2;
		ErrCode2 = STPTI_SlotClearPid(Filter_p->SlotHandle);
		if ( ErrCode2 != ST_NO_ERROR )
		STTBX_Print(("STPTI_SlotClear()=%s\n", GetErrorText(ErrCode2) ));
		ErrCode2 = STPTI_FilterDisassociate(Filter_p->Filter, Filter_p->SlotHandle);
		if ( ErrCode2 != ST_NO_ERROR )
		STTBX_Print(("STPTI_FilterDisass()=%s\n", GetErrorText(ErrCode2) ));
		ErrCode2 = STPTI_FilterDeallocate(Filter_p->Filter);
		if ( ErrCode2 != ST_NO_ERROR )
		STTBX_Print(("STPTI_FilterDealloc()=%s\n", GetErrorText(ErrCode2) ));
	}

	return( ErrCode );
}


/*-------------------------------------------------------------------------
 * Function : DVB_FilterCreate
 * Input    : 
 * Output   :
 * Return   : None
 * ----------------------------------------------------------------------*/
void DVB_FilterCreate(Filter_t *Filter_p, U32 TableId, U32 Program, U32 Version, U32 Section)
{

    memset(Filter_p->FilterMasks, 0, FILTER_SIZE);
    memset(Filter_p->FilterBytes, 0, FILTER_SIZE); /* initialise to wild card (accept everything) */

    /* set table id */
    if (( TableId & TID_DONT_CARE) == 0 )
    {
        TABLE_ID(Filter_p->FilterMasks) = TID_MASK;
        TABLE_ID(Filter_p->FilterBytes) = TableId;
    }

    /* set program number (for pmt only) */