0031501: Foundation Classes, Message_Printer - remove theToPutEndl argument -- use...
[occt.git] / src / Image / Image_VideoRecorder.cxx
1 // Created on: 2016-04-01
2 // Created by: Anastasia BORISOVA
3 // Copyright (c) 2016 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 // activate some C99 macros like UINT64_C in "stdint.h" which used by FFmpeg
17 #ifndef __STDC_CONSTANT_MACROS
18   #define __STDC_CONSTANT_MACROS
19 #endif
20
21 #include <Image_VideoRecorder.hxx>
22
23 #include <Message.hxx>
24 #include <Message_Messenger.hxx>
25
26 #ifdef HAVE_FFMPEG
27
28 // Suppress deprecation warnings - it is difficult to provide compatibility with old and new API at once
29 // since new APIs are introduced too often.
30 // Should be disabled from time to time to clean up usage of old APIs.
31 #if (defined(__GNUC__) && (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
32   _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
33 #else
34   Standard_DISABLE_DEPRECATION_WARNINGS
35 #endif
36
37 extern "C"
38 {
39 #ifdef _MSC_VER
40   // suppress some common warnings in FFmpeg headers
41   #pragma warning(disable : 4244)
42 #endif
43
44   #include <libavcodec/avcodec.h>
45   #include <libavformat/avformat.h>
46   #include <libswscale/swscale.h>
47   #include <libavutil/imgutils.h>
48
49 #ifdef _MSC_VER
50   #pragma warning(default : 4244)
51 #endif
52 };
53
54 // Undefine macro that clashes with name used by field of Image_VideoParams;
55 // this macro is defined in headers of older versions of libavutil
56 // (see definition of macro FF_API_PIX_FMT in version.h)
57 #ifdef PixelFormat
58 #undef PixelFormat
59 #endif
60
61 #endif
62
63 IMPLEMENT_STANDARD_RTTIEXT(Image_VideoRecorder, Standard_Transient)
64
65 //=============================================================================
66 //function : Constructor
67 //purpose  :
68 //=============================================================================
69 Image_VideoRecorder::Image_VideoRecorder()
70 : myAVContext   (NULL),
71   myVideoStream (NULL),
72   myVideoCodec  (NULL),
73   myFrame       (NULL),
74   myScaleCtx    (NULL),
75   myFrameCount  (0)
76 {
77   myFrameRate.num = 1;
78   myFrameRate.den = 30;
79
80 #ifdef HAVE_FFMPEG
81   // initialize libavcodec, and register all codecs and formats, should be done once
82   av_register_all();
83 #endif
84 }
85
86 //=============================================================================
87 //function : ~Image_VideoRecorder
88 //purpose  :
89 //=============================================================================
90 Image_VideoRecorder::~Image_VideoRecorder()
91 {
92   Close();
93 }
94
95 //=============================================================================
96 //function : formatAvError
97 //purpose  :
98 //=============================================================================
99 TCollection_AsciiString Image_VideoRecorder::formatAvError (const int theError) const
100 {
101 #ifdef HAVE_FFMPEG
102   char anErrBuf[AV_ERROR_MAX_STRING_SIZE] = {};
103   av_strerror (theError, anErrBuf, AV_ERROR_MAX_STRING_SIZE);
104   return anErrBuf;
105 #else
106   return TCollection_AsciiString(theError);
107 #endif
108 }
109
110 //=============================================================================
111 //function : Close
112 //purpose  :
113 //=============================================================================
114 void Image_VideoRecorder::Close()
115 {
116 #ifdef HAVE_FFMPEG
117   if (myScaleCtx != NULL)
118   {
119     sws_freeContext (myScaleCtx);
120     myScaleCtx = NULL;
121   }
122
123   if (myAVContext == NULL)
124   {
125     myFrameCount = 0;
126     return;
127   }
128
129   // Write the trailer, if any. The trailer must be written before you close the CodecContexts open when you wrote the header;
130   // otherwise av_write_trailer() may try to use memory that was freed on av_codec_close().
131   if (myFrameCount != 0)
132   {
133     av_write_trailer (myAVContext);
134     myFrameCount = 0;
135   }
136
137   // close each codec
138   if (myVideoStream != NULL)
139   {
140     avcodec_close (myVideoStream->codec);
141     myVideoStream = NULL;
142   }
143   if (myFrame != NULL)
144   {
145     av_free (myFrame->data[0]);
146     av_frame_free (&myFrame);
147     myFrame = NULL;
148   }
149
150   if (!(myAVContext->oformat->flags & AVFMT_NOFILE))
151   {
152     // close the output file
153     avio_close (myAVContext->pb);
154   }
155
156   // free the stream
157   avformat_free_context (myAVContext);
158   myAVContext = NULL;
159 #endif
160 }
161
162 //=============================================================================
163 //function : Open
164 //purpose  :
165 //=============================================================================
166 Standard_Boolean Image_VideoRecorder::Open (const char* theFileName,
167                                             const Image_VideoParams& theParams)
168 {
169 #ifdef HAVE_FFMPEG
170   Close();
171   if (theParams.Width  <= 0
172    || theParams.Height <= 0)
173   {
174     return Standard_False;
175   }
176
177   // allocate the output media context
178   avformat_alloc_output_context2 (&myAVContext, NULL, theParams.Format.IsEmpty() ? NULL : theParams.Format.ToCString(), theFileName);
179   if (myAVContext == NULL)
180   {
181     ::Message::SendFail ("ViewerTest_VideoRecorder, could not deduce output format from file extension");
182     return Standard_False;
183   }
184
185   // add the audio stream using the default format codecs and initialize the codecs
186   if (!addVideoStream (theParams, myAVContext->oformat->video_codec))
187   {
188     Close();
189     return Standard_False;
190   }
191
192   // open video codec and allocate the necessary encode buffers
193   if (!openVideoCodec (theParams))
194   {
195     Close();
196     return Standard_False;
197   }
198
199 #ifdef OCCT_DEBUG
200   av_dump_format (myAVContext, 0, theFileName, 1);
201 #endif
202
203   // open the output file, if needed
204   if ((myAVContext->oformat->flags & AVFMT_NOFILE) == 0)
205   {
206     const int aResAv = avio_open (&myAVContext->pb, theFileName, AVIO_FLAG_WRITE);
207     if (aResAv < 0)
208     {
209       ::Message::SendFail (TCollection_AsciiString ("Error: could not open '") + theFileName + "', " + formatAvError (aResAv));
210       Close();
211       return Standard_False;
212     }
213   }
214
215   // write the stream header, if any
216   const int aResAv = avformat_write_header (myAVContext, NULL);
217   if (aResAv < 0)
218   {
219     ::Message::SendFail (TCollection_AsciiString ("Error: can not open output file '") + theFileName + "', " + formatAvError (aResAv));
220     Close();
221     return Standard_False;
222   }
223 #else
224   (void )theFileName;
225   (void )theParams;
226 #endif
227   return Standard_True;
228 }
229
230 //=============================================================================
231 //function : addVideoStream
232 //purpose  :
233 //=============================================================================
234 Standard_Boolean Image_VideoRecorder::addVideoStream (const Image_VideoParams& theParams,
235                                                       const Standard_Integer   theDefCodecId)
236 {
237   myFrameRate.num = theParams.FpsNum;
238   myFrameRate.den = theParams.FpsDen;
239
240 #ifdef HAVE_FFMPEG
241   // find the encoder
242   TCollection_AsciiString aCodecName;
243   if (!theParams.VideoCodec.IsEmpty())
244   {
245     myVideoCodec = avcodec_find_encoder_by_name (theParams.VideoCodec.ToCString());
246     aCodecName   = theParams.VideoCodec;
247   }
248   else
249   {
250     myVideoCodec = avcodec_find_encoder ((AVCodecID )theDefCodecId);
251     aCodecName   = avcodec_get_name     ((AVCodecID )theDefCodecId);
252   }
253   if (myVideoCodec == NULL)
254   {
255     ::Message::SendFail (TCollection_AsciiString ("Error: can not find encoder for ") + aCodecName);
256     return Standard_False;
257   }
258
259   const AVCodecID aCodecId = myVideoCodec->id;
260   myVideoStream = avformat_new_stream (myAVContext, myVideoCodec);
261   if (myVideoStream == NULL)
262   {
263     ::Message::SendFail ("Error: can not allocate stream");
264     return Standard_False;
265   }
266   myVideoStream->id = myAVContext->nb_streams - 1;
267
268   AVCodecContext* aCodecCtx = myVideoStream->codec;
269   aCodecCtx->codec_id = aCodecId;
270   // resolution must be a multiple of two
271   aCodecCtx->width    = theParams.Width;
272   aCodecCtx->height   = theParams.Height;
273   // Timebase is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
274   // For fixed-fps content, timebase should be 1/framerate and timestamp increments should be identical to 1.
275   aCodecCtx->time_base.den = myFrameRate.num;
276   aCodecCtx->time_base.num = myFrameRate.den;
277   aCodecCtx->gop_size      = 12; // emit one intra frame every twelve frames at most
278
279   // some formats want stream headers to be separate
280   if (myAVContext->oformat->flags & AVFMT_GLOBALHEADER)
281   {
282     aCodecCtx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
283   }
284   return Standard_True;
285 #else
286   (void )theParams;
287   (void )theDefCodecId;
288   return Standard_False;
289 #endif
290 }
291
292 //=============================================================================
293 //function : openVideoCodec
294 //purpose  :
295 //=============================================================================
296 Standard_Boolean Image_VideoRecorder::openVideoCodec (const Image_VideoParams& theParams)
297 {
298 #ifdef HAVE_FFMPEG
299   AVDictionary* anOptions = NULL;
300   AVCodecContext* aCodecCtx = myVideoStream->codec;
301
302   // setup default values
303   aCodecCtx->pix_fmt = AV_PIX_FMT_YUV420P;
304   //av_dict_set (&anOptions, "threads", "auto", 0);
305   if (aCodecCtx->codec == avcodec_find_encoder_by_name ("mpeg2video"))
306   {
307     // just for testing, we also add B frames
308     aCodecCtx->max_b_frames = 2;
309     aCodecCtx->bit_rate = 6000000;
310   }
311   else if (aCodecCtx->codec == avcodec_find_encoder_by_name ("mpeg4"))
312   {
313     //
314   }
315   else if (aCodecCtx->codec == avcodec_find_encoder_by_name ("mjpeg"))
316   {
317     aCodecCtx->pix_fmt = AV_PIX_FMT_YUVJ420P;
318     aCodecCtx->qmin = aCodecCtx->qmax = 5;
319   }
320   else if (aCodecCtx->codec == avcodec_find_encoder_by_name ("huffyuv"))
321   {
322     aCodecCtx->pix_fmt = AV_PIX_FMT_RGB24;
323   }
324   else if (aCodecCtx->codec == avcodec_find_encoder_by_name ("png"))
325   {
326     aCodecCtx->pix_fmt = AV_PIX_FMT_RGB24;
327     aCodecCtx->compression_level = 9; // 0..9
328   }
329   else if (aCodecCtx->codec == avcodec_find_encoder_by_name ("h264")
330         || aCodecCtx->codec == avcodec_find_encoder_by_name ("libx264"))
331   {
332     // use CRF (Constant Rate Factor) as best single-pass compressing method
333     av_dict_set (&anOptions, "crf",     "20",        0); // quality 18-28, 23 is default (normal), 18 is almost lossless
334     av_dict_set (&anOptions, "preset",  "slow",      0); // good compression (see also "veryslow", "ultrafast")
335
336     // live-capturing
337     //av_dict_set (&anOptions, "qp",     "0",         0); // instead of crf
338     //av_dict_set (&anOptions, "preset", "ultrafast", 0);
339
340     // compatibility with devices
341     //av_dict_set (&anOptions, "profile", "baseline",  0);
342     //av_dict_set (&anOptions, "level",   "3.0",       0);
343   }
344   else if (aCodecCtx->codec == avcodec_find_encoder_by_name ("vp8")
345         || aCodecCtx->codec == avcodec_find_encoder_by_name ("vp9"))
346   {
347     av_dict_set (&anOptions, "crf", "20", 0); // quality 4-63, 10 is normal
348   }
349
350   // override defaults with specified options
351   if (!theParams.PixelFormat.IsEmpty())
352   {
353     const AVPixelFormat aPixFormat = av_get_pix_fmt (theParams.PixelFormat.ToCString());
354     if (aPixFormat == AV_PIX_FMT_NONE)
355     {
356       ::Message::SendFail (TCollection_AsciiString ("Error: unknown pixel format has been specified '") + theParams.PixelFormat + "'");
357       return Standard_False;
358     }
359
360     aCodecCtx->pix_fmt = aPixFormat;
361     for (Resource_DataMapOfAsciiStringAsciiString::Iterator aParamIter (theParams.VideoCodecParams);
362          aParamIter.More(); aParamIter.Next())
363     {
364       av_dict_set (&anOptions, aParamIter.Key().ToCString(), aParamIter.Value().ToCString(), 0);
365     }
366   }
367
368   // open codec
369   int aResAv = avcodec_open2 (aCodecCtx, myVideoCodec, &anOptions);
370   if (anOptions != NULL)
371   {
372     av_dict_free (&anOptions);
373   }
374   if (aResAv < 0)
375   {
376     ::Message::SendFail (TCollection_AsciiString ("Error: can not open video codec, ") + formatAvError (aResAv));
377     return Standard_False;
378   }
379
380   // allocate and init a re-usable frame
381   myFrame = av_frame_alloc();
382   if (myFrame == NULL)
383   {
384     ::Message::SendFail ("Error: can not allocate video frame");
385     return Standard_False;
386   }
387
388   // allocate the encoded raw picture
389   aResAv = av_image_alloc (myFrame->data, myFrame->linesize,
390                            aCodecCtx->width, aCodecCtx->height, aCodecCtx->pix_fmt, 1);
391   if (aResAv < 0)
392   {
393     memset (myFrame->data,     0, sizeof(myFrame->data));
394     memset (myFrame->linesize, 0, sizeof(myFrame->linesize));
395     ::Message::SendFail (TCollection_AsciiString ("Error: can not allocate picture ")
396                        + aCodecCtx->width+ "x" + aCodecCtx->height + ", " + formatAvError (aResAv));
397     return Standard_False;
398   }
399   // copy data and linesize picture pointers to frame
400   myFrame->format = aCodecCtx->pix_fmt;
401   myFrame->width  = aCodecCtx->width;
402   myFrame->height = aCodecCtx->height;
403
404   const Standard_Size aStride = aCodecCtx->width + 16 - (aCodecCtx->width % 16);
405   if (!myImgSrcRgba.InitZero (Image_PixMap::ImgRGBA, aCodecCtx->width, aCodecCtx->height, aStride))
406   {
407     ::Message::SendFail (TCollection_AsciiString ("Error: can not allocate RGBA32 picture ")
408                        + aCodecCtx->width+ "x" + aCodecCtx->height);
409     return Standard_False;
410   }
411
412   myScaleCtx = sws_getContext (aCodecCtx->width, aCodecCtx->height, AV_PIX_FMT_RGBA,
413                                aCodecCtx->width, aCodecCtx->height, aCodecCtx->pix_fmt,
414                                SWS_BICUBIC, NULL, NULL, NULL);
415   if (myScaleCtx == NULL)
416   {
417     ::Message::SendFail ("Error: can not initialize the conversion context");
418     return Standard_False;
419   }
420   return Standard_True;
421 #else
422   (void )theParams;
423   return Standard_False;
424 #endif
425 }
426
427 //=============================================================================
428 //function : writeVideoFrame
429 //purpose  :
430 //=============================================================================
431 Standard_Boolean Image_VideoRecorder::writeVideoFrame (const Standard_Boolean theToFlush)
432 {
433 #ifdef HAVE_FFMPEG
434   int aResAv = 0;
435   AVCodecContext* aCodecCtx = myVideoStream->codec;
436   if (!theToFlush)
437   {
438     uint8_t* aSrcData[4]     = { (uint8_t*)myImgSrcRgba.ChangeData(),   NULL, NULL, NULL };
439     int      aSrcLinesize[4] = { (int     )myImgSrcRgba.SizeRowBytes(), 0,    0,    0    };
440     sws_scale (myScaleCtx,
441                aSrcData, aSrcLinesize,
442                0, aCodecCtx->height,
443                myFrame->data, myFrame->linesize);
444   }
445
446   AVPacket aPacket;
447   memset (&aPacket, 0, sizeof(aPacket));
448   av_init_packet (&aPacket);
449   {
450     // encode the image
451     myFrame->pts = myFrameCount;
452     int isGotPacket = 0;
453     aResAv = avcodec_encode_video2 (aCodecCtx, &aPacket, theToFlush ? NULL : myFrame, &isGotPacket);
454     if (aResAv < 0)
455     {
456       ::Message::SendFail (TCollection_AsciiString ("Error: can not encode video frame, ") + formatAvError (aResAv));
457       return Standard_False;
458     }
459
460     // if size is zero, it means the image was buffered
461     if (isGotPacket)
462     {
463       const AVRational& aTimeBase = aCodecCtx->time_base;
464
465       // rescale output packet timestamp values from codec to stream timebase
466       aPacket.pts          = av_rescale_q_rnd (aPacket.pts,      aTimeBase, myVideoStream->time_base, AVRounding(AV_ROUND_NEAR_INF | AV_ROUND_PASS_MINMAX));
467       aPacket.dts          = av_rescale_q_rnd (aPacket.dts,      aTimeBase, myVideoStream->time_base, AVRounding(AV_ROUND_NEAR_INF | AV_ROUND_PASS_MINMAX));
468       aPacket.duration     = av_rescale_q     (aPacket.duration, aTimeBase, myVideoStream->time_base);
469       aPacket.stream_index = myVideoStream->index;
470
471       // write the compressed frame to the media file
472       aResAv = av_interleaved_write_frame (myAVContext, &aPacket);
473     }
474     else
475     {
476       aResAv = 0;
477     }
478   }
479
480   if (aResAv < 0)
481   {
482     ::Message::SendFail (TCollection_AsciiString ("Error: can not write video frame, ") + formatAvError (aResAv));
483     return Standard_False;
484   }
485
486   ++myFrameCount;
487   return Standard_True;
488 #else
489   (void)theToFlush;
490   return Standard_False;
491 #endif
492 }