/******************************************************************** * * Dmw_ChannelTask.c * * Channel decoding task, video and channel command * * Copyright 2002-2004 Digital STREAM Technology, Inc. * All Rights Reserved * * Dmw_ChannelTask.c, v 1.0 2003/11/27 cafrii * *******************************************************************/ #include "DMW_Platform.h" #include "DHL_SYS.h" #include "DHL_AVCAP.h" #include "DHL_DBG.h" //#include "DHL_DEV.h" //#include #define SETRECT(rect, xx, yy, ww, hh) { \ (rect)->x = (xx); \ (rect)->y = (yy); \ (rect)->w = (ww); \ (rect)->h = (hh); \ } #define outOfOSResourcesError DHL_FAIL_OUT_OF_RESOURCE #include "DMW_Config.h" #include "DMW_DebugUtil.h" #include "DMW_Status.h" #define __DEFINE_DMC_STRING_FN__ // 이 소스 파일에서만 DMW_Channel.h를 포함하기 전에 이 macro를 선언하면 된다. // Middleware #include "DMW_Channel.h" #include "dmw_channel_priv.h" #include "DMW_ChannelDemux.h" #include "DMW_ChannelUtil.h" //#include "dmw_nvram_priv.h" // nvram init 작업 때문에 포함. DHL_MODULE("$dmc", 1); #if COMMENT ________Config________(){} #endif //=========================================================================== // // Configuration parameters // // 각종 옵션 기능의 On/Off 설정, 컴파일러 옵션 설정, // 드라이버 관련 환경 설정 등.. // // // cafrii 070830 add // // Freeze, Hide 와 같이 Tuning과 직접적인 관련이 없는 ETC 함수들을 // DMC task로 defer 시켜서 동작시킬 것인지 설정. // // 1이면 모든 작업을 DMC task로 이관해서 동작을 하며 (이전 방식) // 0이면 그냥 임의 task에서 바로 HAL 함수를 호출한다. // // 앞으로는 DMC task에 synchronize 시키지 않고 바로 HAL 함수를 호출하도록 한다. // // #define SUPPORT_ETC_API_SYNC 0 // // Config Param: [0 ~ ] 단위: millisecond // // 각종 Timeout limit 값. 단위는 ms. // int g_Timeout_SignalLock = 1900; // 디지털 신호 Lock timeout. int g_Timeout_AnalogSignalLock = 200; // 아날로그 Lock timeout. cafrii 041208, 500 -> 200 int g_Timeout_VctLoading = 6000; int g_Timeout_PatLoading = 6000; int g_Timeout_PmtLoading = 6000; // // Config MACRO: priority는 권장값 그대로. stack size는 충분하게. // // DMC task를 생성할때 사용되는 값 // // Priority는 Cougar classic example의 VideoControlTask의 값과 // 동일하게 사용하는게 좋다. stack size는 가끔씩 task info를 검사해서 // margin이 부족하면 늘려주도록 하자. // // @todo zooyouny 100629 DHL에 DMC_TASK 값과 동일하게 하였음 // 숫자 값 대신 signiture 상수 사용할 것.. #define DMC_TASK_PRIORITY TASK_PRI_DMC_TASK #define DMC_TASK_STACKSIZE 32768 // // Config MACRO: // // DMC Event Queue 크기 // // Event Que크기 값으로 부족하지 않게 충분히 잡도록 하자.. // #define MAX_DECODE_MESSAGES 50 #if COMMENT ________State________(){} #endif //=========================================================================== // // DMC State Variables // //----------------------------------------------------------- // DMC Task 및 communication 관련 // // task, event, sema4 // DHL_OS_TASK_ID dmc_TaskID; // 이 DMC 태스크에서 실제적인 video start/stop 등 모든것을 처리한다. //----------------------------------------------------------- tDHL_TSD *dmc_tsd; // 이 모듈 내에서 global하게 사용하고 있는 TSD. // //----------------------------------------------------------- static BOOLEAN dmc_bInitCM; // TRUE이면 비디오 태스크 관련 리소스가 초기화되었음. UINT32 dmc_tickStarted; // cafrii 060720 add BOOL dmc_bTestNoAux; // cafrii 060728 add for test //----------------------------------------------------------- #define ErrorString DMW_CDB_ErrString // TL의 DHL_RESULT를 포함하여 DMW의 STATUS까지 에러를 문자열로 변환하는 함수 치환. // DMW_CDB_ErrString은 TL의 error 상수값까지 모두 string 처리를 할 수 있다. #if COMMENT ________Config________(){} #endif // AudioChange 할때 사용되는 command parameter block typedef struct { UINT32 audioPID; UINT32 pcrPID; UINT32 audioType; } CmdParam_ChangeAudio; // ChangeDislay에서 사용되는 command parameter block typedef struct { VOUT_COLOR color; VOUT_FORMAT format; VOUT_RATIO ratio; tDHL_DispARC adj; AuxVideoSetting aux; } CmdParam_ChangeDisplay; // cafrii 060519 add // VideoResize에서 사용되는 command parameter block typedef struct { UINT16 x; UINT16 y; UINT16 w; UINT16 h; } CmdParam_VideoResize; // cafrii 060928 add // typedef struct { tDHL_DispARC adj; UINT16 x, y, w, h; } CmdParam_AdjustScreen; typedef struct { DMC_FN_DPC dpcfn; UINT32 param1; UINT32 param2; UINT32 param3; UINT32 param4; // cafrii 070412, add 3 more params. total 4. } CmdParam_DPC; //--------------------------------------------------------------- // // Forward Declarations here.. // #if COMMENT ________Comm________(){} #endif //----------------------------------------------------------- // Dmc_SendCommandEx // 비디오 태스크 (DmcTask)로 command를 보낸다. // 필요하면 response wait도 한다. (bWaitForComplete가 TRUE일때) // bCancelPrevCommand가 TRUE이면 이전에 보낸 모든 command를 cancel시키도록 // cancel msg를 먼저 보낸다. // STATUS Dmc_SendCommandEx(DmcMsgType cmd, UINT32 param, DMC_FN_CANCELFREE pfnFree, BOOL bWaitForComplete, DMC_FN_COMPLETED pfnCompleted, UINT32 userparam, BOOL bCancelPrevCommand) { DmcMessage msg; BOOL bUrgent = FALSE; UINT32 cancelId1=0, cancelId2; // cafrii 040910 add STATUS status = statusOK; DHL_OS_SEMA_ID waitSem = 0; if (Dmc_IsDmcTask()) { dprint(0, "!! Send dmc command from dmc task!\n"); if (pfnFree && param) (*pfnFree)(param); return statusInvalidState; } memset(&msg, 0, sizeof(msg)); if (bCancelPrevCommand) { // 이 전에 보낸 모든 command를 취소하기 위해서 먼저 cancel msg를 보낸다. // cancelId1 = doDmc_GetNewMultipleCancelIds(2); // 2개의 연속된 cancel ID를 얻어온다. // cancelId1이 첫번째 cancel ID이다. Dmc_SendCancelCommand(cancelId1); cancelId2 = doDmc_GetNextCancelId(cancelId1, 1); // 그 다음 cancel ID를 사용한다. } else { cancelId2 = doDmc_GetNewCancelId(); } if (!Dmc_IsCommand(cmd)) { #if DEVELOPMENT_BUILD DHL_ASSERT(bWaitForComplete == FALSE, "event msg cannot be synchronous"); #else // event 이면서 synchronous 방식으로 호출이 된 경우이다. // 잘못 사용된 예인데, 그냥 에러 리턴을 할 수도 있는데, // 그냥 wait_for_complete를 무시하고 async 처리를 하도록 하자. // // cafrii 080910 fix. if (bWaitForComplete) { dprint(0, "!! event sent in synchronous mode! act in async mode\n"); bWaitForComplete = FALSE; } #endif } if (bWaitForComplete) { #if 0 // zooyouny 100629 : resuable semaphore 사용 안하도록 DHL에서 지원 안함 // cafrii 070416 use reusable semaphore waitSem = OS_CreateReuseSemaphore("", OS_SEM_FIFO, FALSE); #else waitSem = DHL_OS_CreateBinarySemaphore("", OS_SEM_FIFO, FALSE); #endif if (waitSem == 0) { dprint(0, "!! wait sema4 create err\n"); if (pfnFree && param) (*pfnFree)(param); return statusOutOfResource; } } msg.type = cmd; msg.param = param; // command parameter msg.pfnResourceFree = pfnFree; msg.pfnCompleted = pfnCompleted; msg.userParam = userparam; msg.bWaitForComplete = bWaitForComplete; msg.cancelId = cancelId2; if (bWaitForComplete) { msg.pStatus = (UINT32 *)&status; msg.waitSem = waitSem; } if (bCancelPrevCommand) dprint(3, " send cancel cmd cid %d, send cmd '%d' cid %d\n", cancelId1, cmd, cancelId2); else dprint(3, " send cmd '%d' cid %d\n", cmd, cancelId2); // todo // urgent event/command를 보내는 방법을 제공할 필요가 있는가? // -> cancel 기능을 제공하기 때문에 그럴 필요는 없음. status = doDmc_AddUserMsg(&msg); if (status) { dprint(0, "!! Send%sMessage error %d\n", bUrgent ? "Urgent" : "", status); if (pfnFree && param) (*pfnFree)(param); return statusQueueFull; } // queue에 제대로 add 되었다면 이제 param 후처리는 더이상 이곳에서 책임지지 않는다. // if (bWaitForComplete) { DHL_OS_TakeSemaphore(waitSem, DHL_TIMEOUT_FOREVER); dprint(2, ".. send_cmd end. result %d\n", status); #if 0 // zooyouny 100629: reusable semaphore DHL에서 지원 안함 // cafrii 070416 use reusable semaphore OS_DeleteReuseSemaphore(waitSem); #else DHL_OS_DeleteSemaphore(waitSem); #endif } return status; } /* Dmc_SendCommandEx의 간소화 버전. */ STATUS Dmc_SendCommand(DmcMsgType cmd, UINT32 param, BOOL bCancelPrevCommand) { return Dmc_SendCommandEx(cmd, param, NULL, TRUE, // wait mode NULL, 0, // no user callback bCancelPrevCommand); } /* 주로 Driver callback, ISR 등에서 DMC task로 이벤트를 전달할 때 사용하는 API. */ STATUS Dmc_DeferEvent(DmcMsgType event, UINT32 param, DMC_FN_CANCELFREE pfnFree, DMC_FN_COMPLETED pfnDpc, UINT32 userParam) { if (Dmc_IsCommand(event)) return statusInvalidArgument; return Dmc_SendCommandEx(event, param, pfnFree, FALSE, // no wait mode.. event should not be synchronous!! pfnDpc, userParam, FALSE); // do not cancel prev event.. } // cafrii 060831 add // cafrii 090120, this function is called with int disabled. so removing printf encouraged. void Dmc_DeleteDmcMessage(DmcMessage *pmsg, STATUS result) { if (Dmc_IsCommand(pmsg->type) && pmsg->pfnCompleted) { (pmsg->pfnCompleted)(result, pmsg->userParam, NULL); // 콜백 인자를 통한 에러 리턴.. } if (pmsg->pfnResourceFree) { //dprint(3, " free parameter 0x%x\n", pmsg->param); pmsg->pfnResourceFree(pmsg->param); } } //----------------------------------------------------------- // Dmc_CheckCancel // // 이 함수는 반드시 Dmc task에서만 불려야 한다. // 그러나 static인 doDmc_CheckCancel과 달리 외부에서 부를 수 있도록 extern 되는 public API이다. // 이 함수의 용도는 DMC Task에서 각종 application으로의 callback 루틴에서 사용한다. // BOOL Dmc_CheckCancel() { // This function should be called in DMC task. // Application can use this function to check whether current msg is cancelled or not. // DMC routines can use doDmc_CheckCancel() directly. // if (dmc_TaskID != Dmc_GetCurrentTaskID()) { dprint(0, "!! Dmc_CheckCancel() should be called only in DmcTask.\n"); return FALSE; // return NOT_CANCELLED; } return doDmc_CheckCancel(); } tDHL_TSD *Dmc_GetCurrentTsd() { return dmc_tsd; } // Dmc_GetCurrentTaskID // 현재 Task ID를 리턴한다. // DHL_OS_TASK_ID Dmc_GetCurrentTaskID() { return DHL_OS_GetTaskID(); } // Dmc_IsDmcTask // 현재 task 가 DMC task 이면 TRUE를 리턴한다. // BOOL Dmc_IsDmcTask() { return (Dmc_GetCurrentTaskID() == dmc_TaskID) ? TRUE : FALSE; } #if !SUPPORT_ETC_API_SYNC /* Dmc_SendCommand 와 달리 DMC task로 defer 시키지 않고 직접 호출할 때 사용하는 API. 일반적으로 기존에 SendCommand를 wait mode로 cancel 없이 동작하는 경우였다면 현재의 task에서 직접 실행이 가능하다. */ STATUS Dmc_ExecuteCommand(DmcMsgType cmd, UINT32 param, STATUS (*fn)(DmcMessage *)) { DmcMessage msg; STATUS status = statusInvalidArgument; memset(&msg, 0, sizeof(msg)); msg.type = cmdChangeDisplay; msg.param = param; // command parameter msg.cancelId = 0; // cancel할때 사용되는 일련번호. msg.bWaitForComplete = TRUE; if (fn) status = (*fn)(&msg); return status; } #endif // !SUPPORT_ETC_API_SYNC #if COMMENT _______SubAPI_1_______(){} #endif static STATUS doDmc_CmdExtInputCapture(DmcMessage *pmsg) { STATUS status; CaptureParam *pCapParam; dprint(1, "cmdExtInputCapture: cid %d\n", pmsg->cancelId); pCapParam = (CaptureParam *) pmsg->param; if (!pCapParam) { dprint(0, " !! capParam NULL! stop!\n"); status = statusInvalidArgument; goto label_end_tune; } // 기존 비디오가 동작중이면 닫는다. doDmc_Stop(); if (doDmc_CheckCancel()) goto label_cancelled; dprint(2, "\tstart analog video..\n"); // arzhna, 100203 // CA PMT를 전달하기 위한 callback 호출 doDmc_Notify(DMC_NOTIFY_CaPmt, (UINT32)NULL); status = doDmc_StartAnalog(pCapParam); if (status) { dprint(0, "!! err in start analog, err %d. stop!\n", status); } else { doDmc_UpdateProgramInfoAnalog(0, pCapParam->input_video, pCapParam->input_audio); } goto label_end_tune; label_cancelled: status = statusCancelled; goto label_end_tune; label_end_tune: //------------------------------------------------------------ if (pCapParam) DHL_OS_Free((void**)&pCapParam); // caller task에서 Alloc한 메모리이다. "반드시" free 시키자. return status; } static STATUS doDmc_CmdStop(DmcMessage *pmsg) { dprint(1, "cmdVideoStop: cid %d\n", pmsg->cancelId); doDmc_Stop(); // analog/digital 공용 함수 return statusOK; } static STATUS doDmc_CmdRestartVideo(DmcMessage *pmsg) { STATUS status; ProgramAVInfo *av; if (pmsg == NULL) dprint(1, "cmdRestartVideo: called from DMC context..\n"); else dprint(1, "cmdRestartVideo: cid %d\n", pmsg->cancelId); av = Dmc_LockAVMutex(); if (dmc_TaskID != Dmc_GetCurrentTaskID()) { dprint(0, "!! doDmc_CmdRestartVideo should be called only in DmcTask.\n"); status = statusError; goto label_end_tune; } if (av->active == FALSE) { dprint(0, "!! cannot restart video. currently no program\n"); status = statusError; goto label_end_tune; } if (doDmc_CheckCancel()) goto label_cancelled; //---------------- if (av->analog) // NTSC, or DV { int prev_rf; CaptureParam capParam; // Stop을 시키면 pav 정보가 소실될 수 있으므로 필요한 정보는 // 미리 backup을 해 두어야 할 것이다. memset(&capParam, 0, sizeof(capParam)); prev_rf = av->rf; capParam.input_video = av->input_video; capParam.input_audio = av->input_audio; doDmc_Stop(); dprint(2, "\trestart analog video..\n"); status = doDmc_StartAnalog(&capParam); if (status) { status = statusAnalogError; dprint(0, "!! err in start analog, err %d. stop!\n", status); } else { doDmc_UpdateProgramInfoAnalog(prev_rf, capParam.input_video, capParam.input_audio); } goto label_end_tune; // 아날로그 채널은 이것으로 모든 작업이 끝난다. } else { ProgramAVInfo pgm_backup, *pgm = &pgm_backup; *pgm = *av; doDmc_StopDigital(FALSE, FALSE); // do not cancel monitors // PsiControl도 삭제하지 않고, dmc_pat/pmt도 삭제하지 않는다. // 그냥 VideoContext만 내린다. // important change/major change 이벤트가 올때 restart video 명령을 사용하는 // 경우가 많다. // 그러므로 이 시점에서 queue에 여러개 쌓여 있는 important change, major change 등의 // event는 없애버리는게 좋다. // 그래야 restart 후에 다시 이런 이벤트들에 의해 다시 restart될 일이 없기 때문. // 단 cid의 변경에 따른 cancel ID의 변경, 이로 인한 CheckCancel 함수의 동작에 // 영향은 없는지 체크해 봐야 한다. // if (1) { //dprint(2, "\t Delete some event message..\n"); doDmc_DeleteMsg(evtVideoImportantChange); doDmc_DeleteMsg(evtVideoMajorChange); } status = doDmc_StartDigital(pgm->video_pid, pgm->audio_pid, pgm->pcr_pid, (DMC_VIDEO_CACHE)0, pgm->video_type, pgm->audio_type); if (status == statusOK) { doDmc_UpdateProgramInfoDigital(pgm->rf, pgm->mod, pgm->method, pgm->major, pgm->minor, pgm->program_number, pgm->video_pid, pgm->audio_pid, pgm->pcr_pid, pgm->video_type, pgm->audio_type); goto label_digital_success; } else { doDmc_ClearProgramInfo(); } } label_digital_success: //------------------------------------------------------------ if (doDmc_CheckCancel()) goto label_cancelled; // 앞에서 Monitor들을 free시키지 않았다면 여기에서 할 다시 할 필요는 없다. // 기존의 monitor들을 가능하면 재사용한다. // doDmc_StartFinalPsiMonitor(FALSE); goto label_end_tune; label_cancelled: status = statusCancelled; goto label_end_tune; label_end_tune: Dmc_UnlockAVMutex(); return status; } static STATUS doDmc_CmdEnqueueDPC(DmcMessage *pmsg) { UINT32 *cmdParam = (UINT32 *)pmsg->param; DMC_FN_DPC dpcfn; UINT32 arg1, arg2, arg3, arg4; dprint(1, "cmdEnqueuDPC: cid %d\n", pmsg->cancelId); dprint(2, "\t param: %x, callback fn %x\n", pmsg->param, pmsg->pfnCompleted); dpcfn = (DMC_FN_DPC) cmdParam[0]; arg1 = cmdParam[1]; arg2 = cmdParam[2]; arg3 = cmdParam[3]; arg4 = cmdParam[4]; dprint(3, "\t free paramblk %x\n", cmdParam); DHL_OS_Free((void**)&cmdParam); //제대로 하려면 다음과 같이.. //if (pmsg->pfnResourceFree) // (pmsg->pfnResourceFree)((UINT32)cmdParam); dprint(2, "\t DPC function %x, arg %x %x %x %x\n", dpcfn, arg1, arg2, arg3, arg4); if (dpcfn) dpcfn(arg1, arg2, arg3, arg4); // tune callback은 tuning관련 command에서만 error를 리턴하는 것임. // 일반 command에는 해당되지 않는다. //doDmc_ReturnTuneResult(event->fn, statusOK, (UINT32)event->param, event->userParam); return statusOK; } #if COMMENT _______SubAPI_2_______(){} #endif // 이곳의 함수들은 기존에는 DMC task에서 실행되었으나 // HAL 구조로 변경되면서 직접 client task에서 실행된다. // // /* Dmc_ChangeDisplay의 sub 실행 함수. */ static STATUS doDmc_CmdChangeDisplay(DmcMessage *pmsg) { DHL_RESULT dhlResult; tDHL_DispColorSpace videoOutputColor; //video output tDHL_DispFormat displayFormat; //video output format // tDHL_DispAspectRatio AspectRatio; //display aspect ration // tDHL_DispARC Adjustment; // DHL_DISP_AUXSETTING AuxSetting; CmdParam_ChangeDisplay *arg = (CmdParam_ChangeDisplay *)pmsg->param; dprint(1, "cmdChangeDisplay: cid %d\n", pmsg->cancelId); videoOutputColor = arg->color == VOUT_YPBPR ? eDHL_DISP_CS_YCBCR : eDHL_DISP_CS_RGB; displayFormat = arg->format == VOUT_480I ? eDHL_DISP_720x480i : arg->format == VOUT_480P ? eDHL_DISP_720x480p : arg->format == VOUT_720P ? eDHL_DISP_1280x720p : arg->format == VOUT_1080I ? eDHL_DISP_1920x1080i : eDHL_DISP_1920x1080i; // AspectRatio = arg->ratio == VOUT_NARROW ? eDHL_DISP_ASPECT_4_3 : eDHL_DISP_ASPECT_16_9; // Adjustment = (tDHL_DispARC) arg->adj; // AuxSetting = (DHL_DISP_AUXSETTING) arg->aux; // cafrii 060728 test if (dmc_bTestNoAux) { dprint(0, "!! no aux test mode\n"); // AuxSetting = noAuxVideo; } // todo.. check point. // 아날로그일 경우.. // audio only service인 경우.. // // video가 stop 되어 있는 경우.. --> SetSingle.. 은 나중에 진짜 시작할때로 미뤄진다. // // cafrii 060831 add comment // 일반적으로 change display는 wait mode로 호출되기 때문에 // pfnResourceFree를 사용하지는 않는다. // 만약에 나중에 no-wait 모드로 사용할 경우를 대비해서 // free하는 코드를 호출해준다. // if (pmsg->pfnResourceFree) (pmsg->pfnResourceFree)((UINT32)arg); #if 0 // cafrii 060718 delete, ChangeVideoFormat에서 모두 처리. // 사용자의 요구대로 display를 설정하는 것이기 때문에 // 다시 callback으로 확인할 필요가 없다. // //doDmc_ProcessScreenAdjustment(); DHL_AV_SetScreenAdjustment(Adjustment, NULL); #endif #if 1 dhlResult = DHL_AV_DispSetFormat(eDHL_DISP_PORT_COMPONENT, displayFormat, videoOutputColor); #else dhlResult = DHL_AV_ChangeVideoFormat(VideoOutput, VidOutFormat, AspectRatio); // if error occurs, there is NO CHANGE in display setting since last good setting. // (last successful display setting is kept) // caller should check this err value and do some treatment. (retry or give-up) #endif return dhlResult ? statusError : statusOK; } /* Dmc_ChangeVideoAdjustment 의 sub 실행 함수. */ static STATUS doDmc_CmdChangeVideoAdjustment(DmcMessage *pmsg) { DHL_RESULT dhlResult = DHL_OK; tDHL_DispARC adj_hd = (tDHL_DispARC) (pmsg->param & 0xffff); tDHL_DispARC adj_sd = (tDHL_DispARC) ((pmsg->param >> 16) & 0xffff); dprint(1, "cmdVideoAdjustment: cid %d, adj_hd %d, adj_sd %d\n", pmsg->cancelId, adj_hd, adj_sd); #if 1 DHL_AV_VideoSetARC(adj_hd, adj_sd); #else // chjeon 091222 // ARC 적용을 SD와 HD 출력에 동시에 적용한다. dhlResult = DHL_AV_ChangeVideoAdjustment(eDHL_DISP_TYPE_HD, adj_hd, NULL); dhlResult = DHL_AV_ChangeVideoAdjustment(eDHL_DISP_TYPE_SD, adj_sd, NULL); #endif return dhlResult ? statusError : statusOK; } /* Dmc_AdjustVideoScreen 의 sub 실행 함수. */ static STATUS doDmc_CmdAdjustScreen(DmcMessage *pmsg) { DHL_RESULT dhlResult = DHL_OK; CmdParam_AdjustScreen *arg = (CmdParam_AdjustScreen *) pmsg->param; DHL_Rect rect; dprint(1, "cmdAdjustScreen: cid %d\n", pmsg->cancelId); #if 0 SETRECT(&rect, arg->x, arg->y, arg->w, arg->h); dhlResult = DHL_AV_ChangeVideoAdjustment(eDHL_DISP_TYPE_HD, arg->adj, &rect); #else dhlResult = DHL_AV_VideoResize(0, arg->x, arg->y, arg->w, arg->h); #endif return dhlResult ? statusError : statusOK; } /* Dmc_ResizeVideo 의 sub 실행 함수. */ static STATUS doDmc_CmdVideoResize(DmcMessage *pmsg) { DHL_RESULT dhlResult = DHL_OK; CmdParam_VideoResize *arg = (CmdParam_VideoResize *) pmsg->param; dprint(1, "cmdVideoResize: cid %d\n", pmsg->cancelId); dhlResult = DHL_AV_VideoResize(0, arg->x, arg->y, arg->w, arg->h); return dhlResult ? statusError : statusOK; } #if COMMENT ________Task____________(){} #endif void tDmc_Task(INT32 arg) { DmcMessage msg; STATUS status; while(1) { status = statusOK; //------------------------- User Message 처리 코드 -------------------------------- // // 현재 상태에서 모든 DmcQMsg가 UserMsgQ로 이동되었다. // //doDmc_PrintUserMsgs(); // cafrii 040910 add, UserMsgQ의 모든 msg에 대해 cid 정보를 표시한다. if (SCN_ScanRunning()) { status = doDmc_GetUserMsg(&msg, 50); if (status != statusOK) { SCN_ScanTask(); continue; } } else { // 별도의 background idle 작업이 없을 경우엔 wait forever한다. status = doDmc_GetUserMsg(&msg, 0xFFFFFFFF); // wait forever.. if (status) { dprint(0, "!! No message in UserMsgQueue ??\n"); DHL_OS_Delay(100); continue; // no message. } } if (doDmc_RefreshCancelQue()) // 가장 마지막으로 들어온 cancel request ID를 얻는다. { // cancel command가 오면 현재 진행 중인 scan도 중지한다. if (SCN_ScanRunning()) { DmcMessage msg; memset(&msg, 0, sizeof(DmcMessage)); msg.param = TRUE; // bUpdate dprint(2, "\t new cancel %d. stop scan.\n", doDmc_GetLastCancelId()); status = SCN_ScanStop(&msg); // ignore status value because this is cancel. } } dprint(2, "\t %s (%d) cid %d (last %d)\n", Dmc_MsgString(msg.type), msg.type, msg.cancelId, doDmc_GetLastCancelId()); if (doDmc_IsCancelledMsg(msg.cancelId)) { dprint(1, "!! %s %s cid %d canceled by cid %d\n", Dmc_IsCommand(msg.type) ? "command" : "event", Dmc_MsgString(msg.type), msg.cancelId, doDmc_GetLastCancelId()); // command가 아닌 event의 경우에는 event.fn 값이 NULL일것이다. // 이 경우에는 callback를 부르지 않는다. // cafrii 091222 comment // 현재 어떤 command인지 구분하지 않은 상태이므로 마지막 인자를 NULL로 줄 수 밖에 없음. // 각 complete callback 함수 내에서 null 체크 필요함. if (Dmc_IsCommand(msg.type) && msg.pfnCompleted) { (msg.pfnCompleted)(statusCancelled, msg.userParam, NULL); // 콜백 인자를 통한 에러 리턴.. } if (msg.pfnResourceFree) { dprint(3, " free parameter 0x%x\n", msg.param); msg.pfnResourceFree(msg.param); } // cancel이 된 command라도 ack를 보내줘야 한다. // status = statusCancelled; goto label_wait_for_complete; } switch (msg.type) { case evtPatChange: doDmc_HandlePatChange(&msg); // new PAT break; case evtPmtChange: doDmc_HandlePmtChange(&msg); // new PMT break; case evtVideoImportantChange: doDmc_HandleImportantVideoChange(&msg); break; case evtVideoUserChange : doDmc_HandleUserChange(&msg); break; case evtVideoMajorChange: doDmc_HandleMajorVideoChange(&msg); break; case evtVideoFatalError: dprint(0, "!! evtVideoFatalError: cid %d\n", msg.cancelId); doDmc_HandleMajorVideoChange(&msg); break; case evtFreezeVideoEnd: doDmc_HandleFreezeVideoEnd(&msg); break; case evtVideoScrambled: doDmc_HandleVideoScrambled(&msg); break; //--------------------------------------------- case cmdRfTune: status = doDmc_CmdRfTune(&msg); break; case cmdExtInputCapture: status = doDmc_CmdExtInputCapture(&msg); break; case cmdVideoStop: status = doDmc_CmdStop(&msg); break; case cmdRestartVideo: status = doDmc_CmdRestartVideo(&msg); break; case cmdChangeDisplay: status = doDmc_CmdChangeDisplay(&msg); break; case cmdChangeVideoAdjustment: status = doDmc_CmdChangeVideoAdjustment(&msg); break; case cmdAdjustScreen: // cafrii 060928 add status = doDmc_CmdAdjustScreen(&msg); break; case cmdVideoResize: // cafrii 060519 add status = doDmc_CmdVideoResize(&msg); break; case cmdEnqueueDPC: status = doDmc_CmdEnqueueDPC(&msg); break; //--------------------------------------------- // 아래 세 함수는 Autoscan 기능을 DMC task를 이용해서 수행하기 위해 작성되었음. // // 이 함수들은 별도로 parameter 내부에 AutoScan Callback 함수가 있어서 // 그 callback을 이용하여 대부분의 communication을 수행한다. // case cmdScanStart: status = SCN_ScanStart(&msg); break; case cmdScanStop: status = SCN_ScanStop(&msg); break; case cmdScanChannel: status = SCN_ScanOneChannel(&msg); break; //--------------------------------------------- case cmdVideoSelfDelete: dprint(1, "cmdVideoSelfDelete: cid %d\n", msg.cancelId); doDmc_Stop(); Dmc_DeleteCancelQue(); doDmc_DeleteUserMsgQue(); dmc_bInitCM = FALSE; dmc_TaskID = 0; if (msg.waitSem) DHL_OS_GiveSemaphore(msg.waitSem); DHL_OS_SelfDeleteTask(); break; default: #if DEVELOPMENT_BUILD DHL_ASSERT(0,"Dmc_Task: bad event. check event type constant."); #else dprint(0, "!! %s: bad event %d\n", __FUNCTION__, msg.type); break; #endif } // switch (event.type) label_wait_for_complete: if (msg.bWaitForComplete) { // synchronous mode로 호출된 API의 경우 // 실행후의 결과값을 리턴해줄 수 있다. dprint(2, "dmc command complete.. result %d\n", status); if (msg.pStatus) *(msg.pStatus) = status; if (msg.waitSem) DHL_OS_GiveSemaphore(msg.waitSem); else dprint(0, "!! wait mode, but no waitSem!!\n"); } } // while (1) DHL_OS_SelfDeleteTask(); } #if COMMENT _____API_________________(){} #endif //----------------------------------------------------------- // Dmc_InitChannelTask // 시스템을 초기화 하고, 비디오 테스크를 생성한다. // 이 함수는 임의의 태스크에서 불린다. // STATUS Dmc_InitChannelTask() { DHL_OS_TASK_ID tid; STATUS status; //--------- DMC component 초기화 ------------ if (dmc_bInitCM) { dprint(0, "!! dmc already inited. skip..\n"); return statusOK; } status = Dmc_InitAVResources(); if (status) { dprint(0, "!! AV resource init err %d\n", status); return status; } SCN_ScanInit(); //--------- DMC 초기화 ------------ status = doDmc_InitUserMsgQue(sizeof(DmcMessage), MAX_DECODE_MESSAGES); if (status) { dprint(0, "!! init dmc MsgQ err %d\n", status); return status; } if (Dmc_InitCancelQue(MAX_DECODE_MESSAGES)) return statusOutOfResource; tid = DHL_OS_CreateTask((DHL_OS_TASKFUNCTION)tDmc_Task, "tDmc", DMC_TASK_PRIORITY, DMC_TASK_STACKSIZE, 0); // reference // VIDEOCONTROL_TASK_PRIORITY, VIDEOCONTROL_TASK_STACKSIZE if (tid == (DHL_OS_TASK_ID)0) { dprint(0, "!!! DHL_OS_CreateTask error! dmc_TaskID %x\n", tid); return statusOutOfResource; } dmc_TaskID = tid; dmc_tsd = DHL_DMX_GetTsd(); dmc_tickStarted = DHL_OS_GetMsCount(); // cafrii 060720 add dmc_bInitCM = TRUE; return statusOK; } //----------------------------------------------------------- // Dmc_Terminate // Call this function to undo everything we did above // 사실 이 함수를 부를 일은 거의 없다. // void Dmc_EndChannelTask(void) { STATUS status; dprint(1, "Dmc_EndChannelTask()\n"); if (dmc_TaskID) { status = Dmc_SendCommandEx(cmdVideoSelfDelete, 0, NULL, TRUE, // no wait NULL, 0, // no callback TRUE); // cancel prev cmds if (status) { DHL_OS_Delay(1000); dprint(0, "!! Dmc_Task would not die\n"); //DHL_OS_DeleteTask(dmc_TaskID); dmc_TaskID = 0; } dprint(2, "Dmc_Task deleted.\n"); } // dmc_eventQ는 dmc_Task에서 삭제를 하고 self-die를 하도록 되어 있지만, // 강제 delete 된 경우라면 eventQ가 살아 있을 것임.. // 그래서 여기서 다시 한번 확인하고 삭제한다. // doDmc_DeleteUserMsgQue(); Dmc_DeleteCancelQue(); dmc_bInitCM = FALSE; // DmcTask에서 FALSE로 setting하지만 한번 더 확인. } //----------------------------------------------------------- // Dmc_GetSystemRunningTime // // return runnig time in seconds // UINT32 Dmc_GetSystemRunningTime(void) { return (DHL_OS_GetMsCount() - dmc_tickStarted)/1000; } //----------------------------------------------------------- // Dmc_StopVideo // // 모든 종류의 Audio/Video를 모두 stop 시킨다. // Analog/Digital, Air/Cable, RF/1394/DV 관계없이 현재 동작중인 작업을 모두 Stop시킨다. // STATUS Dmc_StopVideo() { dprint(1, "Dmc_StopVideo()\n"); return Dmc_SendCommand(cmdVideoStop, 0, TRUE); // cancel prev-cmds. // jump to doDmc_Stop(); } STATUS Dmc_RestartVideo(void) { // DMC task에서 불렸다면 send command를 할 필요도 없이 바로 작업 수행.. // 이 경우 항상 wait for completion 모드로 동작하게 된다. // if (Dmc_GetCurrentTaskID() == dmc_TaskID) { return doDmc_CmdRestartVideo(NULL); } else { return Dmc_SendCommand(cmdRestartVideo, 0, TRUE); // jump to doDmc_CmdRestartVideo .. } } #if COMMENT _____Enque_API__________(){} #endif void *Dmc_ParamHeapAllocator(UINT32 size) { void* ptr; ptr = DHL_OS_Malloc(size); memset(ptr, 0, size); return ptr; } void Dmc_ParamHeapDeallocator(UINT32 param) { // 실제로 arg는 어떤 메모리의 pointer일 것임. void *ptr = (void *)param; DHL_OS_Free((void**)&ptr); } //----------------- // Dmc_EnqueueDPC // // 특정 작업을 DMC task에 defer시켜서 처리하고 싶을때 사용하는 함수 // param에 memory block과 같은 리소스 링크를 사용한 경우 // 리턴값이 DmcQFull 이 될 경우를 꼭 체크해서 필요할 경우 리소스를 해제시켜야 한다. // // cafrii 070412 add more params. // 하나의 param으로는 DPC로 사용가능한 함수가 너무 제약적이다. // STATUS Dmc_EnqueueDPC(DMC_FN_DPC dpcfn, UINT32 param1, UINT32 param2, UINT32 param3, UINT32 param4, BOOL bWaitComplete) { CmdParam_DPC *paramblk; STATUS status; if (dpcfn == NULL) // 이 인자는 반드시 필요하다. 이 API의 목적이기 때문.. return statusInvalidArgument; paramblk = Dmc_ParamHeapAllocator(sizeof(CmdParam_DPC)); if (paramblk == NULL) return statusOutOfMemory; dprint(1, "Dmc_EnqueueDPC(%x, %x %x %x %x): paramblk %x\n", dpcfn, param1, param2, param3, param4, paramblk); paramblk->dpcfn = dpcfn; paramblk->param1 = param1; paramblk->param2 = param2; paramblk->param3 = param3; paramblk->param4 = param4; status = Dmc_SendCommandEx(cmdEnqueueDPC, (UINT32)paramblk, Dmc_ParamHeapDeallocator, bWaitComplete, // wait for complete NULL, 0, // user callback¶m FALSE); // do not cancel previous command // jump to doDmc_CmdEnqueueDPC // cafrii 060529 delete. codes are inside SendCommandEx. //if (status) { // Dmc_ParamHeapDeallocator((UINT32)param); //} return status; } #if COMMENT ______Tuning_API_______(){} #endif //----------------------------------------------------------- // STATUS Dmc_ChangeRfChannelByTuneParam(TuneParam *param, BOOL bWaitForCompletion, void *pfnCallback, UINT32 userparam) { TuneParam *tuneParam; STATUS status; char flagstring[50]; dprint(1, "Dmc_ChangeRfChannelTuneParam(%s)\n", bWaitForCompletion ? "wait" : "NoWait"); // Note, 030614 // bWaitForCompletion 옵션을 사용할 수 있게 하려면 TuneParam 구조체 포인터를 바로 DMC task에 // 넘기면 안되고 복사를 해야 한다. // 문제는 TuneParam 내부의 VideoStreamDescriptor 메모리 영역까지 복사를 해야 한다는 점이다. // 따라서 현재는 vidDesc 포인터 부분은 복사하지 않고 NULL로 세팅한다. tuneParam = Dmc_ParamHeapAllocator(sizeof(TuneParam)); if (tuneParam == NULL) { dprint(0, "!! ChangeRfChannel: out of memory for TuneParam\n"); return statusOutOfResource; //outOfOSResourcesError; } memcpy(tuneParam, param, sizeof(TuneParam)); // cafrii 060630 add.. 내부에서 알아서 하지만 명시적으로 지정.. if (tuneParam->vidPid == 0 && tuneParam->audPid == 0 && tuneParam->pcrPid == 0) tuneParam->flag |= CTF_SkipPrescanPidInfo; //neverdai add. 100802 after autoscan, at the first time of tuning, audio type and video type are 0. if(tuneParam->vidType == eDHL_VIDEO_TYPE_UNKNOWN && tuneParam->audType == eDHL_VIDEO_TYPE_UNKNOWN) tuneParam->flag |= CTF_SkipPrescanPidInfo; // cafrii 031205 add if ((tuneParam->flag & CTF_Mask_Tuning) == CTF_VCTOnly) { sprintf(flagstring, "0x%x: %sVCT%s%s", tuneParam->flag, tuneParam->flag & CTF_RetryAnalogIfSignalUnlock ? "[+NTSC] " : "", tuneParam->flag & CTF_RetryOtherChannel ? "+" : "", tuneParam->flag & CTF_RetryMainChannel ? "*" : ""); } else if ((tuneParam->flag & CTF_Mask_Tuning) == CTF_PSIOnly) { sprintf(flagstring, "0x%x: PSI%s", tuneParam->flag, tuneParam->flag & CTF_RetryOtherProgram ? "+" : ""); } else { sprintf(flagstring, "0x%x: %sVCT%s%s/PSI%s", tuneParam->flag, tuneParam->flag & CTF_RetryAnalogIfSignalUnlock ? "[+NTSC] " : "", tuneParam->flag & CTF_RetryOtherChannel ? "+" : "", tuneParam->flag & CTF_RetryMainChannel ? "*" : "", tuneParam->flag & CTF_RetryOtherProgram ? "+" : ""); } dprint(2, "\tParam: rf %d, type %d, p%d v%d a%d, %d-%d #%d\n" "\t flag %s\n", //tuneParam->tuneRequired ? "" : "prev", // cafrii 060630 delete tuneParam->rf, tuneParam->type, tuneParam->pcrPid, tuneParam->vidPid, tuneParam->audPid, tuneParam->major, tuneParam->minor, tuneParam->progNumber, flagstring ); status = Dmc_SendCommandEx(cmdRfTune, (UINT32)tuneParam, Dmc_ParamHeapDeallocator, bWaitForCompletion, (DMC_FN_COMPLETED)pfnCallback, userparam, TRUE); // jump to doDmc_CmdRfTune // previous command는 모두 cancel 시킨다. // cafrii 060529 delete. codes are inside SendCommandEx. //if (status) { // cafrii 040528 add err handle code // // send command에 에러가 발생하면 이 command는 감쪽같이 사라져 버린 것이므로 // // allocation한 메모리는 해제한 다음 리턴을 해야 한다. // Dmc_ParamHeapDeallocator((UINT32)tuneParam); //} return status; } STATUS Dmc_ChangeRfChannel(int rf, ModulationType type, BOOL bWaitForCompletion, void *fn, UINT32 userparam) { // RF로 바로 튜닝해서 채널 변경을 하는 함수이다. // TuneParam param, *tuneParam = ¶m; dprint(1, "Dmc_ChangeRfChannel(rf%d type %d)\n", rf, type); memset(tuneParam, 0, sizeof(TuneParam)); if (rf == 0) { ProgramAVInfo *av = Dmc_LockAVMutex(); //tuneParam->tuneRequired = FALSE; // cafrii 060630 delete tuneParam->rf = av->rf; tuneParam->type = av->mod; // // tuneRequired 라고 해도 반드시 rf에는 올바른 rf 번호를 넘겨줘야 한다. // modulation type은 내부에서 retry code가 있으므로 // digital/analog 구분만 해도 된다. Dmc_UnlockAVMutex(); dprint(2, "\tNo tunet set. previous rf %d, type %d used.\n", tuneParam->rf, tuneParam->type); } else { tuneParam->rf = rf; //tuneParam->tuneRequired = TRUE; // cafrii 060630 delete // 방법 1: 사용자가 지정한 값이 그대로 들어간다. //tuneParam->type = type; // 방법 2: Digital Cable 인 경우는 Auto detect 로 수행한다. tuneParam->type = type == 0 ? Modulation_NTSC : g_CurChannelType == ChannelType_Air ? Modulation_8VSB : Modulation_CableAuto; } tuneParam->major = tuneParam->minor = 0; tuneParam->progNumber = 0; tuneParam->flag = CTF_Automatic | CTF_RetryOtherChannel | CTF_RetryOtherProgram | CTF_DontRetryTVCTOnCable | CTF_SkipPrescanPidInfo; return Dmc_ChangeRfChannelByTuneParam(tuneParam, bWaitForCompletion, fn, userparam); } STATUS Dmc_ChangeRfChannel2(int rf, ModulationType type, int pPid, int vPid, int aPid, int major, int minor, int progNumber, BOOL bWaitForCompletion, void *fn, UINT32 userparam) { // // if you don't want to use prescan PIDs, set PIDs to all zero. // if one of these three is non-zero, // 'pPid' should be non-zero. // 'vPid' or 'aPid' either should be non-zero. // // ex: // 6-1, #3 : try VCT 6-1 first -> try #3 PMT program. // 9-1, #0 : try VCT 9-1 first -> try any program. // 0-0, #2 : try any VCT channel -> try #2 PMT program. // 9-1, #-1 : try VCT 9-1. do not use PSI info. // 0-0, #0 : try any VCT channel -> try any program. // -1-?, #2 : try #2 PMT program. do not use VCT info. // -1-?, #0 : try any PMT program. do not use VCT info. // -1-?, #-1 : error. TuneParam param_0, *param = ¶m_0; dprint(1, "Dmc_ChangeRfChannel2(rf%d type %d)\n", rf, type); // cafrii, for safety, reset first.. memset(param, 0, sizeof(TuneParam)); // if 'rf' is zero, we do not set tuner. use last tuned frequency. if (rf == 0) { ProgramAVInfo *av = Dmc_LockAVMutex(); param->rf = av->rf; param->type = av->mod; //param->tuneRequired = FALSE; // cafrii 060630 delete Dmc_UnlockAVMutex(); dprint(2, "\tNo tunet set. previous rf %d, type %d used.\n", param->rf, param->type); } else { param->rf = rf; //param->tuneRequired = TRUE; // cafrii 060630 delete param->type = type; } // if PID values are zero, we will ignore this pre-scan PID values. if (pPid == 0 && vPid == 0 && aPid == 0) { param->flag |= CTF_SkipPrescanPidInfo; } else { param->pcrPid = pPid; param->vidPid = vPid; param->audPid = aPid; } // if 'major' is zero, we will tune first (lowest) channels and repeat next channel if error. // if 'major' is non-zero, we try only that major-minor channel, not others. param->major = major; param->minor = minor; //leon 2003.10.30 audio is mute bug at ATSC // if audio type is AC-3, mute bug. //param->audType = (tDHL_AudioCodingType) 0; if (major == 0) param->flag |= CTF_RetryOtherChannel; else if (major < 0) param->flag = ((param->flag & ~CTF_Mask_Tuning) | CTF_PSIOnly); // do not use VCT info. // if 'progNumber' is non-zero, do not use VCT info. PSI only mode. param->progNumber = progNumber; if (progNumber == 0) param->flag |= CTF_RetryOtherProgram; else if (progNumber < 0) param->flag = ((param->flag & ~CTF_Mask_Tuning) | CTF_VCTOnly); // do not use PSI info. //param->flag |= CTF_DontRetryTVCTOnCable; // for PCE, this flag also available. return Dmc_ChangeRfChannelByTuneParam(param, bWaitForCompletion, fn, userparam); // param 구조체는 Dmc_ChangeRfChannelByTuneParam() 함수 안에서 // 다시 allocate하므로 여기서는 간단하게 stack을 이용해도 된다. } //---------------------- // Dmc_ChangeExtInput // // // // STATUS Dmc_ChangeExtInput(tDHL_CapVideoInput video, tDHL_CapAudioInput audio, BOOL bWaitForCompletion) { // 지금은 callback을 지원하지는 않는다. // video와 audio input은 서로 일치하도록 지정해줘야 한다. STATUS status; CaptureParam *pCapParam; dprint(1, "Dmc_ChangeExtInput(video %d, audio %d, %s)\n", video, audio, bWaitForCompletion ? "wait" : "NoWait"); pCapParam = Dmc_ParamHeapAllocator(sizeof(CaptureParam)); if (pCapParam == NULL) { dprint(0, "!! Dmc_ChangeExtInput: out of memory for CaptureParam\n"); return statusOutOfMemory; } pCapParam->input_video = video; pCapParam->input_audio = audio; status = Dmc_SendCommandEx(cmdExtInputCapture, (UINT32)pCapParam, Dmc_ParamHeapDeallocator, TRUE, // wait for complete NULL, 0, // user callback¶m TRUE); // cancel prev commands // jump to doDmc_CmdExtInputCapture // cafrii 060529 delete. codes are inside SendCommandEx. //if (status) { // // send command에 에러가 발생하면 이 command는 감쪽같이 사라져 버린 것이므로 // // allocation한 메모리는 해제한 다음 리턴을 해야 한다. // // // Dmc_ParamHeapDeallocator((UINT32)pCapParam); //} return status; } //---------------------- // Dmc_ChangeProgram // // Digital TS playback 일 경우 다른 program을 play한다. // play하고 싶은 program number를 지정한다. // invalid된 program_number를 지정하면 next program을 선택. // 만약 1 program 만 있는 경우라면 no action.. // STATUS Dmc_ChangeProgram(int program_number, BOOL bWaitForCompletion) { int i; STATUS status; ProgramAVInfo *av; dprint(1, "Dmc_ChangeProgram(prog num %d, wait %d)\n", program_number, bWaitForCompletion); // AVInfo mutex와 PSI mutex 두개가 동시에 필요한데, // dead-lock의 위험을 피하기 위해서 aVInfo는 복사해서 사용하고 // psi mutex만 사용하기로 한다. av = Dmc_LockAVMutex(); if (av->active == 0 || av->analog) { dprint(0, "!! ChangeAudio: invalid state! active %d, analog %d\n", av->active, av->analog); status = statusInvalidState; goto label_exit; } // PMT를 찾아서 새 프로그램의 program_number만 건네준다. if (program_number <= 0) { // next program mode.. for (i=0; ipat->numPrograms; i++) { if (av->pat->programs[i].program_number == av->program_number) break; } if (i >= av->pat->numPrograms) { dprint(0, "!! ChangeProgram: cannot find current program !\n"); status = statusInvalidPSI; goto label_exit; } if (av->pat->numPrograms < 2) { dprint(0, "\tonly one program exist. no other program !\n"); status = statusNotFound; goto label_exit; } // 다음 프로그램을 선택한다. 마지막이면 wrap-around 된다. program_number = av->pat->programs[(i+1)%av->pat->numPrograms].program_number; } if (1) { // NIM mode TuneParam param; memset(¶m, 0, sizeof(TuneParam)); param.rf = av->rf; param.type = av->mod; //param.tuneRequired = FALSE; // cafrii 060630 delete param.flag = CTF_PSIOnly; param.progNumber = program_number; dprint(2, " program number %d selected (rf %d, type %d)\n", program_number, param.rf, param.type); // 밑에서 tuning 함수가 synchronous mode일 수 있기 때문에 // lock을 풀어줘야만 한다. // Dmc_UnlockAVMutex(); status = Dmc_ChangeRfChannelByTuneParam(¶m, bWaitForCompletion, NULL, 0); return status; } label_exit: Dmc_UnlockAVMutex(); return status; } #if COMMENT ______ETC_API_______(){} #endif #if 0 STATUS dmc_change_audio_stream(UINT32 param1, UINT32 param2, UINT32 param3) { // this function should be called in DMC task!! // DHL_RESULT dhlResult; STATUS status; // cafrii 070412 change 새롭게 변경된 DPC 구조에 맞춤. // UINT32 audioPID = param1; UINT32 pcrPID = param2; tDHL_AudioCodingType audioType = (tDHL_AudioCodingType) param3; DHL_AUD_STREAMTYPE streamType; ProgramAVInfo *av; av = Dmc_LockAVMutex(); if (av->active == 0 || av->analog) { dprint(0, "!! ChangeAudio: invalid state! active %d, analog %d\n", av->active, av->analog); status = statusInvalidState; goto label_end; } streamType = audioType == tDHL_AudioCodingType_AC3 ? DHL_STREAM_AUDIO_AC3 : audioType == tDHL_AudioCodingType_MPEG_2 ? DHL_STREAM_AUDIO_MPEG2 : audioType == tDHL_AudioCodingType_AAC ? DHL_STREAM_AUDIO_AAC : DHL_STREAM_AUDIO_AC3; // default.. if (pcrPID == 0) { dprint(2, " pcrPID 0.. use current pcr %d\n", av->pcr_pid); pcrPID = av->pcr_pid; } dprint(2, " stop current audio..\n"); dhlResult = DHL_AV_AudioStop(); // just continue without error check dprint(2, " restart new audio (%d, %d, 0x%x)..\n", audioPID, pcrPID, streamType); dhlResult = DHL_AV_AudioStart(audioPID, pcrPID, streamType); status = dhlResult ? statusError : statusOK; av->audio_pid = audioPID; // 에러가 발생했어도 pid는 update를 해주자.. label_end: Dmc_UnlockAVMutex(); return status; } #else STATUS dmc_change_audio_stream(UINT32 audioPID, UINT32 pcrPID, tDHL_AudioCodingType audioType) { ProgramAVInfo *av; STATUS status; dprint(1, "%s (0x%x 0x%x)\n", __FUNCTION__, audioPID, pcrPID); if (pcrPID == 0) { av = Dmc_LockAVMutex(); dprint(2, " pcrPID 0.. use current pcr %d\n", av->pcr_pid); pcrPID = av->pcr_pid; Dmc_UnlockAVMutex(); } // audio 만 stop을 한다. video는 건드리면 안됨. doDmc_StopDigitalAudio(); // video는 빼고 audio만 start를 한다. status = doDmc_StartDigital(0, /* uVidPID */ audioPID, pcrPID, (DMC_VIDEO_CACHE)0, /* DMC_VIDEO_CACHE vcache */ (tDHL_VideoCodingType)0, audioType); av = Dmc_LockAVMutex(); if (status) { av->audio_pid = 0; } else { av->audio_pid = audioPID; av->audio_type = audioType; av->pcr_pid = pcrPID; } label_end: Dmc_UnlockAVMutex(); return status; } #endif STATUS dmc_change_video_stream(UINT32 videoPID, UINT32 pcrPID, tDHL_VideoCodingType videoType) { ProgramAVInfo *av; STATUS status; dprint(1, "%s (0x%x 0x%x)\n", __FUNCTION__, videoPID, pcrPID); if (pcrPID == 0) { av = Dmc_LockAVMutex(); dprint(2, " pcrPID 0.. use current pcr %d\n", av->pcr_pid); pcrPID = av->pcr_pid; Dmc_UnlockAVMutex(); } // video 만 stop을 한다. doDmc_StopDigitalVideo(FALSE); // cache에 저장 하지 않음.. // video만 start를 한다. status = doDmc_StartDigital(videoPID, 0, /* uAudPID */ pcrPID, (DMC_VIDEO_CACHE)0, /* DMC_VIDEO_CACHE vcache */ videoType, (tDHL_AudioCodingType)0 /* tDHL_AudioCodingType */ ); av = Dmc_LockAVMutex(); if (status) { av->video_pid = 0; } else { av->video_pid = videoPID; av->video_type=videoType; av->pcr_pid = pcrPID; } Dmc_UnlockAVMutex(); return status; } STATUS Dmc_ChangeAudioStream(UINT32 audioPID, UINT32 pcrPID, tDHL_AudioCodingType audioType) { // Audio만 다시 선택하여 재생한다. // 직접 Dmc_Audio API를 이용해도 되지만, ChannelTask에서 warpper API를 별도로 제공한다. // // 이미 digital TS가 가동중이어야 한다. (from NIM이든, from 1394든 구별하지 않음) // // DmcAudioAPI는 dmc_tsd 를 입력으로 하는데, dmc_tsd는 마지막 tuning API에서 // 설정된 것을 그대로 사용한다. // PCR PID를 0으로 지정하면 기존 PCR PID를 그대로 사용한다. (일반적인 상황임) // audioType 은 일반적으로 AC3 (2)의 값을 가질 것이다. // STATUS status; if (audioPID == 0) return statusInvalidArgument; // Updated by Chjeon 2007.09.07 if (Dmc_IsDmcTask()) { // Caller is DmcTask (Direct Call) status = dmc_change_audio_stream(audioPID, pcrPID, audioType); } else { // Caller is not DmcTask (Deffered Call) status = Dmc_EnqueueDPC((DMC_FN_DPC)dmc_change_audio_stream, audioPID, pcrPID, audioType, 0, FALSE); } return status; } STATUS Dmc_ChangeVideoStream(UINT32 videoPID, UINT32 pcrPID, tDHL_VideoCodingType videoType) { STATUS status; if (videoPID == 0) return statusInvalidArgument; // Updated by Chjeon 2007.09.07 if (Dmc_IsDmcTask()) { // Caller is DmcTask (Direct Call) status = dmc_change_video_stream(videoPID, pcrPID, videoType); } else { // Caller is not DmcTask (Deffered Call) status = Dmc_EnqueueDPC((DMC_FN_DPC)dmc_change_video_stream, videoPID, pcrPID, videoType, 0, FALSE); // Wait Option 추가 FALSE 기다리지 않는다 . } return status; } #if COMMENT ______Wrapper_API_______(){} #endif // cafrii 070830 comment // // 이 함수들은 사실상 Channel Tuning 작업과 큰 관련이 없는 작업 들이다. // // 이런 함수의 호출은 cancel 동작에 애매함만 가중시키기 때문에 // 가능하면 HAL 함수를 직접 사용하도록 변경하는 게 낫다. // // Channel Tuning Task는 오로지 시간이 많이 소요되는 Channel Tuning 작업만 전담하도록 한다. // /* 출력 timing 설정하는 API. */ STATUS Dmc_ChangeDisplay(VOUT_COLOR color, VOUT_FORMAT format, VOUT_RATIO ratio, tDHL_DispARC ScrAdj, AuxVideoSetting AuxType) { CmdParam_ChangeDisplay param; STATUS status; param.color = color; param.format = format; param.ratio = ratio; param.adj = ScrAdj; param.aux = AuxType; #if SUPPORT_ETC_API_SYNC status = Dmc_SendCommand(cmdChangeDisplay, (UINT32)¶m, FALSE); // jump to doDmc_CmdChangeDisplay #else // 현재의 task에서 직접 호출. status = Dmc_ExecuteCommand(cmdChangeDisplay, (UINT32)¶m, doDmc_CmdChangeDisplay); #endif return status; } /* 출력 Aspect Ration Adjustment 설정/변경 하는 API. 미리 출력 timing 설정이 되어 있어야 한다. */ STATUS Dmc_ChangeVideoAdjustment(tDHL_DispARC adj_hd, tDHL_DispARC adj_sd) { STATUS status; UINT32 param; dprint(1, "Dmc_VideoAspectRatioAdjustment(%d, %d)\n", adj_hd, adj_sd); param = ((UINT32)adj_sd << 16) | ((UINT32)adj_hd & 0xffff); #if SUPPORT_ETC_API_SYNC // send command with wait mode, not cancel prev commands.. status = Dmc_SendCommand(cmdChangeVideoAdjustment, param, FALSE); // jumpt doDmc_CmdChangeVideoAdjustment #else // 현재의 task에서 직접 호출. status = Dmc_ExecuteCommand(cmdChangeVideoAdjustment, param, doDmc_CmdChangeVideoAdjustment); #endif return status; } /* 비디오의 출력 화면 설정하는 API. Dmc_ChangeVideoAdjustment의 super set 기능. */ STATUS Dmc_AdjustVideoScreen(tDHL_DispARC adj, INT32 x, INT32 y, INT32 w, INT32 h) { STATUS status; CmdParam_AdjustScreen param; dprint(1, "Dmc_AdjustVideoScreen(%d, %d)\n", adj); param.adj = adj; param.x = x; param.y = y; param.w = w; param.h = h; #if SUPPORT_ETC_API_SYNC // send command with wait mode, not cancel prev commands.. status = Dmc_SendCommand(cmdAdjustScreen, (UINT32)¶m, FALSE); // jumpt doDmc_CmdAdjustScreen #else // 현재의 task에서 직접 호출. status = Dmc_ExecuteCommand(cmdAdjustScreen, (UINT32)¶m, doDmc_CmdAdjustScreen); #endif return status; } /* 비디오 화면이 나오는 window 크기를 변경하는 함수. */ STATUS Dmc_ResizeVideo(INT32 x, INT32 y, UINT32 w, UINT32 h) { // cafrii 060519 add CmdParam_VideoResize param; STATUS status; param.x = x; param.y = y; param.w = w; param.h = h; #if SUPPORT_ETC_API_SYNC // send command with wait mode, not cancel prev commands.. status = Dmc_SendCommand(cmdVideoResize, (UINT32)¶m, FALSE); // jump to doDmc_CmdVideoResize #else // 현재의 task에서 직접 호출. status = Dmc_ExecuteCommand(cmdVideoResize, (UINT32)¶m, doDmc_CmdVideoResize); #endif return status; } STATUS Dmc_FreezeVideo(UINT32 bFreeze, BOOL bWaitComplete) { #if SUPPORT_ETC_API_SYNC // cafrii 070830 do not synchronize dmc task // cafrii 070412 add 'bWaitComplete' arg. // app may want to call hide/show command without pending. // but app should care all possible side-effects when 'No Wait' mode is used. // if (bWaitComplete && !Dmc_IsDmcTask()) { dprint(1, "Dmc_FreezeVideo(%d)\n", bFreeze); return Dmc_EnqueueDPC((DMC_FN_DPC)Dmc_FreezeVideo, (UINT32)bFreeze, FALSE, 0, 0, TRUE); } #endif // SUPPORT_ETC_API_SYNC { DHL_RESULT dhlResult = DHL_OK; dprint(1, "cmdVideoFreeze(%d):\n", bFreeze); dhlResult = DHL_AV_VideoFreeze(0, bFreeze ? TRUE : FALSE); return dhlResult ? statusError : statusOK; } } STATUS Dmc_HideVideo(UINT32 bHide, BOOL bWaitComplete) { #if SUPPORT_ETC_API_SYNC // cafrii 070830 do not synchronize dmc task // cafrii 070412 add 'bWaitComplete' arg. // app may want to call hide/show command without pending. // but app should care all possible side-effects when 'No Wait' mode is used. // if (bWaitComplete && !Dmc_IsDmcTask()) { dprint(1, "Dmc_HideVideo(%d)\n", bHide); return Dmc_EnqueueDPC((DMC_FN_DPC)Dmc_HideVideo, (UINT32)bHide, FALSE, 0, 0, TRUE); } #endif // SUPPORT_ETC_API_SYNC { DHL_RESULT dhlResult = DHL_OK; dprint(1, "cmdVideoHide(%d):\n", bHide); if (bHide) dmc_bRequestVideoHide |= DMC_VIDEO_HIDE_USER; else dmc_bRequestVideoHide &= ~DMC_VIDEO_HIDE_USER; if (1) { ProgramAVInfo *av = Dmc_LockAVMutex(); av->video_hidden = (dmc_bRequestVideoHide & DMC_VIDEO_HIDE_USER) ? TRUE : FALSE; Dmc_UnlockAVMutex(); } dhlResult = DHL_AV_VideoHide(0, dmc_bRequestVideoHide ? TRUE : FALSE); return dhlResult ? statusError : statusOK; } } #if COMMENT ________(){} #endif #if DMW_REGISTER_DEBUG_SYMBOL static DHL_SymbolTable ChannelSymbols[] = { //---- functions DHL_FNC_SYM_ENTRY(Dmc_StopVideo), DHL_FNC_SYM_ENTRY(Dmc_FreezeVideo), DHL_FNC_SYM_ENTRY(Dmc_RestartVideo), DHL_FNC_SYM_ENTRY(Dmc_HideVideo), DHL_FNC_SYM_ENTRY(Dmc_ChangeDisplay), DHL_FNC_SYM_ENTRY(Dmc_ChangeVideoAdjustment), DHL_FNC_SYM_ENTRY(Dmc_ResizeVideo), DHL_FNC_SYM_ENTRY(Dmc_ChangeRfChannelByTuneParam), DHL_FNC_SYM_ENTRY(Dmc_ChangeRfChannel), DHL_FNC_SYM_ENTRY(Dmc_ChangeRfChannel2), DHL_FNC_SYM_ENTRY(Dmc_ChangeExtInput), DHL_FNC_SYM_ENTRY(Dmc_ChangeProgram), DHL_FNC_SYM_ENTRY(Dmc_ChangeAudioStream), //---- variables DHL_VAR_SYM_ENTRY(g_Timeout_SignalLock), DHL_VAR_SYM_ENTRY(g_Timeout_AnalogSignalLock), DHL_VAR_SYM_ENTRY(g_Timeout_VctLoading), DHL_VAR_SYM_ENTRY(g_Timeout_PatLoading), DHL_VAR_SYM_ENTRY(g_Timeout_PmtLoading), //DHL_VAR_SYM_ENTRY(g_Trace_DmcMain), DHL_VAR_SYM_ENTRY(dmc_bTestNoAux), }; #endif // DMW_REGISTER_DEBUG_SYMBOL void Dmc_RegisterChannelSymbols() { #if DMW_REGISTER_DEBUG_SYMBOL DHL_DBG_RegisterSymbols(ChannelSymbols, DHL_NUMSYMBOLS(ChannelSymbols)); RegisterChannelAVSymbols(); RegisterChannelTuneSymbols(); RegisterChannelUtilSymbols(); RegisterChannelScanSymbols(); #endif } /************************************************************************** 2.26 2005/4/4 Dmc_Init에서 Demux start 추가 2.25 2005/3/22 Dmc_IsDmcTask 추가 dmc_TaskID 의 const specifier 삭제 2.24 2005/3/15 ParseXXX API 사용 후 에러 리턴하면 반드시 pointer NULL 설정하도록 수정 MonitorPMT의 pid값 validity 체크 NtscFreqOffset->freqOffset 이름 변경 2.23 2005/2/21 ProcessTimingChange 에서 source/display wide를 구분해서 적용 2.22 2005/1/26 DigitalCable 튜닝시 모든 modulation에 g_Timeout_SignalLock 적용 2.21 2005/1/24 ReportCaPmt in NTSC, dmc_bRequestVideoWidthReduction 관련 초기값 지정 2.20 2005/01/19 Tning시 Modulation 자동 검색 기능 추가 2.19 2004/12/01 PmtChange 에도 DHL_AV_ReportPmtChange 추가 단 PodActiveMode 에서만 호출하도록 함. tuner set 후 성공이면 DHL_AV_ReportTunerStatus 전송 Pod 모드에서 PSI로만 튜닝하도록 수정 CTF_SkipPrescanPidInfo 조건 추가 doDmc_MakeAppBannerPararm 에 program_number 추가 2.18 2004/11/11 AppBannerParam 에서 type field 추가 2.17 2004/11/10 PID tuning에서 StartDigital이 cancel 된 경우 처리 추가 2.16 2004/11/5 Dmc_PrintVideoFormat debug level 추가 2.15 2004/11/4 Dmc_ChangeRfChannel 에서 digital cable이면 modulation autodetect 모드 analog RfTune/video restart 에서 freeze 적용 2.14 2004/11/3 audio only 채널에서 AddProgramFlattenInfo 하지 않음, pcr pid update Dmc_PrintProgramInfo 에서 dbg level 인수 추가 2.13 2004/9/20 DMW_Config 도입, config 사항 이동 2.12 2004/9/10 cancel id 관련 디버그 메시지를 추가 Dmc_RegisterPodActivityReporter 추가 2.11 2004/9/03 Video width reduction 함수/변수 추가 IsWideDisplay api 추가 ChangeDisplayEx 에서 wide 인자 사용하지 않음 2.10 2004/8/30 ChannelAPI 헤더 분리, Channel.h 에 HAL, ChannelType 등의 변수 추가 2.09 2004/7/26 send_command에서 OS_LockTask/OS_UnlockTask 추가 2.08 2004/7/23 debug print categorization 2.07 2004/7/21 comment update, restructuring of CmdParam_xxx 2.06 2004/7/8 smart video freeze, selective audio play bugfix deferred video adjustment 2.05 2004/6/16 xVCT,PSI에서 selectAudioStream에 audio type 추가, audType display bugfix ChangeAudioStream, PlayNextAudio 추가 _Dmc_DecodeStopCallback 구현하고 StopDigitalVideoCtx에서 이를 불러줌 2.04 2004/06/04 tuning할때 selectAudioStream 이후 pid가 유효한지 체크한 후 에러처리 2.03 2004/06/03 _dmc_PatEventProc에서 dmc_pmtPsiCtl 체크 2.02 2004/06/01 Dmc_EnqueueDPC API 추가 2.01 2004/05/31 statusDmcQFull 체크 추가 2.0 2004/05/28 send_command 실패할 경우 리소스 누수 문제 수정 tunecallback에 userparam 추가 1.4 2004/01/12 SLD 없는 VCT일 경우 PSI 우회 처리 기능 추가 , #SupportVCTWithoutSLD 1.3 2003/12/31 AppBanner지원, CTF_SemiAutomatic 추가 1.2 2003/12/30 새로운 PCE Tuning Policy적용. CTF_RetryMainChannel 추가 1.1 2003/12/05 에러 발생시 retry를 할 수 있도록 플래그 추가 1.0 2003/11/27 remove all VideoFlatten feature (do not use anymore) support 1394 by default (remove SUPPORT_1394_INPUT) * **************************************************************************/