0027961: Visualization - remove unused and no more working OpenGl_AVIWriter
[occt.git] / src / OpenGl / OpenGl_AVIWriter.hxx
1 // Created on: 2007-04-15
2 // Created by: Alexey MORENOV & Alexander GRIGORIEV
3 // Copyright (c) 2007-2014 OPEN CASCADE SAS
4 //
5 // This file is part of Open CASCADE Technology software library.
6 //
7 // This library is free software; you can redistribute it and/or modify it under
8 // the terms of the GNU Lesser General Public License version 2.1 as published
9 // by the Free Software Foundation, with special exception defined in the file
10 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
11 // distribution for complete text of the license and disclaimer of any warranty.
12 //
13 // Alternatively, this file may be used under the terms of Open CASCADE
14 // commercial license or contractual agreement.
15
16 #ifndef __OPENGL_AVIWRITER_H
17 #define __OPENGL_AVIWRITER_H
18
19 #if defined(_WIN32)
20   #include <windows.h>
21 #endif
22
23 #include <Standard_Macro.hxx>
24
25 #if defined(_MSC_VER) && !defined(OCCT_UWP)
26
27 #include <stdlib.h>
28 #include <vfw.h>
29 #include <TCollection_AsciiString.hxx>
30
31 /**
32  * Class providing the API to record AVI files using a codec installed in the
33  * system -- Only on Windows NT/2k/XP/Vista platform under MS Visual Studio.
34  * The following tasks are supported:
35  * <ol>
36  *
37  * <li>Creation of AVI data stream: launched by the constructor.
38  * The constructor accepts the filename, FOURCC video code and the frame rate
39  * setting as parameters.
40  * The default codec name used here is MPG4. To use a different codec, pass
41  * its FOURCC value as the input parameter for dwCodec.
42  * For example,
43  * <ul>
44  * <li>pass mmioFOURCC('D','I','V','X') to use DIVX codec, or</li>
45  * <li>pass mmioFOURCC('I','V','5','0') to use IV50 codec etc...</li>
46  * </ul>
47  * Also, you can pass just 0 to avoid the codecs altogether. In that case,
48  * the frames would be saved as they are without any compression; However,
49  * the output movie file size would be very huge in that case.
50  *
51  * Finally, make sure you have the codec installed on the machine before
52  * passing its Fourcc here.
53  * </li>
54  * <li>
55  * Start the recording: call the method StartRecording(). This method should be
56  * called at least once; execution of the constructor does not begin the
57  * process.
58  * </li>
59  * <li>
60  * Stop the recording: call the method StopRecording(). Can be omitted if the
61  * next to execute would be the destructor.
62  * </li>
63  * <li>
64  * Close the AVI file and exit the process of recording. This is done
65  * automatically by the destructor.
66  * </li>
67  * </ol>
68  */
69 class OpenGl_AVIWriter
70 {
71 public:
72
73   /**
74    * Constructor. Initializes the internal data structures, prepares for the
75    * creation of an AVI stream when the first frame is ready to be captured.
76    * @param theFileName
77    *   Name of the output movie file to create.
78    * @param theCodec
79    *   FourCC of the Video Codec to be used for compression
80    * @param theFrameRate
81    *   The Frames Per Second (FPS) setting to be used for the movie
82    */
83   Standard_EXPORT OpenGl_AVIWriter(const char * theFileName, 
84                                    DWORD theCodec = mmioFOURCC('M','P','G','4'),
85                                    Standard_Integer theFrameRate = 25);
86
87   /**
88    * Destructor: closes the movie file and flushes all the frames
89    */
90   Standard_EXPORT ~OpenGl_AVIWriter     ();
91
92   /**
93    * Begin the recording.
94    */
95   Standard_EXPORT void    StartRecording(const HANDLE hWin = NULL);
96
97   /**
98    * Stop the recording (can be restarted using StartRecording()).
99    */
100   Standard_EXPORT void    StopRecording ();
101
102   /**
103    * Query the state of recording.
104    */
105   inline Standard_Boolean IsRecording   () const { return myIsAllowRecord; }
106
107   /**
108    * Returns the last error message, if any.
109    */
110   inline Standard_EXPORT const TCollection_AsciiString&
111                           GetLastErrorMessage() const
112   { return myErrMsg; }
113
114   /**
115    * Get the instance of AVI Writer class.
116    */ 
117   static Standard_EXPORT OpenGl_AVIWriter *
118                           GetInstance   ();
119
120   /**
121    * Get the Window handle that contains the actual OpenGl context.
122    */
123   inline HANDLE           HWindow () const
124   { return myhWindow; }
125
126   /// Inserts the given HBitmap into the movie as a new Frame at the end.
127   HRESULT         AppendNewFrame(HBITMAP hBitmap);
128
129   /// Inserts the given bitmap bits into the movie as a new Frame at the end.
130   /// The width, height and nBitsPerPixel are the width, height and bits per pixel
131   /// of the bitmap pointed to by the input pBits.
132   HRESULT         AppendNewFrame(int nWidth,
133                                  int nHeight,
134                                  LPVOID pBits,
135                                  int nBitsPerPixel);
136
137 private:
138
139   void call_avi();
140
141 private:
142   static OpenGl_AVIWriter       * MyAVIWriterInstance;
143   Standard_Boolean                myIsAllowRecord;
144
145   BYTE                          * mypBits;
146   UINT                            myWidth;
147   UINT                            myHeight;
148
149   HDC                   myhAviDC;
150   HANDLE                myhHeap;
151   HANDLE                myhWindow;   // window containing the OGL context 
152   LPVOID                mylpBits;    // Useful to hold the bitmap content if any
153   LONG                  mylSample;   // Keeps track of the current Frame Index
154   PAVIFILE              mypAviFile;
155   PAVISTREAM            mypAviStream;
156   PAVISTREAM            mypAviCompressedStream;
157   AVISTREAMINFO         myAviStreamInfo;
158   AVICOMPRESSOPTIONS    myAviCompressOptions;
159   char *                myFileName; // Holds the Output Movie File Name
160   TCollection_AsciiString myErrMsg; // Holds the Last Error Message, if any
161
162   int                   myAppendFuncSelector;  //0=Dummy 1=FirstTime 2=Usual
163
164   HRESULT               AppendFrameFirstTime(HBITMAP );
165   HRESULT               AppendFrameUsual(HBITMAP);
166   HRESULT               AppendDummy(HBITMAP);
167   HRESULT       (OpenGl_AVIWriter::*pAppendFrame[3])(HBITMAP hBitmap);
168
169   HRESULT               AppendFrameBitsFirstTime(int, int, LPVOID,int );
170   HRESULT               AppendFrameBitsUsual(int, int, LPVOID,int );
171   HRESULT               AppendDummyBits(int, int, LPVOID,int );
172   HRESULT       (OpenGl_AVIWriter::*pAppendFrameBits[3])(int, int, LPVOID, int);
173
174   /// Takes care of creating the memory, streams, compression options etc.
175   /// required for the movie
176   HRESULT InitMovieCreation(int nFrameWidth,int nFrameHeight,int nBitsPerPixel);
177
178   /// Takes care of releasing the memory and movie related handles
179   void ReleaseMemory();
180
181   /// Sets the Error Message
182   void SetErrorMessage(const char * theErrMsg);
183 };
184
185 Standard_EXPORT void OpenGl_AVIWriter_AVIWriter(void * pp,
186                                                 int  nWidth,
187                                                 int  nHeight,
188                                                 int  nBitsPerPixel);
189
190 Standard_EXPORT Standard_Boolean OpenGl_AVIWriter_AllowWriting(void * hWin);
191
192 #endif // _MSC_VER
193 #endif