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

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

ffmpegInterface.c

 /***********************************************************************
 *                                                                      *
 * ViTooKi                                                              *
 *                                                                      *
 * title:       ffmpegInterface.cpp                                           *
 *                                                                      *
 *                                                                      *
 *                                                                      *
 * 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:                                                   *
 *                                                                      *
 *                                                                      *
 *                                                                      *
 ***********************************************************************/

#ifndef WINCE



//#undef DEBUG
#include "ffmpegInterface.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "assert.h"

#ifdef ENABLE_FFMPEG

  #if BUILD_ARCH_INTEL
  #include "dsputil.h"
  #endif

  //mutex is necessary since ffmpeg is not thrdad-safe!!
  //since this is plain C, we cannot use the capsuled VMutex.hpp
  #include <pthread.h>
  static pthread_mutex_t ffmpeg_mutex = PTHREAD_MUTEX_INITIALIZER;

#endif



int FFMPEGDecoderInit(char **pDecoderHandle, enum CodecID codecID, 
                                                                                        unsigned int uiWidth, unsigned int uiHeight) {
#ifndef ENABLE_FFMPEG
        fprintf(stderr,"FFMPEGDecoderInit: ffmpeg disabled in this build!\n");
        exit(2);
#else
#ifndef WIN32
        pthread_mutex_lock(&ffmpeg_mutex);
#endif
        AVCodec *codec;
        AVCodecContext *cc= NULL;
        
#if BUILD_ARCH_INTEL
        /* this is done for using the img_convert(YUV420P to RGBA32) function
                 just because the one-time init of croptbl, needed for img_convert,
                 is a side effect of init'ing a DSPContext for which we have no use! */
        DSPContext dspctx;
#endif

#if DEBUG_LEVEL>1
        printf("FFMPEGDecoderInit : codecID = %d\n", codecID);  
#endif
        //first see if codec is available or not
        codec = avcodec_find_decoder(codecID);
        if (!codec) {
                printf("ffmpeginterface::FFMPEGDecoderInit: Video codec not found\n");
#ifndef WIN32
                pthread_mutex_unlock(&ffmpeg_mutex);
#endif
                return ERR;
        }
        *pDecoderHandle = NULL;
        
        //allocate AVCodecContext object
        cc = avcodec_alloc_context();
        
        /*      if(codecID == CODEC_ID_MPEG4) { //This initialization is only required for MPEG4
                cc->width = uiWidth;
                cc->height = uiHeight;
                }
        */
        assert(cc);

#if BUILD_ARCH_INTEL
        //This is done for initializing some tables for img_convert fuction
        dsputil_init(&dspctx, cc);
#endif
        
        //Everything's set - now open the codec
        if (avcodec_open(cc, codec) < 0) {
                printf("ffmpeginterface::FFMPEGDecoderInit: Could not open video codec\n");
#ifndef WIN32
                pthread_mutex_unlock(&ffmpeg_mutex);
#endif
                return ERR;
        }
        else
                {
                        *pDecoderHandle = (char*)cc;                   // cc is the handle to the codec 
#ifndef WIN32
                        pthread_mutex_unlock(&ffmpeg_mutex);
#endif
                        return ERR_OK;
                }
#endif
}


void FFMPEGDecoderClose(char **pDecoderHandle) {
#ifndef ENABLE_FFMPEG
        fprintf(stderr,"FFMPEGDecoderClose: ffmpeg disabled in this build!\n");
        exit(2);
#else
#ifndef WIN32
        pthread_mutex_lock(&ffmpeg_mutex);
#endif

        if(*pDecoderHandle) {
                avcodec_close((AVCodecContext *) *pDecoderHandle);
                av_free(*pDecoderHandle); 
                *pDecoderHandle = NULL;
        }
#ifndef WIN32
        pthread_mutex_unlock(&ffmpeg_mutex);
#endif

#endif  
}


int FFMPEGDecoderGetWidth(char *pDecoderHandle) {
#ifndef ENABLE_FFMPEG
        fprintf(stderr,"FFMPEGDecoderGetWidth: ffmpeg disabled in this build!\n");
        exit(2);
#else
        if(pDecoderHandle != NULL)
                {
                        return ((AVCodecContext *)pDecoderHandle)->width;
                }
        
        return 0;
#endif
}


int FFMPEGDecoderGetHeight(char *pDecoderHandle) {
#ifndef ENABLE_FFMPEG
        fprintf(stderr,"FFMPEGDecoderGetHeight: ffmpeg disabled in this build!\n");
        exit(2);
#else   
        if(pDecoderHandle != NULL)
                {
                        return ((AVCodecContext *)pDecoderHandle)->height;
                }
        
        return 0;
#endif
}



int FFMPEGDecodeFrame(char *pDecoderHandle, char *pCompressedFrame, int iCFSize, 
                                                                                        char* pYUVFrame, ffmpegColorSpace eColorSpace) {
#ifndef ENABLE_FFMPEG
        fprintf(stderr,"FFMPEGDecodeFrame: ffmpeg disabled in this build!\n");
        exit(2);
#else
#ifndef WIN32
        pthread_mutex_lock(&ffmpeg_mutex);
#endif

        AVFrame *frame;
        AVPicture picture, *formatted_picture, picture_format_temp;
        AVCodecContext *dec;
        int got_picture, lengthDecoded, i;
        int width, height, ref = 0; 
        char* decodedFrame = pYUVFrame; 
        
        frame= avcodec_alloc_frame();                 
        width = ((AVCodecContext *)pDecoderHandle)->width; 
        height = ((AVCodecContext *)pDecoderHandle)->height; 
        dec = ((AVCodecContext *)pDecoderHandle);
        
        
        /* Everything's set ... so decode video now!!
                 
        @param dec The decoder handle
        @param frame Contains the Uncompressed frame after decoding. The uncompressed frame is 
        not exactly in YUV format you need to retrieve the YUV frame using "linesize"(see below)
        @param got_picture Is TRUE if complete uncompressed frame is obtained after deocding
        @param pCompressedFrame Contains the frame to be decoded
        iCFSize size of the compressed frame
        @return the length of pCompressedFrame that is deocded
        
        @see ffmpeg 3rdparty/ffmpeg/libavcoded/avcodec.h
        */
        
        lengthDecoded = avcodec_decode_video(dec, frame, &got_picture,
                                                                                                                                                         (uint8_t*)pCompressedFrame, iCFSize);
        //Look into libavcodec/avcodec.h to difference between AVframe and AVPicture
        picture= *(AVPicture*)frame;
        
        if (got_picture) {
                u8 *buf = NULL; // *src, *dest;
                
                /*the colorspace of decoded frame is YUV420P 
                  ....so do colorSpace conversion if required */
                if((signed)dec->pix_fmt != eColorSpace && eColorSpace != FFMPEGColorSpaceYV12) {
                        int size;
                        /* create temporary picture */
                        size = avpicture_get_size(eColorSpace, dec->width, dec->height);
                        buf = av_malloc(size);
                        if (!buf)       {
                                printf("ffmpegInterface::FFMPEGDecodeFrame: Error in allocating Buffer\n");
#ifndef WIN32
                                pthread_mutex_unlock(&ffmpeg_mutex);
#endif

                                exit(1);//return -1;
                        }
                        formatted_picture = &picture_format_temp;
                        avpicture_fill(formatted_picture, buf, eColorSpace, dec->width, dec->height);
                        if(img_convert(formatted_picture, eColorSpace, 
                                                                                 &picture, dec->pix_fmt, 
                                                                                 dec->width, dec->height) < 0) {
                                        printf("ffmpegInterface::FFMPEGDecodeFrame: Pixel format conversion not handled\n");
#ifndef WIN32
                                        pthread_mutex_unlock(&ffmpeg_mutex);
#endif

                                        exit(1);//return -1;
                        }
                        
                } else
                        formatted_picture = &picture;
                
                
                /* the decoded frame data is stored in frame->data as follows :
                 * frame->data[0] = Y
                 * frame->data[1] = U
                 * frame->data[2] = V
                 * 
                 * so write this in the outputBuffer in the required way 
                 * i.e. YUVI420 or YV12 or RGB32
                 * NOTE: always use frame->linesize, which tells the size of Y, U, or V Component
                 */
                switch(eColorSpace) {
                case FFMPEGColorSpaceYV12:       //FIXME: why not just copy all in one or even keep "frame"???
                        for(i=0; i< height; i++) {
                                memcpy(decodedFrame + i*width, 
                                                         formatted_picture->data[0] + i * formatted_picture->linesize[0],
                                                         width);
                        }
                        ref = height*width;
                        for(i=0; i<height/2; i++) {
                                memcpy(decodedFrame + ref + i*width/2,
                                                         formatted_picture->data[1] + i * formatted_picture->linesize[1], 
                                                         width/2);
                        }
                        ref += height*width/4;
                        for(i=0; i<height/2; i++) {
                                memcpy(decodedFrame + ref + i*width/2, 
                                                         formatted_picture->data[2] + i * formatted_picture->linesize[2], 
                                                         width/2);
                        }
                        break;
                        
                case FFMPEGColorSpaceI420: 
                        for(i=0; i< height; i++) {
                                memcpy(decodedFrame + i*width, 
                                                         formatted_picture->data[0] + i * formatted_picture->linesize[0], 
                                                         width);
                        }
                        ref = height*width;
                        for(i=0; i<height/2; i++) {
                                memcpy(decodedFrame + ref + i*width/2, 
                                                         formatted_picture->data[2] + i * formatted_picture->linesize[2], 
                                                         width/2);
                        }
                        ref += height*width/4;
                        for(i=0; i<height/2; i++) {
                                memcpy(decodedFrame + ref + i*width/2,
                                                         formatted_picture->data[1] + i * formatted_picture->linesize[1], 
                                                         width/2);
                        }
                        break;
                        
                case FFMPEGColorSpaceRGB24:
                        for(i=0; i< height; i++) 
                                memcpy(decodedFrame + i*width*3, 
                                                         formatted_picture->data[0] + i * formatted_picture->linesize[0], 
                                                         width*3);
                        
                        //memcpy(decodedFrame, formatted_picture->data[0],  width*height*3);
                        break;
                        
                case FFMPEGColorSpaceRGB32:
                        for(i=0; i< height; i++) 
                                memcpy(decodedFrame + i*width*4, 
                                                         formatted_picture->data[0] + i * formatted_picture->linesize[0], 
                                                         width*4);
                        break;
                        
                case FFMPEGColorSpaceRGB565:   // 16bit colorspace
                        for(i=0; i< height; i++) 
                                memcpy(decodedFrame + i*width*2, 
                                                         formatted_picture->data[0] + i * formatted_picture->linesize[0], 
                                                         width*2);
                        break;
                        
                case FFMPEGColorSpaceGRAY8:
                  for (i=0; i < height; i++)
                    memcpy(decodedFrame + i*width, 
                                                         formatted_picture->data[0] + i*formatted_picture->linesize[0], 
                                                         width);
                  break;
                        
                default :
                        printf("ffmpegInterface::FFMPEGDecodeFrame: Specified ColorSpace not supported\n");
                        pthread_mutex_unlock(&ffmpeg_mutex);

                        exit(1);        
                        
                        
                }
                
                av_free(buf);
        }
        else
                lengthDecoded = 0-lengthDecoded; /* this is made negative just to differentiate
                                                                                                                                                        * this info in MP4Decoder class
                                                                                                                                                        * This is done to manage buffer in MP4Decoder class */
        av_free(frame); 
        
#ifndef WIN32
        pthread_mutex_unlock(&ffmpeg_mutex);
#endif
        return lengthDecoded;
#endif
}


int FFMPEGEncoderInit(char **pEncoderHandle, enum CodecID id, int iWidth, int iHeight,
                                                                                        int bitrate, int iFramerate, int numBFrames, int keyFrameInterval) {
#ifndef ENABLE_FFMPEG
        fprintf(stderr,"FFMPEGEncoderInit: ffmpeg disabled in this build!\n");
        exit(2);
#else
#ifndef WIN32
        pthread_mutex_lock(&ffmpeg_mutex);
#endif

        AVCodec *codec=NULL;
        AVCodecContext *cc= NULL;       
        
        //assert(pEncoderHandle);
        
        /* Make sure that the required encoder exists in the ffmpeg library */
        codec = avcodec_find_encoder(id);
        if (!codec) {
                printf("ffmpegInterface::FFMPEGEncoderInit: Codec not found\n");
                if(*pEncoderHandle) {
                        av_free(*pEncoderHandle);
                        *pEncoderHandle=NULL;
                }
#ifndef WIN32
                pthread_mutex_unlock(&ffmpeg_mutex);
#endif
                return ERR;
        }
        if(*pEncoderHandle==NULL) {
                cc= avcodec_alloc_context();
                
                //set the default values of encoding parameters
                avcodec_get_context_defaults(cc);
                
                /*Set all the encoding parameters here */
                //cc->flags |= CODEC_FLAG_QSCALE;
                fprintf(stdout,"ffmpegInterface::FFMPEGEncoderInit: created encoder with bitrate %u, fps %i, BbetweenP %i, keyFrameInterval %i\r\n",bitrate,iFramerate, numBFrames, keyFrameInterval);

                cc->bit_rate = bitrate;
                cc->bit_rate_tolerance = cc->bit_rate * 5;
                cc->width = iWidth;
                cc->height = iHeight;
                cc->pix_fmt = PIX_FMT_YUV420P;
                
                cc->qmin = 4;
                cc->qmax = 31;
                cc->mpeg_quant = 1;             //0-> h263 quant 1-> mpeg quant

                //cc->rc_max_rate = bitrate*2;
                //cc->rc_min_rate = bitrate/2;
                //cc->rc_buffer_size = 1.5 * 1024 * 1024 * 1024;        // 4 MegaByte: size in bytes -> for rate control
                //              cc->rc_buffer_size = bitrate*5;

                cc->max_b_frames = numBFrames;
                cc->time_base.num = 1;
                cc->time_base.den = iFramerate;     //XXX for variable fps ???

                cc->gop_size = keyFrameInterval;
                cc->refs = 1; //number of reference frames

                //      cc->flags |= CODEC_FLAG_GLOBAL_HEADER;
        }
        else
                cc=(AVCodecContext*) (*pEncoderHandle);

        // open the codec for encoding
        if (avcodec_open(cc, codec) < 0) {
                fprintf(stderr,"ffmpegInterface::FFMPEGEncoderInit: Could not open codec\n");
                av_free(cc);
                *pEncoderHandle=NULL;
#ifndef WIN32
                pthread_mutex_unlock(&ffmpeg_mutex);
#endif
                return ERR;     
        }
        else 
                *pEncoderHandle = (char*)cc;

#ifndef WIN32
        pthread_mutex_unlock(&ffmpeg_mutex);
#endif
        return ERR_OK;
#endif
}


void FFMPEGEncoderClose(char **pEncoderHandle) {
#ifndef ENABLE_FFMPEG
        fprintf(stderr,"FFMPEGEncoderClose: ffmpeg disabled in this build!\n");
        exit(2);
#else
        if(*pEncoderHandle) {
                avcodec_close((AVCodecContext *) *pEncoderHandle);
                *pEncoderHandle=NULL;
        }
        av_free(*pEncoderHandle);
#endif
}

int FFMPEGEncodeFrame(char *pEncoderHandle, char *inBuf, char *outBuf, ffmpegColorSpace eColorSpace, int forceIFrame) {
#ifndef ENABLE_FFMPEG
        fprintf(stderr,"FFMPEGEncodeFrame: ffmpeg disabled in this build!\n");
        exit(2);
#else
#ifndef WIN32
        pthread_mutex_lock(&ffmpeg_mutex);
#endif

        AVFrame *frame;
        int width, height, size, frame_length;

        frame= avcodec_alloc_frame();                 
        
        width = ((AVCodecContext *)pEncoderHandle)->width;
        height = ((AVCodecContext *)pEncoderHandle)->height;
        
        size = width * height;
        
        frame->linesize[0] = width;
        frame->linesize[1] = width / 2;
        frame->linesize[2] = width / 2;

        /* Feed data to the encoder according to the input colorspace type */
        switch(eColorSpace) {
                case FFMPEGColorSpaceI420:
                        frame->data[0] = (uint8_t*)inBuf;
                        frame->data[2] = frame->data[0] + size;
                        frame->data[1] = frame->data[2] + size / 4;
                        break;
                case FFMPEGColorSpaceYV12:
                        frame->data[0] = (uint8_t*)inBuf;
                        frame->data[1] = frame->data[0] + size;
                        frame->data[2] = frame->data[1] + size / 4;
                        break;
                default:
                        printf("ffmpegInterface::FFMPEGEncodeFrame: ColorSpace = eColorSpace %d NOT supported!!\n", eColorSpace); 
        }

        if(forceIFrame == 1) {
                printf( "ffmpegInterface::FFMPEGEncodeFrame: forceIFrame not implemented.... ignoring...\n");
        }
        
        frame_length = avcodec_encode_video((AVCodecContext *)pEncoderHandle, (uint8_t*)outBuf, MAX_FRAME_SIZE, frame);  

        av_free(frame);
#ifndef WIN32
        pthread_mutex_unlock(&ffmpeg_mutex);
#endif

        return frame_length;
#endif
}


int FFMPEGEncodeFile(char *in, int width, int height, int bitrate, ffmpegColorSpace iColorSpace, char *out) {
#ifndef ENABLE_FFMPEG
        fprintf(stderr,"FFMPEGEncodeFile: ffmpeg disabled in this build!\n");
        exit(2);
#else
        fprintf(stderr,"FFMPEGEncodeFile: not implemented!\n");
        return 0;
#endif
}


/***************************************************************************************/
/* AUDIO STUFF */
/***************************************************************************************/

int FFMPEGaudioDecoderInit(char **pDecoderHandle, enum CodecID codecID) {
#ifndef ENABLE_FFMPEG
        fprintf(stderr,"FFMPEGaudioDecoderInit: ffmpeg disabled in this build!\n");
        exit(2);
#else
#ifndef WIN32
        pthread_mutex_lock(&ffmpeg_mutex);
#endif

        AVCodec *codec;
        AVCodecContext *cc= NULL;
        
        //first see if codec is available or not
        codec = avcodec_find_decoder(CODEC_ID_MP3); //ONLY ***MP3****
        if (!codec) {
                printf("ffmpegInterface::FFMPEGaudioDecoderInit: Audio codec not found\n");
#ifndef WIN32
                pthread_mutex_unlock(&ffmpeg_mutex);
#endif

                return ERR;
        }
        
        //allocate AVCodecContext object
        cc= avcodec_alloc_context();
        
        /*Now open the codec*/
        if (avcodec_open(cc, codec) < 0) {
                printf("ffmpegInterface::FFMPEGaudioDecoderInit: Could not open audio codec\n");
#ifndef WIN32
                pthread_mutex_unlock(&ffmpeg_mutex);
#endif
                return ERR;
        } else  {
                *pDecoderHandle = (char*)cc;                   //cc is the handle to the codec
#ifndef WIN32
                pthread_mutex_unlock(&ffmpeg_mutex);
#endif
                return ERR_OK;
        }
#endif
}


void FFMPEGaudioDecoderClose(char **pDecoderHandle) {
#ifndef ENABLE_FFMPEG
        fprintf(stderr,"FFMPEGaudioDecoderClose: ffmpeg disabled in this build!\n");
        exit(2);
#else
#ifndef WIN32
        pthread_mutex_lock(&ffmpeg_mutex);
#endif

        avcodec_close((AVCodecContext *) *pDecoderHandle);
        av_free(*pDecoderHandle);
        *pDecoderHandle=NULL;
#ifndef WIN32
        pthread_mutex_unlock(&ffmpeg_mutex);
#endif

#endif
}


int FFMPEGaudioDecodeFrame(char *pDecoderHandle, char *pCompressedFrame,
                                int iCFSize, char* PCMFrame, int *outsize) {
#ifndef ENABLE_FFMPEG
        fprintf(stderr,"FFMPEGaudioDecodeFrame: ffmpeg disabled in this build!\n");
        exit(2);
#else
#ifndef WIN32
        pthread_mutex_lock(&ffmpeg_mutex);
#endif

        AVCodecContext *dec;
        char* decodedFrame = PCMFrame;
        int CFSize = iCFSize, len1 = 0, lengthDecoded = 0, out_size= 0, total_size = 0;
        
        dec = ((AVCodecContext *)pDecoderHandle);
        
        /* decode the entire audio frame ... the decoder may take more than one round to decoded a frame
           However this is done specially for those cases where we do not send packets that are more than
           one frame
        */
        while (CFSize > 0 ) { 
                /* Function to decode an audio frame
                   @param dec The decoder handle
                   @param (decodedFrame+total_size) The pointer to the uncompresses frame buffer where decoded frame 
                         is to be stored
                   @param out_size Size of the uncompressed/decoded audio frame
                   @param pCompressedFrame The frame to be decoded
                   @param CFSize Total size of the compressed frame
                         
                   @return len1 Length of the compressed that is decoded after this call
                         
                   @see 3rdparty/libavcodec/avcodec.h
                */
                len1 = avcodec_decode_audio(dec, (short *)(decodedFrame+total_size), &out_size,
                                                                                                                                (uint8_t*)(pCompressedFrame + lengthDecoded), CFSize);
                
                // dprintf_full("ffmpegInterface::FFMPEGaudioDecodeFrame: len input = %d len decoded = %d output = %d\n", CFSize, len1, out_size);
                if(len1 < 0) {
#ifndef WIN32
                        pthread_mutex_unlock(&ffmpeg_mutex);
#endif
                        return lengthDecoded;
                }

                if(out_size <= 0) { 
                        CFSize -= len1;
                        continue;
                }
                lengthDecoded += len1;
                CFSize -= len1;
                total_size += out_size;
                
        } //while
        // dprintf_full("FFMPEGaudioDecodeFrame : inSize = %d, lenghtDecoded = %d and outsize = %d\n", iCFSize, lengthDecoded, total_size);
        
        if(total_size <= 0)
                lengthDecoded = 0;
        *outsize = total_size;
#ifndef WIN32
        pthread_mutex_unlock(&ffmpeg_mutex);
#endif

        return lengthDecoded;
#endif
}


int FFMPEGaudioEncoderInit( char **pEncoderHandle, int iBitrate,  int iSampleRate, int iChannels, int iBits) {
#ifndef ENABLE_FFMPEG
        fprintf(stderr,"FFMPEGaudioEncoderInit: ffmpeg disabled in this build!\n");
        exit(2);
#else
#ifndef WIN32
        pthread_mutex_lock(&ffmpeg_mutex);
#endif

        AVCodec *codec;
        AVCodecContext *cc= NULL;
        int ret;

        /* Make sure that mpeg4 encoder is available */
        codec = avcodec_find_encoder(CODEC_ID_MP3);

        if (!codec || (codec->type != CODEC_TYPE_AUDIO)) {
                fprintf(stderr,"ffmpegInterface::FFMPEGaudioEncoderInit: Audio codec not found\n");
#ifndef WIN32
                pthread_mutex_unlock(&ffmpeg_mutex);
#endif

                return ERR;
        }

        //assert(codec == &mp3lame_encoder);

        cc = avcodec_alloc_context();
        //set the default values of encoding parameters
        avcodec_get_context_defaults(cc);
        
        /* Set all the encoding parameters here */
        assert((iBitrate/1000==128) || (iBitrate/1000==96) || (iBitrate/1000==64) || (iBitrate/1000==32));
        cc->bit_rate = iBitrate;
        cc->sample_rate = iSampleRate;
        cc->channels = iChannels;
        cc->bits_per_sample = iBits;
        
        /* open the codec */
        if ((ret=avcodec_open(cc, codec)) < 0) {
                fprintf(stderr,"ffmpegInterface::FFMPEGaudioEncoderInit: Could not open audio codec, bitrate %i, err %i\n",cc->bit_rate,ret);
                *pEncoderHandle=NULL;
#ifndef WIN32
                pthread_mutex_unlock(&ffmpeg_mutex);
#endif

                return ERR;
        }
        else
                *pEncoderHandle = (char*)cc;

        fprintf(stderr,"ffmpegInterface::audioEncInit pcm frame size %i\n",cc->frame_size);
#ifndef WIN32
        pthread_mutex_unlock(&ffmpeg_mutex);
#endif

        return ERR_OK;
#endif

}


void FFMPEGaudioEncoderClose(char **pEncoderHandle) {
#ifndef ENABLE_FFMPEG
        fprintf(stderr,"FFMPEGaudioEncoderClose: ffmpeg disabled in this build!\n");
        exit(2);
#else
#ifndef WIN32
        pthread_mutex_lock(&ffmpeg_mutex);
#endif

        avcodec_close((AVCodecContext *) *pEncoderHandle);
        av_free(*pEncoderHandle);
        *pEncoderHandle=NULL;
#ifndef WIN32
        pthread_mutex_unlock(&ffmpeg_mutex);
#endif

#endif
}


int FFMPEGaudioEncodeFrame(char *pEncoderHandle, char *PCMFrame, char *pCompressed) {
#ifndef ENABLE_FFMPEG
        fprintf(stderr,"FFMPEGaudioEncodeFrame: ffmpeg disabled in this build!\n");
        exit(2);
#else
#ifndef WIN32
        pthread_mutex_lock(&ffmpeg_mutex);
#endif

        int frame_length;
        AVCodecContext *cc = (AVCodecContext *)pEncoderHandle;  
        /* encode the  audio frame*/
        frame_length = avcodec_encode_audio(cc, (uint8_t*)pCompressed, 
                                                                                                                                                        0, /* ffmpeg takes its own cc->frame_size */
                                                                                                                                                        (const short*)PCMFrame);
#ifndef WIN32
        pthread_mutex_unlock(&ffmpeg_mutex);
#endif
                        
        return frame_length;
#endif
}

#endif //wince

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