tparty.c

codec engine中的视频操作界面的历程

/*
 * tparty.c
 *
 * ============================================================================
 * Copyright (c) Texas Instruments Inc 2005
 *
 * Use of this software is controlled by the terms and conditions found in the
 * license agreement under which this software has been supplied or provided.
 * ============================================================================
 */

/* Standard Linux headers */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <dirent.h>
#include <string.h>
#include <errno.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>

/* Davinci EVM utility libraries */
#include <msp430lib.h>
#include <simplewidget.h>

/* Application header file */
#include "interface.h"

#define START_PICTURE  "data/pics/startup.png"

#define NAV_BUTTON_X              225
#define NAV_BUTTON_Y              310

#define WRONG_BUTTON_X            100
#define WRONG_BUTTON_Y            340

#define NAV_BUTTON                "data/pics/Button_DIAG.png"
#define NAV_BUTTON_OK_PRESSED     "data/pics/Center_Diag_SEL.png"
#define NAV_BUTTON_UP_PRESSED     "data/pics/Top_Diag_SEL.png"
#define NAV_BUTTON_DOWN_PRESSED   "data/pics/Bottom_Diag_SEL.png"

#define WRONG_BUTTON              "data/pics/nowrongbutton.png"
#define WRONG_BUTTON_PRESSED      "data/pics/wrongbutton.png"

#define THIRDPARTY_DEMODIR "thirdpartydemos"
#define DESTINATION_DIR "/tmp"
#define READMETXT_MAXSIZE 40

#define MAX_FILES 4

#define SELECTOR_X 130
#define SELECTOR_Y 40
#define SELECTOR_W 500
#define SELECTOR_H 35

#define SELECTOR_R 0xff
#define SELECTOR_G 0
#define SELECTOR_B 0

enum InitLevels {
    CREATEDINTERFACE = 1,
    MSP430LIBINITIALIZED
};

static simplewidget_screen  simpleScreen = NULL;

static simplewidget_png     navImg            = NULL;
static simplewidget_png     navUpImg          = NULL;
static simplewidget_png     navDownImg        = NULL;
static simplewidget_png     navOkImg          = NULL;

static simplewidget_png     wrongImg          = NULL;
static simplewidget_png     noWrongImg        = NULL;

enum Buttons {
    NAVUP,
    NAVDOWN,
    WRONG
};

typedef struct Button {
    simplewidget_png *pressedImgPtr;
    simplewidget_png *origImgPtr;
    int               x;
    int               y;
} Button; 

static Button buttons[9] = {
    {
        &navUpImg,
        &navImg,
        NAV_BUTTON_X,
        NAV_BUTTON_Y
    },
    {
        &navDownImg,
        &navImg,
        NAV_BUTTON_X,
        NAV_BUTTON_Y
    },
    {
        &wrongImg,
        &noWrongImg,
        WRONG_BUTTON_X,
        WRONG_BUTTON_Y
    }
};

typedef struct ThirdPartyDemo {
    simplewidget_jpeg logoImg;
    simplewidget_text demoText;
    char execPath[30];
} ThirdPartyDemo;

ThirdPartyDemo thirdPartyDemos[MAX_FILES];

int selection = 0;
static int numDemos;

/******************************************************************************
 * demoSelect
 ******************************************************************************/
void demoSelect(int r, int g, int b)
{
    int y = SELECTOR_Y + selection * YSCALE(65);
    ThirdPartyDemo *demo = &thirdPartyDemos[selection];

    if (selection < numDemos) {
        if (simplewidget_screen_draw_rectangle(simpleScreen,
                                               SELECTOR_X,
                                               y,
                                               SELECTOR_W,
                                               SELECTOR_H,
                                               r,
                                               g,
                                               b) == FAILURE) {
            ERR("Failed to draw rectangle\n");
            return;
        }

        if (simplewidget_text_show(demo->demoText, simpleScreen) == -1) {
            ERR("Failed to show demo description text\n");
        } 
    }
}

/******************************************************************************
 * generateDemoList
 ******************************************************************************/
int generateDemoList(void)
{
    ThirdPartyDemo *demo;
    DIR *demoDirectory;
    struct dirent *dirEntry;
    char *extension;
    char string1[512];
    char string2[512];
    int ret;
    char baseName[100];
    int numChars;
    int fd;
    int i = 0;
    int yLogo = 30;
    int yText = 70;

    demoDirectory = opendir(THIRDPARTY_DEMODIR);

    if (demoDirectory == NULL) {
        ERR("Failed to open demo directory (%s) [%s]", THIRDPARTY_DEMODIR,
                                                       strerror(errno));
        return FAILURE;
    } 

    dirEntry = readdir(demoDirectory);

    while (dirEntry != NULL && i < MAX_FILES) {
        DBG("Processing file %s\n", dirEntry->d_name);

        demo = &thirdPartyDemos[i];

        extension = rindex(dirEntry->d_name, '.');

        if (extension != NULL && strcmp(extension, ".gz") == 0) {
            /* First extract the archive */
            numChars = strcspn(dirEntry->d_name, ".");

            strncpy(baseName, dirEntry->d_name, numChars);

            sprintf(string2, "%s/%s", DESTINATION_DIR, baseName);

            /* Make sure old contents are deleted */
            sprintf(string1, "rm -rf %s\n", string2);
            system(string1);

            if (mkdir(string2, 511) == -1 && errno != EEXIST) {
                ERR("Failed to create directory %s\n", string2);
                return FAILURE;
            }  

            DBG("unzipping %s into %s\n", dirEntry->d_name, string2);

            sprintf(string1, "tar -x -z -C %s -f %s/%s\n", string2,
                                                           THIRDPARTY_DEMODIR,
                                                           dirEntry->d_name);
            DBG("Executing: %s\n", string1);

            ret = system(string1);

            if (ret == -1) {
                ERR("Failed: %s (fork failed, command in path?)\n", string1);
                return FAILURE;
            }
            else if (ret != 0) {
                ERR("Failed: %s\n", string1);
                dirEntry = readdir(demoDirectory);
                continue;
            }

            DBG("Successfully executed: %s\n", string1);

            strcpy(demo->execPath, string2);

            DBG("Demo execPath string is %s\n", demo->execPath);

            /* Then read the logo and show it */
            sprintf(string1, "%s/logo.jpg", string2);

            DBG("Showing JPEG: %s\n", string1);

            if (simplewidget_jpeg_create(string1, &demo->logoImg) == 0) {
                simplewidget_jpeg_show(demo->logoImg, simpleScreen, 60, yLogo);
            }

            /* Then read the readme.txt and print it */
            sprintf(string1, "%s/readme.txt", string2);

            DBG("Opening text file: %s\n", string1);

            fd = open(string1, O_RDONLY);

            if (fd == -1) {
                ERR("Failed to open: %s", string1);
                continue;
            }

            numChars = read(fd, string1, READMETXT_MAXSIZE);

            if (numChars == -1) {
                ERR("Failed to read from: %s\n", string1);
                continue;
            }

            close(fd);

            string1[numChars] = '\0';
            numChars = strcspn(string1, "\n\r");

            string1[numChars] = '\0'; // Skip new lines

            if (simplewidget_text_create(140, yText, 18, string1,
                                         &demo->demoText) == -1) {
                ERR("Failed to create demo description text\n");
                continue;
            }

            if (simplewidget_text_show(demo->demoText, simpleScreen) == -1) {
                ERR("Failed to show demo description text\n");
                continue;
            } 

            i++;
            yLogo += YSCALE(65);
            yText += YSCALE(65);
        }

        dirEntry = readdir(demoDirectory);
    }

    numDemos = i;

    if (closedir(demoDirectory) == -1) {
        ERR("Failed to close directory (%s)\n", THIRDPARTY_DEMODIR);
        return FAILURE;
    }

    return SUCCESS; 
}    

/******************************************************************************
 * uiPressButton
 ******************************************************************************/
static int uiPressButton(enum Buttons btnIdx)
{
    Button *btnPtr = &buttons[btnIdx];

    if (simplewidget_png_show(*btnPtr->pressedImgPtr, simpleScreen,
                              btnPtr->x, YSCALE(btnPtr->y)) == -1) {
        ERR("Failed to show pressed button png image\n");
        return FAILURE;
    }

    usleep(500000);

    if (simplewidget_png_show(*btnPtr->origImgPtr, simpleScreen,
                              btnPtr->x, YSCALE(btnPtr->y)) == -1) {
        ERR("Failed to show original button png image\n");
        return FAILURE;
    }

    return SUCCESS;
}

/******************************************************************************
 * uiCreate
 ******************************************************************************/
static int uiCreate(void)
{
    /* Initialize the screens on which to draw widgets */
    if (simplewidget_screen_init(getDisplay(), SCREEN_WIDTH,
                                 SCREEN_HEIGHT, &simpleScreen) == -1) {
        ERR("Failed to initialize simplewidget screen\n");
        return FAILURE;
    }

    /* Create the navigation button in all permutations */
    if (simplewidget_png_create(NAV_BUTTON, &navImg) == -1) {
        ERR("Failed to create png image\n");
        return FAILURE;
    }

    if (simplewidget_png_create(NAV_BUTTON_UP_PRESSED, &navUpImg) == -1) {
        ERR("Failed to create png image\n");
        return FAILURE;
    }

    if (simplewidget_png_create(NAV_BUTTON_DOWN_PRESSED, &navDownImg) == -1) {
        ERR("Failed to create png image\n");
        return FAILURE;
    }

    if (simplewidget_png_create(NAV_BUTTON_OK_PRESSED, &navOkImg) == -1) {
        ERR("Failed to create png image\n");
        return FAILURE;
    }

    if (simplewidget_png_create(WRONG_BUTTON, &noWrongImg) == -1) {
        ERR("Failed to create png image\n");
        return FAILURE;
    }

    if (simplewidget_png_create(WRONG_BUTTON_PRESSED, &wrongImg) == -1) {
        ERR("Failed to create png image\n");
        return FAILURE;
    }

    return SUCCESS;
}

/******************************************************************************
 * uiDraw
 ******************************************************************************/
static int uiDraw(void)
{
    /* Clear the OSD window */
    simplewidget_screen_clear(simpleScreen, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);

    if (simplewidget_png_show(navImg, simpleScreen,
                              NAV_BUTTON_X, YSCALE(NAV_BUTTON_Y)) == -1) {
        ERR("Failed to show png image\n");
        return FAILURE;
    }

    generateDemoList();

    demoSelect(SELECTOR_R, SELECTOR_G, SELECTOR_B);

    return SUCCESS;
}

/******************************************************************************
 * uiDelete
 ******************************************************************************/
static int uiDelete(void)
{
    if (wrongImg) {
        simplewidget_png_delete(wrongImg);
    }

    if (noWrongImg) {
        simplewidget_png_delete(noWrongImg);
    }

    if (navUpImg) {
        simplewidget_png_delete(navUpImg);
    }

    if (navDownImg) {
        simplewidget_png_delete(navDownImg);
    }

    if (navImg) {
        simplewidget_png_delete(navImg);
    }

    if (simpleScreen) {
        simplewidget_screen_exit(simpleScreen);
    }

    return SUCCESS;
}

/******************************************************************************
 * keyAction
 ******************************************************************************/
static int keyAction(enum msp430lib_keycode key, DemoEnv *envp, int *quitPtr)
{
    switch(key) {
        case MSP430LIB_KEYCODE_PLAY:
            if (numDemos == 0) {
                *quitPtr = NOSELECTION;
            }
            else {
                *quitPtr = TRUE;
            }
            break;

        case MSP430LIB_KEYCODE_STOP:
            *quitPtr = NOSELECTION;
            break;

        case MSP430LIB_KEYCODE_CHANINC:
            if (numDemos > 0) {
                demoSelect(0, 0, 0);
                if (selection - 1 < 0) {
                    selection = numDemos - 1;
                }
                else {
                    selection--;
                }
                demoSelect(SELECTOR_R, SELECTOR_G, SELECTOR_B);
            }

            if (uiPressButton(NAVUP) == FAILURE) {
                return FAILURE;
            }
            break;

        case MSP430LIB_KEYCODE_CHANDEC:
            if (numDemos > 0) {
                demoSelect(0, 0, 0);
                selection = (selection + 1) % numDemos;
                demoSelect(SELECTOR_R, SELECTOR_G, SELECTOR_B);
            }

            if (uiPressButton(NAVDOWN) == FAILURE) {
                return FAILURE;
            }
            break;

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

    return SUCCESS;
}

/******************************************************************************
 * interfaceFxn
 ******************************************************************************/
int thirdPartyFxn(DemoEnv *envp)
{
    enum InitLevels        initLevel = 0;
    int                    status    = SUCCESS;
    int                    quit      = 0;
    enum msp430lib_keycode key;

    if (uiCreate() == FAILURE) {
        CLEANUP(FAILURE);
    }

    initLevel = CREATEDINTERFACE;

    if (setOsdTransparency(0x77) == FAILURE) {
        CLEANUP(FAILURE);
    }

    if (uiDraw() == FAILURE) {
        CLEANUP(FAILURE);
    }

    if (msp430lib_init() == MSP430LIB_FAILURE) {
        ERR("Failed to initialize msp430lib.\n");
        CLEANUP(FAILURE);
    }

    initLevel = MSP430LIBINITIALIZED;

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

        DBG("Got IR key %#x from the MSP430\n", key);

        /* If an IR key had been pressed, service it */
        if (key != 0) {
            if (keyAction(key, envp, &quit) == FAILURE) {
                BREAK_LOOP(FAILURE);
            }
        }

        usleep(500000);
    }

    envp->thirdPartyCmdPath = thirdPartyDemos[selection].execPath;

    if (quit == NOSELECTION) {
        status = NOSELECTION;
    }

cleanup:
    if (initLevel >= MSP430LIBINITIALIZED) {
        msp430lib_exit();
    }

    if (initLevel >= CREATEDINTERFACE) {
        uiDelete();
    }

    return status;
}