VideoFFmpeg.h

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of VideoTexture library

Copyright (c) 2007 The Zdeno Ash Miklas

This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser 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, or go to
http://www.gnu.org/copyleft/lesser.txt.
-----------------------------------------------------------------------------
*/

#if !defined VIDEOFFMPEG_H
#define VIDEOFFMPEG_H

#ifdef WITH_FFMPEG
extern "C" {
#undef __cplusplus
#include <pthread.h>

#include "ffmpeg_compat.h"

#include "DNA_listBase.h"
#include "BLI_threads.h"
#include "BLI_blenlib.h"
#define __cplusplus
}

#if LIBAVFORMAT_VERSION_INT < (49 << 16)
#define FFMPEG_OLD_FRAME_RATE 1
#else
#define FFMPEG_CODEC_IS_POINTER 1
#endif

#if LIBAVFORMAT_VERSION_INT >= (52 << 16)
#define FFMPEG_PB_IS_POINTER 1
#endif

#ifdef FFMPEG_CODEC_IS_POINTER
static inline AVCodecContext* get_codec_from_stream(AVStream* stream)
{
    return stream->codec;
}
#else
static inline AVCodecContext* get_codec_from_stream(AVStream* stream)
{
    return &stream->codec;
}
#endif

#include "VideoBase.h"

#define CACHE_FRAME_SIZE    10
#define CACHE_PACKET_SIZE   30

// type VideoFFmpeg declaration
class VideoFFmpeg : public VideoBase
{
public:
    VideoFFmpeg (HRESULT * hRslt);
    virtual ~VideoFFmpeg ();

    void initParams (short width, short height, float rate, bool image=false);
    virtual void openFile (char * file);
    virtual void openCam (char * driver, short camIdx);

    virtual bool release (void);

    virtual bool play (void);
    virtual bool pause (void);
    virtual bool stop (void);
    virtual void setRange (double start, double stop);
    virtual void setFrameRate (float rate);
    // some specific getters and setters
    int getPreseek(void) { return m_preseek; }
    void setPreseek(int preseek) { if (preseek >= 0) m_preseek = preseek; }
    bool getDeinterlace(void) { return m_deinterlace; }
    void setDeinterlace(bool deinterlace) { m_deinterlace = deinterlace; }
    char *getImageName(void) { return (m_isImage) ? m_imageName.Ptr() : NULL; }

protected:
    // format and codec information
    AVCodec *m_codec;
    AVFormatContext *m_formatCtx;
    AVCodecContext *m_codecCtx;
    // raw frame extracted from video file
    AVFrame *m_frame;
    // deinterlaced frame if codec requires it
    AVFrame *m_frameDeinterlaced;
    // decoded RGB24 frame if codec requires it
    AVFrame *m_frameRGB;
    // conversion from raw to RGB is done with sws_scale
    struct SwsContext *m_imgConvertCtx;
    // should the codec be deinterlaced?
    bool m_deinterlace;
    // number of frame of preseek
    int m_preseek;
    // order number of stream holding the video in format context
    int m_videoStream;

    // the actual frame rate
    double m_baseFrameRate;

    long m_lastFrame;

    bool m_eof;

    bool m_externTime;

    long m_curPosition;

    double m_startTime;

    short m_captWidth;
    
    short m_captHeight;

    float m_captRate;

    bool m_isImage;

    bool m_isThreaded;

    bool m_isStreaming;

    STR_String m_imageName;

    virtual void calcImage (unsigned int texId, double ts);

    void setPositions (void);

    double actFrameRate (void) { return m_frameRate * m_baseFrameRate; }

    int openStream(const char *filename, AVInputFormat *inputFormat, AVFormatParameters *formatParams);

    AVFrame* grabFrame(long frame);

    void releaseFrame(AVFrame* frame);

    bool startCache();
    void stopCache();

private:
    typedef struct {
        Link link;
        long framePosition;
        AVFrame *frame;
    } CacheFrame;
    typedef struct {
        Link link;
        AVPacket packet;
    } CachePacket;

    bool m_stopThread;
    bool m_cacheStarted;
    ListBase m_thread;
    ListBase m_frameCacheBase;  // list of frames that are ready
    ListBase m_frameCacheFree;  // list of frames that are unused
    ListBase m_packetCacheBase; // list of packets that are ready for decoding
    ListBase m_packetCacheFree; // list of packets that are unused
    pthread_mutex_t m_cacheMutex;

    AVFrame *allocFrameRGB();
    static void *cacheThread(void *);
};

inline VideoFFmpeg * getFFmpeg (PyImage * self) 
{
    return static_cast<VideoFFmpeg*>(self->m_image); 
}

#endif  //WITH_FFMPEG

#endif