/* DMW_ChannelAV.c DMW Middleware Channel AV decoding Module Digital STERAM Technology, Inc. */ #include "DMW_Platform.h" #include "DHL_OSAL.h" #include "DHL_Demux.h" #include "DHL_SYS.h" #include "DHL_AVCAP.h" #include "DHL_DBG.h" #define VideoContextIsAnalog(x) FALSE #define DHL_AV_IsDigitalContext(x) TRUE #define SETRECT(rect, xx, yy, ww, hh) { \ (rect)->x = (xx); \ (rect)->y = (yy); \ (rect)->w = (ww); \ (rect)->h = (hh); \ } //#endif #include "DMW_Config.h" #include "DMW_Status.h" #include "DMW_Channel.h" #include "dmw_channel_priv.h" #include "DMW_ChannelDemux.h" #include "DMW_ChannelUtil.h" #include "DMW_ChannelPM.h" // Performance monitor #include "DMW_Timer.h" //#include DHL_MODULE("$dmc", 2); #if COMMENT ____Config____(){} #endif // 1 이면 video unhide 처리를 seqhdr 수신 이후로 미룸. // 현재는 1만 테스트 되고 있음. // #define DMC_DELAYED_VIDEO_SHOW 1 // cafrii 071031 add // // Config Param: TRUE or FALSE // // 1 이면 프로그램이 갑자기 사라진 경우 // 다른 프로그램으로 retry 하지 않고 완전히 정지 시킨다. // #define DMC_STOP_WHEN_PROGRAM_DISAPPEAR 0 // cafrii 100705 add // 새로운 DHL API 인터페이스로 인한 변경 #define NEW_DHL_API 1 #if 0 // NEW_DHL_API // // // Config Param: TRUE or FALSE // // TRUE 이면 waited audio start 함수를 사용한다. // 실제로 pid만 있고 audio ES가 없는 bad stream의 경우 // audio only check를 쉽게 수행할 수 있다. 그러나 channel tuning 속도는 떨어진다. // // cafrii 070528 chagne // audio가 없는 stream 체크를 하기 위해서 1로 설정. // // cafrii 080910 // audio frame count check api 제공 전까지 0으로.. // cafrii 080923, set to 1 // // cafrii 081222 set to 0. // audio recovery code가 별도로 제공 안되므로 0. // driver 안정성에 문제가 없다면 0을 사용하는 것이 더 좋음. // int dmc_bUseAudioStartWait = 0; #endif // // Config Param: TRUE or FALSE // // 테스트 변수 // // TRUE 이면 PsiMonitor를 사용하지 않는다. // Psi monitor를 다른 task에서 담당할 경우에 유용하게 사용할수있음. // int gDmcTestNoPsiMonitor = 0; char *gDmcStringNoPsiMonitor = "******** !!!! DmcTest: PsiMonitor disabled !!!! ************\n"; // // Config Param: 0 / 1 // // 이 flag가 1이면 Audio를 재생하지 않는다. (테스트 용도) // int dmc_bRunWithoutAudio; // // Config Param: 0 / 1 // // 이 flag가 1이면 Video를 재생하지 않는다. (테스트 용도) // int dmc_bRunWithoutVideo; // // Config Param: psiVersionChange (2) or psiCRCChange (3) // // PSI Monitor를 시작할 때 사용될 update mode // // DMC에서는 Channel tuning이 종료되면 Psi monitor를 시작하는데 // 이때 지정하는 update mode이다. 일반적으로 version change를 사용하지만 // CRC change가 더 다양한 변경 사항을 수신할 수 있다는 의견이 있어서 // CRC change를 사용하고 있다. // // cafrii 101208 change // pat는 crc change를, pmt는 version change 사용. // 스트림이 변경될 때 버전은 동일하면서 내용이 다른 경우에 대응하기 위함. // pat가 새로 갱신되면 pmt는 다시 시작하므로 pmt는 그냥 ver change도 괜찮을 듯.. // tDHL_PSI_Update dmc_PatUpdateMode = ePSIUPDATE_CRCCHANGE; tDHL_PSI_Update dmc_PmtUpdateMode = ePSIUPDATE_VERCHANGE; // // Config Param: TRUE or FALSE // // PSI (Pat/Pmt) Change event 발생시 "동등"한 Psi를 무시할것인지 여부 // // TRUE이면 PSI change event가 발생했어도 equivalent PSI라면 // 적용하지 않는다. // PMT Equivalence 조건: 각종 Elementary stream들의 PID가 같은 경우 // PAT Equivalence 조건: program number, PMT PID가 동일한 경우 // BOOL dmc_bIgnoreEquivPat = TRUE; BOOL dmc_bIgnoreEquivPmt = TRUE; // // Config Param: TRUE or FALSE // // PSI (Pat/Pmt) Change event 발생시 "동등"한 Psi를 무시할것인지 여부 // // TRUE이면 audio를 시작할 때 임시 mute를 걸고 // 나중에 video가 나오기 시작할 때 임시 mute를 풀어서 동기화 시킨다. // // 여기서 사용하는 audio mute는 사용자의 audio mute, rating block mute등과 // 겹치지 않도록 독립적인 mute API를 사용해야 한다. // // cafrii 080923, // video freeze event not support. so disable this. // for av_sync_start to work correctly, // freeze_end_event and audio_temp_mute should be supported. // // cafrii 100810, add for newby // BOOL dmc_bAudioVideoSyncStart = TRUE; //----------------------------------------------------------- #if COMMENT ____Types____(){} #endif //----------------------------------------------------------- #if COMMENT ____Variables____(){} #endif DMC_FN_USERDATA _Dmc_UserDataProc; // // 이 함수 포인터가 유효하면 UserData가 발견될 때 이 함수를 호출한다. // CC module이 initialize될 때 이 함수 포인터를 초기화 하면 된다. int dmc_nPmtChangeRetryCount; // PmtChange 도중에 에러가 날때 1씩 증가하고 다시 재 시도 한다. int dmc_LimitPmtChangeRetryCount = 3; // 이 이상으로 error가 나면 PmtChange는 포기한다. //----------------------------------------------------------- // PSI Management // // 디지털 채널의 AV decoding 이 동작중일 때 현재 채널의 PAT/PMT는 항상 감시를 하고 // 마지막 Table instance는 보관이 되어 있다. //MPEG_PAT *av->pat = NULL; //MPEG_PMT *av->pmt = NULL; // Dmc task에서는 PAT와 PMT에 대해서 Monitoring을 수행한다. // 따라서 이 PsiCtl들이 작동중일 경우에는 GetPAT나 GetPMT가 동작하지 않는다. // StartDigital() 에서부터 StopDigital()이 불릴때까지 monitor가 동작한다. // // 이 구간중에 꼭 GetPAT/PMT()를 사용할 필요가 있을때는 // PausePsiMonitor/ResumePsiMonitor를 사용하도록 하자. // //PSIControl *av->patPsiCtl = NULL; //PSIControl *av->pmtPsiCtl = NULL; //tDHL_VideoSeqHdr dmc_SeqHdr; // 현재 디코딩 되고 있는 Video stream의 sequence header 정보 //----------------------------------------------------------- // 아래 변수들은 모두 mutex lock 상태에서 접근해야 한다. // static ProgramAVInfo s_programinfo; // // 현재 시청중인 프로그램에 대한 정보 // DHL_OS_SEMA_ID dmc_psiSema4; // // av->pat/pmt, pat/pmt psi control 등의 변수를 보호하는 mutex DHL_OS_SEMA_ID dmc_avSema4; // BOOL dmc_bWaitFirstFreezeVideoEndEvent = FALSE; // video를 처음 시작하면 이 변수를 set하고 // 처음 freeze end가 왔을때 callback을 해준다. DMC_FN_NOTIFY _Dmc_Notify; // // application으로 notify 하기 위한 callback 함수. // notify 되는 event들.. DMC_FN_NOTIFY _Dmc_DecodeStartCallback; DMC_FN_NOTIFY _Dmc_DecodeStopCallback; // 1394 PTS를 위한 callback handler. // // 디코딩 처음 시작시 PMT가 새로 수신되었을 때, // 디코딩이 진행 중에 PMT가 새로 update되었을 때에 불린다. // // param1 : 현재 디코딩 중인 프로그램의 program number // param2 (bThisPmtIsIgnoredInDmc) : DMC에서 이 PMT가 ignore된 것이라면 TRUE // DMC에서 ignore가 되었더라도 callback은 불린다. // // DecodeStopCallback은 VideoStop이 될 때 불리는 callback으로 PTS 중지 작업 등을 위함이다. // 이 callback의 parameter는 아직 undefined 이다. UINT8 dmc_bRequestVideoHide; // 비디오 Hide request가 들어오면 이 flag가 TRUE이다. // // BOOL 에서 UINT8 로 변경 하였으며, bit flag로 사용한다. #define TIMER_ID_AUDIO_TEMPMUTE_LIMIT 9191 // 다른 id와 겹치면 안되니 app 에서 관리하는 것이 좋은데.. // 일단 이곳에서 임의 값 정해서 사용하기로 함. int g_AudioTempMuteLimitMs = 3000; // av sync start 기능에서 혹시 video에 문제가 있어서 audio temp unmute를 하지 못하는 // 문제에 대비하기 위해서 timeout을 걸어두는데, 그 timeout 시간. // 단위는 millisec. // #if COMMENT ________Debug________(){} #endif BOOL g_Trace_bDmcPsiEvent = 0; // PAT/PMT Hanlder에 관련된 메시지.. 이 flag는 TRUE/FALSE 만 지정 가능. // 이 trace flag는 g_Trace_DmcMain 에 의해 다시한번 check 되기 때문에 // true를 하더라도 g_Trace_DmcMain이 낮은 값이면 출력이 되지 않을 수 있음. // 현재 video format을 알아내는 utility // void Dmc_ShowSeqHeader(int level, tDHL_VideoSeqHdr *seq) { char *chroma[4] = { "Unknown", "4:2:0", "4:2:2", "4:4:4" }; if (seq == NULL) return; dprint(level, "tDHL_VideoSeqHdr %x, %s format\n", seq); dprint(level, "\thorz: %d, vert:%d, framerate %5.2f, aspect_ratio %d (%s)\n", seq->horizontal_size, seq->vertical_size, seq->frame_rate, seq->aspect_ratio_information, DHL_AV_IsWideoFormat(seq) ? "wide" : "narrow"); dprint(level, "\tbitrate %d, vbv buffer %d, constrained param %d, MPEG%d\n", seq->bit_rate, seq->vbv_buffer_size, seq->constrained_parameter_flag, seq->MPEG2 ? 2 : 1); dprint(level, "\tprofile %d, %s, chroma %s, low delay %d\n", seq->profile_and_level_indication, seq->progressive_sequence ? "progressive" : "interlace", chroma[seq->chroma_format & 3], seq->low_delay); } STATUS Dmc_PrintVideoFormat(int level, BOOL bDisplayBrief) { tDHL_VideoSeqHdr seq; BOOL bWide; DHL_RESULT dhlResult = DHL_AV_VideoSeqInfo(0, &seq); if (dhlResult) { dprint(0, "!! Dmc_PrintVideoFormat: no valid seq hdr.\n"); return statusError; } bWide = DHL_AV_IsWideoFormat(&seq); if (bDisplayBrief) { dprint(level, "\tsource: %4dx%4d %c %5.2fHz %s\n", seq.horizontal_size, seq.vertical_size, seq.progressive_sequence ? 'p' : 'i', seq.frame_rate, bWide ? "wide" : "narrow"); } else { Dmc_ShowSeqHeader(level, &seq); } return (STATUS)0; } void Dmc_PrintProgramInfo(int dbglevel) { ProgramAVInfo *av = Dmc_LockAVMutex(); // cafrii 041103 add 'dbglevel' argument if (av->active) { dprint(dbglevel, "\t%s \n", av->analog ? "Analog" : "Digital"); if (av->analog) { if (av->input_video == eDHL_CAP_NTSC0_VIDEO || av->input_video == eDHL_CAP_NTSC1_VIDEO) dprint(dbglevel, "\tNTSC, RF: %d\n", av->rf); else dprint(dbglevel, "\tExt, video %d, audio %d\n", av->input_video, av->input_audio); } else if (av->method == TUNE_METHOD_ByPIDs) dprint(dbglevel, "\tRF %d, Method: by PIDs, #%d, p%d v%d a%d\n", av->rf, av->program_number, av->pcr_pid, av->video_pid, av->audio_pid); else if (av->method == TUNE_METHOD_ByCVCT) dprint(dbglevel, "\tRF %d, Method: by CVCT, %d-%d, #%d, p%d v%d a%d\n", av->rf, av->major, av->minor, av->program_number, av->pcr_pid, av->video_pid, av->audio_pid); else if (av->method == TUNE_METHOD_ByTVCT) dprint(dbglevel, "\tRF %d, Method: by TVCT, %d-%d, #%d, p%d v%d a%d\n", av->rf, av->major, av->minor, av->program_number, av->pcr_pid, av->video_pid, av->audio_pid); else if (av->method == TUNE_METHOD_ByPSI) dprint(dbglevel, "\tRF %d, Method: by PSI, #%d, p%d v%d a%d\n", av->rf, av->program_number, av->pcr_pid, av->video_pid, av->audio_pid); else dprint(dbglevel, "\tUnknown method!\n"); } else dprint(dbglevel, "\tNot tuned!! (inactive)\n"); dprint(dbglevel, "\tfreeze %s, hidden %s\n", av->video_freezed ? "ON" : "Off", av->video_hidden ? "ON" : "Off"); dprint(dbglevel, "\tpat 0x%x, pmt 0x%x\n", av->pat, av->pmt); #if USE_CH_MW_ALL_PMT_DOWNLOAD if (1) { int i; for (i=0; av->pat && av->pmtList && ipat->numPrograms; i++) dprint(dbglevel, "\t pmt[%d] 0x%x\n", i, av->pmtList[i]); } #endif dprint(dbglevel, "\tpatPsiCtl 0x%x, pmtPsiCtl 0x%x\n", av->patPsiCtl, av->pmtPsiCtl); #if USE_CH_MW_ALL_PMT_DOWNLOAD dprint(dbglevel, "\t pmtPsiCtl2 0x%x\n", av->pmtPsiCtl2); #endif dprint(dbglevel, "\tFN_Notify %x\n", _Dmc_Notify); Dmc_UnlockAVMutex(); } #if COMMENT _______Utils________(){} #endif /* DMC tuning task의 핵심 정보 구조체인 ProgramAVInfo 정보를 참조할 때는 lock/unlock을 해야 한다. */ ProgramAVInfo *Dmc_LockAVMutex() { DHL_OS_TakeSemaphore(dmc_avSema4, DHL_TIMEOUT_FOREVER); return &s_programinfo; } void Dmc_UnlockAVMutex(void) { DHL_OS_GiveSemaphore(dmc_avSema4); } // Dmc_GetCurrentProgramInfo // DMC 의 Program 정보를 넘겨준다. // Program은 DMC의 각종 상태 정보가 들어있는 아주 중요한 정보이다. // void Dmc_GetCurrentProgramInfo(ProgramAVInfo *av1) { ProgramAVInfo *av2 = Dmc_LockAVMutex(); memcpy(av1, av2, sizeof(ProgramAVInfo)); Dmc_UnlockAVMutex(); } // Dmc_GetCurrentProgramNumber // 현재 디코딩 중인 Program number를 되돌려준다. // Program 정보를 이용해서 알 수도 있다. // 0이면 프로그램 번호를 알수 없는 상태를 의미한다. // int Dmc_GetCurrentProgramNumber() { int program_number; ProgramAVInfo *av = Dmc_LockAVMutex(); if (av->active) { if (av->analog) program_number = 0; // 아날로그 상태에서 program number는 의미가 없음. else program_number = av->program_number; } else program_number = 0; // decoder가 정지 상태에서도 program number는 의미가 없음. Dmc_UnlockAVMutex(); return program_number; } // Dmc_GetVideoSequenceHeader // Video sequence header 정보를 넘겨준다. // 없으면 FALSE를 리턴한다. // BOOL Dmc_GetVideoSequenceHeader(tDHL_VideoSeqHdr *pSeq) { DHL_RESULT dhlResult; if (pSeq == NULL) return FALSE; dhlResult = DHL_AV_VideoSeqInfo(0, pSeq); return dhlResult ? FALSE : TRUE; } #if COMMENT _______ProgramInfo________(){} #endif void doDmc_ClearProgramInfo() { ProgramAVInfo *av = Dmc_LockAVMutex(); av->active = FALSE; Dmc_UnlockAVMutex(); } // // tuning이 끝난 후에 현재 상태를 Program 구조체에 저장한다. // void doDmc_UpdateProgramInfoDigital(int rf, ModulationType mod, TUNE_METHOD method, int major, int minor, int program_number, UINT16 vidPid, UINT16 audPid, UINT16 pcrPid, tDHL_VideoCodingType vidType, tDHL_AudioCodingType audType) { ProgramAVInfo *av = Dmc_LockAVMutex(); av->active = TRUE; av->analog = FALSE; // digital av->rf = rf; av->mod = mod; av->method = method; av->major = major; av->minor = minor; av->program_number = program_number; av->video_pid = vidPid; av->audio_pid = audPid; av->pcr_pid = pcrPid; av->video_type = vidType; av->audio_type = audType; av->input_video = eDHL_CAP_DTV_TS0; av->input_audio = eDHL_CAP_DTV_TS0_AUDIO; Dmc_UnlockAVMutex(); } void doDmc_UpdateProgramInfoAnalog(int rf, tDHL_CapVideoInput video, tDHL_CapAudioInput audio) { ProgramAVInfo *av = Dmc_LockAVMutex(); av->active = TRUE; av->analog = TRUE; av->rf = rf; av->mod = Modulation_NTSC; av->input_video = video; av->input_audio = audio; av->method = TUNE_METHOD_NONE; av->major = 0; av->minor = 0; av->program_number = 0; Dmc_UnlockAVMutex(); } // // // 새롭게 수신한 pat/pmt를 AVINFO에 저장한다. // void doDmc_UpdatePsiInfo(MPEG_PAT *pat, MPEG_PMT *pmt) { ProgramAVInfo *av = Dmc_LockAVMutex(); #if DMC_CHECK_HEAP_SIZE UINT32 heap_before; #endif if (pat) { if (av->pat) { #if USE_CH_MW_ALL_PMT_DOWNLOAD // pat가 새롭게 갱신하면 모든 pmt 들도 다 replace 되도록 한다. int i; for (i=0; ipat->numPrograms; i++) { if (av->pmtList[i]) { //dprint(2, "######## free pmt[%d] %x\n", i, av->pmtList[i]); FreePMT(av->pmtList[i]); } } if (av->pat->numPrograms != pat->numPrograms) { dprint(2, "num programs changed %d -> %d\n", av->pat->numPrograms, pat->numPrograms); DHL_OS_Free((void **)&av->pmtList); } #endif #if DMC_CHECK_HEAP_SIZE heap_before = DHL_GetFreeHeapSize(0); #endif FreePAT(av->pat); // tuning에 성공하면 pat/pmt에 바로 update한다. #if DMC_CHECK_HEAP_SIZE dprint(3, "free prev pat %x, heap %u->%u\n", av->pat, heap_before, DHL_GetFreeHeapSize(0)); #else dprint(3, "free prev pat %x\n", av->pat); #endif } av->pat = pat; #if USE_CH_MW_ALL_PMT_DOWNLOAD if (av->pmtList == NULL) av->pmtList = DHL_OS_Malloc(av->pat->numPrograms * sizeof(MPEG_PMT *)); if (av->pmtList == NULL) dprint(0, "!! out of mem for pmtlist\n"); else memset(av->pmtList, 0, av->pat->numPrograms * sizeof(MPEG_PMT *)); #endif } if (pmt) { if (av->pmt) { #if DMC_CHECK_HEAP_SIZE heap_before = DHL_GetFreeHeapSize(0); #endif FreePMT(av->pmt); #if DMC_CHECK_HEAP_SIZE dprint(3, "free prev pmt %x, heap %u->%u\n", av->pmt, heap_before, DHL_GetFreeHeapSize(0)); #else dprint(3, "free prev pmt %x\n", av->pmt); #endif } av->pmt = pmt; } Dmc_UnlockAVMutex(); } #if COMMENT ____EventProc____(){} #endif static void _Dmc_SendDecodeEvent(DmcMsgType msgtype, UINT32 userParam) { STATUS status; status = Dmc_SendCommandEx(msgtype, userParam, NULL, FALSE, // "NO" wait for complete NULL, 0, // user callback¶m FALSE); // do not cancel previous command if (status) dprint(0, "!! send event err %d\n", status); // send message에 에러 발생시 특별히 에러처리를 할 일은 없다 } //----------------------------------------------------------------------------- // 아래 _Dmc_xxx 콜백 함수들은 driver task에서 바로 불리기 때문에 // high priority 이고, 이곳에서 많은 일을 하지 않도록 한다. // void _Dmc_PatEventProc(tDHL_PSI_Event psiEvent, tDHL_PSI_ControlHandle psiCtl, UINT32 userParam) { STATUS status; DHL_RESULT err; tDHL_PSI_DataArray *desc; MPEG_PAT *pat; DmcMessage msg; #if DMC_CHECK_HEAP_SIZE UINT32 heap_before; #endif // comment: userParam은 사용되지 않는다. memset(&msg, 0, sizeof(msg)); if (psiEvent == ePSIEVENT_DATARECEIVED) { // data recieved event는 debug print하지 않는다. // err = DHL_PSI_ReadPSIData(psiCtl, &desc); if (err) { dprint(0, "_Dmc_PatEventProc: DHL_PSI_ReadPSIData returned %s\n", ErrorString(err)); return; } #if DMC_CHECK_HEAP_SIZE heap_before = DHL_GetFreeHeapSize(0); #endif err = ParsePAT(desc, &pat); DHL_PSI_FreePSIData(desc); if (IsError(err)) { // cafrii 050315 change dprint(0, "_Dmc_PatEventProc: ParsePAT returned %s\n",ErrorString(err)); return; } #if 0 // cafrii 060303 // 이제부터는 pat/pmt에 접근하기 위해서는 mutex를 lock 해야 하는데, // 이 task에서 lock을 하는 것은 위험할 수 있다. // descriptor 자체를 저장하는 다른 방법을 고려해보도록 하자. // Note!! // 이 태스크는 TSDXX 로 Dmc task가 아니기 때문에 pat/pmt를 여기서 참조하는 것은 // 안전하지 못할 수도 있다.. // if (Dmc_CheckIfSamePat(pat, av->pat)) { // cafrii 040529 add if (av->pmt && av->pmtPsiCtl) { // cafrii 040604 add av->pmtPsiCtl if (g_Trace_bDmcPsiEvent) dprint(2, "_Dmc_PatEventProc: Same PAT\n"); FreePAT(pat); return; } else { //if (g_Trace_bDmcPsiEvent) // dprint(2, "_Dmc_PatEventProc: Same PAT.. notify to DMC\n"); // PMT가 없는 경우에는 비록 같은 PAT가 수신되었다 하더라도 Dmc에 알려줘야 한다. } } #endif if (g_Trace_bDmcPsiEvent) { #if DMC_CHECK_HEAP_SIZE dprint(2, "New PAT: TSID %d, v%d, %d programs, 0x%x, heap: %u->%u\n", pat->transport_stream_id, pat->version_number, pat->numPrograms, pat, heap_before, DHL_GetFreeHeapSize(0)); #else dprint(2, "New PAT: TSID %d, v%d, %d programs\n", pat->transport_stream_id, pat->version_number, pat->numPrograms); #endif } } else { // cafrii 030901, add if (g_Trace_bDmcPsiEvent) { if (psiEvent != ePSIEVENT_LOSTPACKET) dprint(3, "_Dmc_PatEventProc: psiEvent %s\n", DHL_PSIEventString(psiEvent)); } return; } status = Dmc_SendCommandEx(evtPatChange, (UINT32)pat, (DMC_FN_CANCELFREE)FreePAT, FALSE, // "NO" wait for complete NULL, 0, // user callback¶m FALSE); // do not cancel previous command if (status) { // DMC Q가 overflow되어 들어가지 않았기 때문에 // 할당한 테이블을 삭제해서 메모리 누수를 막는다 if (g_Trace_bDmcPsiEvent) dprint(0, "!!_Dmc_PatEventProc: DmcQ full\n"); //neverdai. 081110 위 함수에서 에러가 생기면 FreePAT를 호출하기 때문에 //따로 FreePAT를 호출하면 문제 생길 수 있음. //FreePAT(pat); } } void _Dmc_PmtEventProc(tDHL_PSI_Event psiEvent, tDHL_PSI_ControlHandle psiCtl, UINT32 userParam) { STATUS status; DHL_RESULT err; tDHL_PSI_DataArray *desc; MPEG_PMT *pmt; DmcMessage msg; #if DMC_CHECK_HEAP_SIZE UINT32 heap_before; #endif // comment: userparam은 사용되지 않는다. memset(&msg, 0, sizeof(msg)); if (psiEvent == ePSIEVENT_DATARECEIVED) { err = DHL_PSI_ReadPSIData(psiCtl, &desc); if (err) { dprint(0, "_Dmc_PmtEventProc: DHL_PSI_ReadPSIData returned %s\n",ErrorString(err)); return; } #if DMC_CHECK_HEAP_SIZE heap_before = DHL_GetFreeHeapSize(0); #endif err = ParsePMT(desc, &pmt); DHL_PSI_FreePSIData(desc); if (IsError(err)) { // cafrii 050315 change dprint(0, "_Dmc_PmtEventProc: ParsePMT returned %s\n",ErrorString(err)); return; } #if 0 // cafrii 060303 // 이제부터는 pat/pmt에 접근하기 위해서는 mutex를 lock 해야 하는데, // 이 task에서 lock을 하는 것은 위험할 수 있다. // descriptor 자체를 저장하는 다른 방법을 고려해보도록 하자. // Note!! // 이 태스크는 TSDXX 로 Dmc task가 아니기 때문에 av->pat/pmt를 여기서 참조하는 것은 // 안전하지 못할 수도 있다.. // if (Dmc_CheckIfSamePmt(pmt, av->pmt)) { if (g_Trace_bDmcPsiEvent) dprint(2, "_Dmc_PmtEventProc: Same PMT\n"); FreePMT(pmt); return; } #endif if (g_Trace_bDmcPsiEvent) { #if DMC_CHECK_HEAP_SIZE dprint(2, "New PMT: PID %d, #%d, v%d, PCR %d, 0x%x, heap %u->%u\n", pmt->PID, pmt->program_number, pmt->version_number, pmt->PCR_PID, pmt, heap_before, DHL_GetFreeHeapSize(0)); #else dprint(2, "New PMT: PID %d, #%d, v%d, PCR %d\n", pmt->PID, pmt->program_number, pmt->version_number, pmt->PCR_PID); #endif } } else { // cafrii 030918, add if (g_Trace_bDmcPsiEvent) { if (psiEvent != ePSIEVENT_LOSTPACKET) dprint(3, "_Dmc_PmtEventProc: psiEvent %s\n",DHL_PSIEventString(psiEvent)); } return; } status = Dmc_SendCommandEx(evtPmtChange, (UINT32)pmt, (DMC_FN_CANCELFREE)FreePMT, FALSE, // "NO" wait for complete NULL, 0, // user callback¶m FALSE); // do not cancel previous command if (status) { // DMC Q가 overflow되어 들어가지 않았기 때문에 // 할당한 테이블을 삭제해서 메모리 누수를 막는다 if (g_Trace_bDmcPsiEvent) dprint(0, "!!_Dmc_PmtEventProc: DmcQ full\n"); //neverdai. 081110 위 함수에서 에러가 생기면 FreePAT를 호출하기 때문에 //따로 FreePAT를 호출하면 문제 생길 수 있음. //FreePMT(pmt); } } #if 0 // remove old callback function BOOL _Dmc_UserDataCallback(TLVideoContext *context, UINT32 userParam) { if (_Dmc_UserDataProc) _Dmc_UserDataProc(context); return FALSE; } /* * _Dmc_ImportantVideoChangeEvent is called directly in response to a videoImportantChange event * from the video driver task. We do most of the work by sending * a decode event in a message queue which causes handleImportantVideoChange to be called in the * lower priority video control task. This function needs to return TRUE only in outtput=input * mode when we know that handleImportantVideoChange will change the format anyway. Otherwise * it returns false meaning that the high-level video driver code should handle the format * change for a fixed output format. Performing this check in both tasks avoides changing the * format twice. We should not modify the current TL850VideoDisplay or timing from within the * video driver task. */ BOOL _Dmc_ImportantVideoChangeCallback(TLVideoContext *context, UINT32 userParam) { if (VideoContextIsAnalog(context)) return FALSE; // Don't worry about analog contexts // videoUserProc에서 importantChange event가 수신된 경우 이 함수가 불린다. // // 리턴값의 의미: (bProcessed) // TRUE이면 event 처리가 끝났으므로 driver에서 아무 일도 하지 말라는 의미. // application에서 대응을 하겠다 // FALSE를 리턴하면 driver가 알아서 대응한다. // // NaturalMode를 지원하지만 여러가지 리소스 문제 (pixmap plane등)로 // 바로 해상도를 변경하기 어려운 경우가 많다. (예: OSD가 떠있는 경우) // 그래서 일단 driver로 하여금 최소한의 대응만을 하도록 한다. // 나중에 적절한 상황이 되면 (OSD가 exit되는 등), application에서 천천히 // Resolution change를 하면 된다. // _Dmc_SendDecodeEvent(evtVideoImportantChange, userParam); // jump to doDmc_HandleImportantVideoChange return FALSE; } BOOL _Dmc_UserVideoChangeCallback(TLVideoContext *context, UINT32 userParam) { // driver에서 수행하는 코드를 잘 보고 // 만약 그 밖의 추가 작업을 하고 싶을 경우 아래와 같이 low priority task로 // 작업을 미뤄 수행하도록 한다. // _Dmc_SendDecodeEvent(evtVideoUserChange, userParam); // jump to doDmc_HandleUserChange return FALSE; } BOOL _Dmc_MajorVideoChangeCallback(TLVideoContext *context, UINT32 userParam) { _Dmc_SendDecodeEvent(evtVideoMajorChange, userParam); // jump to doDmc_HandleMajorVideoChange return FALSE; } // cafrii 060721 add BOOL _Dmc_VideoScrambledCallback(TLVideoContext *context, UINT32 userParam) { _Dmc_SendDecodeEvent(evtVideoScrambled, userParam); // jump to doDmc_HandleVideoScrambled return FALSE; } BOOL _Dmc_AudioInfoCallback(void *info, UINT32 userParam) { // note that this event is called directly from driver task. // don't do any heavy job in this callback. doDmc_Notify(DMW_NOTIFY_AudioInfo, 0); return FALSE; } #else // remove old callback function BOOL _Dmc_VideoFreezeEndCallback(TLVideoContext *context, UINT32 userParam) { _Dmc_SendDecodeEvent(evtFreezeVideoEnd, userParam); // jump to doDmc_HandleFreezeVideoEnd return FALSE; } BOOL _Dmc_ImportantVideoChangeCallback(TLVideoContext *context, UINT32 userParam) { if (VideoContextIsAnalog(context)) return FALSE; // Don't worry about analog contexts // videoUserProc에서 importantChange event가 수신된 경우 이 함수가 불린다. // // 리턴값의 의미: (bProcessed) // TRUE이면 event 처리가 끝났으므로 driver에서 아무 일도 하지 말라는 의미. // application에서 대응을 하겠다 // FALSE를 리턴하면 driver가 알아서 대응한다. // // NaturalMode를 지원하지만 여러가지 리소스 문제 (pixmap plane등)로 // 바로 해상도를 변경하기 어려운 경우가 많다. (예: OSD가 떠있는 경우) // 그래서 일단 driver로 하여금 최소한의 대응만을 하도록 한다. // 나중에 적절한 상황이 되면 (OSD가 exit되는 등), application에서 천천히 // Resolution change를 하면 된다. // _Dmc_SendDecodeEvent(evtVideoImportantChange, userParam); // jump to doDmc_HandleImportantVideoChange return FALSE; } void _Dmc_CommonAVCallback(tDHL_AVCallbackType cb_type, UINT32 param) { if (cb_type == eDHL_CB_VideoSeqHdr) { _Dmc_ImportantVideoChangeCallback((TLVideoContext)0, 0); } else if (cb_type == eDHL_CB_FirstVideoShow) { _Dmc_VideoFreezeEndCallback((TLVideoContext)0, 0); } } #endif #if COMMENT _______________(){} #endif //----------------------------------------------------------------- // doDmc functions. // // These functions can be called only in dmc task. // void doDmc_Notify(UINT32 event, UINT32 param) { const char *name = Dmc_NotifyEventString(event); if (_Dmc_Notify) { dprint(3, "----> %s start.. (%x)\n", name, param); _Dmc_Notify(event, param); } else { dprint(3, " Notify '%s' (%d) not registerred. skip\n", name, event); // cafrii 040521 add event number for easy debugging } } //---------------------------------------------------------------------- // doDmc_StartFinalPsiMonitor // // digital channel tuning이 모두 끝나고 나면 PSI 모니터를 시작한다. // void doDmc_StartFinalPsiMonitor(BOOL bCancelPrevMonitors) { DHL_RESULT err; ProgramAVInfo *av = Dmc_LockAVMutex(); #if USE_EPG_MW_PSI_DOWNLOAD // 기존 psi monitor는 강제로 중단 한다. if (av->pmtPsiCtl) DHL_PSI_StopMonitor(av->pmtPsiCtl); av->pmtPsiCtl = NULL; if (av->patPsiCtl) DHL_PSI_StopMonitor(av->patPsiCtl); av->patPsiCtl = NULL; #else // !USE_EPG_MW_PSI_DOWNLOAD //TLASSERT(av->active, "Video should be already started!"); if (bCancelPrevMonitors) { #if USE_CH_MW_ALL_PMT_DOWNLOAD if (av->pmtPsiCtl2) { DHL_PSI_StopMonitor(av->pmtPsiCtl2); av->pmtPsiCtl2 = (tDHL_PSI_ControlHandle)0; } #endif if (av->pmtPsiCtl) { DHL_PSI_StopMonitor(av->pmtPsiCtl); av->pmtPsiCtl = (tDHL_PSI_ControlHandle)0; } if (av->patPsiCtl) { DHL_PSI_StopMonitor(av->patPsiCtl); av->patPsiCtl = (tDHL_PSI_ControlHandle)0; } } if (gDmcTestNoPsiMonitor) { dprint(2, gDmcStringNoPsiMonitor); } else if (av->patPsiCtl) { dprint(2, " Psi monitor already exist\n"); } else { dprint(2, " Start monitor PAT..\n"); err = MonitorPAT(Dmc_GetCurrentTsd(), TRUE, // 항상 current PAT만 받는다!! FALSE, // not eager dmc_PatUpdateMode, _Dmc_PatEventProc, 0, &av->patPsiCtl); if (err) { dprint(0, "!! MonitorPAT returned %s\n", ErrorString(err)); } } #endif // USE_EPG_MW_PSI_DOWNLOAD Dmc_UnlockAVMutex(); } static void doDmc_CancelMonitors() { int i; ProgramAVInfo *av = Dmc_LockAVMutex(); #if USE_CH_MW_ALL_PMT_DOWNLOAD if(av->pmtPsiCtl2) { DHL_PSI_StopMonitor(av->pmtPsiCtl2); av->pmtPsiCtl2 = (tDHL_PSI_ControlHandle)0; } #endif if(av->pmtPsiCtl) { DHL_PSI_StopMonitor(av->pmtPsiCtl); av->pmtPsiCtl = (tDHL_PSI_ControlHandle)0; } if(av->patPsiCtl) { DHL_PSI_StopMonitor(av->patPsiCtl); av->patPsiCtl = (tDHL_PSI_ControlHandle)0; } if (av->pmt) FreePMT(av->pmt); av->pmt = NULL; #if USE_CH_MW_ALL_PMT_DOWNLOAD for (i=0; av->pat && av->pmtList && ipat->numPrograms; i++) if (av->pmtList[i]) FreePMT(av->pmtList[i]); DHL_OS_Free((void **)&av->pmtList); #endif if (av->pat) FreePAT(av->pat); av->pat = NULL; Dmc_UnlockAVMutex(); } /* app callback을 이용하여, app에서 원하는 audio 스트림을 선택하도록 하는 함수. 기본적으로 MW 내부의 DecidePidInfo 루틴에서 적절한 pid를 선택한다. 그러나 MW 내부 로직은 language code는 고려하지 않으므로, preferred language 기능이 있는 제품의 app 이라면 callback을 반드시 구현해야 한다. */ void doDmc_SelectAudioStream(MPEG_PMT *pmt, xvctChannelPtr_t vctc, UINT32 *pAudioPID, tDHL_AudioCodingType *pAudioType) { // Notification callback을 이용하여 application에서 어떤 audio를 원하는지 알아낸다. // AudioPidSelectParam apsp; UINT32 audioPID; tDHL_AudioCodingType audioType; apsp.pmt = pmt; apsp.vctChannel = vctc; // 아래 두 값에는 callback 이 구현되었는지를 체크하기 위한 초기값을 넣어둔다. apsp.returnAudioPid = 0; apsp.returnAudioType = eDHL_AUDIO_TYPE_UNKNOWN; doDmc_Notify(DMW_NOTIFY_SelectAudio, (UINT32) &apsp); if (apsp.returnAudioPid || apsp.returnAudioType) { if (apsp.returnAudioPid != 0) audioPID = apsp.returnAudioPid; if (apsp.returnAudioType != eDHL_AUDIO_TYPE_UNKNOWN) audioType = apsp.returnAudioType; dprint(2, "\t user select audio PID %d, type %d\n", audioPID, audioType); if (pAudioPID) *pAudioPID = audioPID; if (pAudioType) *pAudioType = audioType; } else { /* pAudioPID 와 pAudioType에는 이미 MW 내부에서 선택한 값이 들어 있으므로 값을 변경하면 안된다. */ } } /* app callback을 이용하여, app에서 원하는 video 스트림을 선택하도록 하는 함수. 기본적으로 MW 내부의 DecidePidInfo 루틴에서 적절한 pid를 선택한다. 특별한 로직이 필요하지 않는 한, callback을 구현할 필요 까지는 없다. */ void doDmc_SelectVideoStream(MPEG_PMT *pmt, xvctChannelPtr_t vctc, UINT32 *pVideoPID, tDHL_VideoCodingType *pVideoType) { // Notification callback을 이용하여 application에서 어떤 video를 원하는지 알아낸다. // VideoPidSelectParam vpsp; UINT32 videoPID; tDHL_VideoCodingType videoType; vpsp.pmt = pmt; vpsp.vctChannel = vctc; // 아래 두 값에는 callback 이 구현되었는지를 체크하기 위한 초기값을 넣어둔다. vpsp.returnVideoPid = 0; vpsp.returnVideoType = eDHL_VIDEO_TYPE_UNKNOWN; doDmc_Notify(DMW_NOTIFY_SelectVideo, (UINT32) &vpsp); if (vpsp.returnVideoPid || vpsp.returnVideoType != eDHL_VIDEO_TYPE_UNKNOWN) { if (vpsp.returnVideoPid != 0) videoPID = vpsp.returnVideoPid; if (vpsp.returnVideoType != eDHL_VIDEO_TYPE_UNKNOWN) videoType = vpsp.returnVideoType; dprint(2, "\t user select video PID %d, type %d\n", videoPID, videoType); if (pVideoPID) *pVideoPID = videoPID; if (pVideoType) *pVideoType = videoType; } else if(pmt) { //neverdai 101019 video stream의 경우, pid와 stream type을 pmt에서 찾아 설정해줌. #define StreamTypeToVideoType(t) ( \ (t) == StreamType_MPEG2Video ? eDHL_VIDEO_TYPE_MPEG2 : \ (t) == StreamType_DC2Video ? eDHL_VIDEO_TYPE_MPEG2 : \ (t) == StreamType_MPEG1Video ? eDHL_VIDEO_TYPE_MPEG1 : \ (t) == StreamType_H264 ? eDHL_VIDEO_TYPE_H264 : \ eDHL_VIDEO_TYPE_UNKNOWN ) int i, num_video, video_idx; for(i=0, num_video=0; inumStreams; i++) { if(StreamTypeToVideoType(pmt->streams[i].stream_type)!=eDHL_VIDEO_TYPE_UNKNOWN) { num_video++; videoPID=pmt->streams[i].elementary_PID; videoType=StreamTypeToVideoType(pmt->streams[i].stream_type); } } if(num_video==1) { if (pVideoPID) *pVideoPID = videoPID; if (pVideoType) *pVideoType = videoType; } } else { /* pVideoPID 와 pVideoType에는 이미 MW 내부에서 선택한 값이 들어 있으므로 값을 변경하면 안된다. */ } } /* running time 중에 importantchange (seqhdr 수신) 발생시 호출. synchronous start 인 경우에는 video start 시에도 호출. */ BOOL doDmc_CheckIfFormatChanged(void) { DHL_RESULT dhlResult; BOOL bFormatChanged = FALSE; char buf1[80], buf2[80]; tDHL_VideoSeqHdr seqtmp, *seq1, *seq2 = &seqtmp; ProgramAVInfo *av = Dmc_LockAVMutex(); //------- // find new video format. if analog, seq set to NULL. if (!DHL_AV_IsDigitalContext()) seq2 = NULL; else { // 여기에서는 절대 에러가 발생하면 안된다. dhlResult = DHL_AV_VideoSeqInfo(0, seq2); if (dhlResult) { dprint(0, "!! %s: get seqhdr err\n", __func__); seq2 = NULL; } } // previous old video format seq1 = av->seq_hdr_valid ? &av->seq_hdr : NULL; if (seq1 && seq2 && seq1->generationNumber == seq2->generationNumber) { dprint(2, "same seq_hdr number %u\n", seq1->generationNumber); goto label_end; } // make description string. // cafrii 070725 fix, 일부 platform에서 float형 print 불가능하여 // interger type 출력만 사용하도록 수정. if (seq1) sprintf(buf1, "(%d: %4dx%4d %c %2d.%02dHz %s)", Dmc_WhichATSCFormat(seq1), seq1->horizontal_size, seq1->vertical_size, seq1->progressive_sequence ? 'p' : 'i', (int)(seq1->frame_rate), (int)(seq1->frame_rate*100) % 100, DHL_AV_IsWideoFormat(seq1) ? "wide" : "narrow"); else strcpy(buf1, "(00: Analog)"); if (seq2) sprintf(buf2, "(%d: %4dx%4d %c %2d.%02dHz %s)", Dmc_WhichATSCFormat(seq2), seq2->horizontal_size, seq2->vertical_size, seq2->progressive_sequence ? 'p' : 'i', (int)(seq2->frame_rate), (int)(seq2->frame_rate*100) % 100, DHL_AV_IsWideoFormat(seq2) ? "wide" : "narrow"); else strcpy(buf2, "(00: Analog)"); dprint(2, "\tsource %s\n\t ---> %s\n", buf1, buf2); if (seq1) { if (seq2) { // digital --> digital bFormatChanged = Dmc_CheckIfFormatChanged(seq2, seq1); // new, old memcpy(&av->seq_hdr, seq2, sizeof(tDHL_VideoSeqHdr)); av->seq_hdr_valid = TRUE; } else { bFormatChanged = TRUE; // digital --> analog av->seq_hdr_valid = FALSE; } } else // seq1 == NULL { if (seq2) { // analog --> digital bFormatChanged = TRUE; memcpy(&av->seq_hdr, seq2, sizeof(tDHL_VideoSeqHdr)); av->seq_hdr_valid = TRUE; } else { bFormatChanged = FALSE; // analog --> analog av->seq_hdr_valid = FALSE; } } label_end: Dmc_UnlockAVMutex(); //------- return bFormatChanged; } // doDmc_ProcessScreenAdjustment // tuning 단계에서, 적용할 adjustment 방법을 callback으로 query해서 적용한다. // // user에게 알려줄 내용 // input: // 현재 display ratio (wide/narrow) // 현재 source format ratio (wide/narrow) // output: // tDHL_DispARC // force widebar // winRect // void doDmc_ProcessScreenAdjustment(void) { // video start 할 때 display start 하기 전에 불린다. ScreenAdjustmentParam sap; DHL_RESULT dhr; ProgramAVInfo *av = Dmc_LockAVMutex(); memset(&sap, 0, sizeof(sap)); // input sap.bSourceWide = DHL_AV_IsWideoFormat(&av->seq_hdr) ? TRUE : FALSE; sap.bDisplayWide = TRUE; // 이 display ratio는 원래 Dmc_ChangeDisplay api 인자를 기억해 두어서 전달해 주는 값인데, // 현재 MW 구조에서는 별도로 기억을 안해두고 있다. // MW 정보 보다 app 정보가 더 신뢰할 수 있으므로 app 에서는 이 정보를 무시하고, // app 변수를 참고하는 것이 좋겠다. // output // fill with special indicator value. sap.adjustment_hd = eDHL_ARC_UNKNOWN; // this value should not be used. SETRECT(&sap.rect, 0, 0, 0, 0); Dmc_UnlockAVMutex(); doDmc_Notify(DMC_NOTIFY_ScreenAdjustment, (UINT32)&sap); if (sap.bKeepCurrent) { dprint(2, "keep current adj setting\n"); return; } if (sap.adjustment_hd == (tDHL_DispARC)eDHL_ARC_UNKNOWN) { dprint(0, "!! screen adjust noti not impl. use default\n"); sap.adjustment_hd = eDHL_ARC_FULLSCREEN; sap.adjustment_sd = eDHL_ARC_FULLSCREEN; } dhr = DHL_AV_VideoSetARC(sap.adjustment_hd, sap.adjustment_sd); if (dhr) { dprint(0, "!! set arc err 0x%x. retry..\n", dhr); DHL_OS_Delay(100); DHL_AV_VideoSetARC(sap.adjustment_hd, sap.adjustment_sd); } } #if USE_CH_MW_ALL_PMT_DOWNLOAD /* 현재 시청중이 아닌 다른 pmt들도 다 다운로드 한다. */ void doDmc_StartAllPmtMonitor(ProgramAVInfo *av) { DHL_RESULT err; int program_index; UINT16 pmt_pid, program_number; int i; if (!av->pat) goto label_exit; if (!av->pmtList) goto label_exit; // 하나의 filter로 여러 pmt를 한꺼번에 다 받는 것이 아니라 // pmt를 하나씩 순차적으로 받는 방법을 사용한다. // 새 MW에서는 이런 부분은 개선이 가능함.. if (av->pmtPsiCtl2) { dprint(2, " stop allpmt psictl2\n"); DHL_PSI_StopMonitor(av->pmtPsiCtl2); av->pmtPsiCtl2 = (tDHL_PSI_ControlHandle)0; } // 다른 서브 채널 중에서 아직 받아지지 않은 program 선택. program_index = -1; for (i=0; av->pmtList && ipat->numPrograms; i++) { if (av->pat->programs[i].program_number == av->program_number) continue; // 이 프로그램은 '현재' 프로그램이므로 skip.. if (av->pmtList[i]) continue; // 이미 받아져 있다면 skip.. program_index = i; pmt_pid = av->pat->programs[i].program_map_PID; program_number = av->pat->programs[i].program_number; break; } if (program_index < 0) { // 이미 다 받아진 경우라면 그냥 종료. // cafrii 110331 add param AllPsiRxNotifyInfo param; memset(¶m, 0, sizeof(param)); param.av = av; dprint(2, " all other %d pmts are downloaded.\n", av->pat->numPrograms-1); doDmc_Notify(DMC_NOTIFY_AllPsiReceived, (UINT32)¶m); goto label_exit; } // 다운로드 시작.. dprint(2, " monitor other pmt[%d] pid %d, #%d..\n", program_index, pmt_pid, program_number); err = MonitorPMT(Dmc_GetCurrentTsd(), pmt_pid, program_number, TRUE, ePSIUPDATE_ONESHOT, _Dmc_PmtEventProc, 0, &av->pmtPsiCtl2); if (err) { dprint(0, "!! MonitorPMT returned %s\n", ErrorString(err)); } goto label_exit; label_exit: return; } #endif // USE_CH_MW_ALL_PMT_DOWNLOAD void doDmc_AudioTempMute(BOOL bMute) { // 다른 MW 등에서 Decoder mute는 사용하지 않고 있어서 // 이것을 temp mute로 사용함. DHL_AV_AudioMuteControl(eDHL_AUDIO_MUTE_DECODER, bMute); } void doDmc_AudioTempMuteLimitTimerProc(UINT32 nIDTimer, UINT32 param) { dprint(2, "\t audio temp unmute by timer limit\n"); doDmc_AudioTempMute(FALSE); } #if COMMENT _______EventHandler________(){} #endif // doDmc_HandlePatChange // // PAT monitor의 결과로 불리는 event procedure. // PAT Change Event의 DMC level Deferred Procedure // Dmc task 에서 호출된다. // void doDmc_HandlePatChange(DmcMessage *pmsg) { DHL_RESULT err; int i; int program_index = -1; BOOL bIgnoreNewPat = FALSE; UINT16 pmt_pid; UINT16 program_number; MPEG_PAT *pat = (MPEG_PAT *)pmsg->param; ProgramAVInfo *av = Dmc_LockAVMutex(); if (g_Trace_bDmcPsiEvent) dprint(1, "evtPatChange:::: cid %d\n", pmsg->cancelId); #if 1 // PSI_WO_CHVIEW if (av->active == 0) { dprint(2, " psi w/o chview\n"); } #else if (av->active == 0 || av->analog) { dprint(0, "!! pat is received in invalid state\n"); goto label_exit; } #endif if (pat == NULL || pat->numPrograms == 0 || pat->programs == NULL) { dprint(0, "!! invalid new PAT in in HandlePatChange\n"); goto label_exit; } // StopVideo를 하는 그 순간에 MessageQueue에 있는 PAT change event가 남아 있다가 // 나중에 이 handler에서 다시 video가 restart되는 문제가 있을 수 있다. // 이 문제는 StopVideo를 하면서 Queue에 있는 모든 event msg를 삭제하는 것으로 해결한다. // // 그래도 혹시 오래된 event msg가 늦게 올 경우를 대비해서 psiControl이 이미 삭제된 경우라면 // 이 이벤트를 무시한다. // if (av->patPsiCtl == 0) { dprint(0, "!! patPsiCtl is NULL! it is already stopped context\n"); goto label_exit; } // Pat change event가 너무 자주 불리는 경우 // 그 처리 속도가 새 pat의 수신 빈도를 따라가지 못하면 // Queue에 쌓여 있을 수도 있다. // Queue에 PAT change event가 이미 있으면 이번 event는 무시해도 된다. // if (doDmc_CheckMsgExist(evtPatChange)) { dprint(2, "!! Future PAT Change event detected. ignore this..\n"); goto label_exit; } // current program number of decoded program.. program_number = av->program_number; if (g_Trace_bDmcPsiEvent) { dprint(2, "PAT change event! TSID %d, version %d, num_program %d\n", pat->transport_stream_id, pat->version_number, pat->numPrograms); } if (1) { PSIChangeNotifyInfo pcni; // Notify to user first. memset(&pcni, 0, sizeof(pcni)); pcni.pmtchanged = FALSE; // This is PAT. pcni.pat = pat; //pcni.ignore = FALSE; // This is [out] parameter. FALSE by default pcni.program_index = -1; // cafrii 060804 add two more parameters pcni.userParam = av->userParam; pcni.av = av; doDmc_Notify(DMC_NOTIFY_PATChanged, (UINT32)&pcni); program_index = pcni.program_index; } // 아래 조건이면 이 새로 받은 pat를 처리하지 않는다. // // 1. option에서 equiv pat를 무시하라고 되어 있고, // 2. 검사 결과 동일한 pat로 결과가 나왔으며, // 3. pmt monitor가 존재하면 (이게 정말로 동일한 것인지는 확인 불가) // if (dmc_bIgnoreEquivPat && Dmc_CheckIfSamePat(av->pat, pat) && av->pmtPsiCtl) // cafrii 060707 bugfix!! <-- av->pmtPsiCtl == 0 { bIgnoreNewPat = TRUE; } // Note: // PMT Monitor가 아직 기동되지 않았다면 어떠한 경우라도 Ignore를 하면 안된다. // 설령 NewPat를 무시하라는 결과가 나왔더라도 // Pmt Monitor가 아직 시작하지 않은 상태라면 Monitor를 시작해야 한다. // // todo.. // is pmtPsiCtl consistent with one of pat's entry? // PSIControl: av->pmtPsiCtl->psiFilter->entries[0..2] 를 직접 조사해야 함.. // -> 그정도까지는 필요 없을 듯.. if (bIgnoreNewPat) { if (g_Trace_bDmcPsiEvent) dprint(2, "!! PAT is ignored. similar PAT is already active..\n"); //FreePAT(pat); // 아래에서 같이 처리함. goto label_exit; } doDmc_UpdatePsiInfo(pat, NULL); pat = NULL; //-------------------- // new pat udpated. now processing.. // decide program index.. if (program_index < 0 || program_index >= av->pat->numPrograms) { // 사용자가 program_index를 설정하지 않았거나 // 지정한 program_index가 invalid 한 경우이다. // 가장 적당한 program 을 선택해야 한다. // // search current program in PAT using current program_number. // 새로운 PAT에서 지금까지 사용해왔던 프로그램의 program number를 찾는다. // dprint(2, "\tsearch program number %d\n", program_number); for (i=0; ipat->numPrograms; i++) { if (av->pat->programs[i].program_number == program_number) break; } if (i >= av->pat->numPrograms) { dprint(0, "\n!!!! program number %d not found in PAT.\n", program_number); #if !DMC_STOP_WHEN_PROGRAM_DISAPPEAR #if 0 dprint(0, "!!!! re-tune first program..\n"); program_index = 0; // try using first program.. #else //neverdai 임시..최소 program_number를 선택한다. { int j,numMin,minIdx; for(j=0, numMin=0xffff,minIdx=0; jpat->numPrograms; j++){ if(numMin>av->pat->programs[j].program_number) { numMin=av->pat->programs[j].program_number; minIdx=j; } } program_index=minIdx; } #endif #else dprint(0, "ignore pat.. do nothing\n"); program_index = -1; // just keep current state. // probably video will be freezed if pid is not matched. // follow your customers optinion.. #endif // DMC_STOP_WHEN_PROGRAM_DISAPPEAR } else { // found matched program. // program_index = i; } } if (program_index < 0 || program_index >= av->pat->numPrograms) { dprint(0, "!! program index %d invalid. should be [%d~%d]\n", program_index, 0, av->pat->numPrograms-1); #if DMC_STOP_WHEN_PROGRAM_DISAPPEAR goto label_fail; #else goto label_exit; #endif } pmt_pid = av->pat->programs[program_index].program_map_PID; program_number = av->pat->programs[program_index].program_number; if (pmt_pid <= 0 || pmt_pid >= 0x1FFF) { dprint(0, "!! PMT pid 0x%x invalid\n", pmt_pid); goto label_exit; } // PMT monitor만 삭제한다. // 기존 PMT 리소스는 삭제하지 않도록 한다. // 밑에서 PmtMonitor를 시작하므로 얼마 후에 새 PMT가 수신되면 그때 교체한다. // if (av->pmtPsiCtl) DHL_PSI_StopMonitor(av->pmtPsiCtl); av->pmtPsiCtl = (tDHL_PSI_ControlHandle)0; dprint(2, "\tmonitor PMT (pid %d) of program idx %d, prognum %d\n", pmt_pid, program_index, program_number); err = MonitorPMT(Dmc_GetCurrentTsd(), pmt_pid, program_number, TRUE, // current dmc_PmtUpdateMode, _Dmc_PmtEventProc, 0, // userParam &av->pmtPsiCtl); if (err) { dprint(0, "!! MonitorPMT returned %s\n", ErrorString(err)); } // 먼저 현재 시청 중인 프로그램의 pmt 부터 받은 후에 시작하는 것이 좋겠음. #if 0 // USE_CH_MW_ALL_PMT_DOWNLOAD //doDmc_StartAllPmtMonitor(av); #endif goto label_exit; #if DMC_STOP_WHEN_PROGRAM_DISAPPEAR label_fail: // 실행 중인 AV를 중지시킨다. dprint(2, "!! stop current AV..\n"); doDmc_Stop(); // 필요하면 application에 이 상황을 통보해 줄 필요가 있다. doDmc_Notify(DMC_NOTIFY_PATChangeError, 0); #endif label_exit: if (pat) { #if DMC_CHECK_HEAP_SIZE UINT32 heap_before = DHL_GetFreeHeapSize(0); FreePAT(pat); dprint(2, "free pat 0x%x.. heap %u->%u\n", pat, heap_before, DHL_GetFreeHeapSize(0)); #else FreePAT(pat); dprint(2, "free pat 0x%x..\n", pat); #endif } Dmc_UnlockAVMutex(); } // doDmc_HandlePmtChange // // PMT Change Event의 DMC level Deferred Procedure // Dmc task 에서 호출된다. // #if USE_CH_MW_ALL_PMT_DOWNLOAD // 현재 시청 중인 채널의 pmt 이든, 시청하지 않는 pmt 이든 간에 모두 이 // callback 에서 처리된다. 따라서 이 둘을 잘 구분해야 함. #endif void doDmc_HandlePmtChange(DmcMessage *pmsg) { UINT32 videoPID = 0, audioPID = 0, pcrPID = 0; tDHL_AudioCodingType audioType = eDHL_AUDIO_TYPE_UNKNOWN; tDHL_VideoCodingType videoType = eDHL_VIDEO_TYPE_UNKNOWN; BOOL bVideoOutputExist; DHL_RESULT err; STATUS status; PidInfo psiPid; MPEG_PMT *pmt = (MPEG_PMT *)pmsg->param; UINT16 pmt_pid, program_number; ProgramAVInfo prev_av, *av = Dmc_LockAVMutex(); if (g_Trace_bDmcPsiEvent) dprint(1, "evtPmtChange:::: cid %d\n", pmsg->cancelId); if (av->pmtPsiCtl == 0) { // VideoStop을 하고 나면 doDmc_DeleteAllEventMsg 를 불러서 자동으로 // 모든 PsiCtl을 cancel 시키고 있기 때문에 논리적으로 이런게 발생하면 안된다. // dprint(0, "!! pmtPsiCtl is NULL! it is already stopped context\n"); goto label_exit; } if (doDmc_CheckMsgExist(evtPmtChange)) { dprint(2, "!! Future PMT Change event detected. ignore this..\n"); goto label_exit; } // check integrity // if (av->pat == NULL || av->pat->numPrograms == 0 || av->pat->programs == NULL) goto label_exit; if (pmt == NULL) { dprint(0, "!! Invalid pmt\n"); goto label_exit; } #if 1 // PSI_WO_CHVIEW if (av->active == 0) { dprint(2, " psi w/o chview\n"); } #else if (av->active == 0 || av->analog) { dprint(0, "!! pmt is received in invalid state\n"); goto label_exit; } #endif #if USE_CH_MW_ALL_PMT_DOWNLOAD if (pmt->program_number != av->program_number) { // 현재 시청중이 아닌 서브채널의 pmt인 경우이다. int i; dprint(2, "non-viewing program pmt #%d received\n", pmt->program_number); for (i=0; ipat->numPrograms; i++) { if (av->pat->programs[i].program_number == pmt->program_number) break; } if (i >= av->pat->numPrograms) { dprint(0, "!! pmt #%d received, but not in pat list\n", pmt->program_number); goto label_exit; } if (!av->pmtList) { dprint(0, "!! pmt received without pmtlist\n"); goto label_exit; } if (av->pmtList[i]) { dprint(2, "pmt[%d] already exist. #%d\n", i, av->pmtList[i]->program_number); } else { av->pmtList[i] = pmt; pmt = NULL; } // 이제 다른 program pmt가 더 있는지 찾아본다. //doDmc_StartAllPmtMonitor(av); goto label_exit; } #endif // USE_CH_MW_ALL_PMT_DOWNLOAD if (g_Trace_bDmcPsiEvent) { dprint(2, "PMT change event! PID %d, program_num %d, version %d\n", pmt->PID, pmt->program_number, pmt->version_number); } // compare // 기존의 PMT랑 비교를 해본다. 동일한 PMT로 판명되면 계속 진행할 필요가 없다. // if (dmc_bIgnoreEquivPmt) { int diff; diff = Dmc_CheckPmtDifference(av->pmt, pmt); if (diff == 0) { if (g_Trace_bDmcPsiEvent) dprint(2, "!! Same PMT is already active..\n"); //FreePMT(pmt); // 아래에서 동시에 free 함. goto label_exit; } if (g_Trace_bDmcPsiEvent) dprint(2, "\t new pmt, difference point is %d\n", diff); } // process new PMT.. // pmt_pid = pmt->PID; program_number = pmt->program_number; videoPID = audioPID = pcrPID = 0; // MW 디폴트 선택 로직에 의해 각 stream 별 pid를 선택한다. status = Dmc_DecidePidInfo(pmt, NULL, &psiPid, 0); if (status == statusOK && psiPid.bValid) { videoPID = psiPid.video; audioPID = psiPid.audio; pcrPID = psiPid.pcr; videoType = psiPid.videoType; audioType = psiPid.audioType; } else dprint(2, "!! pid from pmt err %d\n", status); // application callback에 의한 override를 처리한다. // 만약 callback이 등록 안된 경우라면 앞에서 선택된 값이 그대로 사용되어야 한다. doDmc_SelectAudioStream(pmt, NULL, &audioPID, &audioType); doDmc_SelectVideoStream(pmt, NULL, &videoPID, &videoType); if (pcrPID == 0 || (videoPID == 0 && audioPID == 0)) { dprint(0, "!! No valid PIDs in PMT. p%d/v%d/a%d, ignored.\n", pcrPID, videoPID, audioPID); //if (pmt) FreePMT(pmt); // 아래에서 동시에 수행.. //pmt = NULL; // 다시 한번 더 현재 PMT 수신을 시도해 보는게 좋겠다. // dmc_nPmtChangeRetryCount++; goto label_retry_pmt_monitor; // cafrii 030916 } if (dmc_bIgnoreEquivPmt) { // 알아낸 PID가 현재 PID와 동일하다면 Restart를 할 필요가 없을 수도 있다. // // NOTE! descriptor가 변경되었을 수도 있으므로 app noti는 빼먹으면 안됨. // todo.. 아래 코드가 필요한 이유는? // cafrii 030916, Only Audio drop의 경우에는 PmtChange를 무시하도록 하였다. // Audio가 나오다가 그냥 무음 상태로만 될 것이다. // // dprint(1,"av->video_type(%d), videoType(%d)\n", av->video_type, videoType); if (av->video_pid == videoPID && av->video_type == videoType && ( (av->audio_pid == audioPID) /* || (prev_av.audio_pid != 0 && audioPID == 0) */ ) && av->pcr_pid == pcrPID) { // PMT가 ignore 된 경우라도 몇가지 처리해줄 작업들이 있다. 이 곳에서 수행. // if (g_Trace_bDmcPsiEvent) dprint(2, "!! PMT is ignored. similar & active context already running..\n"); av->program_number = pmt->program_number; // PmtChange는 어쨌든 성공적으로 된 것이므로 0으로 리셋. // dmc_nPmtChangeRetryCount = 0; doDmc_UpdatePsiInfo(NULL, pmt); // pmt는 이 내부에서 별도 저장한다. pmt = NULL; goto label_completed; } else dprint(2, "\t pid diff. pva %x %x %x != %x %x %x\n", av->pcr_pid, av->video_pid, av->audio_pid, pcrPID, videoPID, audioPID); } doDmc_UpdatePsiInfo(NULL, pmt); // pmt는 이 내부에서 별도 저장한다. pmt = NULL; // backup av info because other essential parameters are preserved. prev_av = *av; // cafrii 081125 add // 만약 audio pid만 변경된 경우라면 (또는 audio가 없다가 시작하는 경우라면) // audio만 restart 하면 된다. // // cafrii 090212 bugfix // 새 audio PID가 0인 경우 StartDigital에서 오류 발생하는 문제 발견. // video가 정상적인 경우, 그리고 새 audio PID가 정상적인 경우에만 // audio restart only 방법을 제한적으로 적용한다. // 새 audio pid가 0인 경우 화면이 1번 깜빡하는 경우 있다. #if 1 // NEW_DHL_API if (1) { tDHL_VideoStatus video_status; DHL_AV_VideoGetStatus(0, &video_status); bVideoOutputExist = video_status.bOutputExist; } #else bVideoOutputExist = DHL_AV_VideoOutputExist(); #endif if (av->video_pid == videoPID && av->video_type==videoType && bVideoOutputExist && audioPID) { doDmc_StopDigitalAudio(); // video pid를 0으로 지정하면 audio만 play 한다. status = doDmc_StartDigital(0, audioPID, pcrPID, (DMC_VIDEO_CACHE)NULL, videoType, audioType); } else { doDmc_StopDigital(FALSE, FALSE); // do not cancel monitors status = doDmc_StartDigital(videoPID, audioPID, pcrPID, (DMC_VIDEO_CACHE)NULL, videoType, audioType); // Note!! // 이 함수를 부르는 순간에 video가 running중이라면, // 이 함수 안에서 기존의 video context를 강제 stop 시키면서 동시에 MonitorPAT도 해제된다. // 반드시 미리미리 light stop을 시켜놓아서 안에서 자동 stop 되는일이 없도록 하자. // } if (status == statusCancelled) { dprint(1, "\tStartDigital in PMT change cancelled by user\n"); doDmc_ClearProgramInfo(); // cancel이 된 경우는 곧바로 다른 decoding을 시작할 것이기 때문에 // retry도 안하고 callback도 안한다. goto label_exit; } else if (status) { // timeout Error도 포함.. dprint(0, "!! RestartVideo by NewPMT err %d\n", status); doDmc_ClearProgramInfo(); // 다시 한번 더 PMT 수신 시도.. 아마 수집된 PID가 잘못된 것일 수 있다. // dmc_nPmtChangeRetryCount++; goto label_retry_pmt_monitor; } doDmc_UpdateProgramInfoDigital(prev_av.rf, prev_av.mod, prev_av.method, prev_av.major, prev_av.minor, av->pmt->program_number, videoPID, audioPID, pcrPID, videoType, audioType); // program number만은 기존 것과 다를 수도 있다. 이 핸들러에서 처리 중에 // 새 PMT에서 program_number가 바뀌었을 수도 있으므로.. dmc_nPmtChangeRetryCount = 0; // 성공했으므로 0으로 리셋한다. label_completed: if (1) // Notify to user. Application으로 PmtChange event를 보낸다. { PSIChangeNotifyInfo pcni; memset(&pcni, 0, sizeof(pcni)); pcni.pmtchanged = TRUE; // This is PMT pcni.pmt = av->pmt; // new PMT pcni.pat = av->pat; // new or existing PAT //pcni.ignore = FALSE; // This is [out] parameter. FALSE by default // cafrii 060804 add two more parameters. pcni.userParam = av->userParam; pcni.av = av; doDmc_Notify(DMC_NOTIFY_PMTChanged, (UINT32)&pcni); // arzhna, 100203 // CA PMT를 전달하기 위한 callback 호출 doDmc_Notify(DMC_NOTIFY_CaPmt, (UINT32)&pcni); } label_exit: #if USE_CH_MW_ALL_PMT_DOWNLOAD doDmc_StartAllPmtMonitor(av); #endif // cafrii 060830 add bugfix!! memory leak for some odd case.. if (pmt) { #if DMC_CHECK_HEAP_SIZE UINT32 heap_before = DHL_GetFreeHeapSize(0); FreePMT(pmt); dprint(2, "free pmt 0x%x.. heap %u->%u\n", pmt, heap_before, DHL_GetFreeHeapSize(0)); #else FreePMT(pmt); dprint(2, "free pmt 0x%x..\n", pmt); #endif } Dmc_UnlockAVMutex(); return; label_retry_pmt_monitor: // cafrii 060830 add bugfix!! memory leak for some odd case.. if (pmt) { dprint(2, "free pmt 0x%x..\n", pmt); FreePMT(pmt); } // 1. 수신된 PMT의 내용에 문제가 있을때 (PID 검색 불가, 또는 잘못된 PID) // 2. A/V decoding 도중에 문제가 생겼을 때 // dprint(0, "!! PMT change error! retry count %d\n", dmc_nPmtChangeRetryCount); // Application으로 callback을 할 경우.. // // doDmc_Notify(DMC_NOTIFY_PMTChangeError, 0); // application은 이 루틴에서 모종의 조치를 취해야 한다. // 현재 video는 안나오고 있을 수도 있다. if (dmc_nPmtChangeRetryCount > dmc_LimitPmtChangeRetryCount) { dprint(0, "!! PMT change error retry count is over MAX %d, Ignore PmtChange!!\n", dmc_nPmtChangeRetryCount); //return; goto label_retry_exit; } if (pmt_pid <= 0 || pmt_pid >= 0x1FFF) { dprint(0, "!! pmt pid 0x%x invalid\n", pmt_pid); } else { DHL_PSI_StopMonitor(av->pmtPsiCtl); av->pmtPsiCtl = (tDHL_PSI_ControlHandle)0; err = MonitorPMT(Dmc_GetCurrentTsd(), pmt_pid, program_number, TRUE, // current dmc_PmtUpdateMode, _Dmc_PmtEventProc, 0, // userParam &av->pmtPsiCtl); if (err) { dprint(0, "!! MonitorPMT returned %s\n", ErrorString(err)); } } label_retry_exit: #if USE_CH_MW_ALL_PMT_DOWNLOAD doDmc_StartAllPmtMonitor(av); #endif Dmc_UnlockAVMutex(); } /* * handleImportantVideoChange is called from within the video control task * in response to an importantChange event which was in turn sent by the higher priority * video driver task. The change has already occurred and this is an after-the-fact notification. * We use this mostly to handle output=input mode */ void doDmc_HandleImportantVideoChange(DmcMessage *pmsg) { BOOL bFormatChanged = FALSE; DHL_RESULT dhr; dprint(1, "evtVideoImportantChange: cid %d\n", pmsg->cancelId); // todo.. // 이 시점에서 이미 driver의 video context가 새로운 정보로 갱신된 것인가? bFormatChanged = doDmc_CheckIfFormatChanged(); if (bFormatChanged == FALSE) { dprint(2, "\t source format not changed. keep current timing..\n"); // important video change 의 경우에는 format 이 unchange된 경우에는 // notify등의 작업을 전혀 할 필요가 없다. return; } // todo.. // user에게 callback으로 notification을 하고 // 필요한 경우 timing change를 한다. // // cafrii 070725 add // runtime 시에 해상도 변경되는 스트림 지원. doDmc_ProcessScreenAdjustment(); // restore video temp-mute dmc_bRequestVideoHide &= ~DMC_VIDEO_HIDE_VIDEO_START; dprint(2, "check video temp-mute.. 0x%x\n", dmc_bRequestVideoHide); if (dmc_bRequestVideoHide == 0) { dhr = DHL_AV_VideoHide(0, FALSE); if (dhr) dprint(0, "!! video unblank err\n", dhr); } } // doDmc_HandleImportantVideoChange void doDmc_HandleUserChange(DmcMessage *pmsg) { // 디폴트로 driver에서 수행하는 작업으로 만족한다. } void doDmc_HandleMajorVideoChange(DmcMessage *pmsg) { STATUS status; ProgramAVInfo prev_av; MajorChangeEventParam arg; // 어떤 경우에 이 major event가 오는가? // --> majorchange video event. // 버퍼가 부족할 경우 expand 시키기 위해 불린다. // 즉 현재 상태 그대로에서 다시 video context만 다시 만들면 될 듯 하다. // // 후처리로 PAT monitoring을 다시 하는게 적당한가? // --> 우리는 현재 PID 정보를 다 가지고 있기 때문에 이를 활용해서 AV start만 하고, // psiMonitorControl은 건드리지 않는다. // ProgramAVInfo *av = Dmc_LockAVMutex(); dprint(1, "evtVideoMajorChange: cid %d\n", pmsg->cancelId); // cafrii 060814 add // US14 stream의 경우 important change가 1회 호출되고 나서 // 그 이후 major change event가 연달아서 4회 발생한다. // 미래에 major change가 발견되는 경우 처리를 하지 않고 미루도록 하자. // if (doDmc_CheckMsgExist(evtVideoMajorChange)) { dprint(2, "!! Future Major Change event detected. ignore this..\n"); goto label_exit; } if (!av->active || av->analog) { dprint(0, "!! illegal state (%s, %d)! majorVideoChange ignored.\n", av->active ? "active" : "inactive", av->analog ? "analog" : "digital"); goto label_exit; } if (1) { // application notification memset(&arg, 0, sizeof(arg)); arg.ignore = FALSE; // cafrii 060519, TRUE->FALSE doDmc_Notify(DMW_NOTIFY_MajorChangeEvent, (UINT32)&arg); if (arg.ignore) { dprint(2, "!! User want to ignore this MajorChange event.. skip.\n"); goto label_exit; } } dprint(2, "\tPreviously tuned %s\n", TuneMethodString(av->method)); prev_av = *av; // video context만을 삭제한다. 다른 것들은 삭제하지 않는다. // doDmc_StopDigital(FALSE, FALSE); // do not cancel monitors status = doDmc_StartDigital(prev_av.video_pid, prev_av.audio_pid, prev_av.pcr_pid, (DMC_VIDEO_CACHE)NULL, prev_av.video_type, prev_av.audio_type); if (status == statusCancelled) { dprint(0, "!! StartDigital in MajorChange cancelled by user\n"); doDmc_ClearProgramInfo(); // cancel이 된 경우는 곧바로 다른 decoding을 시작할 것이기 때문에 // retry도 안하고 callback도 안한다. } else if (status) { dprint(0, "!! restart video error %d in major change event!\n", status); doDmc_ClearProgramInfo(); // 다시 한번 시도를 할 방법이 있는가? // } else { // success!! // doDmc_UpdateProgramInfoDigital(prev_av.rf, prev_av.mod, prev_av.method, prev_av.major, prev_av.minor, prev_av.program_number, prev_av.video_pid, prev_av.audio_pid, prev_av.pcr_pid, prev_av.video_type, prev_av.audio_type); } label_exit: Dmc_UnlockAVMutex(); } // doDmc_HandleMajorVideoChange void doDmc_HandleFreezeVideoEnd(DmcMessage *pmsg) { // 대부분의 작업은 video driver에서 처리하였으며, // application에 통보의 목적으로 이벤트를 받는다. dprint(1, "eventFreezeVideoEnd: cid %d\n", pmsg->cancelId); if (dmc_bWaitFirstFreezeVideoEndEvent) // 현재 wait 중이면.. { BOOL bProcessed = FALSE; dprint(2, "\tfirst FreezeEndEvent\n"); doDmc_Notify(DMW_NOTIFY_VideoFreezeEndEvent, (UINT32) &bProcessed); // Zoran decoder에서는 일반적으로 처음에 두개의 freeze video end // event가 발생하고 있다. 처음것 외에는 필요가 없기 때문에 // 혹시 msgQ 에 존재하는 동일 event는 삭제해주면 좋다. // doDmc_DeleteMsg(evtFreezeVideoEnd); if (bProcessed == FALSE) { //dprint(2, "\tAudio TempMute Off in First video frame\n"); // cafrii, 030610, channel change시에 Audio Pop noise를 막기 위해, // stop video에서 Audio mute, freeze_end시에 mute off를 한다. dprint(2, "\t audio temp mute off\n"); doDmc_AudioTempMute(FALSE); // 항상 TempMuteOff를 할 필요는 없고, 원래는 특정 조건이 될때만 해야한다. // // dmc_bUseAudioTempMuteAtStart == TRUE // dmc_bAudioVideoSyncStart == TRUE // // 위 두 조건이 TRUE가 아니면 TempMute가 안된 상태이다. // 그러나 TempMuteOff를 여러번 호출한다고 문제가 되는것이 아니므로 // 여기서는 그냥 무조건 호출해주도록 하자. } dmc_bWaitFirstFreezeVideoEndEvent = FALSE; } return; } // cafrii 060721 add void doDmc_HandleVideoScrambled(DmcMessage *pmsg) { // cafrii 060831 comment // // 간혹 driver에서 정상적인 스트림인데도 driver에서 scrambled event를 보내줄 때가 있다. // 이 경우 한번에 scramble이라고 판단하기에는 위험한 면이 있다. // // 대책 1. // scramble check를 일정 시간 내에 일정 횟수 이상 report 될 때에만 action을 취한다. // driver에 관련 API가 제공되어야 함. // // 대책 2. // runtime 중에는 scramble event에 대해서 대응하지 않는다. // 처음 시작할 때에 대응 하는 것으로 충분. #if 0 // cafrii 060831 delete code, use policy #2. // video 시작할 때 가 아니라 runtime 중에 scramble로 변경된 경우 발생. // SigMon 등에서 NoProgram / AudioOnly banner를 띄울 수 있도록 조치한다. // BOOL bAudioExist; // 만약 audio도 없는 상태라면 완전히 내려야 한다. // 1회만 체크해도 안전한가? // { ProgramAVInfo *av = Dmc_LockAVMutex(); dprint(2, "\t \n", av->rf, av->program_number); DHL_AV_SaveVideoToCache(av->rf, av->program_number); Dmc_UnlockAVMutex(); } bAudioExist = DHL_AV_AudioOutputExist(); if (bAudioExist == FALSE) { dprint(2, "video scrambled and no audio detect. stop!\n"); doDmc_StopDigital(TRUE, FALSE); } else { // video context만 내린다. // dprint(2, "audio detected. stop video only\n"); doDmc_StopDigitalVideo(FALSE); // cache에는 저장하지 말자. scramble 된 것이라면 의미가 없음. } #endif } #if COMMENT _______AVControl________(){} #endif void doDmc_StopDigitalVideo(BOOL bSaveToCache) { DHL_RESULT dhlResult; dprint(2, " \tstop digital video..\n"); #if 0 // NEW_DHL_API // decoding과 display까지 모두 stop한다. // DHL_AV_DispStop(); #endif #if SUPPORT_DMW_VIDEO_CACHE if (bSaveToCache) // cafrii 060630 add { ProgramAVInfo *av; av = Dmc_LockAVMutex(); dprint(2, "\tsave video to cache.. rf %d, #%d..\n", av->rf, av->program_number); DHL_AV_SaveVideoToCache(av->rf, av->program_number); Dmc_UnlockAVMutex(); } #endif dhlResult = DHL_AV_VideoStop(0); if (dhlResult) dprint(0, "!! DHL_AV_VideoStop err 0x%x\n", dhlResult); } void doDmc_StopDigitalAudio(void) { AudioDecodeStopParam adsp; DHL_RESULT dhlResult; dprint(2, "\tstop digital audio..\n"); memset(&adsp, 0, sizeof(AudioDecodeStopParam)); //adsp.mode = MOCHA_ATSC_INPUT; adsp.result = statusNotImpl; // my default. doDmc_Notify(DMW_NOTIFY_AudioDecodeStop, (UINT32) &adsp); if (adsp.result == statusNotImpl) { // 디폴트 구현: dhlResult = DHL_AV_AudioStop(); if (dhlResult) dprint(0, "!! DHL_AV_AudioStop err 0x%x\n", dhlResult); } else if (adsp.result == statusOK) { // 특별히 할일 없음. } } // // tsd stop, routing 등은 수행하지 않고 오직 decoding 만 중지한다. // void doDmc_StopDigital(BOOL bCancelMonitors, BOOL bSaveToCache) { if (!Dmc_IsDmcTask()) { dprint(0, "!! doDmc_StopDigital() should be called only in DmcTask.\n"); return; } dprint(1, "\tStop digital video/audio, cancel monitor %d\n", bCancelMonitors); dmc_bWaitFirstFreezeVideoEndEvent = FALSE; // 더이상 지원하지 않음. //if (_Dmc_DecodeStopCallback) // _Dmc_DecodeStopCallback(0, 0); // 현재는 특별한 parameter가 없음.. doDmc_StopDigitalAudio(); doDmc_StopDigitalVideo(bSaveToCache); if (bCancelMonitors) { doDmc_CancelMonitors(); // Stop이 되면서 Psi Monitor Control이 삭제되었으므로 // 이미 DmcQ에 들어와 있는 모든 Psi 이벤트들도 다 식제해야 한다. // // 단 vxWorks message Q의 한계로 새 방식의 UserQue를 사용하지 않으면 이 기능을 수행할 수 없다. dprint(2, "\t Delete all event message..\n"); doDmc_DeleteAllEventMsg(); // 모든 event를 Q에서 삭제.. } doDmc_ClearProgramInfo(); // cafrii 060721 add } void doDmc_StopAnalog() { DHL_RESULT dhlResult; AudioDecodeStopParam adsp; if (!Dmc_IsDmcTask()) { dprint(0, "!! doDmc_StopAnalog() should be called only in DmcTask.\n"); return; } dprint(1, "\tStop analog video/audio\n"); //--------------- Audio Stop -------------- memset(&adsp, 0, sizeof(AudioDecodeStopParam)); adsp.result = statusNotImpl; // my default. //adsp.mode = MOCHA_NTSC_INPUT; doDmc_Notify(DMW_NOTIFY_AudioDecodeStop, (UINT32) &adsp); if (adsp.result == statusNotImpl) { // 디폴트 구현: dhlResult = DHL_CAP_AudioStop(); if (dhlResult) dprint(0, "!! DHL_CAP_AudioStop err 0x%x\n", dhlResult); } //--------------- Video Stop -------------- dhlResult = DHL_CAP_VideoStop(0); if (dhlResult) dprint(0, "!! DHL_CAP_VideoStop err 0x%x\n", dhlResult); // Stop context를 할 때 디폴트 상태로 plane을 보이게 할 것인지 아닌지는 알아서 결정.. #if 0 DHL_AV_VideoHide(FALSE); av = Dmc_LockAVMutex(); av->video_hidden = FALSE; Dmc_UnlockAVMutex(); #endif // 0 doDmc_ClearProgramInfo(); // cafrii 060721 add } void doDmc_Stop() { ProgramAVInfo *av; if (!Dmc_IsDmcTask()) { dprint(0, "!! doDmc_Stop() should be called only in DmcTask.\n"); return; } av = Dmc_LockAVMutex(); dprint(2, "doDmc_Stop: current activity %d\n", av->active); if (av->active) { if (av->analog) { dprint(2, "Stop Analog TV\n"); doDmc_StopAnalog(); } else { dprint(2, "Stop Digital TV\n"); doDmc_StopDigital(TRUE, TRUE); // cancel all monitors } } else { dprint(2, " video already stopped.\n"); } doDmc_ClearProgramInfo(); // cafrii 060721 add // cafrii 030917 // Tuner의 이상 등으로 해서 context가 기동이 안된 경우, inactive 상태이지만 // application에서 PsiMonitor만 별도로 launch했을 수도 있다. // 따라서 위에서 제대로 stop이 안되었을 수도 있으므로 여기서 PsiMonitor는 // cancel을 해주어야 한다. // doDmc_CancelMonitors(); Dmc_UnlockAVMutex(); } // cafrii 060630, add video cache function // STATUS doDmc_StartDigital(UINT16 uVidPID, UINT16 uAudPID, UINT16 uPcrPID, DMC_VIDEO_CACHE vcache, tDHL_VideoCodingType vtype, tDHL_AudioCodingType atype) { // video pid, pcr pid로 비디오 디코딩을, audio pid를 이용하여 오디오 디코딩을 개시한다. // 이 전에 이미 Demux_tsdStart() 되어 있어야 한다. // // context는 새로 생성된다. // 만약 flatten 된 정보가 있다면 그것을 restore 시켜 사용한다. // 에러가 나면 바로 리턴한다. (timeout error인 경우에도 리턴함.) // AudioDecodeStartParam adsp; DHL_RESULT dhlResult; BOOL bVideoFormatChanged = FALSE; BOOL bVideoStarted = FALSE; if (!Dmc_IsDmcTask()) { dprint(0, "!! doDmc_StartDigital() should be called only in DmcTask.\n"); return statusInvalidState; } if (uPcrPID == 0 || (uVidPID == 0 && uAudPID == 0)) { dprint(0, "!! doDmc_StartDigital(): PID error. pcr %d, video %d, audio %d\n", uPcrPID, uVidPID, uAudPID); return statusInvalidArgument; } if (dmc_bRunWithoutVideo) { dprint(0, "skip video by flag\n"); goto process_audio; } if (uVidPID == 0) { dprint(2, "\t null video pid. skip..\n"); #if SUPPORT_DMW_VIDEO_CACHE if (vcache) { DHL_AV_DeleteVideoCacheData((tDHL_VideoCacheHandle)vcache); vcache = 0; } #endif goto process_audio; } // ------- video route setting ------------ dhlResult = DHL_CAP_ChangeVideoSource(0, eDHL_CAP_DTV_TS0); if (dhlResult) { dprint(0, "!! DHL_CAP_ChangeVideoSource err\n"); // do nothing.. just go! dhlResult = DHL_OK; } // ------- process video ------------ #if USE_PERF_MON DHL_PerfMonCheck(gDmcPMTune, PM_EV_TUNE_VIDEO_START, 0); #endif // do video temp-mute not to see initial noisy screen dmc_bRequestVideoHide |= DMC_VIDEO_HIDE_VIDEO_START; dprint(2, "apply video temp-mute.. flag 0x%x\n", dmc_bRequestVideoHide); dhlResult = DHL_AV_VideoHide(0, TRUE); if (dhlResult) dprint(0, "!! temp video hide err 0x%x\n", dhlResult); #if SUPPORT_DMW_VIDEO_CACHE if (vcache) // video cache 정보가 있으면 그것으로 먼저 시도.. { dprint(2, "\tvideo start using vcache..\n"); dhlResult = DHL_AV_StartCachedVideo(vcache); if (dhlResult) { dprint(0, "!! video vcache invalid? ignored!\n"); DHL_AV_DeleteVideoCacheData(vcache); vcache = (DMC_VIDEO_CACHE)NULL; } } #endif if (vcache == (DMC_VIDEO_CACHE)NULL) { dprint(2, "\t video normal start, v 0x%x, p 0x%x a 0x%x, vt %d\n", uVidPID, uPcrPID, uAudPID, vtype); dhlResult = DHL_AV_VideoStart(0, uVidPID, uPcrPID, vtype); } #if 1 // for new hal architecture, new approach.. // 과거에는 DHL_AV_VideoStart() api 안에 cancel_check 함수가 건네지고 // 제대로 된 video decoding 이 확인 될 때 까지 blocking 되는 방식이었음. // neo hal 에서부터 api가 변경되었는데, mw 쪽에는 반영이 안되고 있음. // arc 관련 문제 해결을 위해서는 seq hdr 정보가 필수이므로 // 여기서 waiting 을 할 수 있음. (doDmc_CheckCancel() polling 하면서..) // 그러나 이 방법은 audio start가 늦어진다는 단점이 있다. // // 이에 대한 또 다른 방안은 여기서는 그냥 진행 하고 audio start를 하며, // 나중에 seq hdr change callback이 불리면 그 때 arc 적용을 하는 것이다. // 그러면 아래에 formatchange 정보는 당분간은 엉터리가 될 수 있다. #endif if (dhlResult) { dprint(0, "!! DHL_AV_VideoStart err 0x%x\n", dhlResult); // cafrii 050723 add // 만약 video context 생성이 scrambledError가 아닌 다른 에러가 발생했다면 // video는 그냥 두고 audio로 계속 진행한다. if (dhlResult == DHL_WARN_SCRAMBLED) { // audio 도 틀림없이 scramble 되었다고 가정하고 그냥 종료한다. // cafrii 060711 change // video scramble 이더라도 audio 진행하도록 한다. // 또한 air channel의 경우 video scramble은 잘못된 것이므로 invalid PES와 다를 바 없다. //return statusScrambled; } if (dhlResult == DHL_FAIL_CANCELLED_BY_USER) { return statusCancelled; } if (dhlResult) { //return err; // audio pid가 0이면 에러를 리턴해야 한다. if (uAudPID == 0) { dprint(0, "!! video only program, but video invalid.\n"); return statusVideoError; } bVideoStarted = FALSE; // uVidPID는 valid하지만 문제가 있어서 video 디코딩 실패.. goto process_audio; } } bVideoStarted = TRUE; dprint(2, "\tDHL_AV_VideoStart OK\n"); #if DMC_DELAYED_VIDEO_SHOW // 그냥 여기서는 기존 seq hdr 정보만 reset 을 하고 // 나중에 seq hdr change callback 이 오면 그 때 ARC 적용 및 temp blank unhide를 한다. { ProgramAVInfo *av = Dmc_LockAVMutex(); av->seq_hdr_valid = FALSE; Dmc_UnlockAVMutex(); } #else bVideoFormatChanged = FALSE; // 가장 마지막에 저장된 Sequence Header와 현재 seq와 비교해서 // 변경된 사항이 있을 경우에만 적용한다. // bVideoFormatChanged = doDmc_CheckIfFormatChanged(); // Note! // 최초 Tuning시에는 dmc_SeqHdr의 값들이 모두 0일 것이므로 // 처음 1회 format change는 꼭 불리게 된다. (설령 현재 timing이 적절한 것이라해도..) // 이미 설정해 둔 timing과 비교해 봐서 변경할 필요가 없을 수도 있는데, // 이때는 application에서 Dmc_InitDisplay에서 설정한 값과 비교해서 // skip 하게 할 수도 있을 것이다. // MW는 무조건 notify를 해준다. if (bVideoFormatChanged == FALSE) dprint(2, "\t source format not changed\n"); else dprint(2, "\t source format changed\n"); // 사용자 설정값이 있는 경우, Adjustment, Sidebar, WinRect 등을 미리 설정해놓는다. // 나중에 Display start할 때 적용되도록.. // if (bVideoFormatChanged) doDmc_ProcessScreenAdjustment(); #if 0 // NEW_DHL_API dhlResult = DHL_AV_DispStart(NULL); if (dhlResult) dprint(0, "!! DHL_AV_DispStart err 0x%x\n", dhlResult); #endif #if 0 // hide 푸는 시점은 뒤에.. if (dmc_bRequestVideoHide) { DHL_AV_VideoHide(0, TRUE); } else { // show // 이 부분의 코드를 실행하면 비디오가 깨지는 문제 발생. // todo // video stop시에 hide 된 것이라면 풀어주지 않아서 문제가 생기지 않는가? // 그럴 경우 DHL에서 관리해줘야 함. #if 0 DHL_AV_VideoHide(FALSE); #endif } #endif #endif // DMC_DELAYED_VIDEO_SHOW if (1) { ProgramAVInfo *av = Dmc_LockAVMutex(); av->video_hidden = (dmc_bRequestVideoHide & DMC_VIDEO_HIDE_USER) ? TRUE : FALSE; Dmc_UnlockAVMutex(); } #if USE_PERF_MON DHL_PerfMonCheck(gDmcPMTune, PM_EV_TUNE_VIDEO_START, 1); #endif process_audio: if (uAudPID == 0) { dprint(2, "\t null audio pid. skip..\n"); goto label_end; } if (dmc_bRunWithoutAudio) { dprint(0, "skip audio by flag.\n"); goto label_end; } dhlResult = DHL_CAP_ChangeAudioSource(eDHL_CAP_DTV_TS0_AUDIO); if (dhlResult) { dprint(0, "!! DHL_CAP_ChangeAudioSource err\n"); // do nothing.. just go! dhlResult = DHL_OK; } #if USE_PERF_MON DHL_PerfMonCheck(gDmcPMTune, PM_EV_TUNE_AUDIO_START, 0); #endif // ------- audio route setting ------------ dhlResult = DHL_CAP_ChangeAudioSource(eDHL_CAP_DTV_TS0_AUDIO); if (dhlResult) { dprint(0, "!! DHL_CAP_ChangeAudioSource err\n"); // do nothing.. just go! dhlResult = DHL_OK; } // ------- audio processing ------------ dmc_bWaitFirstFreezeVideoEndEvent = TRUE; // 030918 cafrii // audio를 세팅하는 순간 pop noise가 발생할 수 있어서 // 보통 Audio 시작 전에 mute를 한다. // mute를 off하는 시점은 video가 나오기 시작하는 시점이 // 적당하므로 이 순간에 freeze video end를 기다리는 flag를 추가한다. // // freeze_end 가 너무 빨리 나와버렸다면 앞으로 영원히 audio가 나오지 않는 문제가 생길수가 있는데, // 아직 적당한 해결 방법은 없다. // --> freeze_end 가 아무리 빨리 나오더라도 DMC task에서 freeze end를 처리하므로 // 이 함수가 끝나기 전까지는 freeze end가 처리되지 않는다. 문제 없음. // // 또한 Audio only channel이 있을수 있으므로 video가 없을 경우에는 audio mute를 // 바로 꺼야만 한다. memset(&adsp, 0, sizeof(AudioDecodeStartParam)); adsp.result = statusNotImpl; // my default. adsp.audPid = uAudPID; adsp.pcrPid = uPcrPID; adsp.audType = atype; //adsp.mode = MOCHA_ATSC_INPUT; // cafrii 031117 add doDmc_Notify(DMW_NOTIFY_AudioDecodeStart, (UINT32) &adsp); if (adsp.result == statusNotImpl) { tDHL_AudioCodingType dhlAudType; if (dmc_bAudioVideoSyncStart) { dprint(2, "\tAudio muted for sync start\n"); doDmc_AudioTempMute(TRUE); DMW_SYS_SetTimer(TIMER_ID_AUDIO_TEMPMUTE_LIMIT, g_AudioTempMuteLimitMs, doDmc_AudioTempMuteLimitTimerProc, 0, TRUE); } #if 0 // todo // 현재 DD HAL에서 지원하는 audio type이 몇개 안된다. // driver에서는 tDHL_AudioCodingType 종류가 상당히 많다. (물론 모두 다 지원하는것은 아님) // // arzhna, 100315 // audio type과 stream type을 구분해야함, // DHL_AV_AudioStart 에서 필요한 인자는 audiotype #define eDHL_AUDIO_TYPE_2_DHLAUDIOTYPE(a) ( \ (a) == eDHL_AUDIO_TYPE_AC3 ? eDHL_AUDIO_TYPE_AC3 : \ (a) == eDHL_AUDIO_TYPE_MPEG_1 ? eDHL_AUDIO_TYPE_MPEG_1 : \ (a) == eDHL_AUDIO_TYPE_MPEG_2 ? eDHL_AUDIO_TYPE_MPEG_2 : \ (a) == eDHL_AUDIO_TYPE_AAC ? eDHL_AUDIO_TYPE_AAC : \ eDHL_AUDIO_TYPE_AC3) // cafrii 070718, use 'atype' argument dhlAudType = eDHL_AUDIO_TYPE_2_DHLAUDIOTYPE(atype); #else dhlAudType = atype; #endif dprint(2, "\t audio start, a 0x%x p 0x%x, at %d\n", uAudPID, uPcrPID, dhlAudType); #if 1 // NEW_DHL_API dhlResult = DHL_AV_AudioStart(uAudPID, uPcrPID, dhlAudType); if (dhlResult) dprint(0, "!! audio start err 0x%x\n", dhlResult); #else // cafrii 060711 add audio start check if (dmc_bUseAudioStartWait == 0) dhlResult = DHL_AV_AudioStart(uAudPID, uPcrPID, dhlAudType); else { dhlResult = DHL_AV_AudioStartWait(uAudPID, uPcrPID, dhlAudType, doDmc_CheckCancel); // cafrii 060808 add, bugfix! if (dhlResult == DHL_FAIL_CANCELLED_BY_USER) { if (bVideoStarted) { #if 0 // NEW_DHL_API DHL_AV_DispStop(); #endif // zooyouny 100629 : tDHL_VDID는 일단 0으로 처리, 문제 될 수 있음 DHL_AV_VideoStop(0); } return statusCancelled; } if (dhlResult) { dprint(0, "!! audio start err 0x%x\n", dhlResult); // video 마저 없다면 이는 에러이다. if (bVideoStarted == FALSE) return statusError; } } #endif // tDHL_AudioCodingType 과 DHL_AUD_STREAMTYPE 구분.. if (dmc_bAudioVideoSyncStart) { // sync start를 위해서는 여기서 unmute를 하지 않고 // video first freeze end가 왔을때 풀어주도록 한다. // if (bVideoStarted) { dprint(2, "\tAV SyncStart mode.. AudioTmpMute off deferred later..\n"); } else { dprint(2, "\tAV SyncStart mode, but no video.. Clear AudioTmpMute..\n"); dmc_bWaitFirstFreezeVideoEndEvent = FALSE; // 여기서 바로 처리하므로 wait하지 않는다. doDmc_AudioTempMute(FALSE); } } } else if (adsp.result == statusOK) { } else { dprint(0, "!! AudioDecodeStart err %d\n", adsp.result); if (bVideoStarted == FALSE) return adsp.result; } #if USE_PERF_MON DHL_PerfMonCheck(gDmcPMTune, PM_EV_TUNE_AUDIO_START, 1); #endif label_end: // 현재 이 함수에서는 program number를 알 수 없다. // 1394 지원하지 않음. //if (_Dmc_DecodeStartCallback) // _Dmc_DecodeStartCallback(dmc_program->program_number, FALSE); return statusOK; } STATUS doDmc_StartAnalog(CaptureParam *pCapParam) { // Analog Video context를 생성하고 관련된 audio를 처리한다. // TS가 아닌 uncompressed video(656 format)은 모두 analog video context로 처리된다. // NTSC, External Video, DV 등이 모두 이 경우에 해당한다. DHL_RESULT dhlResult; AudioDecodeStartParam adsp; ProgramAVInfo *av; STATUS status = statusOK; if (!Dmc_IsDmcTask()) { dprint(0, "!! doDmc_StartAnalog() should be called only in DmcTask.\n"); return statusInvalidState; } av = Dmc_LockAVMutex(); if (av->active) { // 기본 방침을 StartDigital, StartAnalog 하기 전에 caller에서 // 이전 video를 stop 시키는 것으로 정함. // dprint(1, "!! Warning! stop video before tuning new channel!\n"); doDmc_Stop(); // no delete task } // cafrii 070413 add // audio만 capture 시작하는 특수 모드 지원. if (pCapParam->input_video == eDHL_CAP_VIDEO_NONE) { dprint(2, " audio capture only\n"); goto label_audio; } // ------- process video ------------ #if USE_PERF_MON DHL_PerfMonCheck(gDmcPMTune, PM_EV_TUNE_VIDEO_START, 0); #endif dhlResult = DHL_CAP_ChangeVideoSource(0, pCapParam->input_video); if (dhlResult) dprint(0, "!! DHL_CAP_ChangeVideoSource err 0x%x\n", dhlResult); dhlResult = DHL_CAP_VideoStart(0); if (dhlResult) { dprint(0, "!! DHL_CAP_VideoStart err 0x%x\n", dhlResult); status = statusVideoError; goto label_end; // cafrii 060714 bugfix! } // bVideoFormatChanged = doDmc_CheckIfFormatChanged(); // cafrii 060609 add doDmc_ProcessScreenAdjustment(); dhlResult = DHL_CAP_DispStart(); if (dhlResult) { dprint(0, "!! DHL_CAP_DispStart err 0x%x\n", dhlResult); status = statusVideoError; goto label_end; // cafrii 060714 bugfix! } if (dmc_bRequestVideoHide) { DHL_AV_VideoHide(0, TRUE); } else { // show DHL_AV_VideoHide(0, FALSE); } av->video_hidden = dmc_bRequestVideoHide ? TRUE : FALSE; #if USE_PERF_MON DHL_PerfMonCheck(gDmcPMTune, PM_EV_TUNE_VIDEO_START, 1); #endif // ------- process audio ------------ label_audio: #if USE_PERF_MON DHL_PerfMonCheck(gDmcPMTune, PM_EV_TUNE_AUDIO_START, 0); #endif dhlResult = DHL_CAP_ChangeAudioSource(pCapParam->input_audio); if (dhlResult) dprint(0, "!! DHL_CAP_ChangeAudioSource err 0x%x\n", dhlResult); if (dmc_bRunWithoutAudio == 0) { // 참고로 Analog의 경우에는 AVSyncStart는 지원하지 않는다. // //dmc_bWaitFirstFreezeVideoEndEvent = FALSE; // do not wait FreezeVideoEnd event. // cafrii 070102, analog도 freeze end event 필요함. dmc_bWaitFirstFreezeVideoEndEvent = TRUE; memset(&adsp, 0, sizeof(AudioDecodeStartParam)); adsp.result = statusNotImpl; // my default. //adsp.mode = MOCHA_NTSC_INPUT; doDmc_Notify(DMW_NOTIFY_AudioDecodeStart, (UINT32) &adsp); if (adsp.result == statusNotImpl) { dhlResult = DHL_CAP_AudioStart(); if (dhlResult) dprint(0, "!! DHL_CAP_AudioStart err 0x%x\n", dhlResult); } else if (adsp.result == statusOK) { } else { dprint(0, "!! AudioDecodeStart err %d\n", adsp.result); return adsp.result; // 전체 튜닝 에러로 리턴한다. 주의!! } } #if USE_PERF_MON DHL_PerfMonCheck(gDmcPMTune, PM_EV_TUNE_AUDIO_START, 1); #endif label_end: Dmc_UnlockAVMutex(); return status; } #if COMMENT _______________(){} #endif #if 0 DMC_VIDEO_CACHE doDmc_LoadVideoCache(int rf, int program_number, int video_pid, int pcr_pid) { DMC_VIDEO_CACHE cache; cache = DHL_AV_LoadVideoFromCache(rf, program_number, video_pid, pcr_pid); return cache; } doDmc_SaveVideoCache() { } #endif #if COMMENT _______________(){} #endif #if !USE_EPG_MW_PSI_DOWNLOAD //----------------------------------------------------------- // PSI Monitor Control 관리 // 채널 튜닝이 끝나면 DMC는 PSI 모니터를 가동시켜서 PSI Change에 대비하게끔 한다. // 이것때문에 다른 곳에서 PSI Table을 받으려고 해도 timeout 에러가 발생한다. // // 이에 대한 해결책으로는 // (1) Table을 새로 받는 대신 DMC가 관리하고 있는 PSI table을 lock 상태에서 이용하거나, // (2) Psi monitor를 일시 중지시켜놓고 다운로드 한다음 다시 resume시키는 방법을 사용한다. // STATUS Dmc_PausePsiMonitor(UINT32 bPause) { DHL_RESULT err = DHL_OK; ProgramAVInfo *av; if (!Dmc_IsDmcTask()) { dprint(2, "Dmc_PausePsiMonitor(%d)\n", bPause); return Dmc_EnqueueDPC((DMC_FN_DPC)Dmc_PausePsiMonitor, bPause, 0, 0, 0, TRUE); } dprint(1, "cmdPausePsiMonitor(%d):\n", bPause); av = Dmc_LockAVMutex(); if (bPause) // Pause { #if USE_CH_MW_ALL_PMT_DOWNLOAD dprint(2, "\t pause current PsiCtl monitor (pat 0x%08x pmt1 0x%08x pmt2 0x%08x)..\n", av->patPsiCtl, av->pmtPsiCtl, av->pmtPsiCtl2); #else dprint(2, "\tPause current PsiCtl monitor (pat 0x%08x, pmt 0x%08x)..\n", av->patPsiCtl, av->pmtPsiCtl); #endif #if USE_CH_MW_ALL_PMT_DOWNLOAD DHL_PSI_StopMonitor(av->pmtPsiCtl2); av->pmtPsiCtl2 = (tDHL_PSI_ControlHandle)0; #endif DHL_PSI_StopMonitor(av->pmtPsiCtl); av->pmtPsiCtl = (tDHL_PSI_ControlHandle)0; DHL_PSI_StopMonitor(av->patPsiCtl); av->patPsiCtl = (tDHL_PSI_ControlHandle)0; // Queue에 남아있는 PAT/PMT Change event는 비워야 하는가? // --> 나중에 pat/pmt handler에서 PsiCtl이 NULL인지를 체크를 하기 때문에 // 그럴 필요는 없다. } else { // 현재 모니터링이 가동중이면 아무일도 하지 않는다. if (av->patPsiCtl == 0) { dprint(2, "\tPAT monitor resume..\n"); if (av->pat == NULL || av->pmt == NULL) { dprint(2, " Psi Not prepared (pat %x, pmt %x).. wait first pmt..\n", av->pat, av->pmt); } err = MonitorPAT(Dmc_GetCurrentTsd(), TRUE, // 항상 current PAT만 받는다!! FALSE, // not eager dmc_PatUpdateMode, _Dmc_PatEventProc, 0, &av->patPsiCtl); if (err) dprint(0, "!! MonitorPAT returned %s\n", ErrorString(err)); } // PMT Monitor는 PAT가 수신된 이후에, 그 시점에서 동작중인 Video의 program number를 // 이용해 PMT를 선택한 다음 시작한다. } Dmc_UnlockAVMutex(); return err ? statusError : statusOK; } #endif // !USE_EPG_MW_PSI_DOWNLOAD STATUS Dmc_InitAVResources(void) { dmc_psiSema4 = DHL_OS_CreateMutexSemaphore("DmcPsi"); if (dmc_psiSema4 == 0) { dprint(0, "!! create psi sema4 failed"); return statusOutOfResource; } dmc_avSema4 = DHL_OS_CreateMutexSemaphore("DmcAV"); if (dmc_avSema4 == 0) { dprint(0, "!! create av sema4 failed"); return statusOutOfResource; } DHL_AV_SetCallback(eDHL_CB_VideoSeqHdr, _Dmc_CommonAVCallback); DHL_AV_SetCallback(eDHL_CB_FirstVideoShow, _Dmc_CommonAVCallback); return statusOK; } // Dmc_RegisterDecodeStartCallback // Decode start callback 핸들러를 등록/해제한다. // 디코딩이 시작될 때 (StartDigital 이후) 마다 이 핸들러가 호출된다. // 주로 Partial stream 출력을 위해서 사용된다. // 이전에 등록되어 있는 handler가 리턴되므로 callback chaining을 할수 있다. // DMC_FN_NOTIFY Dmc_RegisterDecodeStartCallback(DMC_FN_NOTIFY callback) { // return previously registerred callback pointers. // so that notification chaining is possible. DMC_FN_NOTIFY fnPrevCallback; fnPrevCallback = _Dmc_DecodeStartCallback; _Dmc_DecodeStartCallback = callback; if (callback) dprint(1, "DecodeStart callback %x registerred\n", callback); else dprint(1, "DecodeStart callback unregistered\n"); return fnPrevCallback; } // Dmc_RegisterDecodeStopCallback // Decode stop callback 핸들러를 등록/해제한다. // 디코딩이 끝날 때 호출된다. // DMC_FN_NOTIFY Dmc_RegisterDecodeStopCallback(DMC_FN_NOTIFY callback) { // return previously registerred callback pointers. // so that notification chaining is possible. DMC_FN_NOTIFY fnPrevCallback; fnPrevCallback = _Dmc_DecodeStopCallback; _Dmc_DecodeStopCallback = callback; if (callback) dprint(1, "DecodeStop callback %x registerred\n", callback); else dprint(1, "DecodeStop callback unregistered\n"); return fnPrevCallback; } // Dmc_RegisterNotificationCallback // Notification callback을 등록/해제한다. // DMC에서 일어나는 여러가지 유용한 정보를 Notification 을 통해서 // 알려주기 때문에 가능하면 이 기능을 사용하는게 좋다. // DMC_FN_NOTIFY Dmc_RegisterNotificationCallback(DMC_FN_NOTIFY callback) { // return previously registerred callback pointers, // so that notification chaining is possible. DMC_FN_NOTIFY fnPrevCallback; fnPrevCallback = _Dmc_Notify; _Dmc_Notify = callback; if (callback) dprint(1, "Notification callback %x registerred.\n", callback); else dprint(1, "Notification callback unregistered.\n"); return fnPrevCallback; } /* neverdai 101019 add. autoscan 시 callback을 받아서 비디오 화면에 보이는 문제가 있음 scan할 때는 callback을 받지 않도록 변경하는 것이 좋을 듯함. */ void DMC_RegisterVideoCallback(BOOL bset) { if(bset) { DHL_AV_SetCallback(eDHL_CB_VideoSeqHdr, _Dmc_CommonAVCallback); DHL_AV_SetCallback(eDHL_CB_FirstVideoShow, _Dmc_CommonAVCallback); } else { DHL_AV_SetCallback(eDHL_CB_VideoSeqHdr, NULL); DHL_AV_SetCallback(eDHL_CB_FirstVideoShow, NULL); } } // cafrii 060724 add void Dmc_PrintAVInfo(int level) { ProgramAVInfo *av = Dmc_LockAVMutex(); dprint(level, " active %d, analog %d, input video %d/audio %d\n", av->active, av->analog, av->input_video, av->input_audio); dprint(level, " rf %d, mod %d (%s), tune method %d (%s)\n", av->rf, av->mod, ServiceTypeString(av->mod), av->method, TuneMethodString(av->method)); dprint(level, " major %d, minor %d, #%d, pid pva %x/%x/%x\n", av->major, av->minor, av->program_number, av->pcr_pid, av->video_pid, av->audio_pid); dprint(level, " freezed %d, hidden %d\n", av->video_freezed, av->video_hidden); dprint(level, " pat 0x%x, pmt 0x%x, psictl pat %x, pmt %x\n", av->pat, av->pmt, av->patPsiCtl, av->pmtPsiCtl); // pmtlist 정보를 보고 싶다면 Dmc_PrintProgramInfo 를 사용할 것!! Dmc_UnlockAVMutex(); } #if COMMENT ________(){} #endif #if DMW_REGISTER_DEBUG_SYMBOL static DHL_SymbolTable symbols[] = { //---- functions DHL_FNC_SYM_ENTRY(Dmc_PrintAVInfo), //---- vars DHL_VAR_SYM_ENTRY(dmc_bRunWithoutAudio), DHL_VAR_SYM_ENTRY(dmc_bRunWithoutVideo), DHL_VAR_SYM_ENTRY(dmc_bRequestVideoHide), DHL_VAR_SYM_ENTRY(g_Trace_bDmcPsiEvent), //DHL_VAR_SYM_ENTRY(dmc_bUseAudioStartWait), }; #endif void RegisterChannelAVSymbols(void) { #if DMW_REGISTER_DEBUG_SYMBOL DHL_DBG_RegisterSymbols(symbols, DHL_NUMSYMBOLS(symbols)); #endif }