89b3dc21a8ca33e2e03e0845cb70cb0075224c80
[occt.git] / src / Media / Media_FormatContext.cxx
1 // Created by: Kirill GAVRILOV
2 // Copyright (c) 2019 OPEN CASCADE SAS
3 //
4 // This file is part of Open CASCADE Technology software library.
5 //
6 // This library is free software; you can redistribute it and/or modify it under
7 // the terms of the GNU Lesser General Public License version 2.1 as published
8 // by the Free Software Foundation, with special exception defined in the file
9 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
10 // distribution for complete text of the license and disclaimer of any warranty.
11 //
12 // Alternatively, this file may be used under the terms of Open CASCADE
13 // commercial license or contractual agreement.
14
15 // activate some C99 macros like UINT64_C in "stdint.h" which used by FFmpeg
16 #ifndef __STDC_CONSTANT_MACROS
17   #define __STDC_CONSTANT_MACROS
18 #endif
19
20 #include <Media_FormatContext.hxx>
21
22 #include <Message.hxx>
23 #include <Message_Messenger.hxx>
24
25 #ifdef HAVE_FFMPEG
26 #include <Standard_WarningsDisable.hxx>
27 extern "C"
28 {
29   #include <libavformat/avformat.h>
30 };
31 #include <Standard_WarningsRestore.hxx>
32 #endif
33
34 IMPLEMENT_STANDARD_RTTIEXT(Media_FormatContext, Standard_Transient)
35
36 namespace
37 {
38   static const double THE_SECONDS_IN_HOUR = 3600.0;
39   static const double THE_SECONDS_IN_MINUTE = 60.0;
40   static const double THE_SECOND_IN_HOUR   = 1.0 / THE_SECONDS_IN_HOUR;
41   static const double THE_SECOND_IN_MINUTE = 1.0 / THE_SECONDS_IN_MINUTE;
42
43 #ifdef HAVE_FFMPEG
44   static const AVRational ST_AV_TIME_BASE_Q = {1, AV_TIME_BASE};
45   static const double     ST_AV_TIME_BASE_D = av_q2d (ST_AV_TIME_BASE_Q);
46
47   //! Format framerate value.
48   static TCollection_AsciiString formatFps (double theVal)
49   {
50     const uint64_t aVal = uint64_t(theVal * 100.0 + 0.5);
51     char aBuff[256];
52     if(aVal == 0)
53     {
54       Sprintf (aBuff, "%1.4f", theVal);
55     }
56     else if (aVal % 100)
57     {
58       Sprintf (aBuff, "%3.2f", theVal);
59     }
60     else if (aVal % (100 * 1000))
61     {
62       Sprintf (aBuff, "%1.0f", theVal);
63     }
64     else
65     {
66       Sprintf (aBuff, "%1.0fk", theVal / 1000);
67     }
68     return aBuff;
69   }
70 #endif
71 }
72
73 // =======================================================================
74 // function : FormatAVErrorDescription
75 // purpose  :
76 // =======================================================================
77 TCollection_AsciiString Media_FormatContext::FormatAVErrorDescription (int theErrCodeAV)
78 {
79 #ifdef HAVE_FFMPEG
80   char aBuff[4096];
81   memset (aBuff, 0, sizeof(aBuff));
82   if (av_strerror (theErrCodeAV, aBuff, 4096) != -1)
83   {
84     return TCollection_AsciiString (aBuff);
85   }
86
87 #ifdef _MSC_VER
88   wchar_t aBuffW[4096];
89   memset (aBuffW, 0, sizeof(aBuffW));
90   if (_wcserror_s (aBuffW, 4096, AVUNERROR(theErrCodeAV)) == 0)
91   {
92     return TCollection_AsciiString (aBuffW);
93   }
94 #elif defined(_WIN32)
95   // MinGW has only thread-unsafe variant
96   char* anErrDesc = strerror (AVUNERROR(theErrCodeAV));
97   if (anErrDesc != NULL)
98   {
99     return TCollection_AsciiString (anErrDesc);
100   }
101 #endif
102   return TCollection_AsciiString (aBuff);
103 #else
104   return TCollection_AsciiString ("AVError #") + theErrCodeAV;
105 #endif
106 }
107
108 // =======================================================================
109 // function : FormatUnitsToSeconds
110 // purpose  :
111 // =======================================================================
112 double Media_FormatContext::FormatUnitsToSeconds (int64_t theTimeUnits)
113 {
114 #ifdef HAVE_FFMPEG
115   return (theTimeUnits != AV_NOPTS_VALUE)
116         ? (ST_AV_TIME_BASE_D * theTimeUnits) : 0.0;
117 #else
118   (void )theTimeUnits;
119   return 0.0;
120 #endif
121 }
122
123 // =======================================================================
124 // function : UnitsToSeconds
125 // purpose  :
126 // =======================================================================
127 double Media_FormatContext::UnitsToSeconds (const AVRational& theTimeBase,
128                                             int64_t theTimeUnits)
129 {
130 #ifdef HAVE_FFMPEG
131   return (theTimeUnits != AV_NOPTS_VALUE)
132         ? (av_q2d (theTimeBase) * theTimeUnits) : 0.0;
133 #else
134   (void )&theTimeBase;
135   (void )theTimeUnits;
136   return 0.0;
137 #endif
138 }
139
140 // =======================================================================
141 // function : StreamUnitsToSeconds
142 // purpose  :
143 // =======================================================================
144 double Media_FormatContext::StreamUnitsToSeconds (const AVStream& theStream,
145                                                   int64_t theTimeUnits)
146 {
147 #ifdef HAVE_FFMPEG
148   return UnitsToSeconds (theStream.time_base, theTimeUnits);
149 #else
150   (void )&theStream;
151   (void )theTimeUnits;
152   return 0.0;
153 #endif
154 }
155
156 // =======================================================================
157 // function : SecondsToUnits
158 // purpose  :
159 // =======================================================================
160 int64_t Media_FormatContext::SecondsToUnits (double theTimeSeconds)
161 {
162 #ifdef HAVE_FFMPEG
163   return int64_t(theTimeSeconds / ST_AV_TIME_BASE_D);
164 #else
165   (void )theTimeSeconds;
166   return 0;
167 #endif
168 }
169
170 // =======================================================================
171 // function : SecondsToUnits
172 // purpose  :
173 // =======================================================================
174 int64_t Media_FormatContext::SecondsToUnits (const AVRational& theTimeBase,
175                                              double theTimeSeconds)
176 {
177 #ifdef HAVE_FFMPEG
178   return int64_t(theTimeSeconds / av_q2d (theTimeBase));
179 #else
180   (void )&theTimeBase;
181   (void )theTimeSeconds;
182   return 0;
183 #endif
184 }
185
186 // =======================================================================
187 // function : Media_FormatContext
188 // purpose  :
189 // =======================================================================
190 int64_t Media_FormatContext::StreamSecondsToUnits (const AVStream& theStream,
191                                                    double theTimeSeconds)
192 {
193 #ifdef HAVE_FFMPEG
194   return SecondsToUnits (theStream.time_base, theTimeSeconds);
195 #else
196   (void )&theStream;
197   (void )theTimeSeconds;
198   return 0;
199 #endif
200 }
201
202 // =======================================================================
203 // function : Media_FormatContext
204 // purpose  :
205 // =======================================================================
206 Media_FormatContext::Media_FormatContext()
207 : myFormatCtx   (NULL),
208   myPtsStartBase(0.0),
209   myDuration    (0.0)
210 {
211   //
212 }
213
214 // =======================================================================
215 // function : ~Media_FormatContext
216 // purpose  :
217 // =======================================================================
218 Media_FormatContext::~Media_FormatContext()
219 {
220   Close();
221 }
222
223 // =======================================================================
224 // function : NbSteams
225 // purpose  :
226 // =======================================================================
227 unsigned int Media_FormatContext::NbSteams() const
228 {
229 #ifdef HAVE_FFMPEG
230   return myFormatCtx->nb_streams;
231 #else
232   return 0;
233 #endif
234 }
235
236 // =======================================================================
237 // function : Stream
238 // purpose  :
239 // =======================================================================
240 const AVStream& Media_FormatContext::Stream (unsigned int theIndex) const
241 {
242 #ifdef HAVE_FFMPEG
243   return *myFormatCtx->streams[theIndex];
244 #else
245   (void )theIndex;
246   throw Standard_ProgramError("Media_FormatContext::Stream()");
247 #endif
248 }
249
250 // =======================================================================
251 // function : OpenInput
252 // purpose  :
253 // =======================================================================
254 bool Media_FormatContext::OpenInput (const TCollection_AsciiString& theInput)
255 {
256 #ifdef HAVE_FFMPEG
257   const int avErrCode = avformat_open_input (&myFormatCtx, theInput.ToCString(), NULL, NULL);
258   if (avErrCode != 0)
259   {
260     Message::DefaultMessenger()->Send (TCollection_AsciiString ("FFmpeg: Couldn't open video file '") + theInput
261                                     + "'\nError: " + FormatAVErrorDescription (avErrCode), Message_Fail);
262     Close();
263     return false;
264   }
265
266   // retrieve stream information
267   if (avformat_find_stream_info (myFormatCtx, NULL) < 0)
268   {
269     Message::DefaultMessenger()->Send (TCollection_AsciiString ("FFmpeg: Couldn't find stream information in '") + theInput + "'", Message_Fail);
270     Close();
271     return false;
272   }
273
274 #ifdef _DEBUG
275   av_dump_format (myFormatCtx, 0, theInput.ToCString(), false);
276 #endif
277
278   myDuration = 0.0;
279   myPtsStartBase = 0.0;
280
281   TCollection_AsciiString anExt = theInput;
282   anExt.LowerCase();
283   if (anExt.EndsWith (".png")
284    || anExt.EndsWith (".jpg")
285    || anExt.EndsWith (".jpeg")
286    || anExt.EndsWith (".mpo")
287    || anExt.EndsWith (".bmp")
288    || anExt.EndsWith (".tif")
289    || anExt.EndsWith (".tiff"))
290   {
291     // black-list images to workaround non-zero duration
292     return true;
293   }
294
295   myDuration = FormatUnitsToSeconds (myFormatCtx->duration);
296   if (myFormatCtx->nb_streams != 0)
297   {
298     myPtsStartBase = 2.e+100;
299     for (unsigned int aStreamId = 0; aStreamId < myFormatCtx->nb_streams; ++aStreamId)
300     {
301       const AVStream& aStream = *myFormatCtx->streams[aStreamId];
302       myPtsStartBase = Min (myPtsStartBase, StreamUnitsToSeconds (aStream, aStream.start_time));
303       myDuration     = Max (myDuration,     StreamUnitsToSeconds (aStream, aStream.duration));
304     }
305   }
306
307   return true;
308 #else
309   Message::DefaultMessenger()->Send ("Error: FFmpeg library is unavailable", Message_Fail);
310   (void )theInput;
311   return false;
312 #endif
313 }
314
315 // =======================================================================
316 // function : Close
317 // purpose  :
318 // =======================================================================
319 void Media_FormatContext::Close()
320 {
321   if (myFormatCtx != NULL)
322   {
323   #ifdef HAVE_FFMPEG
324     avformat_close_input (&myFormatCtx);
325     //avformat_free_context (myFormatCtx);
326   #endif
327   }
328 }
329
330 // =======================================================================
331 // function : FormatTime
332 // purpose  :
333 // =======================================================================
334 TCollection_AsciiString Media_FormatContext::FormatTime (double theSeconds)
335 {
336   double aSecIn = theSeconds;
337   unsigned int aHours   = (unsigned int )(aSecIn * THE_SECOND_IN_HOUR);
338   aSecIn -= double(aHours) * THE_SECONDS_IN_HOUR;
339   unsigned int aMinutes = (unsigned int )(aSecIn * THE_SECOND_IN_MINUTE);
340   aSecIn -= double(aMinutes) * THE_SECONDS_IN_MINUTE;
341   unsigned int aSeconds = (unsigned int )aSecIn;
342   aSecIn -= double(aSeconds);
343   double aMilliSeconds = 1000.0 * aSecIn;
344
345   char aBuffer[64];
346   if (aHours > 0)
347   {
348     Sprintf (aBuffer, "%02u:%02u:%02u", aHours, aMinutes, aSeconds);
349     return aBuffer;
350   }
351   else if (aMinutes > 0)
352   {
353     Sprintf (aBuffer, "%02u:%02u", aMinutes, aSeconds);
354     return aBuffer;
355   }
356   else if (aSeconds > 0)
357   {
358     Sprintf (aBuffer, "%2u s", aSeconds);
359     return aBuffer;
360   }
361
362   return TCollection_AsciiString (aMilliSeconds) + " ms";
363 }
364
365 // =======================================================================
366 // function : FormatTimeProgress
367 // purpose  :
368 // =======================================================================
369 TCollection_AsciiString Media_FormatContext::FormatTimeProgress (double theProgress,
370                                                                  double theDuration)
371 {
372   double aSecIn1 = theProgress;
373   unsigned int aHours1   = (unsigned int )(aSecIn1 * THE_SECOND_IN_HOUR);
374   aSecIn1 -= double(aHours1) * THE_SECONDS_IN_HOUR;
375   unsigned int aMinutes1 = (unsigned int )(aSecIn1 * THE_SECOND_IN_MINUTE);
376   aSecIn1 -= double(aMinutes1) * THE_SECONDS_IN_MINUTE;
377   unsigned int aSeconds1 = (unsigned int )aSecIn1;
378   aSecIn1 -= double(aSeconds1);
379
380   double aSecIn2 = theDuration;
381   unsigned int aHours2   = (unsigned int )(aSecIn2 * THE_SECOND_IN_HOUR);
382   aSecIn2 -= double(aHours2) * THE_SECONDS_IN_HOUR;
383   unsigned int aMinutes2 = (unsigned int )(aSecIn2 * THE_SECOND_IN_MINUTE);
384   aSecIn2 -= double(aMinutes2) * THE_SECONDS_IN_MINUTE;
385   unsigned int aSeconds2 = (unsigned int )aSecIn2;
386   aSecIn2 -= double(aSeconds2);
387
388   char aBuffer[256];
389   if (aHours1 > 0
390    || aHours2 > 0)
391   {
392     Sprintf (aBuffer, "%02u:%02u:%02u / %02u:%02u:%02u", aHours1, aMinutes1, aSeconds1, aHours2, aMinutes2, aSeconds2);
393     return aBuffer;
394   }
395   Sprintf (aBuffer, "%02u:%02u / %02u:%02u", aMinutes1, aSeconds1, aMinutes2, aSeconds2);
396   return aBuffer;
397 }
398
399 // =======================================================================
400 // function : StreamInfo
401 // purpose  :
402 // =======================================================================
403 TCollection_AsciiString Media_FormatContext::StreamInfo (unsigned int theIndex,
404                                                          AVCodecContext* theCodecCtx) const
405 {
406 #ifdef HAVE_FFMPEG
407   const AVStream& aStream = *myFormatCtx->streams[theIndex];
408
409   AVCodecContext* aCodecCtx = theCodecCtx;
410   if (aCodecCtx == NULL)
411   {
412   Standard_DISABLE_DEPRECATION_WARNINGS
413     aCodecCtx = aStream.codec;
414   Standard_ENABLE_DEPRECATION_WARNINGS
415   }
416
417   char aFrmtBuff[4096] = {};
418   avcodec_string (aFrmtBuff, sizeof(aFrmtBuff), aCodecCtx, 0);
419   TCollection_AsciiString aStreamInfo (aFrmtBuff);
420
421   if (aStream.sample_aspect_ratio.num && av_cmp_q(aStream.sample_aspect_ratio, aStream.codecpar->sample_aspect_ratio))
422   {
423     AVRational aDispAspectRatio;
424     av_reduce (&aDispAspectRatio.num, &aDispAspectRatio.den,
425                aStream.codecpar->width  * int64_t(aStream.sample_aspect_ratio.num),
426                aStream.codecpar->height * int64_t(aStream.sample_aspect_ratio.den),
427                1024 * 1024);
428     aStreamInfo = aStreamInfo + ", SAR " + aStream.sample_aspect_ratio.num + ":" + aStream.sample_aspect_ratio.den
429                 + " DAR " + aDispAspectRatio.num + ":" + aDispAspectRatio.den;
430   }
431
432   if (aStream.codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
433   {
434     if (aStream.avg_frame_rate.den != 0 && aStream.avg_frame_rate.num != 0)
435     {
436       aStreamInfo += TCollection_AsciiString(", ") + formatFps (av_q2d (aStream.avg_frame_rate)) + " fps";
437     }
438     if (aStream.r_frame_rate.den != 0 && aStream.r_frame_rate.num != 0)
439     {
440       aStreamInfo += TCollection_AsciiString(", ") + formatFps (av_q2d (aStream.r_frame_rate)) + " tbr";
441     }
442     if (aStream.time_base.den != 0 && aStream.time_base.num != 0)
443     {
444       aStreamInfo += TCollection_AsciiString(", ") + formatFps(1 / av_q2d (aStream.time_base)) + " tbn";
445     }
446     if (aCodecCtx->time_base.den != 0 && aCodecCtx->time_base.num != 0)
447     {
448       aStreamInfo += TCollection_AsciiString(", ") + formatFps(1 / av_q2d (aCodecCtx->time_base)) + " tbc";
449     }
450   }
451   if (myDuration > 0.0)
452   {
453     aStreamInfo += TCollection_AsciiString(", duration: ") + FormatTime (myDuration);
454   }
455   return aStreamInfo;
456 #else
457   (void )theIndex;
458   (void )theCodecCtx;
459   return TCollection_AsciiString();
460 #endif
461 }
462
463 // =======================================================================
464 // function : ReadPacket
465 // purpose  :
466 // =======================================================================
467 bool Media_FormatContext::ReadPacket (const Handle(Media_Packet)& thePacket)
468 {
469   if (thePacket.IsNull())
470   {
471     return false;
472   }
473
474 #ifdef HAVE_FFMPEG
475   return av_read_frame (myFormatCtx, thePacket->ChangePacket()) >= 0;
476 #else
477   return false;
478 #endif
479 }
480
481 // =======================================================================
482 // function : SeekStream
483 // purpose  :
484 // =======================================================================
485 bool Media_FormatContext::SeekStream (unsigned int theStreamId,
486                                       double theSeekPts,
487                                       bool theToSeekBack)
488 {
489 #ifdef HAVE_FFMPEG
490   const int aFlags = theToSeekBack ? AVSEEK_FLAG_BACKWARD : 0;
491   AVStream& aStream = *myFormatCtx->streams[theStreamId];
492   if ((aStream.disposition & AV_DISPOSITION_ATTACHED_PIC) != 0)
493   {
494     return false;
495   }
496
497   int64_t aSeekTarget = StreamSecondsToUnits (aStream, theSeekPts + StreamUnitsToSeconds (aStream, aStream.start_time));
498   bool isSeekDone = av_seek_frame (myFormatCtx, theStreamId, aSeekTarget, aFlags) >= 0;
499
500   // try 10 more times in backward direction to work-around huge duration between key frames
501   // will not work for some streams with undefined cur_dts (AV_NOPTS_VALUE)!!!
502   for (int aTries = 10; isSeekDone && theToSeekBack && aTries > 0 && (aStream.cur_dts > aSeekTarget); --aTries)
503   {
504     aSeekTarget -= StreamSecondsToUnits (aStream, 1.0);
505     isSeekDone = av_seek_frame (myFormatCtx, theStreamId, aSeekTarget, aFlags) >= 0;
506   }
507   if (isSeekDone)
508   {
509     return true;
510   }
511
512   TCollection_AsciiString aStreamType = aStream.codecpar->codec_type == AVMEDIA_TYPE_VIDEO
513                                       ? "Video"
514                                       : (aStream.codecpar->codec_type == AVMEDIA_TYPE_AUDIO
515                                        ? "Audio"
516                                        : "");
517   Message::DefaultMessenger()->Send (TCollection_AsciiString ("Error while seeking ") + aStreamType + " stream to "
518                                    + theSeekPts + " sec (" + (theSeekPts + StreamUnitsToSeconds (aStream, aStream.start_time)) + " sec)",
519                                      Message_Warning);
520   return false;
521 #else
522   (void )theStreamId;
523   (void )theSeekPts;
524   (void )theToSeekBack;
525   return false;
526 #endif
527 }
528
529 // =======================================================================
530 // function : Seek
531 // purpose  :
532 // =======================================================================
533 bool Media_FormatContext::Seek (double theSeekPts,
534                                 bool   theToSeekBack)
535 {
536 #ifdef HAVE_FFMPEG
537   const int aFlags      = theToSeekBack ? AVSEEK_FLAG_BACKWARD : 0;
538   int64_t   aSeekTarget = SecondsToUnits (theSeekPts);
539   if (av_seek_frame (myFormatCtx, -1, aSeekTarget, aFlags) >= 0)
540   {
541     return true;
542   }
543
544   const char* aFileName = 
545   #if(LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(58, 7, 100))
546     myFormatCtx->url;
547   #else
548     myFormatCtx->filename;
549   #endif
550
551   Message::DefaultMessenger()->Send (TCollection_AsciiString("Disaster! Seeking to ") + theSeekPts + " [" + aFileName + "] has failed.", Message_Warning);
552   return false;
553 #else
554   (void )theSeekPts;
555   (void )theToSeekBack;
556   return false;
557 #endif
558 }