source: svn/trunk/newcon3bcm2_21bu/dst/dhl/api/test/PsiTest.c @ 2

/*
        PsiTest.c


*/

#include "DHL_PSI.h"
#include "DHL_PSI_Priv.h"
#include "DHL_DBG.h"
#include "DHL_UTL.h"

#include "DLIB_PSI_Parser.h"
#include "DLIB_PSIP_Parser.h"
#include "DLIB_PSI_Monitor.h"
#include "DLIB_PSIP_Monitor.h"


//#include <string.h>

/*

        Å×½ºÆ® ¹æ¹ý:

                ¸ðµç Å×½ºÆ® ÇÔ¼ö´Â      PsiTest_ ·Î ½ÃÀÛÇÑ´Ù.


        1. ÃʱâÈ­

                ÃʱâÈ­ ºÎºÐ¿¡¼­ DHL_DMX_Init ¹× DHL_PSI_Init ÀÌ È£ÃâµÇÁö ¾Ê¾Ò´Ù¸é 
                Á÷Á¢ shell¿¡¼­ È£ÃâÇØ ÁØ´Ù.

                Shell> DHL_DMX_Init
                Shell> DHL_PSI_Init

        2. ±âº» ¼½¼Ç ¼ö½Å

                all pass filter¸¦ ¼³Á¤ÇÏ°í, 1ÃÊ°£ ´ë±âÇÑ ÈÄ¿¡ filter off ÇÑ´Ù.
                ÇÔ¼öÀÎÀÚ: tsd port.

                Shell> PsiTest_01 0 0 1   // 1ÃÊ µ¿¾È tsd 0 ¿¡¼­ PAT (pid 0) ¼ö½Å.
                Shell> PsiTest_01 1 0 1   // 1ÃÊ µ¿¾È tsd 1 ¿¡¼­ PAT ¼ö½Å.

                Shell> PsiTest_01 0 0x1ffb 1 // 1ÃÊ µ¿¾È tsd 0 ¿¡¼­ ATSC base table ¼ö½Å.

        3. ´ÜÀÏ ¼½¼Ç ¼ö½Å Å×½ºÆ®

                °¢Á¾ update ¸ðµå Å×½ºÆ®
                CRC üũ Å×½ºÆ®. ¾Æ·¡ ¸ðµç Å×½ºÆ®¿¡¼­ CRC ¿¡·¯°¡ ¹ß»ýÇÏ¸é ¾ÈµÊ.

                        PsiTest_Section tsd pid tid update num 
                        update => 1:onehot, 2:version, 3:crc, 4:cont.


                Shell> PsiTest_Section 0 0 0x0 1 5  // Çϳª¸¸ ¹Þ°í timeout ³ª¾ß ÇÔ.
                Shell> PsiTest_Section 0 0 0x0 2 5  // Çϳª¸¸ ¹Þ°í timeout ³ª¾ß ÇÔ.
                Shell> PsiTest_Section 0 0 0x0 3 5  // Çϳª¸¸ ¹Þ°í timeout ³ª¾ß ÇÔ.
                Shell> PsiTest_Section 0 0 0x0 4 5  // 5°³ ¸ðµÎ ¼ö½Å ÇØ¾ß ÇÔ. ´õ ¼ö½ÅµÉ ¼öµµ ÀÖÀ½.


        4. ¼½¼Ç ¼ö½Å ºÎÇÏ Å×½ºÆ®..

                PAT ¼ö½ÅÀ» continuous ¸ðµå·Î ó¸®ÇÑ´Ù.
                ±×·¯´Ù°¡ STT ¼ö½ÅÀ» ÀϺη¯ Áö¿¬ ¼ö½ÅÇϵµ·Ï ó¸®Çϸé PAT ¼ö½Å¿¡ ºÎÇÏ°¡ °É¸²..
                

                Shell> PsiTest_Load_Pat
                        // pat ¼ö½Å »óȲ üũ..
                
                Shell> PsiTest_Load_Stt
                        // stt°¡ ¼ö½Å µÉ ¶§ ¸¶´Ù °­Á¦ Áö¿¬¿¡ ÀÇÇØ pat ¼ö½Å¿¡ ¿µÇâÀ» ÁÖ´Â Çö»ó È®ÀÎ.

                

        5. Å×ÀÌºí ¼ö½Å Å×½ºÆ®

                        PsiTest_Table tsd pid tid

                Shell> PsiTest_Table 0 0 0     // PAT Çϳª¸¦ ¹Þ°í Á¾·á.
                Shell> PsiTest_Table 0 0xnn 2  // PMT ¼ö½Å. PMT°¡ ¿©·µÀÏ °æ¿ì, ¹Ýº¹ ½ÃµµÇÏ¿© ¸ðµç PMT¸¦ ´Ù ¹Þ¾Æº¸µµ·Ï ÇÏÀÚ.
                
                Shell> PsiTest_Table 0 0x1ffb 0xc7  // mgt. timeout ³¯ ¼öµµ ÀÖÀ½.
                Shell> PsiTest_Table 0 0x1ffb 0xc8  // tvct
                Shell> PsiTest_Table 0 0x1ffb 0xc9  // cvct
                Shell> PsiTest_Table 0 0x1ffb 0xca  // rrt
                Shell> PsiTest_Table 0 0x1ffb 0xcd  // stt
                
        6. µ¿ÀÏ pid Å×ÀÌºí ¼ö½Å Å×½ºÆ®
        
                Shell> PsiTest_Load_Mgt
                Shell> PsiTest_Load_Tvct        // Mgt¿Í Tvct µ¿½Ã ¼ö½Å È®ÀÎ
                Shell> PsiTest_Stop_Mgt // Mgt´Â ¼ö½ÅÀÌ Áߴܵǰí Tvct´Â Áö¼ÓÀûÀ¸·Î ¼ö½ÅµÇ´ÂÁö È®ÀÎ
                Shell> PsiTest_Load_Mgt // Mgt¿Í Tvct µ¿½Ã ¼ö½Å È®ÀÎ
                Shell> PsiTest_Load_Stop        // ¼ö½Å Á¾·á 

        7. ett ¼ö½Å Å×½ºÆ®

                        PsiTest_Load_Ett1 pid etmid
                        
                Shell> PsiTest_Load_Ett1 0xnnnn 0xnnnnnnnn // ¼ö½ÅµÈ ettÀÇ etmid°¡ µ¿ÀÏÇÑÁö È®ÀÎ
                Shell> PsiTest_Load_Ett2 0xnnnn 0xmmmmmmmm // (´Ü, n != m) µ¿½Ã¿¡ ¼ö½Å µÇ´ÂÁö È®ÀÎ, etmidµµ È®ÀÎ
                Shell> PsiTest_Load_Stop        // ¼ö½Å Á¾·á 
                        ¡Ø ettÀÇ pid¹× etmid´Â epg_start, epg_list µîÀÇ ÇÔ¼ö¸¦ ÀÌ¿ëÇÏ¿© ¾Ë¼ö ÀÖ´Ù.
                        ¡Ø test ½ºÆ®¸²Àº sarnoff bndb °°Àº ½ºÆ®¸²À» ÀÌ¿ëÇÏ¸é µÈ´Ù. (pid, etmid ¿¹: pid 0x1d07, etmid 0x001d0502, 0x001d0506)

        8. PAT version change test

                Shell> PsiTest_Load_Pat2        // ù ¹ø° pat ¼ö½Å È®ÀÎ ÈÄ  
                                        // ¹öÀüÀÌ º¯°æ µÉ ¶§±îÁö ä³ÎÀ» º¯°æ Çغ¸¸é¼­
                                        // ¹öÀü º¯°æ½Ã update µÊÀ» È®ÀÎ
                                        // ÃÖ¾ÇÀÇ °æ¿ì ¸ðµç ä³ÎÀÇ ¹öÀüÀÌ µ¿ÀÏÇϸé Å×½ºÆ® ºÒ°¡
                        
                        
        x. ¼½¼Ç »ý¼º ÃÖ´ë °¹¼ö Å×½ºÆ®

                Shell> PsiTest_HowManyFilter 0

                        ·Î±×¸¦ »ìÆ캸¸é¼­ ¸î°³ÀÇ ¼½¼ÇÀÌ »ý¼ºµÇ´Ù°¡ ¿¡·¯°¡ ¹ß»ýÇß´ÂÁö Å×½ºÆ®.
                        ´Ù½Ã À§ ÇÔ¼ö¸¦ ¹Ýº¹Çϸ鼭 ÃÖ´ë ¼½¼Ç °¹¼ö¿¡ º¯µ¿ÀÌ ÀÖ´ÂÁö Å×½ºÆ®.
        
                Shell> PsiTest_HowManyFilter 0
                Shell> PsiTest_HowManyFilter 0
                Shell> PsiTest_HowManyFilter 1
                Shell> PsiTest_HowManyFilter 1
        

*/

#define print DHL_OS_Printf
#define CHK_DHR(msg) if (dhr!=DHL_OK) { print("!! %s err %d\n", msg, dhr); goto errexit; }


typedef struct 
{
        //--- common
        UINT32 magic;

        UINT32 cmd;
        UINT32 section_count;

        //--- Section test
        UINT32 max_count;
        BOOL full_dump;

        //--- Table test
        DHL_OS_SEMA_ID sem;  // ¼ö½Å ÅëÁö semaphore
        tDHL_PSI_DataArray *data;
        
} PsiTestContext;

#define PSI_CTX_MAGIC 0xcafebabe

static void reset_ctx(PsiTestContext *ctx)
{
        memset(ctx, 0, sizeof(*ctx));
        ctx->magic = PSI_CTX_MAGIC;
}

static DHL_RESULT get_tsd(UINT32 tsd_id, tDHL_TSD *pHandle)
{
        tDHL_TSD handle;
        if (tsd_id >= DHL_CFG_MAX_NUM_TSD) {
                return DHL_FAIL_INVALID_PARAM;
        }
        handle = DHL_DMX_GetTsdByID(tsd_id);
        if (handle == NULL) return DHL_FAIL_INVALID_HANDLE;
        *pHandle = handle;
        return DHL_OK;
}



#if COMMENT
____Test_1____(){}
#endif

/*
        pat ¼ö½Å Å×½ºÆ®.
        Á¦´ë·Î TS ¼³Á¤ÀÌ µÇ¾ú´Ù¸é 1ÃÊ¿¡ Àû¾îµµ ¸î °³ÀÇ PAT´Â ¼ö½ÅµÇ¾î¾ß ÇÑ´Ù.

        Å×½ºÆ® ¹æ¹ý:
*/


static void PsiTest_01_Proc(tDHL_PSI_Event event, tDHL_PSI_ControlHandle psiCtl, UINT32 userParam)
{
        DHL_RESULT dhr;
        PsiTestContext *ctx = (PsiTestContext *)userParam;

        if (!ctx || ctx->magic != PSI_CTX_MAGIC) {
                print("!! invalid ctx\n");
                return;
        }
        
        if (event == ePSIEVENT_DATARECEIVED) 
        {
                ctx->section_count++;

                // PsiData Àд ·çƾÀÌ ¾ø´õ¶óµµ system¿¡ ¾Ç¿µÇâÀº ¾ø¾î¾ß ÇÑ´Ù.
        #if 0
                dhr = DHL_PSI_ReadPSIData(psiCtl, &data);
                DHL_PSI_FreePSIData(data);
        #endif
                
        }
}

/*
        ÁöÁ¤ÇÑ tsd, pid ¿¡¼­ ¸ðµç ¼½¼ÇÀ» ´Ù ¼ö½ÅÇÑ´Ù.

        ÁöÁ¤ÇÑ ½Ã°£ µ¿¾È ¸î °³ÀÇ ¼½¼ÇÀÌ ¼ö½ÅµÇ¾ú´ÂÁö üũ °¡´ÉÇÏ´Ù.
        tsd ¸¦ ¹Ù²Ù¾î °¡¸é¼­ Å×½ºÆ® °¡´É.
        pid¸¦ º¯°æÇØ °¡¸é¼­ Å×½ºÆ® °¡´É.
*/
void PsiTest_01(UINT32 tsd_id, UINT16 pid, UINT16 waitSecond)
{
        DHL_RESULT dhr;
        tDHL_TSD tsd;
        tDHL_PSI_ControlHandle handle = 0;
        tDHL_PSI_Filter *f = NULL;
        PsiTestContext ctx;

        reset_ctx(&ctx);

        print("section receive basic test\n");
        print("  use all pass filter at tsd port %u\n", tsd_id);
        
        dhr = get_tsd(tsd_id, &tsd);
        CHK_DHR("get tsd");

        dhr = DHL_PSI_AllocGenericFilter(&f);

        CHK_DHR("alloc filter");

        // ¸ð´ÏÅÍ ½ÃÀÛ..
        dhr = DHL_PSI_StartMonitor(tsd, pid,
                ePSIMODE_SECTION, ePSIUPDATE_CONTINEOUS, f, 
                4096, 256, PsiTest_01_Proc, (UINT32)&ctx, &handle);
        CHK_DHR("start monitor");

        DHL_OS_Delay(waitSecond*1000);

        // ¸ð´ÏÅÍ ÇØÁ¦..
        DHL_PSI_StopMonitor(handle);
        handle = 0;
        f = 0;
        
        print("\n total %u sections received\n", ctx.section_count);

errexit:        
        if (handle) DHL_PSI_StopMonitor(handle);
        if (f) DHL_PSI_FreeFilter(f);

}




#if COMMENT
____Test_1____(){}
#endif


static void PsiTest_Section_Proc(tDHL_PSI_Event event, tDHL_PSI_ControlHandle psiCtl, UINT32 userParam)
{
        DHL_RESULT dhr;
        PsiTestContext *ctx = (PsiTestContext *)userParam;

        if (!ctx || ctx->magic != PSI_CTX_MAGIC) {
                print("!! invalid ctx\n");
                return;
        }
        
        if (event == ePSIEVENT_DATARECEIVED) 
        {
                tDHL_PSI_DataArray *data;
                UINT8 *ptr; int len;
                UINT32 crc_insection, crc_calculated;
                
                dhr = DHL_PSI_ReadPSIData(psiCtl, &data);
                if (dhr != DHL_OK) {
                        print("!! read psi data err %d\n", dhr);
                        return;
                }

                memdump(data->sectPtr[0], 16, "section");
                
                ctx->section_count++;

                ptr = data->sectPtr[0];
                len = (((ptr[1] & 0xf)<<8UL) | ptr[2]) + 3; // tid ºÎÅÍ crc±îÁö Àüü Å©±â.

                crc_insection = (ptr[len-4]<<24UL)|(ptr[len-3]<<16UL)|(ptr[len-2]<<8UL)|(ptr[len-1]);
                crc_calculated = DHL_UTL_CalcCRC32(DHL_CRC_START, ptr, len-4);

                if (crc_insection != crc_calculated) {
                        print("!! crc in section %x != crc calculated %x, at section #%d\n",
                                crc_insection, crc_calculated, ctx->section_count);
                }
                
                if (ctx->section_count >= ctx->max_count)
                {
                        // ¿©±â¼­ Áß´Ü ½Ãų ¼ö ÀÖ´Â ¹æ¹ýÀº ¾øÀ½..
                        // API»óÀ¸·Î, DHL_PSI_StopMonitor¸¦ ¾ÈÀüÇÏ°Ô È£ÃâÇÒ ¼ö ÀÖ´Â À§Ä¡´Â ¾Æ´Ï´Ù.
                }
                
                // ¿©±â¼­ µ¥ÀÌÅ͸¦ È®ÀÎÇÏ´Â °ÍÀÌ ¸ñÀûÀÌ ¾Æ´Ï¹Ç·Î ±×³É free.
                DHL_PSI_FreePSIData(data);
        }
}

/*
        ÁöÁ¤ÇÑ tsd, pid ¿¡¼­ ¸ðµç ¼½¼ÇÀ» ´Ù ¼ö½ÅÇÑ´Ù.

        ÁöÁ¤ÇÑ ¼½¼Ç ¼ö ¸¸Å­¸¸ ¹Þ°í Áß´ÜÇÑ´Ù.
*/
void PsiTest_Section(UINT32 tsd_id, UINT16 pid, UINT8 tid, tDHL_PSI_Update update, UINT32 num_section)
{
        DHL_RESULT dhr;
        tDHL_TSD tsd;
        tDHL_PSI_ControlHandle handle = 0;
        tDHL_PSI_Filter *f = NULL;
        int waitSecond = 5;
        PsiTestContext ctx;
        DHL_OS_SEMA_ID mutex;
        int i;  
        
        reset_ctx(&ctx);
        
        print("section rx test, tsd %u, pid %x, tid %x, update %d(%s), %d sections\n", 
                tsd_id, pid, tid, update,
                update==ePSIUPDATE_ONESHOT ? "OneShot" :
                update==ePSIUPDATE_VERCHANGE ? "VerChg" : 
                update==ePSIUPDATE_CRCCHANGE ? "CrcChg" :
                update==ePSIUPDATE_CONTINEOUS ? "Cont." : "?",
                num_section,
                0);

        dhr = get_tsd(tsd_id, &tsd);
        CHK_DHR("get tsd");

        dhr = DHL_PSI_AllocGenericFilter(&f);
        CHK_DHR("alloc filter");


        // ¼½¼Ç ¼ö½ÅÇÒ ÃÖ´ë Ƚ¼ö ÁöÁ¤.
        ctx.max_count = num_section;

        // ¸ð´ÏÅÍ ½ÃÀÛ..
        dhr = DHL_PSI_StartMonitor(tsd, pid,
                ePSIMODE_SECTION, update, f, 
                4096, 256, PsiTest_Section_Proc, (UINT32)&ctx, &handle);
        CHK_DHR("start monitor");

        // ÁÖ±âÀûÀ¸·Î üũ¸¦ Çϸ鼭 ¿øÇÏ´Â ¼½¼Ç °¹¼ö ¼ö½Å È®ÀÎ.
        for (i=0; i<waitSecond; i++) {
                DHL_OS_Delay(500);
                if (ctx.section_count >= num_section)
                        break;
                print("section rx count %d. wait more..\n", ctx.section_count);
        }
        
        // ¸ð´ÏÅÍ ÇØÁ¦..
        DHL_PSI_StopMonitor(handle);    
        f = 0;
        handle = 0;

        // ½ÇÁ¦·Î ¿øÇÏ´Â ¼½¼Ç °¹¼öº¸´Ù ´õ ¸¹ÀÌ ¼ö½ÅµÉ ¼ö ÀÖÀ½.
        print("\n=== total %u sections received\n", ctx.section_count);

errexit:        
        if (handle) DHL_PSI_StopMonitor(handle);
        if (f) DHL_PSI_FreeFilter(f);
        
}



#if COMMENT
____Test_1____(){}
#endif


static void PsiTest_Table_Proc(tDHL_PSI_Event event, tDHL_PSI_ControlHandle psiCtl, UINT32 userParam)
{
        DHL_RESULT dhr;
        PsiTestContext *ctx = (PsiTestContext *)userParam;
        tDHL_PSI_DataArray *data;

        if (!ctx || ctx->magic != PSI_CTX_MAGIC) {
                print("!! invalid ctx\n");
                return;
        }
        
        if (event == ePSIEVENT_DATARECEIVED) 
        {
                tDHL_PSI_DataArray *data;
                dhr = DHL_PSI_ReadPSIData(psiCtl, &data);
                if (dhr) {
                        print("!! read psi data err %d\n", dhr);
                        ctx->data = NULL;
                }
                else
                        ctx->data = data;
                DHL_OS_GiveSemaphore(ctx->sem);
        }
}

void PsiTest_Table(UINT32 tsd_id, UINT16 pid, UINT8 tid, tDHL_PSI_Update update)
{
        DHL_RESULT dhr;
        tDHL_TSD tsd;
        tDHL_PSI_ControlHandle handle = 0;
        tDHL_PSI_Filter *f = NULL;
        int waitSecond = 1;
        PsiTestContext ctx;
        DHL_OS_SEMA_ID sem = 0;
        
        reset_ctx(&ctx);

        //update = ePSIUPDATE_ONESHOT;
        
        print("table receive test, tsd %u, pid %x, tid %x, update %u (%s)\n", 
                tsd_id, pid, tid, update,
                update==ePSIUPDATE_ONESHOT ? "OneShot" :
                update==ePSIUPDATE_VERCHANGE ? "VerChg" : 
                update==ePSIUPDATE_CRCCHANGE ? "CrcChg" :
                update==ePSIUPDATE_CONTINEOUS ? "Cont." : "?",
                0);
        
        dhr = get_tsd(tsd_id, &tsd);
        CHK_DHR("get tsd");

        dhr = DHL_PSI_AllocGenericFilter(&f);
        CHK_DHR("alloc filter");
        
        f->mask[0] = tid; f->coef[0] = f->excl[0] = 0xff;

        // ¼ö½Å ÅëÁö ¼¼¸¶Æ÷¾î »ý¼º.
        sem = DHL_OS_CreateBinarySemaphore("", 0, FALSE);
        ctx.sem = sem;
        
        // ¸ð´ÏÅÍ ½ÃÀÛ..
        dhr = DHL_PSI_StartMonitor(tsd, pid,
                ePSIMODE_TABLE, update, f, 
                4096, 256, PsiTest_Table_Proc, (UINT32)&ctx, &handle);
        CHK_DHR("start monitor");

        f = NULL;
        print("waiting until table rx completed..\n");
        dhr = DHL_OS_TakeSemaphore(sem, 5000);
        if (dhr == DHL_FAIL_TIMEOUT) {
                print("!! table get timeout..\n");
                goto errexit;
        }
        else if (dhr != DHL_OK) {
                print("!! take sem err %d\n", dhr);
                goto errexit;
        }
        
        if (1) {
                int i; char msg[20]; UINT8 *ptr; int len;
                print("\n=== table received. (%d sections)\n", ctx.data->numSections);

                for (i=0; i<ctx.data->numSections; i++) {
                        sprintf(msg, "section[%d]", i);
                        ptr = ctx.data->sectPtr[i];
                        len = (((ptr[1] & 0xf)<<8UL) | ptr[2]) + 3; // tid ºÎÅÍ crc±îÁö Àüü Å©±â.
                        memdump(ptr, len, msg);
                }
        }

        if (pid == 0 && tid == 0) {
                MPEG_PAT *pat;
                int k;
                dhr = ParsePAT(ctx.data, &pat);
                if (dhr == DHL_OK) {
                        print("pat tsid %x, v%d\n", pat->transport_stream_id, pat->version_number);
                        for (k=0; k<pat->numPrograms; k++)
                                print(" (%d) #0x%x, pid 0x%x\n", k, 
                                        pat->programs[k].program_number, pat->programs[k].program_map_PID);
                        FreePAT(pat);
                }
        }
        
errexit:        
        if (ctx.data) DHL_PSI_FreePSIData(ctx.data);
        if (handle) DHL_PSI_StopMonitor(handle);
        if (sem) DHL_OS_DeleteSemaphore(sem);
        if (f) DHL_PSI_FreeFilter(f);

}



#if COMMENT
____Test_1____(){}
#endif

static tDHL_PSI_ControlHandle s_load_pat, s_load_stt, s_load_tvct, s_load_mgt, s_load_eit;

void PsiTest_Load_Proc(tDHL_PSI_Event event, tDHL_PSI_ControlHandle psiCtl, UINT32 userParam)
{
        DHL_RESULT dhr;
        if (event == ePSIEVENT_DATARECEIVED) {
                tDHL_PSI_DataArray *data;
                UINT8 *ptr; 
                //int len;
                
                dhr = DHL_PSI_ReadPSIData(psiCtl, &data);
                if (dhr != DHL_OK) {
                        print("!! read psi data err %d\n", dhr);
                        return;
                }

                ptr = data->sectPtr[0];
                memdump(ptr, 16, ptr[0]==0x0 ? "pat" : 
                                                ptr[0]==0xcd ? "stt" : "?");
                //len = (((ptr[1] & 0xf)<<8UL) | ptr[2]) + 3; // tid ºÎÅÍ crc±îÁö Àüü Å©±â.

                // ¿©±â¼­ µ¥ÀÌÅ͸¦ È®ÀÎÇÏ´Â °ÍÀÌ ¸ñÀûÀÌ ¾Æ´Ï¹Ç·Î ±×³É free.
                DHL_PSI_FreePSIData(data);

                // stt¶ó¸é ÀǵµÀûÀ¸·Î Áö¿¬À» ½ÃÄѼ­ task ¼öÇà ¼º´ÉÀ» ¹æÇØÇÑ´Ù.
                if (userParam == 1) {
                        print("=== stt1 intentional delay!!\n");
                        DHL_OS_Delay(500);
                }

                print("=== user param %d..!!\n", userParam);

        }
}

void PsiTest_Load_Pat()
{
        DHL_RESULT dhr;
        if (s_load_pat) {
                print("pat already run\n");
                return;
        }
        dhr = MonitorPAT(DHL_DMX_GetTsd(), TRUE, FALSE, ePSIUPDATE_CONTINEOUS, 
                PsiTest_Load_Proc, 0, &s_load_pat);
        if (dhr)
                print("!! monitor pat err %d\n", dhr);
}

void PsiTest_Load_Pat2()
{
        DHL_RESULT dhr;
        if (s_load_pat) {
                print("pat already run\n");
                return;
        }
        dhr = MonitorPAT(DHL_DMX_GetTsd(), TRUE, FALSE, ePSIUPDATE_VERCHANGE, 
                PsiTest_Load_Proc, 0, &s_load_pat);
        if (dhr)
                print("!! monitor pat err %d\n", dhr);
}

void PsiTest_Load_Stt()
{
        DHL_RESULT dhr;
        if (s_load_stt) {
                print("stt already run\n");
                return;
        }
        // stt ¼ö½ÅÀÌ µÉ ¶§¿¡´Â parameter·Î 1À» Àü´ÞÇÏ¿© ƯÁ¤ µ¿ÀÛÀ» Çϵµ·Ï ÇÔ.
        dhr = MonitorStt(DHL_DMX_GetTsd(), ePSIUPDATE_CONTINEOUS, 
                PsiTest_Load_Proc, 1, &s_load_stt);
        if (dhr)
                print("!! monitor stt err %d\n", dhr);
}

void PsiTest_Load_Tvct()
{
        DHL_RESULT dhr;
        if (s_load_tvct) {
                print("tvct already run\n");
                return;
        }
        dhr = MonitorTvct(DHL_DMX_GetTsd(), ePSIMODE_TABLE, ePSIUPDATE_CONTINEOUS, 
                PsiTest_Load_Proc, 2, &s_load_tvct);
        if (dhr)
                print("!! monitor tvct err %d\n", dhr);
}

void PsiTest_Load_Mgt()
{
        DHL_RESULT dhr;
        if (s_load_mgt) {
                print("mgt already run\n");
                return;
        }
        dhr = MonitorMgt(DHL_DMX_GetTsd(), ePSIUPDATE_CONTINEOUS, 
                PsiTest_Load_Proc, 3, &s_load_mgt);
        if (dhr)
                print("!! monitor Mgt err %d\n", dhr);
}

void PsiTest_Load_Eit(UINT16 pid, UINT16 sid)
{
        DHL_RESULT dhr;
        if (s_load_eit) {
                print("eit already run\n");
                return;
        }
        dhr = MonitorEit(DHL_DMX_GetTsd(), pid, sid, ePSIMODE_TABLE,
                ePSIUPDATE_CONTINEOUS, 
                PsiTest_Load_Proc, 4, &s_load_eit);
        if (dhr)
                print("!! monitor Eit err %d\n", dhr);
}

void PsiTest_Stop_Pat()
{
        if (s_load_pat) {
                print("stop pat..\n");
                DHL_PSI_StopMonitor(s_load_pat);
                s_load_pat = 0;
        }
}

void PsiTest_Stop_Stt()
{
        if (s_load_stt) {
                print("stop stt..\n");
                DHL_PSI_StopMonitor(s_load_stt);
                s_load_stt = 0;
        }               
}

void PsiTest_Stop_Tvct()
{
        if (s_load_tvct) {
                print("stop tvct..\n");
                DHL_PSI_StopMonitor(s_load_tvct);
                s_load_tvct = 0;
        }       
}

void PsiTest_Stop_Mgt()
{
        if (s_load_mgt) {
                print("stop mgt..\n");
                DHL_PSI_StopMonitor(s_load_mgt);
                s_load_mgt = 0;
        }       
}

void PsiTest_Stop_Eit()
{
        if (s_load_eit) {
                print("stop eit..\n");
                DHL_PSI_StopMonitor(s_load_eit);
                s_load_eit = 0;
        }       
}

#if COMMENT
____ETT_Test____(){}
#endif

static tDHL_PSI_ControlHandle s_load_ett1, s_load_ett2;

void PsiTest_Ett_Proc(tDHL_PSI_Event event, tDHL_PSI_ControlHandle psiCtl, UINT32 userParam)
{
        DHL_RESULT dhr;
        if (event == ePSIEVENT_DATARECEIVED) {
                tDHL_PSI_DataArray *data;
                UINT8 *ptr; 
                UINT32 etmid;
                
                dhr = DHL_PSI_ReadPSIData(psiCtl, &data);
                if (dhr != DHL_OK) {
                        print("!! read psi data err %d\n", dhr);
                        return;
                }

                ptr = data->sectPtr[0];
                memdump(ptr, 16, "ett");

                memcpy(&etmid, &data->sectPtr[9], 4);

                if (userParam != etmid) {
                        print("!! received etmid(0x%x) is not matched to the etmid(0x%x) of filter\n", etmid, userParam);
                }

                DHL_PSI_FreePSIData(data);
        }
}

void PsiTest_Load_Ett1(UINT16 pid, UINT16 etmid)
{
        DHL_RESULT dhr;
        if (s_load_ett1) {
                print("ett1 already run\n");
                return;
        }
        dhr = MonitorEtt(DHL_DMX_GetTsd(), pid, etmid, ePSIUPDATE_CONTINEOUS, 
                PsiTest_Ett_Proc, etmid, &s_load_ett1);
        if (dhr)
                print("!! monitor ett1 err %d\n", dhr);
}

void PsiTest_Load_Ett2(UINT16 pid, UINT16 etmid)
{
        DHL_RESULT dhr;
        if (s_load_ett2) {
                print("ett2 already run\n");
                return;
        }
        dhr = MonitorEtt(DHL_DMX_GetTsd(), pid, etmid, ePSIUPDATE_CONTINEOUS, 
                PsiTest_Ett_Proc, etmid, &s_load_ett2);
        if (dhr)
                print("!! monitor ett2 err %d\n", dhr);
}

void PsiTest_Stop_Ett1()
{
        if (s_load_ett1) {
                print("stop ett1..\n");
                DHL_PSI_StopMonitor(s_load_ett1);
                s_load_ett1 = 0;
        }       
}

void PsiTest_Stop_Ett2()
{
        if (s_load_ett2) {
                print("stop ett2..\n");
                DHL_PSI_StopMonitor(s_load_ett2);
                s_load_ett2 = 0;
        }       
}


void PsiTest_Load_Stop()
{
        if (s_load_pat) {
                print("stop pat..\n");
                DHL_PSI_StopMonitor(s_load_pat);
                s_load_pat = 0;
        }
        if (s_load_stt) {
                print("stop stt..\n");
                DHL_PSI_StopMonitor(s_load_stt);
                s_load_stt = 0;
        }       
        if (s_load_tvct) {
                print("stop tvct..\n");
                DHL_PSI_StopMonitor(s_load_tvct);
                s_load_tvct = 0;
        }       
        if (s_load_mgt) {
                print("stop mgt..\n");
                DHL_PSI_StopMonitor(s_load_mgt);
                s_load_mgt = 0;
        }       
        if (s_load_eit) {
                print("stop eit..\n");
                DHL_PSI_StopMonitor(s_load_eit);
                s_load_eit = 0;
        }       
        if (s_load_ett1) {
                print("stop ett1..\n");
                DHL_PSI_StopMonitor(s_load_ett1);
                s_load_ett1 = 0;
        }       
        if (s_load_ett2) {
                print("stop ett2..\n");
                DHL_PSI_StopMonitor(s_load_ett2);
                s_load_ett2 = 0;
        }       
        
}

#if COMMENT
____Filters____(){}
#endif

#define MAX_FILTER 256 // ÀÌ ¼ýÀÚ ¸¸Å­ Å×½ºÆ® ÇÒ °ÍÀÓ..

tDHL_PSI_ControlHandle f_handle[MAX_FILTER] = {0, };

void PsiTest_HowManyFilter(UINT32 tsd_id)
{
        DHL_RESULT dhr;
        tDHL_TSD tsd;
        tDHL_PSI_Filter *f = NULL;
        int i;
        UINT16 pid = 0x700; // pid´Â Àß »ç¿ëµÇÁö ¾ÊÀ» ¹ýÇÑ °ÍÀ¸·Î ¼±Á¤.
        
        PsiTestContext ctx;
        
        print("section filter test, try maximum %u filters at a time..\n", MAX_FILTER);
        
        dhr = get_tsd(tsd_id, &tsd);
        CHK_DHR("get tsd");

        memset(f_handle, 0, sizeof(f_handle));

        for (i=0; i<MAX_FILTER; i++)
        {
                f = NULL;
                dhr = DHL_PSI_AllocGenericFilter(&f);
                if (dhr) {
                        print("!! at %u th loop..\n", i);
                        CHK_DHR("alloc filter");
                }
                // table_id_extension 16ºñÆ® °ø°£¿¡ i°ª »ç¿ë.

                // 0   1   2   3   4  5   6  7   8     9
                // tid sec_len tid_ex ver sn lsn proto ..
                f->data[3] = i>>8; f->data[4] = i&0xff;
                f->mask[3] = f->mask[4] = 0xff;
                f->mode[3] = f->mode[4] = 0xff;

                memset(&ctx, 0, sizeof(ctx));
                
                // ¸ð´ÏÅÍ ½ÃÀÛ..
                dhr = DHL_PSI_StartMonitor(tsd, pid,
                        ePSIMODE_SECTION, ePSIUPDATE_ONESHOT, f, 
                        4096, 256, PsiTest_01_Proc, 0, &f_handle[i]);
                if (dhr) {
                        print("!! at %u th loop..\n", i);
                        CHK_DHR("start monitor");
                }
        }
        

errexit:        
        for (i=0; i<MAX_FILTER; i++) {
                if (f_handle[i]) DHL_PSI_StopMonitor(f_handle[i]);
        }
        if (f) DHL_PSI_FreeFilter(f);
}

void PsiTest_FreeAllFilter(void);

void PsiTest_ConsumeFilterExcept(UINT32 num_extra, UINT32 tsd_id)
{
        DHL_RESULT dhr;
        tDHL_TSD tsd;
        tDHL_PSI_Filter *f = NULL;
        int i;
        static int n_flt = 0;
        UINT16 pid = 0x700; // pid´Â Àß »ç¿ëµÇÁö ¾ÊÀ» ¹ýÇÑ °ÍÀ¸·Î ¼±Á¤.
        
        PsiTestContext ctx;
        
        print("section filter test, try maximum %u filters at a time..\n", MAX_FILTER);
        
        dhr = get_tsd(tsd_id, &tsd);
        CHK_DHR("get tsd");

        memset(f_handle, 0, sizeof(f_handle));

        PsiTest_FreeAllFilter();        // ÀÌÀü¿¡ µ¿ÀÛÁßÀÌ´ø ÇÊÅÍ´Â Áß´ÜÇÏ°í »õ·Î ½ÃÀÛ

        for (i=0; i<MAX_FILTER; i++)
        {
                f = NULL;
                dhr = DHL_PSI_AllocGenericFilter(&f);
                if (dhr) {
                        print("!! at %u th loop..\n", i);
                        CHK_DHR("alloc filter");
                }
                // table_id_extension 16ºñÆ® °ø°£¿¡ i°ª »ç¿ë.

                // 0   1   2   3   4  5   6  7   8     9
                // tid sec_len tid_ex ver sn lsn proto ..
                f->data[3] = i>>8; f->data[4] = i&0xff;
                f->mask[3] = f->mask[4] = 0xff;
                f->mode[3] = f->mode[4] = 0xff;

                memset(&ctx, 0, sizeof(ctx));
                
                // ¸ð´ÏÅÍ ½ÃÀÛ..
                dhr = DHL_PSI_StartMonitor(tsd, pid,
                        ePSIMODE_SECTION, ePSIUPDATE_ONESHOT, f, 
                        4096, 256, PsiTest_01_Proc, 0, &f_handle[i]);
                if (dhr) {
                        print("!! at %u th loop..\n", i);
                        CHK_DHR("start monitor");
                }
                else 
                        n_flt++;
        }
        

errexit:        
        for (i = 0; i < num_extra; i++) {
                if (f_handle[i]) 
                        DHL_PSI_StopMonitor(f_handle[i]);
                n_flt--;
        }
        if (f) DHL_PSI_FreeFilter(f);

        print("%d filters are enable to use..\n", num_extra);

        dhl_psi_show();
}

void PsiTest_FreeAllFilter()
{
        int i;
        for (i = 0; i < MAX_FILTER; i++) {
                if (f_handle[i]) DHL_PSI_StopMonitor(f_handle[i]);
        }
}

PsiTest_SWFilter()
{
        DHL_RESULT check_sw_filter(tDHL_PSI_Filter* pFilter, UINT8* buf, int len);

        tDHL_PSI_Filter filter1 = {
                /*data*/
                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                0x00, 0x00, 0x00, 0x00, 0x00,
                /*mask*/
                0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                0x00, 0x00, 0x00, 0x00, 0x00,
                /*mode*/
                0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                0x00, 0x00, 0x00, 0x00, 0x00
        };

        tDHL_PSI_Filter filter2 = {
                /*data*/
                0xc7, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 
                0x00, 0x00, 0x00, 0x00, 0x00,
                /*mask*/
                0xff, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 
                0xff, 0x00, 0x00, 0x00, 0x00,
                /*mode*/
                0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                0xff, 0x00, 0x00, 0x00, 0x00
        };

        // ÇÊÅÍ¿Í ÀÏÄ¡µÇ´Â Å×ÀÌºí ¿¹Á¦
        // ½ÇÁ¦ ½ºÆ®¸²À¸·Î ºÎÅÍ ÃßÃâÇÑ ³»¿ëÀÓ
        UINT8 t_table1[] = {
                0x00, 0xb0, 0x11, 0x08, 0x11, 0xc9, 0x00, 0x00, 
                0x00, 0x02, 0xe0, 0x20, 0x00, 0x63, 0xe0, 0x30,
                0x3f, 0x33, 0x40, 0x4d
        };

        // ÇÊÅÍ¿¡ ºÎÇÕÇÏÁö ¾Ê´Â Å×ÀÌºí ¿¹Á¦
        // ½ÇÁ¦ ½ºÆ®¸²À¸·Î ºÎÅÍ ÃßÃâÇÑ ³»¿ë¿¡ pid¸¸ ´Ù¸£°Ô Á¶ÀÛ
        UINT8 t_table2[] = {
                0x01, 0xb0, 0x11, 0x08, 0x11, 0xc9, 0x00, 0x00, 
                0x00, 0x02, 0xe0, 0x20, 0x00, 0x63, 0xe0, 0x30,
                0x3f, 0x33, 0x40, 0x4d
        };

        UINT8 t_table3[] = {
                0xc7, 0xf0, 0x11, 0x00, 0x00, 0xc9, 0x00, 0x00, 
                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                0x00, 0x00, 0x00, 0x00
        };

        DHL_OS_Printf("\n\ncheck_sw_filter test start..\n\n");

        // À߸øµÈ ¼½¼ÇÀ» Á¦´ë·Î °ËÃâÇÏÁö ¸øÇÏ´Â °ÍÀº ¾Æ´ÑÁö °Ë»ç
        if (check_sw_filter(&filter1, t_table2, ((t_table2[1]&0x0f)<<8)|t_table2[2]) == DHL_OK) 
                DHL_OS_Printf("!! check_sw_filter didn't filter out incorrect section!!\n");
        
        // Á¤»óÀûÀÎ ¼½¼ÇÀ» À߸øµÈ ¼½¼ÇÀ¸·Î ÆÇ´ÜÇÏ´Â °ÍÀº ¾Æ´ÑÁö °Ë»ç
        if (check_sw_filter(&filter1, t_table1, ((t_table1[1]&0x0f)<<8)|t_table1[2]) == DHL_FAIL)
                DHL_OS_Printf("!! check_sw_filter missed correct section!!\n");

        // ´Ù¸¥ ¹öÀüÀÇ Å×À̺íÀ» Àß Ã£¾Æ³»´ÂÁö °Ë»ç
        if (check_sw_filter(&filter2, t_table3, ((t_table3[1]&0x0f)<<8)|t_table3[2]) == DHL_FAIL)
                DHL_OS_Printf("!! check_sw_filter missed version change!!\n");
                
        DHL_OS_Printf("\n\ncheck_sw_filter test end..\n\n");
        
}


#if COMMENT
____Test_1____(){}
#endif

#include "DHL_DBG.h"

static DHL_SymbolTable PsiTestSymbols[] =
{
        //---- functions
        
        DHL_FNC_SYM_ENTRY(OS_DelayTest),
        DHL_FNC_SYM_ENTRY(OS_TaskTest),
        DHL_FNC_SYM_ENTRY(OS_MultiTaskTest),
        DHL_FNC_SYM_ENTRY(OS_HowManyTaskTest),
        DHL_FNC_SYM_ENTRY(OS_TaskSelfDeleteTest),
        DHL_FNC_SYM_ENTRY(OS_InterruptTest),
        DHL_FNC_SYM_ENTRY(OS_ISRTest_Loop),
        DHL_FNC_SYM_ENTRY(OS_ISRTest),
        DHL_FNC_SYM_ENTRY(OS_GetCharTest),
};

void PsiTestInit()
{
        DHL_DBG_RegisterSymbols(PsiTestSymbols, DHL_NUMSYMBOLS(PsiTestSymbols));


}