/* 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 /* 테스트 방법: 모든 테스트 함수는 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= 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; inumSections; 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; knumPrograms; 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; idata[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; idata[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)); }