ctrl.c

基于嵌入式linux的程序

    videoKbpsf   = gblGetAndResetVideoBytesEncoded() * 8.0 / deltaTime;
    videoKbps    = videoKbpsf + 0.5;

    soundKbpsf   = gblGetAndResetSoundBytesEncoded() * 8.0 / deltaTime;
    soundKbps    = soundKbpsf + 0.5;

    uiClearScreen(COLUMN_2, 0, COLUMN_3 - COLUMN_2, yScale(220), *workingIdx);

    if (getArmCpuLoad(&procLoad, &armLoad) != FAILURE) {
        sprintf(tempString, "%d%%", procLoad);
        uiDrawText(tempString, COLUMN_2, ROW_1, *workingIdx); 
    }
    else {
        ERR("Failed to get ARM CPU load\n");
    }

    dspLoad = Engine_getCpuLoad(hEngine);

    if (dspLoad > -1) {
        sprintf(tempString, "%d%%", dspLoad); 
        uiDrawText(tempString, COLUMN_2, ROW_2, *workingIdx); 
    }
    else {
        ERR("Failed to get DSP CPU load\n");
    }

    sprintf(tempString, "%d fps", fps);
    uiDrawText(tempString, COLUMN_2, ROW_3, *workingIdx); 

    sprintf(tempString, "%d kbps", videoKbps);
    uiDrawText(tempString, COLUMN_2, ROW_4, *workingIdx); 

    sprintf(tempString, "%d kbps", soundKbps);
    uiDrawText(tempString, COLUMN_2, ROW_5, *workingIdx); 

    timePassed = localtime(&spentTime);
    if (timePassed == NULL) {
        return;
    }

    sprintf(tempString, "%.2d:%.2d:%.2d", timePassed->tm_hour,
                                          timePassed->tm_min,
                                          timePassed->tm_sec);
    uiDrawText(tempString, COLUMN_2, ROW_6, *workingIdx); 

    *displayIdx = (*displayIdx + 1) % NUM_BUFS;
    *workingIdx = (*workingIdx + 1) % NUM_BUFS;

    setOsdBuffer(osdFd, *displayIdx);

    waitForVsync(osdFd);
}

/******************************************************************************
 * keyAction
 ******************************************************************************/
static int keyAction(enum msp430lib_keycode key, int displayIdx,
                     int *osdTransPtr)
{
    static int osdVisible = TRUE;
    switch(key) {
        case MSP430LIB_KEYCODE_OK:              
        case MSP430LIB_KEYCODE_RECORD:
            DBG("Play button pressed\n");
            gblSetRecord(TRUE);

            if (uiPressButton(BTNIDX_CTRLREC, displayIdx) == FAILURE) {
                return FAILURE;
            }
            break;

        case MSP430LIB_KEYCODE_PAUSE:
            DBG("Pause button pressed\n");
            gblSetRecord(FALSE);

            if (uiPressButton(BTNIDX_CTRLPAUSE, displayIdx) == FAILURE) {
                return FAILURE;
            }
            break;

        case MSP430LIB_KEYCODE_STOP:
            DBG("Stop button pressed, quitting demo..\n");
            gblSetQuit();
            break;

        case MSP430LIB_KEYCODE_VOLINC:
            DBG("Volume inc button pressed\n");
            if (*osdTransPtr < MAX_TRANSPARENCY && osdVisible) {
                *osdTransPtr += INC_TRANSPARENCY;
                setOsdTransparency(*osdTransPtr);
            }

            if (uiPressButton(BTNIDX_NAVPLUS, displayIdx) == FAILURE) {
                return FAILURE;
            }
            break;

        case MSP430LIB_KEYCODE_VOLDEC:
            DBG("Volume dec button pressed\n");
            if (*osdTransPtr > MIN_TRANSPARENCY && osdVisible) {
                *osdTransPtr -= INC_TRANSPARENCY;
                setOsdTransparency(*osdTransPtr);
            }

            if (uiPressButton(BTNIDX_NAVMINUS, displayIdx) == FAILURE) {
                return FAILURE;
            }
            break;

        case MSP430LIB_KEYCODE_INFOSELECT:
            DBG("Info/select command received.\n");
            if (osdVisible) {
                setOsdTransparency(NO_TRANSPARENCY);
                osdVisible = FALSE;
            }
            else {
                setOsdTransparency(*osdTransPtr);
                osdVisible = TRUE;
            }   
            break;

        default:
            DBG("Unknown button pressed.\n");
            if (uiPressButton(BTNIDX_WRONGPRESSED, displayIdx) == FAILURE) {
                return FAILURE;
            }
    }

    return SUCCESS;
}

/******************************************************************************
 * getKbdCommand
 ******************************************************************************/
int getKbdCommand(enum msp430lib_keycode *keyPtr)
{
    struct timeval tv;
    fd_set         fds;
    int            ret;
    char           string[80];

    FD_ZERO(&fds);
    FD_SET(fileno(stdin), &fds);

    /* Timeout of 0 means polling */
    tv.tv_sec = 0;
    tv.tv_usec = 0;

    ret = select(FD_SETSIZE, &fds, NULL, NULL, &tv);

    if (ret == -1) {
        ERR("Select failed on stdin (%s)\n", strerror(errno));
        return FAILURE;
    }

    if (ret == 0) {
        return SUCCESS;
    }

    if (FD_ISSET(fileno(stdin), &fds)) {
        if (fgets(string, 80, stdin) == NULL) {
            return FAILURE;
        }

        /* Remove the end of line */
        strtok(string, "\n");

        /* Assign corresponding msp430lib key */
        if (strcmp(string, "rec") == 0) {
            *keyPtr = MSP430LIB_KEYCODE_RECORD;
        }
        else if (strcmp(string, "pause") == 0) {
            *keyPtr = MSP430LIB_KEYCODE_PAUSE;
        }
        else if (strcmp(string, "stop") == 0) {
            *keyPtr = MSP430LIB_KEYCODE_STOP;
        }
        else if (strcmp(string, "inc") == 0) {
            *keyPtr = MSP430LIB_KEYCODE_VOLDEC;
        }
        else if (strcmp(string, "dec") == 0) {
            *keyPtr = MSP430LIB_KEYCODE_VOLINC;
        }
        else if (strcmp(string, "hide") == 0) {
            *keyPtr = MSP430LIB_KEYCODE_INFOSELECT;
        }
        else if (strcmp(string, "help") == 0) {
            printf("\nAvailable commands:\n"
                   "    rec   - Record video and sound\n"
                   "    pause - Pause video and sound\n"
                   "    stop  - Quit demo\n"
                   "    inc   - Increase OSD transparency\n"
                   "    dec   - Decrease OSD transparency\n"
                   "    hide  - Show / hide the OSD\n"
                   "    help  - Show this help screen\n\n");
        }
        else {
            printf("Unknown command: [ %s ]\n", string);
        }

        if (*keyPtr != MSP430LIB_KEYCODE_STOP) {
            printf(COMMAND_PROMPT);
            fflush(stdout);
        }
        else {
            printf("\n");
        }
    }

    return SUCCESS;
}

/******************************************************************************
 * ctrlThrFxn
 ******************************************************************************/
void *ctrlThrFxn(void *arg)
{
    Engine_Handle          hEngine          = NULL;
    unsigned int           initMask         = 0;
    CtrlEnv               *envp             = (CtrlEnv *) arg;
    int                    osdTransparency  = OSD_TRANSPARENCY;
    void                  *status           = THREAD_SUCCESS;
    int                    displayIdx       = 0;
    int                    workingIdx       = 1;
    char                  *osdDisplays[NUM_BUFS];
    enum msp430lib_keycode key;
    UIParams               uiParams;
    int                    osdFd;
    int                    timeSpent;

    /* Initialize the OSD */
    osdFd = osdInit(osdDisplays);

    if (osdFd == FAILURE) {
        cleanup(THREAD_FAILURE);
    }

    DBG("OSD successfully initialized\n");

    initMask |= OSDINITIALIZED;

    /* Initialize the OSD transparency */
    if (setOsdTransparency(osdTransparency) == FAILURE) {
        cleanup(THREAD_FAILURE);
    }

    DBG("OSD transparency initialized\n");

    /* Reset, load, and start DSP Engine */
    hEngine = Engine_open(ENGINE_NAME, NULL, NULL);

    if (hEngine == NULL) {
        ERR("Failed to open codec engine %s\n", ENGINE_NAME);
        cleanup(THREAD_FAILURE);
    }

    DBG("Codec Engine opened in control thread\n");

    initMask |= ENGINEOPENED;

    /* Initialize the MSP430 library to be able to receive IR commands */
    if (msp430lib_init() == MSP430LIB_FAILURE) {
        ERR("Failed to initialize msp430lib.\n");
        cleanup(THREAD_FAILURE);
    }

    DBG("MSP430 library initialized\n");

    initMask |= MSP430LIBINITIALIZED;

    /* Create the user interface */
    uiParams.speechEncoder = envp->speechEncoder;
    uiParams.videoEncoder  = envp->videoEncoder;
    uiParams.osdDisplays   = osdDisplays;
    uiParams.speechFile    = envp->speechFile;
    uiParams.videoFile     = envp->videoFile;
    uiParams.imageWidth    = envp->imageWidth;
    uiParams.imageHeight   = envp->imageHeight;

    if (uiCreate(&uiParams) == FAILURE) {
        cleanup(THREAD_FAILURE);
    }

    DBG("User interface created\n");

    initMask |= UICREATED;

    /* Signal that initialization is done and wait for other threads */
    Rendezvous_meet(envp->hRendezvous);

    /* Initialize the ARM cpu load */
    getArmCpuLoad(NULL, NULL);

    if (envp->keyboard) {
        printf(COMMAND_PROMPT);
        fflush(stdout);
    }

    DBG("Entering control main loop.\n");
    while (!gblGetQuit()) {
        /* Draw the cpu load on the OSD */
        drawDynamicData(hEngine, osdFd, &timeSpent, &displayIdx, &workingIdx);

        /* Has the demo timelimit been hit? */
        if (envp->time > FOREVER && timeSpent >= envp->time) {
            breakLoop(THREAD_SUCCESS);
        }

        /* See if an IR remote key has been pressed */
        if (msp430lib_get_ir_key(&key) == MSP430LIB_FAILURE) {
            DBG("Failed to get IR value.\n");
        }

        if (envp->keyboard) {
            if (getKbdCommand(&key) == FAILURE) {
                breakLoop(THREAD_FAILURE);
            }
        }

        /* If an IR key had been pressed, service it */
        if (key != 0) {
            if (keyAction(key, displayIdx, &osdTransparency) == FAILURE) {
                breakLoop(THREAD_FAILURE);
            }
        }

        usleep(REMOTECONTROLLATENCY);
    }

cleanup:
    /* Make sure the other threads aren't waiting for init to complete */
    Rendezvous_force(envp->hRendezvous);

    /* Clean up the control thread */
    if (initMask & UICREATED) {
        uiDelete();
    }

    if (initMask & MSP430LIBINITIALIZED) {
        msp430lib_exit();
    }

    if (initMask & ENGINEOPENED) {
        Engine_close(hEngine);
    }

    if (initMask & OSDINITIALIZED) {
        osdExit(osdFd);
    }

    return status;
}