Home    News    Components    Get ViTooKi    Documentation    Community    Developers    @sf.net  

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

xvidInterface.c

 /***********************************************************************
 *                                                                      *
 * ViTooKi                                                              *
 *                                                                      *
 * title: xvidInterface.c                                               *
 *                                                                      *
 *                                                                      *
 *                                                                      *
 * ITEC institute of the University of Klagenfurt (Austria)             *
 * http://www.itec.uni-klu.ac.at                                        *
 *                                                                      *
 *                                                                      *
 * For more information visit the ViTooKi homepage:                     *
 * http://ViTooKi.sourceforge.net                                       *
 * vitooki-user@lists.sourceforge.net                                   *
 * vitooki-devel@lists.sourceforge.net                                  *
 *                                                                      *
 * This file is part of ViTooKi, a free video toolkit.                  *
 * ViTooKi is free software; you can redistribute it and/or             *
 * modify it under the terms of the GNU General Public License          *
 * as published by the Free Software Foundation; either version 2       *
 * of the License, or (at your option) any later version.               *
 *                                                                      *
 * This program is distributed in the hope that it will be useful,      *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of       *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the         *
 * GNU General Public License for more details.                         *
 *                                                                      *
 * You should have received a copy of the GNU General Public License    *
 * along with this program; if not, write to the Free Software          *
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston,               *
 * MA  02111-1307, USA.                                                 *
 *                                                                      *
 ***********************************************************************/

 /***********************************************************************
 *                                                                      *
 *  REVISION HISTORY:                                                   *
 *                                                                      *
 *                                                                      *
 *                                                                      *
 ***********************************************************************/


#include "xvidInterface.h" //our own colorspace enum
#ifdef ENABLE_XVID
#ifndef ARCH_X86
#define ARCH_X86
#endif
#define BFRAMES

#include "xvid.h" //the external library
#ifndef WINCE
#include "bitstream/bitstream.h"
#endif
#endif




// WINDOWS CE DEFINITIONS Start

#ifdef WINCE 

#include <afxwin.h>         // MFC core and standard components

typedef DWORD dword;

#include "CodecAPI.h"

        HINSTANCE hDll;
        void *hXvid;

/*
        #define FCC(a, b, c, d) DWORD((d<<24) | (c<<16) | (b<<8) | a)


        //void *InitCodec(dword sx, dword sy, dword fcc);
        typedef void * (CALLBACK *LPFNInitCodec) (DWORD sx, DWORD sy, DWORD fcc);

        //int DecodeFrame(void *handle, const void *buf, dword sz_in, const byte *&y, const byte *&u, const byte *&v, dword &pitch);
        typedef int (CALLBACK *LPFNDecodeFrame) (void *, const void *, DWORD, const byte*&, const byte*&, const byte*&, DWORD &);

        //void CloseCodec(void *handle);
        typedef void (CALLBACK *LPFNCloseCodec) (void *);



        LPFNInitCodec InitCodec;
        LPFNDecodeFrame DecodeFrame;
        LPFNCloseCodec CloseCodec;
*/

#endif

// WINDOWS CE DEFINITIONS End



#include "string.h"
#include <stdio.h>
#include <stdlib.h>


#ifdef WINCE
static int xvid_FrameWidth = 0;
static int xvid_FrameHeight = 0;
#endif


#ifdef WINCE
void XvidSetWidth(int width)
{
        xvid_FrameWidth = width;
}

void XvidSetHeight(int height)
{
        xvid_FrameHeight = height;
}
#endif


/*
static int write_ppm(char *filename, unsigned char *image, int iWidth, int iHeight)
{
        FILE *filehandle;
        filehandle=fopen(filename,"wb");
        if (filehandle)
        {
                fprintf(filehandle,"P6\n\n"); 
                fprintf(filehandle,"%d %d 255\n",iWidth,iHeight);
                fwrite(image,iWidth,iHeight*3,filehandle);
                
                fclose(filehandle);
                return 0;
        }
        else
                return 1;
}
*/


int XVIDDecoderInit2(char **pDecoderHandle, unsigned int uiWidth, unsigned int uiHeight) {
#ifndef ENABLE_XVID
        fprintf(stderr,"XVIDDecoderInit2: xvid disabled in this build!\n");
        exit(2);
#else


#ifdef WINCE
        /*hDll = ::LoadLibrary(_T("\\Windows\\Codecs\\xvid_ppc.dll"));
        InitCodec = (LPFNInitCodec) GetProcAddress(hDll, TEXT("InitCodec"));
        DecodeFrame = (LPFNDecodeFrame) GetProcAddress(hDll, TEXT("DecodeFrame"));
        CloseCodec = (LPFNCloseCodec) GetProcAddress(hDll, TEXT("CloseCodec"));*/

        hXvid = InitCodec(xvid_FrameWidth, xvid_FrameHeight, FCC('x', 'v', 'i', 'd'));
        *pDecoderHandle = (char*) hXvid;
        if (hXvid != NULL) 
                return ERR_OK;
        else 
                return ERR;

#else
        uint32_t                temp;
        xvid_gbl_init_t init_param;
        xvid_dec_create_t param;
        
        memset(&init_param, 0, sizeof(xvid_gbl_init_t));
        memset(&param, 0, sizeof(xvid_dec_create_t));
        init_param.version = XVID_VERSION;
        fprintf(stderr,"xvid: version=%d.%d.%d\n", XVID_VERSION_MAJOR(init_param.version), XVID_VERSION_MINOR(init_param.version), XVID_VERSION_PATCH(init_param.version));
        init_param.debug = 0;
        
        
        init_param.cpu_flags = 0;
        xvid_global(NULL, 0, &init_param, NULL);
        
        param.height = 0;
        param.width = 0;
        param.version = XVID_VERSION;
        
        temp = xvid_decore(NULL, XVID_DEC_CREATE, &param, NULL);
        fprintf(stderr,"xvid_decore (init) : temp=%d\n", temp);

        if (temp == XVID_ERR_FAIL || temp == XVID_ERR_MEMORY || temp == XVID_ERR_FORMAT || temp == XVID_ERR_VERSION || temp == XVID_ERR_END) {
                return ERR;
        } else {
                *pDecoderHandle = (char*)param.handle;
        }
        
        fprintf(stderr, "xvid_init : OK!\n");
        return ERR_OK;

#endif
        
#endif //enable xvid

        return ERR;
}


void XVIDDecoderClose(char **pDecoderHandle) {
#ifndef ENABLE_XVID
        fprintf(stderr,"XVIDDecoderClose: xvid disabled in this build!\n");
        exit(2);
#else
        #ifdef WINCE
                CloseCodec(hXvid);
        #else
                xvid_decore((DECODER*) (*pDecoderHandle), XVID_DEC_DESTROY, NULL, NULL);
                *pDecoderHandle = NULL;
        #endif
#endif
}

int XVIDDecoderGetWidth(char *pDecoderHandle) {
#ifndef ENABLE_XVID
        fprintf(stderr,"XVIDDecoderGetWidth: xvid disabled in this build!\n");
        exit(2);
#else

#ifndef WINCE
        if(pDecoderHandle != NULL)
        {
                return ((DECODER *)pDecoderHandle)->width;
        }
#else
        return xvid_FrameWidth;
#endif
        
        return 0;
#endif
}


int XVIDDecoderGetHeight(char *pDecoderHandle) {
#ifndef ENABLE_XVID
        fprintf(stderr,"XVIDDecoderGetHeight: xvid disabled in this build!\n");
        exit(2);
#else

#ifndef WINCE
        if(pDecoderHandle != NULL)
        {
                return ((DECODER *)pDecoderHandle)->height;
        }
#else
        return xvid_FrameHeight;
#endif
        
        return 0;
#endif
}


int XVIDDecodeFrame(char *pDecoderHandle, char *pCompressedFrame, int iCFSize, char* pYUVFrame, xvidColorSpace eColorSpace) {
#ifndef ENABLE_XVID
        fprintf(stderr,"XVIDDecodeFrame: xvid disabled in this build!\n");
        exit(2);
#else

#ifndef WINCE
        xvid_dec_frame_t frame;
        
        int ret = 0;
        
        frame.version = XVID_VERSION;
        
        if(pDecoderHandle != NULL) {
                frame.bitstream = pCompressedFrame;
                frame.length = iCFSize;
                frame.output.plane[0] = pYUVFrame;
                frame.output.stride[0] = XVIDDecoderGetWidth(pDecoderHandle);
                frame.output.csp = eColorSpace;
                
                ret = xvid_decore(pDecoderHandle, XVID_DEC_DECODE, &frame, NULL);
                //              fprintf(stderr, "xvid decode frame: ret=%d\n", ret);
                if (ret == XVID_ERR_FAIL || ret == XVID_ERR_MEMORY || ret == XVID_ERR_FORMAT || ret == XVID_ERR_VERSION || ret == XVID_ERR_END)
                        return ret;
                else
                        return frame.length;
        }
#else
        DWORD pitch;
        byte *bufY, *bufU, *bufV;


        int mb_width = (xvid_FrameWidth + 15) / 16;
        int edgedWidth = (16 * mb_width + 2 * EDGE_SIZE);

        int size = xvid_FrameHeight * edgedWidth;

        int length = DecodeFrame(hXvid, pCompressedFrame, iCFSize, bufY, bufU, bufV, pitch);

        if (length > 0) {

                int size = xvid_FrameHeight * pitch;
                int i,j,k;
                for (i=0;i<xvid_FrameHeight;i++) memcpy(pYUVFrame + xvid_FrameWidth*i, bufY + pitch*i, xvid_FrameWidth);
                for (j=0;j<xvid_FrameHeight/2;j++) memcpy(pYUVFrame + xvid_FrameWidth*i + xvid_FrameWidth/2*j, bufU + pitch/2*j, xvid_FrameWidth/2);
                for (k=0;k<xvid_FrameHeight/2;k++) memcpy(pYUVFrame + xvid_FrameWidth*i + xvid_FrameWidth/2*j + xvid_FrameWidth/2*k, bufV + pitch/2*k, xvid_FrameWidth/2);
                

                return length;
        }
#endif
        
        return -999;    
#endif
}




#ifdef WINCE

int XVIDDecodeFrameCE(char *pCompressedFrame, int iCFSize, unsigned char *&y, unsigned char *&u, unsigned char *&v) {
#ifndef ENABLE_XVID
        fprintf(stderr,"XVIDDecodeFrame: xvid disabled in this build!\n");
        exit(2);
#else

        DWORD pitch;
        int length = DecodeFrame(hXvid, pCompressedFrame, iCFSize, y, u, v, pitch);

        if (length > 0) {
                return length;
        }
        
        return -999;    
#endif
}

#endif




int XVIDDecodeFile2(char *in, char *out, unsigned int uiWidth, unsigned int uiHeight, xvidColorSpace iColorSpace) {
#ifndef WINCE
#ifndef ENABLE_XVID
        fprintf(stderr,"XVIDDecodeFile2: xvid disabled in this build!\n");
        exit(2);
#else

        int ch = 0;
        int startCode = 0;
        int framesRead = 0;
        
        char *inBuf = (char*)malloc(sizeof(char)*MAX_FRAME_SIZE);
        char *outBuf = (char*)malloc(sizeof(char)*MAX_FRAME_SIZE);
        
        int                             width, height, i=0;
        DECODER                 *dec = NULL;
        long                    readed = 0;
        long                    used;
        
        FILE *fpi=fopen(in,"rb"),
                *fpo=fopen(out,"wb");
    if (fpi == NULL || fpo==NULL){
                if (fpi)
                        fclose(fpi);
                if (fpo)
                        fclose(fpo);
                return(ERR_FILE);
        }
        
        // Read headers and first frame
        while(startCode != 0x1B6 && !feof(fpi))
        {       
                ch = getc(fpi);
                startCode = (startCode << 8) | ch;
                inBuf[readed] = (char) ch;
                readed++;
                if(startCode == 0x1B6)
                {
                        if(framesRead == 1)
                                
                        {
                                fseek(fpi, -4, SEEK_CUR);
                                readed -= 5;
                        }
                        else
                        {
                                framesRead = 1;
                                startCode = 0;
                        }
                }
        }
        
        // DecoderInit((char**)(&dec), inBuf, readed);
        XVIDDecoderInit2((char**)(&dec), uiWidth, uiHeight);
        
        if(dec != NULL)
        {
                width = XVIDDecoderGetWidth((char *)dec);
                height = XVIDDecoderGetHeight((char *)dec);
                // because START_CODE must be 32bit
                while(readed >= 4){
                        printf("Decode Frame %d ",i++);
                        used = XVIDDecodeFrame((char *)dec, inBuf, readed, outBuf, XVIDColorSpaceI420);
                        printf(" used %li\n", used);
                        
                        
                        // Write decoded YUV image, size = width * height * 3 / 2 because in I420 CSP
                        fwrite(outBuf, 1, width * height * 3 / 2, fpo);
                        // write_ppm("test.ppm", outBuf, width, height); // RGB32 colorspace
                        
                        fflush(fpo);
                        
                        readed = fread(inBuf, 1, 4, fpi);
                        startCode = 0;
                        while(startCode != 0x1B6 && !feof(fpi))
                        {       
                                ch = getc(fpi);
                                startCode = (startCode << 8) | ch;
                                inBuf[readed] = (char) ch;
                                readed++;
                                if(startCode == 0x1B6)
                                {
                                        if(framesRead == 1)
                                                
                                        {
                                                fseek(fpi, -4, SEEK_CUR);
                                                readed -= 5;
                                        }
                                        else
                                        {
                                                framesRead = 1;
                                                startCode = 0;
                                        }
                                }
                        }
                }
                
                XVIDDecoderClose( (char **)(&dec));
        }
        
        fclose(fpi);
        fclose(fpo);
        return(ERR_OK);
#endif
#else //wince
        return ERR;
#endif //wince
}



int XVIDEncoderInit(char **pEncoderHandle, int iWidth, int iHeight, int bitrate, int iFramerate, int numBFrames) {
#ifndef ENABLE_XVID
        fprintf(stderr,"XVIDEncoderInit: xvid disabled in this build!\n");
        exit(2);
#else


#ifdef WINCE

/*
        hDll = ::LoadLibrary(_T("\\Windows\\Codecs\\xvid_ppc.dll"));
        InitCodec = (LPFNInitCodec) GetProcAddress(hDll, TEXT("InitCodec"));
        DecodeFrame = (LPFNDecodeFrame) GetProcAddress(hDll, TEXT("DecodeFrame"));
        CloseCodec = (LPFNCloseCodec) GetProcAddress(hDll, TEXT("CloseCodec"));
*/

        hXvid = InitCodec(xvid_FrameWidth, xvid_FrameHeight, FCC('x', 'v', 'i', 'd'));
        return ERR_OK;

#else

        xvid_gbl_init_t init_param;
        xvid_enc_create_t param;
        
        int ret = 0;
        
        // get Xvid core status
        init_param.cpu_flags = 0;
        xvid_global(NULL, 0, &init_param, NULL);
        
        // Check API Version is 2.1?
        if (init_param.version != ((2<<16)|(1)))
                return(-2);
        
        param.width = iWidth;
        param.height = iHeight;
        
        param.profile = XVID_PROFILE_AS_L3;
        param.num_zones = 1;
        
        
        param.fincr = 1;                                // FIXME: fincr=1000 and  fbase=23996 for float fps
        param.fbase = iFramerate;
        
        param.min_quant[0] = 1;
        param.min_quant[0] = 31;
        
        param.max_key_interval = iFramerate * 10;
        
        // FIXME: how to enable b-frame encoding for xvid???
        //      param.max_bframes = numBFrames;
        // use_bidirect is only defined for divx4, not xvid
        //      param.use_bidirect = 1;/*enable*/
        
        ret = xvid_encore(0, XVID_ENC_CREATE, &param, NULL);
        *pEncoderHandle = (char*)param.handle;
        if(ret == 0 && *pEncoderHandle != NULL)
                return ERR_OK;
        else 
                return ERR;
#endif //wince

#endif //enable_xvid

        return ERR;
}

void XVIDEncoderClose(char **pEncoderHandle) {
#ifndef WINCE
#ifndef ENABLE_XVID
        fprintf(stderr,"XVIDEncoderClose: xvid disabled in this build!\n");
        exit(2);
#else
        if (*pEncoderHandle)
                xvid_encore(*pEncoderHandle, XVID_ENC_DESTROY, NULL, NULL);
        *pEncoderHandle = NULL;
#endif
#endif //wince
}

int XVIDEncodeFrame(char *pEncoderHandle, char *inBuf, char *outBuf, xvidColorSpace eColorSpace, int forceIFrame) {
#ifndef WINCE
#ifndef ENABLE_XVID
        fprintf(stderr,"XVIDEncodeFrame: xvid disabled in this build!\n");
        exit(2);
#else

        xvid_enc_frame_t frame;
        xvid_enc_stats_t stats;
        
        // set encode frame param
        frame.vop_flags = XVID_VOP_HALFPEL | XVID_VOP_INTER4V;
        frame.motion = XVID_ME_ADVANCEDDIAMOND8;
        frame.input.plane[0] = inBuf;
        
        
        frame.bitstream = outBuf;
        frame.length = MAX_FRAME_SIZE;
        frame.input.csp = eColorSpace;
        frame.quant = 0;        // CBR mode
        
        frame.vol_flags = XVID_VOL_MPEGQUANT;
        
        frame.quant_inter_matrix = NULL;        // Use default quant matrix
        frame.quant_intra_matrix = NULL;
        
        if (forceIFrame == 1) frame.vop_flags |= XVID_TYPE_IVOP;
        
        xvid_encore(pEncoderHandle, XVID_ENC_ENCODE, &frame, &stats);
        
        return frame.length;
#endif
#else //wince
        return ERR;
#endif //wince
}


int XVIDEncodeFile(char *in, int width, int height, int bitrate, xvidColorSpace iColorSpace, char *out) {
#ifndef WINCE
#ifndef ENABLE_XVID
        fprintf(stderr,"XVIDEncodeFile: xvid disabled in this build!\n");
        exit(2);
#else

        char inBuf[MAX_FRAME_SIZE];     // Image Buffer
        char outBuf[MAX_FRAME_SIZE];    
        
        Encoder                 *pEnc = NULL; // handle to encoder
        int num=0;      // Encoded frames
        int len = 0;
        int temp;
        
        FILE *fpi=fopen(in,"rb"),
                *fpo=fopen(out,"wb");
    if (fpi == NULL || fpo==NULL){
                if (fpi)
                        fclose(fpi);
                if (fpo)
                        fclose(fpo);
                return(ERR_FILE);
        }
        
        if ((unsigned)(height*width*3) > sizeof(inBuf)){
                fclose(fpi);
                fclose(fpo);
                return(-1);
        }
        
        XVIDEncoderInit((char **) (&pEnc), width, height, bitrate, 25 /*GOP size*/, 0 /* BVOPs */);
        
        // Encode Frame
        temp=fread(inBuf, 1, width*height*3/2, fpi);    // Read YUV data
        
        while(temp == width*height*3/2){
                printf("Encode Frame=%d ",num);
                len = XVIDEncodeFrame((char *) pEnc, inBuf, outBuf, XVIDColorSpaceI420, 0);
                printf("len %d\n", len);
                fwrite(outBuf, 1, len, fpo);
                temp=fread(inBuf, 1, width*height*3/2, fpi);    // Read next YUV data
                num++;
        }
        
        
        XVIDEncoderClose((char **) &pEnc);
        fclose(fpi);
        fclose(fpo);
        
        
        return(ERR_OK);
#endif
#else //wince
        return ERR;
#endif //wince
}

© ViTooKi 2003 :: [Lite version] Created with Doxygen