test.c

6410BSP2

Description     : To test Encoder
Parameter       : imageType - JPG_YCBYCR or JPG_RGB16
Return Value    : void
*******************************************************************************
*/
void TestEncoder()
{
    char *InBuf = NULL;
    char *InThumbBuf = NULL;
    char *OutBuf = NULL;
    FILE *fp;
    FILE *CTRfp;
    JPEG_ERRORTYPE ret;
    UINT32 fileSize;
    UINT32 frameSize;
    void *handle;
    ExifFileInfo *ExifInfo;
    char outFilename[128];
    char inFilename[128];
    char widthstr[8], heightstr[8];
    INT32 width, height;
    BOOL result = TRUE;
#if (FPS == 1)
    INT32    encodeTime;
#endif


    RETAILMSG(1,(L"------------------------Encoder 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));
        memset(widthstr, 0x00, sizeof(widthstr));
        memset(heightstr, 0x00, sizeof(heightstr));

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

        fscanf(CTRfp, "%s", outFilename);
        fscanf(CTRfp, "%s", widthstr);
        fscanf(CTRfp, "%s", heightstr);
        width = (INT32)atoi(widthstr);
        height = (INT32)atoi(heightstr);

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


        RETAILMSG(1,(L"inFilename : %s \noutFilename : %s width : %d height : %d\n", 
                inFilename, outFilename, width, height));
        //////////////////////////////////////////////////////////////
        // 1. handle Init                                           //
        //////////////////////////////////////////////////////////////
        #if (FPS == 1)
            encodeTime = GetTickCount();
        #endif
        handle = SsbSipJPEGEncodeInit();
        #if (FPS == 1)        
            encodeTime = GetTickCount() - encodeTime;
            RETAILMSG(1,(L"Initialization Time : %d \n", encodeTime));
        #endif
        if(handle == NULL)
            break;

        //////////////////////////////////////////////////////////////
        // 2. set decode config.                                    //
        //////////////////////////////////////////////////////////////
        if((ret = SsbSipJPEGSetConfig(JPEG_SET_SAMPING_MODE, JPG_422)) != JPEG_OK){
            result = FALSE;
            break;
        }
        if((ret = SsbSipJPEGSetConfig(JPEG_SET_ENCODE_WIDTH, width)) != JPEG_OK){
            result = FALSE;
            break;
        }
        if((ret = SsbSipJPEGSetConfig(JPEG_SET_ENCODE_HEIGHT, height)) != JPEG_OK){
            result = FALSE;
            break;
        }
        if((ret = SsbSipJPEGSetConfig(JPEG_SET_ENCODE_QUALITY, JPG_QUALITY_LEVEL_2)) != JPEG_OK){
            result = FALSE;
            break;
        }
#if (TEST_ENCODE_WITH_THUMBNAIL == 1)
        if((ret = SsbSipJPEGSetConfig(JPEG_SET_ENCODE_THUMBNAIL, TRUE)) != JPEG_OK){
            result = FALSE;
            break;
        }
        if((ret = SsbSipJPEGSetConfig(JPEG_SET_THUMBNAIL_WIDTH, 160)) != JPEG_OK){
            result = FALSE;
            break;
        }
        if((ret = SsbSipJPEGSetConfig(JPEG_SET_THUMBNAIL_HEIGHT, 120)) != JPEG_OK){
            result = FALSE;
            break;
        }
#endif

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

        //////////////////////////////////////////////////////////////
        // 4. get Input buffer address                              //
        //////////////////////////////////////////////////////////////
        printD("filesize : %d\n", fileSize);
        InBuf = SsbSipJPEGGetEncodeInBuf(handle, fileSize);
        if(InBuf == NULL){
            result = FALSE;
            break;
        }
        printD("inBuf : 0x%x\n", InBuf);

        //////////////////////////////////////////////////////////////
        // 5. put YUV stream to Input buffer                        //
        //////////////////////////////////////////////////////////////
        fread(InBuf, 1, fileSize, fp);
        fclose(fp);

    
        //////////////////////////////////////////////////////////////
        // 6. Make Exif info parameters                             //
        //////////////////////////////////////////////////////////////
        ExifInfo = (ExifFileInfo *)malloc(sizeof(ExifFileInfo));
        memset(ExifInfo, 0x00, sizeof(ExifFileInfo));
        makeExifParam(ExifInfo);

        //////////////////////////////////////////////////////////////
        // 7. Encode YUV stream                                     //
        //////////////////////////////////////////////////////////////
        #if (FPS == 1)
            encodeTime = GetTickCount();
        #endif

        #if (TEST_ENCODE_WITH_EXIF == 1)
        ret = SsbSipJPEGEncodeExe(handle, ExifInfo);    //with Exif
        #else
        ret = SsbSipJPEGEncodeExe(handle, NULL);         //No Exif
        #endif

        #if (FPS == 1)        
            encodeTime = GetTickCount() - encodeTime;
            RETAILMSG(1,(L"encodeTime : %d \n", encodeTime));
        #endif
        if(ret != JPEG_OK){
            result = FALSE;
            break;
        }
    
        //////////////////////////////////////////////////////////////
        // 8. get output buffer address                             //
        //////////////////////////////////////////////////////////////
        OutBuf = SsbSipJPEGGetEncodeOutBuf(handle, &frameSize);
        if(OutBuf == NULL){
            result = FALSE;
            break;
        }
        
        printD("OutBuf : 0x%x freamsize : %d\n", OutBuf, frameSize);

        //////////////////////////////////////////////////////////////
        // 9. write JPEG result file                                //
        //////////////////////////////////////////////////////////////
        fp = fopen(outFilename, "wb");
        fwrite(OutBuf, 1, frameSize, fp);
        fclose(fp);

        //////////////////////////////////////////////////////////////
        // 10. finalize handle                                      //
        //////////////////////////////////////////////////////////////
        SsbSipJPEGEncodeDeInit(handle);
        free(ExifInfo);
        Sleep(5);
    }while(1);

    if(result == FALSE){
        SsbSipJPEGEncodeDeInit(handle);
        if(ExifInfo != NULL)
            free(ExifInfo);
    }
    fclose(CTRfp);
    RETAILMSG(1,(L"------------------------Encoder Test Done---------------------\n"));
}
/*
*******************************************************************************
Name            : makeExifParam
Description     : To make exif input parameter
Parameter       : 
Return Value    : exifFileInfo - exif input parameter
*******************************************************************************
*/
void makeExifParam(ExifFileInfo *exifFileInfo)
{
    strcpy(exifFileInfo->Make,"Samsung SYS.LSI make");;
    strcpy(exifFileInfo->Model,"Samsung 2007 model");
    strcpy(exifFileInfo->Version,"version 1.0.2.0");
    strcpy(exifFileInfo->DateTime,"2007:05:16 12:32:54");
    strcpy(exifFileInfo->CopyRight,"Samsung Electronics@2007:All rights reserved");

    exifFileInfo->Height                    = 320;
    exifFileInfo->Width                        = 240;
    exifFileInfo->Orientation                = 1; // top-left
    exifFileInfo->ColorSpace                = 1;
    exifFileInfo->Process                    = 1;
    exifFileInfo->Flash                        = 0;
    exifFileInfo->FocalLengthNum            = 1;
    exifFileInfo->FocalLengthDen            = 4;
    exifFileInfo->ExposureTimeNum            = 1;
    exifFileInfo->ExposureTimeDen            = 20;
    exifFileInfo->FNumberNum                = 1;
    exifFileInfo->FNumberDen                = 35;
    exifFileInfo->ApertureFNumber            = 1;
    exifFileInfo->SubjectDistanceNum        = -20;
    exifFileInfo->SubjectDistanceDen        = -7;
    exifFileInfo->CCDWidth                    = 1;
    exifFileInfo->ExposureBiasNum            = -16;
    exifFileInfo->ExposureBiasDen            = -2;
    exifFileInfo->WhiteBalance                = 6;
    exifFileInfo->MeteringMode                = 3;
    exifFileInfo->ExposureProgram            = 1;
    exifFileInfo->ISOSpeedRatings[0]        = 1;
    exifFileInfo->ISOSpeedRatings[1]        = 2;
    exifFileInfo->FocalPlaneXResolutionNum    = 65;
    exifFileInfo->FocalPlaneXResolutionDen    = 66;
    exifFileInfo->FocalPlaneYResolutionNum    = 70;
    exifFileInfo->FocalPlaneYResolutionDen    = 71;
    exifFileInfo->FocalPlaneResolutionUnit    = 3;
    exifFileInfo->XResolutionNum            = 48;
    exifFileInfo->XResolutionDen            = 20;
    exifFileInfo->YResolutionNum            = 48;
    exifFileInfo->YResolutionDen            = 20;
    exifFileInfo->RUnit                        = 2;
    exifFileInfo->BrightnessNum                = -7;
    exifFileInfo->BrightnessDen                = 1;

    strcpy(exifFileInfo->UserComments,"Usercomments");
}
/*
*******************************************************************************
Name            : DecodeFileOutYUV422
Description     : To change YCBYCR to YUV422, and write result file.
Parameter       :
Return Value    : void
*******************************************************************************
*/
void DecodeFileOutYUV422(char *OutBuf, UINT32 streamSize, char *filename)
{
    UINT32    i;
    UINT32  indexY, indexCB, indexCR;
    char *Buf;
    FILE *fp;

    Buf = (char *)malloc(MAX_YUV_SIZE);
    memset(Buf, 0x00, MAX_YUV_SIZE);

    printD("convertyuvformat\n");
    indexY = 0;
    indexCB = streamSize >> 1;
    indexCR = indexCB+(streamSize >> 2);

    printD("indexY(%ld), indexCB(%ld), indexCR(%ld)\n", indexY, indexCB, indexCR);

    for(i = 0; i < streamSize; i++)
    {
        if((i%2) == 0)
            Buf[indexY++] = OutBuf[i];

        if((i%4) == 1) 
            Buf[indexCB++] = OutBuf[i];

        if((i%4) == 3) 
            Buf[indexCR++] = OutBuf[i];
    }

    fp = fopen(filename, "wb");
    fwrite(Buf, 1, streamSize, fp);
    fclose(fp);
    free(Buf);

}
/*
*******************************************************************************
Name            : DecodeFileOutYCBYCR
Description     : To write result YCBYCR file.
Parameter       :
Return Value    : void
*******************************************************************************
*/
void DecodeFileOutYCBYCR(char *OutBuf, UINT32 streamSize, char *filename)
{
    FILE *fp;

    fp = fopen(filename, "wb");
    fwrite(OutBuf, 1, streamSize, fp);
    fclose(fp);

}