test.c

6410BSP2

//
// Copyright (c) Microsoft Corporation.  All rights reserved.
//
//
// Use of this source code is subject to the terms of the Microsoft end-user
// license agreement (EULA) under which you licensed this SOFTWARE PRODUCT.
// If you did not accept the terms of the EULA, you are not authorized to use
// this source code. For a copy of the EULA, please see the LICENSE.RTF on your
// install media.
//
// Copyright (c) Samsung Electronics. Co. LTD. All rights reserved.
/*++
THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
PARTICULAR PURPOSE.

Module Name:

    jpg_app.c

Abstract:

    This file implements JPEG Test Application.

Functions:


Notes:

--*/

#include <windows.h>
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
// Platform Dependent
#include <SVEDriverAPI.h>
#include "JPGApi.h"

 

#define FPS            1
#define DEBUG        0    


#define TEST_DECODE                    1  // enable decoder test
#define TEST_DECODE_OUTPUT_YUV422    0  // output file format is YUV422(non-interleaved)
#define TEST_DECODE_OUTPUT_YCBYCR    0  // output file format is YCBYCR(interleaved)
#define TEST_DECODE_OUTPUT_RGB16    0  // output file format is RGB16
#define TEST_DECODE_OUTPUT_LCD        1  // output will display to LCD during DISPLAY_TIME

#define TEST_ENCODE                    0 // enable encoder test
#define TEST_ENCODE_WITH_EXIF        1 // encoded jpg file will include Exif info
#define TEST_ENCODE_WITH_THUMBNAIL    0 // enable thumbnail encoding

#if (TEST_DECODE == 1)
    #define CTRL_FILE_NAME    "fname_dec.txt"
#elif (TEST_ENCODE == 1)
    #define CTRL_FILE_NAME    "fname_enc.txt"
#endif


#define PHY_ADDR_FRAME_BUFFER 0x57400000
#define LCD_X        800
#define LCD_Y        480
#define DISPLAY_TIME    5//sec

#define R_RGB565(x)        (unsigned char) (((x) >> 8) & 0xF8)
#define G_RGB565(x)        (unsigned char) (((x) >> 3) & 0xFC)
#define B_RGB565(x)        (unsigned char) ((x) << 3)

void TestDecoder();
void TestEncoder();
void DecodeFileOutYCBYCR(char *OutBuf, UINT32 streamSize, char *filename);
void DecodeFileOutYUV422(char *OutBuf, UINT32 streamSize, char *filename);
void makeExifParam(ExifFileInfo *exifFileInfo);
void DisplayJPEG (int srcAddr, 
                  INT32 srcwidth, INT32 srcheight, 
                  INT32 dstwidth, INT32 dstheight,
                  int displayTime);
BOOL ConvertYCBYCRToRGB(int inBuf, INT32 srcwidth, INT32 srcheight, 
                        unsigned long srcType,
                        int outBuf, INT32 dstwidth, INT32 dstheight,
                        unsigned long dstType);
void DecodeFileOutRGB16ToPPM(unsigned char *p_img, int wd, int hi, char *filename);
void printD(char* fmt, ...);

/*
*******************************************************************************
Name            : main
Description     : Main function
Parameter       :
Return Value    : SUCCESS or FAILURE
*******************************************************************************
*/

int WINAPI WinMain(HINSTANCE hInstance,
                    HINSTANCE hPrevInstance,
                    LPTSTR    lpCmdLine,
                    int       nCmdShow)
{
#if (TEST_DECODE == 1)
    TestDecoder();
#elif (TEST_ENCODE == 1)
    TestEncoder();
#endif

    return 1;
}

/*
*******************************************************************************
Name            : TestDecoder
Description     : To test Decoder
Parameter       : imageType - JPG_YCBYCR or JPG_RGB16
Return Value    : void
*******************************************************************************
*/
void TestDecoder()
{
    char *InBuf = NULL;
    char *OutBuf = NULL;
    char *OutPhyBuf = NULL;
    char *OutRGBBuf = NULL;
    char *OutRGBPhyBuf = NULL;
    FILE *fp;
    FILE *CTRfp;
    UINT32 fileSize;
    UINT32 streamSize;
    void *handle;
    INT32 width, height, samplemode;
    JPEG_ERRORTYPE ret;
    char outFilename[128];
    char inFilename[128];
    BOOL result = TRUE;
#if (FPS == 1)
    INT32    decodeTime;
#endif
    DWORD    startTime;


    RETAILMSG(1,(L"------------------------Decoder Test Start ---------------------\n"));

    //////////////////////////////////////////////////////////////
    // 0. Get input/output file name                            //
    //////////////////////////////////////////////////////////////
    CTRfp = fopen(CTRL_FILE_NAME, "rb");
    if(CTRfp == NULL){
        RETAILMSG(1,(L"file open error : %s\n", CTRL_FILE_NAME));
        return;
    }

    do{
        memset(outFilename, 0x00, sizeof(outFilename));
        memset(inFilename, 0x00, sizeof(inFilename));

        fscanf(CTRfp, "%s", inFilename);

        if(inFilename[0] == '#'){
            RETAILMSG(1,(L"------------------------Decoder Test Done ---------------------\n"));
            fclose(CTRfp);
            return;
        }

        fscanf(CTRfp, "%s", outFilename);

        if(inFilename == NULL || outFilename == NULL){
            RETAILMSG(1,(L"read file error\n"));
            RETAILMSG(1,(L"------------------------Decoder Test Done ---------------------\n"));
            fclose(CTRfp);
            return;
        }

        RETAILMSG(1,(L"inFilename : %s \noutFilename : %s\n", inFilename, outFilename));
        //////////////////////////////////////////////////////////////
        // 1. handle Init                                           //
        //////////////////////////////////////////////////////////////
        #if (FPS == 1)
            decodeTime = GetTickCount();
        #endif
        handle = SsbSipJPEGDecodeInit();
        #if (FPS == 1)        
            decodeTime = GetTickCount() - decodeTime;
            RETAILMSG(1,(L"Initialization Time : %d \n", decodeTime));
        #endif
        if(handle == NULL){
            RETAILMSG(1,(L"Decoder Init failed\n"));
            break;
        }

        //////////////////////////////////////////////////////////////
        // 2. open JPEG file to decode                              //
        //////////////////////////////////////////////////////////////
        fp = fopen(inFilename, "rb");
        if(fp == NULL){
            result = FALSE;
            RETAILMSG(1,(L"file open error : %s\n", inFilename));
            break;
        }
        fseek(fp, 0, SEEK_END);
        fileSize = ftell(fp);
        fseek(fp, 0, SEEK_SET);

        RETAILMSG(1,(L"filesize : %d\n", fileSize));

        //////////////////////////////////////////////////////////////
        // 3. get Input buffer address                              //
        //////////////////////////////////////////////////////////////
        InBuf = SsbSipJPEGGetDecodeInBuf(handle, fileSize);
        if(InBuf == NULL){
            RETAILMSG(1,(L"Input buffer is NULL\n"));
            result = FALSE;
            break;
        }

        RETAILMSG(1,(L"inBuf : 0x%x\n", InBuf));

        //////////////////////////////////////////////////////////////
        // 4. put JPEG frame to Input buffer                        //
        //////////////////////////////////////////////////////////////
        fread(InBuf, 1, fileSize, fp);
        fclose(fp);

        
        //////////////////////////////////////////////////////////////
        // 5. Decode JPEG frame                                     //
        //////////////////////////////////////////////////////////////
        #if (FPS == 1)
            decodeTime = GetTickCount();
        #endif

        ret = SsbSipJPEGDecodeExe(handle);

        #if (FPS == 1)        
            decodeTime = GetTickCount() - decodeTime;
            RETAILMSG(1,(L"decodeTime : %d \n", decodeTime));
        #endif

        if(ret != JPEG_OK){
            RETAILMSG(1,(L"Decoding failed\n"));
            result = FALSE;
            break;
        }

        //////////////////////////////////////////////////////////////
        // 6. get Output buffer address                             //
        //////////////////////////////////////////////////////////////
        OutBuf = SsbSipJPEGGetDecodeOutBuf(handle, &streamSize);
        if(OutBuf == NULL){
            RETAILMSG(1,(L"Output buffer is NULL\n"));
            result = FALSE;
            break;
        }
        printD("OutBuf : 0x%x streamsize : %d\n", OutBuf, streamSize);

        //////////////////////////////////////////////////////////////
        // 7. get decode config.                                    //
        //////////////////////////////////////////////////////////////
        SsbSipJPEGGetConfig(JPEG_GET_DECODE_WIDTH, &width);
        SsbSipJPEGGetConfig(JPEG_GET_DECODE_HEIGHT, &height);
        SsbSipJPEGGetConfig(JPEG_GET_SAMPING_MODE, &samplemode);

        RETAILMSG(1,(L"width : %d height : %d samplemode : %d\n\n", width, height, samplemode));

        //////////////////////////////////////////////////////////////
        // 8. wirte output file                                     //
        //////////////////////////////////////////////////////////////

#if (TEST_DECODE_OUTPUT_YCBYCR == 1)
        DecodeFileOutYCBYCR(OutBuf, streamSize, outFilename);    // YCBYCR interleaved
#elif (TEST_DECODE_OUTPUT_YUV422 == 1)
        DecodeFileOutYUV422(OutBuf, streamSize, outFilename);    // yuv422 non-interleaved
#elif (TEST_DECODE_OUTPUT_RGB16 == 1)                            //RGB16
        OutPhyBuf = SsbSipJPEGGetDecodeOutPhyBuf(handle);
        OutRGBPhyBuf = SsbSipJPEGGetRGBPhyBuf(handle, LCD_X, LCD_Y);
        if(ConvertYCBYCRToRGB((int)OutPhyBuf, width, height, 
                              POST_SRC_YUV422_CRYCBY,
                              (int)OutRGBPhyBuf, LCD_X, LCD_Y,
                              POST_DST_RGB16) == FALSE){
            RETAILMSG(1,(L"ConvertYCBYCRToRGB error\n"));
            result = FALSE;
            break;
        }
        OutRGBBuf = SsbSipJPEGGetRGBBuf(handle, LCD_X, LCD_Y);
        DecodeFileOutRGB16ToPPM(OutRGBBuf, LCD_X, LCD_Y, outFilename); 
#elif(TEST_DECODE_OUTPUT_LCD == 1)
        OutPhyBuf = SsbSipJPEGGetDecodeOutPhyBuf(handle);
        OutRGBPhyBuf = SsbSipJPEGGetRGBPhyBuf(handle, LCD_X, LCD_Y);
        startTime = GetTickCount();
        if(ConvertYCBYCRToRGB((int)OutPhyBuf, width, height, 
                              POST_SRC_YUV422_CRYCBY,
                              (int)OutRGBPhyBuf, LCD_X, LCD_Y,
                              POST_DST_RGB16) == FALSE){
            RETAILMSG(1,(L"ConvertYCBYCRToRGB error\n"));
            result = FALSE;
            break;
        }

        RETAILMSG(1,(L"converting time : %d\n\n", GetTickCount() - startTime));
        RETAILMSG(1,(L"\n\n This image will be disappeared after %d seconds......\n\n", DISPLAY_TIME));
        DisplayJPEG((int)OutRGBPhyBuf, LCD_X, LCD_Y, LCD_X, LCD_Y, DISPLAY_TIME);
#endif

        //////////////////////////////////////////////////////////////
        // 9. finalize handle                                      //
        //////////////////////////////////////////////////////////////
        SsbSipJPEGDecodeDeInit(handle);
        Sleep(5);
    }while(1);

    if(result == FALSE){
        SsbSipJPEGDecodeDeInit(handle);
    }

    fclose(CTRfp);
    RETAILMSG(1,(L"------------------------Decoder Test Done ---------------------\n"));
}
/*
*******************************************************************************
Name            : TestEncoder