MediaPlayer.h

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OpenSpace3D
For the latest info, see http://www.openspace3d.com
 
Copyright (c) 2016 I-maginer
 
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
 
-----------------------------------------------------------------------------
*/
 
#ifndef __BTK_MEDIAPLAYER_H__
#define __BTK_MEDIAPLAYER_H__
 
extern "C"
{
  #include <libavformat/avformat.h>
  #include <libswscale/swscale.h>
  #include <libswresample/swresample.h>
  #include <libavutil/opt.h>
}
 
#include <opencv2/opencv.hpp>
#include <boost/thread.hpp>
#include <boost/array.hpp>
#include <boost/circular_buffer.hpp>
#include <queue>
#include <list>
#include <memory>
 
#include "Prerequisites.h"
 
#define MAX_OUT_BUFFER 262144
 
class MediaPlayer
{
public:
  static const int VIDEO_SIZE_AUTO = 0;
  static const int STREAM_UNDEFINED = -1;
  static const int BUFFER_COUNT = 2;
  static const AVPixelFormat DEST_PIXEL_FORMAT = AV_PIX_FMT_BGR24;
 
  // Time base used internally to represent stream timestamps.
  static const AVRational TIME_BASE;
  // Redeclare AV_TIME_BASE_Q to work around VS2010's lack of C99 support
  static const AVRational FF_AV_TIME_BASE_Q;
 
  // Amount of time in TIME_BASE units beyond which we consider video/audio have desynced
  static const int AV_SYNC_THRESHOLD = 16;
 
  // Number of tolerated consecutive read errors before failing
  static const int MAX_READ_ERRORS = 30;
 
  enum AudioFormats
        {
          AUDIO_8BIT_MONO, 
          AUDIO_8BIT_STEREO,
          AUDIO_16BIT_MONO,
          AUDIO_16BIT_STEREO
        };
 
  enum State
  {
    STOPPED,
    PLAYING,
    PAUSED
  };
 
protected:
private:
 
  class PacketQueue
  {
  public:
    static uint8_t* FLUSH_DATA;
    static uint8_t* QUIT_DATA;
  protected:
  private:
    std::queue<AVPacket*> mQueue;
    boost::mutex mMutex;
    boost::condition_variable mCond;
    size_t mCapacity;
    // Total size of the packet's data (not the number of packets !)
    size_t mSize;
 
  public:
    PacketQueue(size_t capacity);
    virtual ~PacketQueue();
 
    AVPacket* Pop();
 
    AVPacket* TryPop();
 
    bool Push(AVPacket* packet);
 
    void Flush(AVPacket* packet);
 
    bool Empty();
 
    size_t Size();
 
    size_t MaxSize();
 
  protected:
  private:
    void Clear();
  };
 
  class Clock
  {
  public:
  protected:
  private:
    int64_t mInitialTime;
    int64_t mPauseTime;
    int64_t mSystemTime;
    bool mRunning;
 
    boost::mutex mMutex;
 
  public:
    Clock();
 
    int64_t Get();
 
    void Reset(int64_t initialTime);
 
    void Pause();
 
    void Resume();
 
    bool IsPaused();
 
    static int64_t GetSysTime();
  protected:
  private:
  };
 
  struct AudioFrame
  {
  public:
    std::unique_ptr<char> data;
    size_t size;
    int64_t pts;
 
    AudioFrame();
    AudioFrame(const AudioFrame&);
    AudioFrame(AudioFrame&&);
    AudioFrame& operator=(AudioFrame&&);
  };
 
 
  // List of every MediaPlayer instance, used for Android pause function
  static std::list<MediaPlayer*> players;
 
  // Used to pause/unpause all players at once
  static bool globallyPaused;
 
  std::string mFile;
  FILE* mFilePtr;
  AVIOContext* mIoContext;
  AVFormatContext* mContext;
 
  AVCodecContext* mVideoCtx;
  AVCodecContext* mAudioCtx;
  int mVideoStream;
  int mAudioStream;
 
  // Desired size of the final bitmap, set by the user
  int mUserW, mUserH;
  // Actual size of the bitmap, computed from the user's desired values
  int mFinalW, mFinalH;
  // Current size of the source video
  int mSourceW, mSourceH;
  // Set to true when the user has changed the requested size
  bool mSizeChanged;
  // Prevent user size changes while new size is being computed
  boost::mutex mSizeMutex;
  // Set by the user via Stop
  bool mStopped;
  // Toggled via Play / Pause
  bool mPaused;
  // If true, loop media playback.
  bool mLoop;
  // Whether there is a new frame available
  bool mUpdated;
  // Video clock in milliseconds, used for synchonization
  int64_t mVideoClock;
  // Presentation timestamp (PTS) of the current video frame, in the current video stream's time base.
  int64_t mVideoPts;
  // Requested timestamp to seek to, in the current video stream's time base.
  int64_t mSeekPts;
  // Set to true when the decoding thread needs to seek to mSeekPos
  bool mSeekRequested;
  // Guards to prevent audio/video from possibly messing up and waiting too long when seeking backwards
  bool mSeekInProgressAudio;
  bool mSeekInProgressVideo;
  bool mSeekCompletedAudio;
  bool mIsLocal;
  // System clock that both audio and video sync to
  Clock mSystemClock;
 
  cv::Mat mFrameBuffer;
  cv::Mat mFrameRetrieveBuffer;
  AVFrame* mFrame;
  SwsContext* mScalerCtx;
  AVFrame* mVideoBuffer;
 
  // LoadThread
  boost::thread mOpenThread;
 
  // Audio thread related
  boost::thread mAudioThread;
  boost::mutex mAudioMutex;
  PacketQueue mAudioPktQ;
  boost::circular_buffer<AudioFrame> mAudioFrameQ;
  Clock mAudioClock;
 
  SwrContext* mResampleCtx;
  uint64_t mOutChannelLayout;
  AVSampleFormat mOutSampleFormat;
  int mOutSampleRate;
  
  PacketQueue mVideoPktQ;
 
  boost::thread mDecodingThread;
  boost::condition_variable mPauseCond;
  
  // Video thread related
  boost::thread mVideoThread;
  boost::mutex mVideoMutex;
  
public:
  static void InitFFmpeg();
 
  static void DeInitFFmpeg();
 
  static void SetGlobalPause(bool pause);
 
  static bool IsValidPlayer(MediaPlayer* player);
  
  MediaPlayer();
  virtual ~MediaPlayer();
 
  void Open(std::string path);
 
  void OpenUrl(std::string url);
 
  void Close();
 
  bool IsReady();
 
  State GetState();
 
  bool HasAudio();
 
  bool HasVideo();
 
  long GetLength();
 
  bool IsSeekable();
 
  bool IsLiveStream();
 
  void GetSize(int& width, int& height);
 
  void GetSourceSize(int& width, int& height);
 
  void SetSize(int width, int height);
 
  void SetAudioFormat(AudioFormats format, int sampleRate);
 
  void Play(long startPosition = 0);
 
  void Pause();
 
  void Stop();
 
  void SetLoop(bool loop);
 
  void SetCurrentTime(long time);
 
  long GetCurrentTime();
 
  bool GetFrame(ObjBitmap* scolBitmap);
 
  bool GetFrame(cv::Mat &buffer);
 
  cv::Mat GetFrame();
 
  int GetAudioThreaded(char* destBuffer, size_t length);
 
  int SetVideoStream(int streamIndex = -1);
 
  int SetAudioStream(int streamIndex = -1);
 
  std::vector<std::string> ListStreams(AVMediaType type);
 
protected:
private:
  
  // Custom callbacks for FFmpeg file I/O
  static int FileRead(void* player, uint8_t* buf, int buf_size);
  static int FileWrite(void* player, uint8_t* buf, int buf_size);
  static int64_t FileSeek(void* player, int64_t offset, int whence);
 
  int SetStream(AVMediaType type, int index = -1);
 
  int GetActualStreamIndex(int streamIndex, AVMediaType streamType);
 
  long GetStreamDuration(int index);
 
  void Reset();
  
  void SendQuitPacket();
 
  void OpenFileThread(std::string path);
  void OpenUrlThread(std::string url, bool close);
 
  void DecodingThread();
  void VideoThread();
  void AudioThread();
 
  void ComputeSize(int sourceW, int sourceH);
 
  void SetAudioFormat(uint64_t channelLayout, AVSampleFormat format, int sampleRate);
  void AllocResampler(uint64_t outChannelLayout, AVSampleFormat outSampleFormat, int outSampleRate, AVCodecContext* context);
 
  int64_t SynchronizeVideo(AVFrame *srcFrame, int64_t pts);
  void SynchronizeAudio(int64_t pts);
};
 
 
#endif //__BTK_MEDIAPLAYER_H__