mfc_decode.cpp

6410BSP3

// TestCode.cpp : Defines the entry point for the console application.
//
#include <windows.h>
#include <stdio.h>


#include "SsbSipMpeg4Decode.h"
#include "SsbSipMpeg4Encode.h"

#include "SsbSipH264Decode.h"
#include "SsbSipH264Encode.h"

#include "SsbSipVC1Decode.h"

#include "SsbSipMfcDecode.h"

#include "FrameExtractor.h"
#include "MPEG4Frames.h"
#include "H263Frames.h"
#include "H264Frames.h"
#include "VC1Frames.h"


static unsigned char delimiter_mpeg4[3] = {0x00, 0x00, 0x01};
static unsigned char delimiter_h263[3]  = {0x00, 0x00, 0x80};
static unsigned char delimiter_h264[4]  = {0x00, 0x00, 0x00, 0x01};


#define INPUT_BUFFER_SIZE        (1024 * 256)
#define NUM_PIPS                2



#include "FileRead.h"
#ifndef DATAREAD_TYPE
#error "DATAREAD_TYPE is not defined."
#endif
#if (DATAREAD_TYPE == DATA_FILE)
    #define FRAMEX_IN_TYPE_SEL    (FRAMEX_IN_TYPE_FILE)
#else
    #define FRAMEX_IN_TYPE_SEL    (FRAMEX_IN_TYPE_MEM)
#endif


static char msg[256];
static void LogMsg()
{
    FILE *fp;

    fp = fopen("\\NandFlash\\logmsg.txt", "at");
    if (fp == NULL)
        return;
    fprintf(fp, msg);
    fclose(fp);
}


#include "mfc_decode.h"
#if (DECODED_OUTPUT == DECODED_OUT_DISP)
#include "mfc_render.h"

// PROPERTY WINDOW : Video image size, fps information window
#define PROPERTY_WINDOW        0

#define PROPERTY_WINDOW_WIDTH    200
#define PROPERTY_WINDOW_HEIGHT    40

static unsigned short g_property_window[PROPERTY_WINDOW_WIDTH * PROPERTY_WINDOW_HEIGHT];

#include "number_img.h"

extern "C" unsigned char character_img[];
extern "C" unsigned char size_img[];

#endif


/// MFC API related function pointers
typedef void *(*FP_SsbSipDecodeInit)(void);
typedef int   (*FP_SsbSipDecodeExe)(void *, long);
typedef int   (*FP_SsbSipDecodeDeInit)(void *);
typedef void *(*FP_SsbSipDecodeDecodeGetInBuf)(void *, long);
typedef void *(*FP_SsbSipDecodeDecodeGetOutBuf)(void *, long *);
typedef int   (*FP_SsbSipDecodeGetConfig)(void *, unsigned int, void *);
typedef int   (*FP_SsbSipDecodeSetConfig)(void *, unsigned int, void *);

/// Frame Extractor API related function pointers
typedef int  (*FP_NextFrame)(FRAMEX_CTX *, void *, unsigned char [], int, unsigned int *);

typedef struct
{
    FP_SsbSipDecodeInit              fp_SsbSipDecodeInit;
    FP_SsbSipDecodeExe               fp_SsbSipDecodeExe;
    FP_SsbSipDecodeDeInit            fp_SsbSipDecodeDeInit;
    FP_SsbSipDecodeDecodeGetInBuf    fp_SsbSipDecodeDecodeGetInBuf;
    FP_SsbSipDecodeDecodeGetOutBuf   fp_SsbSipDecodeDecodeGetOutBuf;
    FP_SsbSipDecodeGetConfig         fp_SsbSipDecodeGetConfig;
    FP_SsbSipDecodeSetConfig         fp_SsbSipDecodeSetConfig;

    FP_NextFrame                     fp_NextFrame;
} FP_LIST;


static FP_LIST    fp_list[4] =
{
    // fp_list[0] : MPEG4 decode API functions
    {
        SsbSipMPEG4DecodeInit,
        SsbSipMPEG4DecodeExe,
        SsbSipMPEG4DecodeDeInit,
        SsbSipMPEG4DecodeGetInBuf,
        SsbSipMPEG4DecodeGetOutBuf,
        SsbSipMPEG4DecodeGetConfig,
        SsbSipMPEG4DecodeSetConfig,

        NextFrameMpeg4
    },
    // fp_list[1] : H.263 decode API functions
    {
        SsbSipMPEG4DecodeInit,
        SsbSipMPEG4DecodeExe,
        SsbSipMPEG4DecodeDeInit,
        SsbSipMPEG4DecodeGetInBuf,
        SsbSipMPEG4DecodeGetOutBuf,
        SsbSipMPEG4DecodeGetConfig,
        SsbSipMPEG4DecodeSetConfig,

        NULL
    },
    // fp_list[2] : H.264 decode API functions
    {
        SsbSipH264DecodeInit,
        SsbSipH264DecodeExe,
        SsbSipH264DecodeDeInit,
        SsbSipH264DecodeGetInBuf,
        SsbSipH264DecodeGetOutBuf,
        SsbSipH264DecodeGetConfig,
        SsbSipH264DecodeSetConfig,

        NextFrameH264
    },
    // fp_list[3] : VC-1 decode
    {
        SsbSipVC1DecodeInit,
        SsbSipVC1DecodeExe,
        SsbSipVC1DecodeDeInit,
        SsbSipVC1DecodeGetInBuf,
        SsbSipVC1DecodeGetOutBuf,
        SsbSipVC1DecodeGetConfig,
        SsbSipVC1DecodeSetConfig,

        NULL
    }
};


int mfcdec_demo(HWND hWnd, LPCTSTR pszFileName[], CODEC_MODE codec_mode[], int num_pips, int *force_exit)
{
    int      i=0;    // Loop counter
    int      pip;    // Loop counter

    void    *handle[NUM_PIPS];

    void    *fp[NUM_PIPS];
    int      nLoop;

    DWORD    t1, t2, t_diff;    // tick for performance measurement
    int      perf_disp_period = 100;
    wchar_t  str_performance[8];
    float    fps;

    unsigned char     *pStrmBuf[NUM_PIPS];
    int                nFrameLeng[NUM_PIPS];
    unsigned char     *pYUVBuf[NUM_PIPS];
    int                nYUVLeng[NUM_PIPS];

    FRAMEX_CTX        *pFrameExCtx[NUM_PIPS];

    unsigned char     *delimiter;
    int                delimiter_leng;

    FP_LIST           *pFP_LIST[NUM_PIPS];        // MFC API狼 function pointers
    SSBSIP_H264_STREAM_INFO stream_info[NUM_PIPS];



#if (DECODED_OUTPUT == DECODED_OUT_FILE)
    FILE    *fp_out;
#elif (DECODED_OUTPUT == DECODED_OUT_DISP)
    void    *hRender_property=NULL;
    void    *hRender[NUM_PIPS];
    int      render_wd=0, render_hi=0;

    SIZE_IMG_IDX   size_img_idx;
#endif


    if (num_pips > NUM_PIPS) {
        RETAILMSG(1,(L"num_pips must be less than or equal to %d.\n", NUM_PIPS));
        return -1;
    }


#if (DECODED_OUTPUT == DECODED_OUT_FILE)
    /////////////////////////
    // Opening Output File //
    /////////////////////////
    fp_out = fopen(OUT_FILE_NAME, "wb");
    if (fp_out == NULL) {
        RETAILMSG(1,(L"Cannot open the output file.\n"));
        return 0;
    }
#endif

RETAILMSG(1,(L"\t ------------- \n"));

    ////////////////////////
    // Opening Input File //
    ////////////////////////
    for (pip=0; pip < num_pips; pip++) {
        fp[pip] = SSB_FILE_OPEN(pszFileName[pip]);
        if (fp[pip] == NULL) {
            RETAILMSG(1,(L"File not found\n"));
            return 0;
        }

        switch (codec_mode[pip]) {
        case CODEC_MPEG4:
            delimiter      = delimiter_mpeg4;
            delimiter_leng = sizeof(delimiter_mpeg4);

            pFP_LIST[pip] = &(fp_list[0]);
            break;

        case CODEC_H263:
            delimiter      = NULL;
            delimiter_leng = 0;

            pFP_LIST[pip] = &(fp_list[1]);
            break;

        case CODEC_H264:
            delimiter      = delimiter_h264;
            delimiter_leng = sizeof(delimiter_h264);

            pFP_LIST[pip] = &(fp_list[2]);
            break;

        case CODEC_VC1:
            delimiter      = NULL;
            delimiter_leng = 0;

            pFP_LIST[pip] = &(fp_list[3]);
            break;

        default:
            RETAILMSG(1,(L"[mfcdec_init] Undefined codec mode"));
            return -1;
        }


        ///////////////////////////////////
        // FrameExtractor Initialization //
        ///////////////////////////////////
        pFrameExCtx[pip] = FrameExtractorInit(FRAMEX_IN_TYPE_SEL, delimiter, delimiter_leng, 1);
        FrameExtractorFirst(pFrameExCtx[pip], fp[pip]);

        //////////////////////////////////////