== FFMPEG ==
[blender-staging.git] / source / gameengine / VideoTexture / VideoFFmpeg.h
1 /* $Id$
2 -----------------------------------------------------------------------------
3 This source file is part of VideoTexture library
4
5 Copyright (c) 2007 The Zdeno Ash Miklas
6
7 This program is free software; you can redistribute it and/or modify it under
8 the terms of the GNU Lesser General Public License as published by the Free Software
9 Foundation; either version 2 of the License, or (at your option) any later
10 version.
11
12 This program is distributed in the hope that it will be useful, but WITHOUT
13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
14 FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
15
16 You should have received a copy of the GNU Lesser General Public License along with
17 this program; if not, write to the Free Software Foundation, Inc., 59 Temple
18 Place - Suite 330, Boston, MA 02111-1307, USA, or go to
19 http://www.gnu.org/copyleft/lesser.txt.
20 -----------------------------------------------------------------------------
21 */
22
23 /** \file VideoFFmpeg.h
24  *  \ingroup bgevideotex
25  */
26  
27 #if !defined VIDEOFFMPEG_H
28 #define VIDEOFFMPEG_H
29
30 #ifdef WITH_FFMPEG
31 extern "C" {
32 #undef __cplusplus
33 #include <pthread.h>
34 #include <libavformat/avformat.h>
35 #include <libavcodec/avcodec.h>
36 #include <libavutil/rational.h>
37 #include <libavutil/parseutils.h>
38 #include <libswscale/swscale.h>
39 #include "DNA_listBase.h"
40 #include "BLI_threads.h"
41 #include "BLI_blenlib.h"
42 #define __cplusplus
43 }
44
45
46 #if LIBAVFORMAT_VERSION_INT < (49 << 16)
47 #define FFMPEG_OLD_FRAME_RATE 1
48 #else
49 #define FFMPEG_CODEC_IS_POINTER 1
50 #endif
51
52 #if LIBAVFORMAT_VERSION_INT >= (52 << 16)
53 #define FFMPEG_PB_IS_POINTER 1
54 #endif
55
56 #ifdef FFMPEG_CODEC_IS_POINTER
57 static inline AVCodecContext* get_codec_from_stream(AVStream* stream)
58 {
59         return stream->codec;
60 }
61 #else
62 static inline AVCodecContext* get_codec_from_stream(AVStream* stream)
63 {
64         return &stream->codec;
65 }
66 #endif
67
68 #include "VideoBase.h"
69
70 #define CACHE_FRAME_SIZE        10
71 #define CACHE_PACKET_SIZE       30
72
73 // type VideoFFmpeg declaration
74 class VideoFFmpeg : public VideoBase
75 {
76 public:
77         /// constructor
78         VideoFFmpeg (HRESULT * hRslt);
79         /// destructor
80         virtual ~VideoFFmpeg ();
81
82         /// set initial parameters
83         void initParams (short width, short height, float rate, bool image=false);
84         /// open video/image file
85         virtual void openFile (char * file);
86         /// open video capture device
87         virtual void openCam (char * driver, short camIdx);
88
89         /// release video source
90         virtual bool release (void);
91
92         /// play video
93         virtual bool play (void);
94         /// pause video
95         virtual bool pause (void);
96         /// stop video
97         virtual bool stop (void);
98         /// set play range
99         virtual void setRange (double start, double stop);
100         /// set frame rate
101         virtual void setFrameRate (float rate);
102         // some specific getters and setters
103         int getPreseek(void) { return m_preseek; }
104         void setPreseek(int preseek) { if (preseek >= 0) m_preseek = preseek; }
105         bool getDeinterlace(void) { return m_deinterlace; }
106         void setDeinterlace(bool deinterlace) { m_deinterlace = deinterlace; }
107         char *getImageName(void) { return (m_isImage) ? m_imageName.Ptr() : NULL; }
108
109 protected:
110         // format and codec information
111         AVCodec *m_codec;
112         AVFormatContext *m_formatCtx;
113         AVCodecContext *m_codecCtx;
114         // raw frame extracted from video file
115         AVFrame *m_frame;
116         // deinterlaced frame if codec requires it
117         AVFrame *m_frameDeinterlaced;
118         // decoded RGB24 frame if codec requires it
119         AVFrame *m_frameRGB;
120         // conversion from raw to RGB is done with sws_scale
121         struct SwsContext *m_imgConvertCtx;
122         // should the codec be deinterlaced?
123         bool m_deinterlace;
124         // number of frame of preseek
125         int m_preseek;
126         // order number of stream holding the video in format context
127         int m_videoStream;
128
129         // the actual frame rate
130         double m_baseFrameRate;
131
132         /// last displayed frame
133         long m_lastFrame;
134
135         /// end of file reached
136         bool m_eof;
137
138         /// flag to indicate that time is coming from application
139         bool m_externTime;
140
141         /// current file pointer position in file expressed in frame number
142         long m_curPosition;
143
144         /// time of video play start
145         double m_startTime;
146
147         /// width of capture in pixel
148         short m_captWidth;
149         
150         /// height of capture in pixel
151         short m_captHeight;
152
153         /// frame rate of capture in frames per seconds
154         float m_captRate;
155
156         /// is file an image?
157         bool m_isImage;
158
159         /// is image loading done in a separate thread?
160         bool m_isThreaded;
161
162         /// is streaming or camera?
163         bool m_isStreaming;
164
165         /// keep last image name
166         STR_String m_imageName;
167
168         /// image calculation
169         virtual void calcImage (unsigned int texId, double ts);
170
171         /// set actual position
172         void setPositions (void);
173
174         /// get actual framerate
175         double actFrameRate (void) { return m_frameRate * m_baseFrameRate; }
176
177         /// common function to video file and capture
178         int openStream(const char *filename, AVInputFormat *inputFormat, AVFormatParameters *formatParams);
179
180         /// check if a frame is available and load it in pFrame, return true if a frame could be retrieved
181         AVFrame* grabFrame(long frame);
182
183         /// in case of caching, put the frame back in free queue
184         void releaseFrame(AVFrame* frame);
185
186         /// start thread to load the video file/capture/stream 
187         bool startCache();
188         void stopCache();
189
190 private:
191         typedef struct {
192                 Link link;
193                 long framePosition;
194                 AVFrame *frame;
195         } CacheFrame;
196         typedef struct {
197                 Link link;
198                 AVPacket packet;
199         } CachePacket;
200
201         bool m_stopThread;
202         bool m_cacheStarted;
203         ListBase m_thread;
204         ListBase m_frameCacheBase;      // list of frames that are ready
205         ListBase m_frameCacheFree;      // list of frames that are unused
206         ListBase m_packetCacheBase;     // list of packets that are ready for decoding
207         ListBase m_packetCacheFree;     // list of packets that are unused
208         pthread_mutex_t m_cacheMutex;
209
210         AVFrame *allocFrameRGB();
211         static void *cacheThread(void *);
212 };
213
214 inline VideoFFmpeg * getFFmpeg (PyImage * self) 
215 {
216         return static_cast<VideoFFmpeg*>(self->m_image); 
217 }
218
219 #endif  //WITH_FFMPEG
220
221 #endif