videoTexture.cpp

#include "main.h"
#include "videoTexture.h"

extern "C"
{
#define __STDC_CONSTANT_MACROS
#define __STDC_LIMIT_MACROS
#include "avformat.h"
#include "avcodec.h"
#include "swscale.h"
}




// constructor
VideoTexture::VideoTexture()
: texture(NULL),
  avFormatContext(NULL),
  avCodecContext(NULL),
  avCodec(NULL),
  avFrameYUV(NULL),
  avFrameRGB(NULL),
  swsContext(NULL),
  videoStreamIndex(-1),
  videoStreamFPS(-1),
  loopedPlay(true),
  timeSinceLastUpdate(-1)
{
        logger->log( "VideoTexture ctor()" );
    
        // Register all formats and codecs within libavcodec
        // (i.e. play every movie the libavcodec is able to play)
    av_register_all();
}


// destructor
VideoTexture::~VideoTexture()
{
        // remove texture from driver
        if ( NULL != this->texture )
        {
                // todo: assume no other photo still uses this texture
                // driver->removeTexture( this->texture );
                this->texture = NULL;
        }

        // Free the RGB image
        if ( NULL != this->avFrameRGB )
        {
                av_free( this->avFrameRGB );
                this->avFrameRGB = NULL;
        }
        
        // Free the YUV image
        if ( NULL != this->avFrameYUV )
        {
                av_free( this->avFrameYUV );
                this->avFrameYUV = NULL;
        }

        // Close the codec
        if ( NULL != this->avCodecContext )
        {
                avcodec_close( this->avCodecContext );
                this->avCodecContext = NULL;
        }

        // Close the video file
        if ( NULL != this->avFormatContext )
        {
                av_close_input_file( this->avFormatContext );
                this->avFormatContext = NULL;
        }

        // Free the software scaler
        if ( NULL != this->swsContext )
        {
                sws_freeContext( this->swsContext );
                this->swsContext = NULL;
        }

        logger->log( "VideoTexture dtor()" );
}


ERR_TYPE VideoTexture::openStream( stringc fileName, bool loopedPlay )
{
    // Open video file
    if ( 0 != av_open_input_file( &this->avFormatContext, fileName.c_str(), NULL, 0, NULL ) )
        {
                // Couldn't open file
                stringc info( "openStream() cannot open file " );
                info += fileName;
                logger->log( info.c_str() );
        return ERR_UNKWON;
        }

    // Retrieve stream information
        // This function populates avFormatContext->streams with proper information
    if ( av_find_stream_info( this->avFormatContext ) < 0 )
        {
                // Couldn't find stream information
                stringc info( "openStream() cannot find stream info in file " );
                info += fileName;
                logger->log( info.c_str() );
                return ERR_UNKWON;
        }

        // Dump information about file onto standard error
        //dump_format( this->avFormatContext, 0, fileName.c_str(), 0 );

    // Find the first video stream
    for ( s32 i = 0; i < (s32) this->avFormatContext->nb_streams; i++ )
        {
        if ( this->avFormatContext->streams[i]->codec->codec_type == CODEC_TYPE_VIDEO )
        {
            this->videoStreamIndex = i;
                        stringc info( "openStream() using stream " );
                        info += this->videoStreamIndex;
                        info += " as video stream in file ";
                        info += fileName;
                        logger->log( info.c_str() );
            break;
        }
        }
    if ( this->videoStreamIndex == -1 )
        {
                // Didn't find a video stream
                stringc info( "openStream() no video stream found in file " );
                info += fileName;
                logger->log( info.c_str() );
                return ERR_UNKWON;
        }

    // Get a pointer to the codec context for the video stream
    this->avCodecContext = this->avFormatContext->streams[videoStreamIndex]->codec;

    // Find the decoder for the video stream
    this->avCodec = avcodec_find_decoder( this->avCodecContext->codec_id );
    if ( this->avCodec == NULL )
        {
                // Codec not found
                logger->log( "openStream() no proper codec found to handle this video" );
                return ERR_UNKWON;
        }

        // dump info about codec
        stringc codecName( "openStream() using codec " );
        codecName += this->avCodec->name;
        logger->log( codecName.c_str() );

        // get video FPS used by update()
        f32 num = (f32) this->avCodecContext->time_base.num;
        f32 den = (f32) this->avCodecContext->time_base.den;
        this->videoStreamFPS = (f32) (den / num);

        // dump info about frame rate
        stringc framerate( "openStream() frame rate is " );
        framerate += this->videoStreamFPS;
        framerate += " FPS";
        logger->log( framerate.c_str() );

        // dump info about video dimension
        stringc dimension( "openStream() video dimension width=" );
        dimension += this->avCodecContext->width;
        dimension += " height=";
        dimension += this->avCodecContext->height;
        logger->log( dimension.c_str() );

        // dump info about video duration
        stringc duration( "openStream() video duration is " );
        duration += (u32) (this->avFormatContext->duration / AV_TIME_BASE);
        duration += " seconds";
        logger->log( duration.c_str() );

        // Open codec
        if ( avcodec_open( this->avCodecContext, this->avCodec ) < 0 )
        {
                // Could not open codec
                stringc err( "openStream() cannot open codec " );
                err += this->avCodec->name;
                logger->log( err.c_str() );
                return ERR_UNKWON;
        }

        // Now we need a place to actually store the frame:
        // Allocate video frame
        this->avFrameYUV = avcodec_alloc_frame();
        if ( NULL == this->avFrameYUV )
        {
                logger->log( "openStream() cannot allocate video frame" );
                return ERR_UNKWON;
        }

        // we're going to have to convert our frame from its native format to ARGB. 
        // ffmpeg will do these conversions for us. For most projects (including ours) 
        // we're going to want to convert our initial frame to a specific format. 
        // Let's allocate a frame for the converted frame now.

        // Allocate an AVFrame structure
        this->avFrameRGB = avcodec_alloc_frame();
        if ( NULL == this->avFrameRGB )
        {
                logger->log( "openStream() cannot allocate RGB frame" );
                return ERR_UNKWON;
        }

        // set hardware texture size.
        // in terms of performance, we should use source size here,
        // but older graphic cards only accept power2 size
        s32 targetSizeX = 256;
        s32 targetSizeY = 256;

        // we also want to draw a boarder around video
        s32 targetBoarderX = 28;
        s32 targetBoarderY = 28;

        // get the software scaler, used to copy from YUV to RGB color scheme
        // reduce desired target size by boarder size
        this->swsContext = sws_getContext(      this->avCodecContext->width,
                                                                                this->avCodecContext->height,
                                                                                this->avCodecContext->pix_fmt,
                                                                                targetSizeX - targetBoarderX,
                                                                                targetSizeY - targetBoarderY,
                                                                                PIX_FMT_RGB32,
                                                                                SWS_FAST_BILINEAR,
                                                                                NULL,
                                                                                NULL,
                                                                                NULL );
        if ( NULL == this->swsContext )
        {
                logger->log( "openStream() Error creating swsContext" );
                return ERR_UNKWON;      
        }

        this->texture = driver->addTexture(     dimension2d<s32>(targetSizeX, targetSizeY),
                                                                                fileName.c_str(),
                                                                                ECF_A8R8G8B8 ); // force 32-bit texture
        
        if ( NULL == this->texture )
        {
                logger->log( "openStream() Error creating VideoTexture" );
                return ERR_UNKWON;
        }

        ECOLOR_FORMAT colorFormat = this->texture->getColorFormat();
        if ( colorFormat != ECF_A8R8G8B8 )
        {
                logger->log( "openStream() Warning, texture color format mismatch" );
        }

        // get pointer to irrlicht texture buffer
        u8* buffer = (u8*) this->texture->lock();

        // fill whole texture white
        memset( buffer, 0xFF, this->texture->getSize().Width * this->texture->getSize().Height * 4 );

        // adjust start of buffer to simulate a boarder
        // avcodec thinks now, it handles with a smaller rect
        buffer += ( (targetBoarderX*targetSizeX/2) * 4 + (2 * targetBoarderY) );

        // assign buffer to image planes in avFrameRGB
        avpicture_fill( (AVPicture*) this->avFrameRGB, buffer, PIX_FMT_RGB32, targetSizeX, targetSizeY );
        
        this->texture->unlock();

        return ERR_OK;
}



ERR_TYPE VideoTexture::update( u32 timeMS )
{
        // this is a non sophisticated attempt to hit desired video FPS:

        // store start time of video
        if ( -1 == this->timeSinceLastUpdate )
        {
                this->timeSinceLastUpdate = timer->getRealTime();
        }

        // get time since last frame was updated
        u32 now = timer->getRealTime();
        u32 deltaTime = now - this->timeSinceLastUpdate;

        // check if enough time elapsed since last call
        if ( deltaTime < (1000.0f / this->videoStreamFPS) )
        {
                // no, wait to next update() call
                return ERR_VIDEOTEXTURE_WAIT_FOR_SYNC;
        }

        // yes, it's time to process next video frame
        this->timeSinceLastUpdate = now;

        s32 frameFinished = 0;  // if not 0 -> copy frame to irrlicht texture 
        AVPacket packet;                // chunk of data, loaded by libavcodec from file

        while ( 0 == frameFinished )    // read from file until one frame is completed
        {
                if ( av_read_frame( this->avFormatContext, &packet ) >= 0 )
                {
                        // Is this a packet from the video stream?
                        if ( packet.stream_index == this->videoStreamIndex )
                        {
                                // Decode video frame
                                avcodec_decode_video( this->avCodecContext, this->avFrameYUV, &frameFinished, packet.data, packet.size);

                                // Did we get a video frame?
                                if ( frameFinished )
                                {
                                        // Convert the image from its native YUV format to ARGB format
                                        // first, lock the irrlicht texture, we are writing into
                                        this->texture->lock();

                                        sws_scale(      this->swsContext,
                                                                this->avFrameYUV->data,
                                                                this->avFrameYUV->linesize,
                                                                0,
                                                                this->avCodecContext->height,
                                                                this->avFrameRGB->data,
                                                                this->avFrameRGB->linesize );

                                        // finished writing
                                        this->texture->unlock();
                                }
                        }
                }
                else
                {
                        // av_read_frame() indicated no more frames
                        if ( true == this->loopedPlay )
                        {
                                // rewind to frame# 0
                                av_seek_frame( this->avFormatContext, this->videoStreamIndex, 0, 0 );
                        }
                        
                        // Free the packet that was allocated by av_read_frame()
                        av_free_packet( &packet );

                        return ERR_VIDEOTEXTURE_VIDEO_FINISHED;
                }       
        }

        // Free the packet that was allocated by av_read_frame()
        av_free_packet( &packet );

        return ERR_OK;
}


ITexture* VideoTexture::getTexture()
{
        return this->texture;
}

---