MediaPlayer.cpp

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
 
-----------------------------------------------------------------------------
*/
 
#include <scolPlugin.h>
 
#include <sstream>
#include <boost/lexical_cast.hpp>
 
#include "MediaPlayer.h"
#include "ScolConvert.h"
 
#define QUEUE_BUFFER_SIZE 100
#define QUEUE_BUFFERING_RATIO 10
 
/* The av_err2str from FFmpeg uses C99, so we need to define our own
 * because of VS2010.
 */
#if __STDC_VERSION__ < 199901L
#undef av_err2str
#define av_err2str(errnum) \
  av_make_error_string( \
    boost::array<char, AV_ERROR_MAX_STRING_SIZE>().c_array(), \
     AV_ERROR_MAX_STRING_SIZE, \
     errnum)
#endif
 
extern int MEDIAPLAYER_END_CB;
extern int MEDIAPLAYER_LOADED_CB;
 
const AVRational MediaPlayer::TIME_BASE = { 1, 1000 };
// Redeclare AV_TIME_BASE_Q to work around VS2010's lack of C99 support
const AVRational MediaPlayer::FF_AV_TIME_BASE_Q = { 1, AV_TIME_BASE };
 
std::list<MediaPlayer*> MediaPlayer::players;
 
bool MediaPlayer::globallyPaused = false;
 
/*
static int interrupt_cb(void *ctx)
{
  AVFormatContext* formatContext = reinterpret_cast<AVFormatContext*>(ctx);
  return 0;
}
 
static const AVIOInterruptCB int_cb = { interrupt_cb, NULL };
*/
 
void MediaPlayer::InitFFmpeg()
{
  av_register_all();
  avformat_network_init();
  MMechostr(MSKDEBUG, avformat_configuration());
}
 
void MediaPlayer::DeInitFFmpeg()
{
  avformat_network_deinit();
}
 
void MediaPlayer::SetGlobalPause(bool pause)
{
  if (pause && !globallyPaused)
  {
    for (auto it = players.begin(); it != players.end(); it++)
      (*it)->Pause();
 
    globallyPaused = true;
  }
  else if (!pause && globallyPaused)
  {
    for (auto it = players.begin(); it != players.end(); it++)
      (*it)->Play();
 
    globallyPaused = false;
  }
}
 
bool MediaPlayer::IsValidPlayer(MediaPlayer* player)
{
  for (auto it = players.begin(); it != players.end(); it++)
  {
    if (*it == player)
      return true;
  }
 
  return false;
}
 
MediaPlayer::MediaPlayer() :
  mFile(""),
  mFilePtr(NULL),
  mIoContext(NULL),
  mContext(NULL),
  mVideoCtx(NULL),
  mAudioCtx(NULL),
  mVideoStream(MediaPlayer::STREAM_UNDEFINED),
  mAudioStream(MediaPlayer::STREAM_UNDEFINED),
  mUserW(MediaPlayer::VIDEO_SIZE_AUTO),
  mUserH(MediaPlayer::VIDEO_SIZE_AUTO),
  mFinalW(0), mFinalH(0),
  mSourceW(0), mSourceH(0),
  mSizeChanged(false),
  mStopped(true),
  mPaused(false),
  mLoop(false),
  mUpdated(false),
  mVideoClock(0),
  mVideoPts(AV_NOPTS_VALUE),
  mSeekPts(AV_NOPTS_VALUE),
  mSeekRequested(false),
  mSeekInProgressAudio(false),
  mSeekInProgressVideo(false),
  mSeekCompletedAudio(true),
  mIsLocal(true),
  mSystemClock(),
  mFrame(NULL),
  mScalerCtx(NULL),
  mAudioPktQ(QUEUE_BUFFER_SIZE * 16 * 1024),
  mAudioFrameQ(10),
  mAudioClock(),
  mResampleCtx(0),
  mOutChannelLayout(0),
  mOutSampleFormat(AV_SAMPLE_FMT_NONE),
  mOutSampleRate(0),
  mVideoPktQ(QUEUE_BUFFER_SIZE * 256 * 1024)
{
  mFrame = av_frame_alloc();
 
  if (mFrame == NULL)
    throw std::runtime_error("Couldn't allocate frame");
 
    mVideoBuffer = av_frame_alloc();
    if (mVideoBuffer == NULL)
      throw std::runtime_error("Couldn't allocate frame");
 
 
  players.push_back(this);
}
 
MediaPlayer::~MediaPlayer()
{
  if (mOpenThread.joinable())
    mOpenThread.join();
 
  Close();
 
  av_frame_free(&mFrame);
 
  if ((mVideoBuffer != 0) && (mVideoBuffer->data != 0))
    avpicture_free((AVPicture*)mVideoBuffer);
 
  av_frame_free(&mVideoBuffer);
  mVideoBuffer = 0;
 
  mFrameBuffer.release();
  mFrameRetrieveBuffer.release();
 
  players.remove(this);
}
 
void MediaPlayer::OpenFileThread(const std::string path)
{
  try
  {
    Close();
 
    mFilePtr = fopen(path.c_str(), "rb");
    if (mFilePtr == NULL)
    {
      //throw std::runtime_error(std::string("Could not open file ") + path);
      MMechostr(MSKRUNTIME, "Could not open file %s", path.c_str());
 
      //event
      OBJpostEvent(MEDIAPLAYER_LOADED_CB, SCOL_PTR this, 0);
      return;
    }
 
    mFile = path;
 
    mIoContext = avio_alloc_context(NULL, 0, 0, this, FileRead, FileWrite, FileSeek);
    if (mIoContext == NULL)
    {
      //throw std::runtime_error(std::string("Could not allocate AVIOContext for ") + path);
      MMechostr(MSKRUNTIME, "Could not allocate AVIOContext for %s", path.c_str());
 
      //event
      OBJpostEvent(MEDIAPLAYER_LOADED_CB, SCOL_PTR this, 0);
      return;
    }
 
    mContext = avformat_alloc_context();
    if (mContext == NULL)
    {
      //throw std::runtime_error("Could not allocate AVFormatContext");
      MMechostr(MSKRUNTIME, "Could not allocate AVFormatContext for %s", path.c_str());
 
      //event
      OBJpostEvent(MEDIAPLAYER_LOADED_CB, SCOL_PTR this, 0);
      return;
    }
 
    //mContext->flags |= AVFMT_FLAG_NONBLOCK;
    //mContext->interrupt_callback = int_cb;
    //mContext->interrupt_callback.opaque = mContext;
    mContext->pb = mIoContext;
    OpenUrlThread(path, false);
  }
  catch (...)
  {
    Close();
 
    //event
    OBJpostEvent(MEDIAPLAYER_LOADED_CB, SCOL_PTR this, 0);
    return;
  }
}
 
void MediaPlayer::Open(std::string path)
{
  if (mOpenThread.joinable())
    mOpenThread.join();
 
  mOpenThread = boost::thread(&MediaPlayer::OpenFileThread, this, path);
}
 
void MediaPlayer::OpenUrlThread(std::string url, bool close)
{
  try
  {
    if (close)
      Close();
   
    AVDictionary *stream_opts = 0;
    av_dict_set(&stream_opts, "rw_timeout", "8000000", 0); // in micros    
 
    if ((url.compare(0, 2, "//") == 0) || (url.compare(0, 2, "\\") == 0) || (url.compare(0, 4, "rtp:") == 0) || (url.compare(0, 4, "udp:") == 0) || (url.compare(0, 4, "tcp:") == 0) || (url.compare(0, 5, "http:") == 0) || (url.compare(0, 6, "https:") == 0))
    {
      av_dict_set(&stream_opts, "timeout", "8000000", 0); // in micros
      mIsLocal = false;
    }
    else if (url.compare(0, 5, "rtsp:") == 0)
    {
      av_dict_set(&stream_opts, "stimeout", "8000000", 0); // in micros.
      mIsLocal = false;
    }
    else
      mIsLocal = true;
 
    int ret = avformat_open_input(&mContext, url.c_str(), NULL, &stream_opts);
    av_dict_free(&stream_opts);
 
    if (ret < 0)
    {
      //throw std::runtime_error(std::string("Open input error: ") + av_err2str(ret));
      MMechostr(MSKRUNTIME, "Open input error: %s", av_err2str(ret));
 
      //event
      OBJpostEvent(MEDIAPLAYER_LOADED_CB, SCOL_PTR this, 0);
      return;
    }
 
    if (avformat_find_stream_info(mContext, NULL) < 0)
    {
      //throw std::runtime_error(std::string("Could not find stream info for ") + url);
      MMechostr(MSKRUNTIME, "Could not find stream info for %s", av_err2str(ret));
 
      //event
      OBJpostEvent(MEDIAPLAYER_LOADED_CB, SCOL_PTR this, 0);
      return;
    }
 
    mFile = url;
    // Find out if the file has audio and/or video streams
    if (!ListStreams(AVMEDIA_TYPE_VIDEO).empty())
      SetVideoStream();
    else if (!ListStreams(AVMEDIA_TYPE_AUDIO).empty())
      SetAudioStream();
    else
    {
      //throw std::runtime_error(std::string("File ") + url + " contains neither video or audio.");
      MMechostr(MSKRUNTIME, "File %s contains neither video or audio.", url.c_str());
 
      //event
      OBJpostEvent(MEDIAPLAYER_LOADED_CB, SCOL_PTR this, 0);
      return;
    }
  }
  catch (...)
  {
    Close();
 
    //event
    OBJpostEvent(MEDIAPLAYER_LOADED_CB, SCOL_PTR this, 0);
    return;
  }
 
  OBJpostEvent(MEDIAPLAYER_LOADED_CB, SCOL_PTR this, 1);
}
 
void MediaPlayer::OpenUrl(std::string url)
{
  if (mOpenThread.joinable())
    mOpenThread.join();
 
  mOpenThread = boost::thread(&MediaPlayer::OpenUrlThread, this, url, true);
}
 
void MediaPlayer::Close()
{
  Reset();
 
  avformat_close_input(&mContext);
  av_free(mIoContext);
  mIoContext = NULL;
 
  if (mFilePtr != NULL)
  {
    fclose(mFilePtr);
    mFilePtr = NULL;
  }
  mFile = "";
}
 
bool MediaPlayer::IsReady()
{
  return (mContext != NULL) && (HasAudio() || HasVideo());
}
 
MediaPlayer::State MediaPlayer::GetState()
{
  if (mStopped)
    return STOPPED;
  if (mPaused)
    return PAUSED;
 
  return PLAYING;
}
 
bool MediaPlayer::HasAudio()
{
  return (mResampleCtx != NULL) && (mAudioStream != MediaPlayer::STREAM_UNDEFINED);
}
 
bool MediaPlayer::HasVideo()
{
  return mVideoStream != MediaPlayer::STREAM_UNDEFINED;
}
 
long MediaPlayer::GetLength()
{
  if (HasVideo())
    return GetStreamDuration(mVideoStream);
  else if (HasAudio())
    return GetStreamDuration(mAudioStream);
  else
    return -1;
}
 
bool MediaPlayer::IsSeekable()
{
  if (mContext == NULL)
    throw std::runtime_error("No open file or stream");
 
  // Try to get seekable info from AVIOContext
  if (mContext->pb != NULL)
    return mContext->pb->seekable != 0;
  else
    return GetLength() != -1;
}
 
bool MediaPlayer::IsLiveStream()
{
  // Guess : live streams have no duration.
  return GetLength() == -1;
}
 
void MediaPlayer::GetSize(int& width, int& height)
{
  if (IsReady())
  {
    width = mFinalW;
    height = mFinalH;
  }
  else
    throw std::runtime_error("No open video stream");
}
 
void MediaPlayer::GetSourceSize(int& width, int& height)
{
  if (HasVideo())
  {
    width = mSourceW;
    height = mSourceH;
  }
  else
    throw std::runtime_error("No open video stream");
}
 
void MediaPlayer::SetSize(int width, int height)
{
  if ((width == mUserW) && (height == mUserH))
    return;
 
  boost::mutex::scoped_lock l(mSizeMutex);
  mUserW = width;
  mUserH = height;
  // This triggers a size computation and buffer re-allocation in the decoding thread
  mSizeChanged = true;
}
 
void MediaPlayer::SetAudioFormat(AudioFormats format, int sampleRate)
{
  uint64_t channelLayout = 0;
  AVSampleFormat ffmpegFormat = AV_SAMPLE_FMT_NONE;
 
  switch (format)
  {
  case AUDIO_8BIT_MONO:
    channelLayout = AV_CH_LAYOUT_MONO;
    ffmpegFormat = AV_SAMPLE_FMT_U8;
    break;
  case AUDIO_8BIT_STEREO:
    channelLayout = AV_CH_LAYOUT_STEREO;
    ffmpegFormat = AV_SAMPLE_FMT_U8;
    break;
  case AUDIO_16BIT_MONO:
    channelLayout = AV_CH_LAYOUT_MONO;
    ffmpegFormat = AV_SAMPLE_FMT_S16;
    break;
  case AUDIO_16BIT_STEREO:
    channelLayout = AV_CH_LAYOUT_STEREO;
    ffmpegFormat = AV_SAMPLE_FMT_S16;
    break;
  default:
    throw std::runtime_error(std::string("Unsupported format: ") + boost::lexical_cast<std::string>(format));
  }
 
  SetAudioFormat(channelLayout, ffmpegFormat, sampleRate);
}
 
void MediaPlayer::SetAudioFormat(uint64_t channelLayout, AVSampleFormat format, int sampleRate)
{
  boost::mutex::scoped_lock l(mAudioMutex);
 
  if (av_sample_fmt_is_planar(format))
    throw std::logic_error("Planar formats are not supported");
 
  if ((mOutSampleFormat == format) && (mOutSampleRate == sampleRate) && (mOutChannelLayout == channelLayout))
    return;
 
  // If there is no audio stream, the resampler will be configured the next time an audio stream is open
  if (HasAudio())
  {
    AllocResampler(channelLayout, format, sampleRate, mAudioCtx);
 
    // Seek back to the current position in order to trigger a frame queue flush
    if (GetState() != STOPPED)
      SetCurrentTime(this->GetCurrentTime());
  }
 
  mOutSampleFormat = format;
  mOutSampleRate = sampleRate;
  mOutChannelLayout = channelLayout;
}
 
void MediaPlayer::Play(long startPosition)
{
  if (!IsReady())
    throw std::logic_error("No open video stream");
 
  if (mStopped)
  {
    // Make sure to join with the existing thread (in case Stop hasn't been called already)
    Stop();
 
    if (IsSeekable() && (startPosition >= 0))
      this->SetCurrentTime(startPosition);
 
    mStopped = false;
    mDecodingThread = boost::thread(&MediaPlayer::DecodingThread, this);
    mPauseCond.notify_all();
  }
  else if (mPaused)
  {
    if (IsLiveStream())
      av_read_play(mContext);
 
    mPaused = false;
    mPauseCond.notify_all();
  }
}
 
void MediaPlayer::Pause()
{
  if (!IsReady())
    throw std::logic_error("No open video stream");
 
  if (!mStopped)
  {
    boost::mutex::scoped_lock l(mVideoMutex);
 
    // If we're reading a livestream, it might have pause support. Fail if it doesn't.
    if (IsLiveStream() && (av_read_pause(mContext) < 0))
      throw std::runtime_error("Stream doesn't have pause support");
 
    mSystemClock.Pause();
    mAudioClock.Pause();
    mPaused = true;
  }
}
 
void MediaPlayer::Stop()
{
  mStopped = true;
 
  if (mPaused || mSystemClock.IsPaused())
  {
    mPaused = false;
    mPauseCond.notify_all();
  }
 
  if (mDecodingThread.joinable())
  {
    // I don't want Stop to throw anything
    try
    {
      mDecodingThread.join();
    }
    catch (...) {}
  }
 
  mUpdated = false;
}
 
void MediaPlayer::SetLoop(bool loop)
{
  mLoop = loop;
}
 
void MediaPlayer::SetCurrentTime(long time)
{
  if (!IsReady())
    throw std::logic_error("No open video stream");
 
  if (!IsSeekable())
    return;
 
  long streamDuration = GetLength();
 
  // Clamp the requested value to the current stream's bounds
  time = std::max(0L, time);
 
  if (streamDuration != -1)
    time = std::min(streamDuration, time);
 
  mSeekPts = time;
 
  if (HasVideo())
    mSeekInProgressVideo = true;
  if (HasAudio())
    mSeekInProgressAudio = true;
 
  mSeekRequested = true;
 
  // Restart the clock with the requested time
  mSystemClock.Reset(time);
}
 
long MediaPlayer::GetCurrentTime()
{
  return (long)mSystemClock.Get();
}
 
bool MediaPlayer::GetFrame(ObjBitmap* scolBitmap)
{
  if (!IsReady() || !mUpdated || mFrameBuffer.empty())
    return false;
 
  //needed when pixel format is not the same also
  cv::Mat imgdest = ConversionTools::ScolBitmapToMat(scolBitmap);
  if (imgdest.empty())
    return false;
 
  {
    boost::mutex::scoped_lock l(mVideoMutex);
    mFrameBuffer.copyTo(mFrameRetrieveBuffer);
  }
  
  try
  {
    cv::resize(mFrameRetrieveBuffer, imgdest, imgdest.size(), 0, 0, cv::INTER_LINEAR);
  }
  catch (cv::Exception& e)
  {
    MMechostr(MSKDEBUG, "MediaPlayer::GetFrame error %s\n", e.what());
    return false;
  }
 
  mUpdated = false;
  return true;
}
 
bool MediaPlayer::GetFrame(cv::Mat &imgdest)
{
  if (!IsReady() || !mUpdated || imgdest.empty())
    return false;
 
  {
    boost::mutex::scoped_lock l(mVideoMutex);
    mFrameBuffer.copyTo(mFrameRetrieveBuffer);
  }
 
  try
  {
    cv::resize(mFrameRetrieveBuffer, imgdest, imgdest.size(), 0, 0, cv::INTER_LINEAR);
  }
  catch (cv::Exception& e)
  {
    MMechostr(MSKDEBUG, "MediaPlayer::GetFrame error %s\n", e.what());
    return false;
  }
 
  mUpdated = false;
  return true;
}
 
cv::Mat MediaPlayer::GetFrame()
{
  if (!IsReady() || !mUpdated || mFrameBuffer.empty())
    return cv::Mat();
 
  {
    boost::mutex::scoped_lock l(mVideoMutex);
    mFrameBuffer.copyTo(mFrameRetrieveBuffer);
  }
 
  mUpdated = false;
  return mFrameRetrieveBuffer;
}
 
int MediaPlayer::SetVideoStream(int streamIndex)
{
  if (mContext == NULL)
    throw std::logic_error("No opened video file");
 
  streamIndex = GetActualStreamIndex(streamIndex, AVMEDIA_TYPE_VIDEO);
 
  int stream = SetStream(AVMEDIA_TYPE_VIDEO, streamIndex);
 
  State prevState = GetState();
  Reset();
  mVideoStream = stream;
  mVideoCtx = mContext->streams[stream]->codec;
 
  try
  {
    ComputeSize(mVideoCtx->width, mVideoCtx->height);
  }
  catch (std::exception&)
  {
    // Don't bother keeping anything open if allocations fail
    Close();
    throw;
  }
 
  // Select the best audio stream for the new video stream
  try
  {
    SetAudioStream();
  }
  catch (std::exception& e)
  {
    MMechostr(MSKRUNTIME, "No audio : %s\n", e.what());
  }
 
  if (prevState == PLAYING)
    Play();
 
  return stream;
}
 
int MediaPlayer::SetAudioStream(int streamIndex)
{
  if (mContext == NULL)
    throw std::logic_error("No opened video file");
 
  streamIndex = GetActualStreamIndex(streamIndex, AVMEDIA_TYPE_AUDIO);
 
  int stream = SetStream(AVMEDIA_TYPE_AUDIO, streamIndex);
  AVCodecContext* decContext = mContext->streams[stream]->codec;
 
  if (!decContext->channel_layout)
    decContext->channel_layout = av_get_default_channel_layout(decContext->channels);
 
  // If output format is unspecified, set it to the stream's format
  if ((mOutChannelLayout == 0) || (mOutSampleFormat == AV_SAMPLE_FMT_NONE) || (mOutSampleRate == 0))
  {
    mOutChannelLayout = decContext->channel_layout;
    mOutSampleFormat = decContext->sample_fmt;
    mOutSampleRate = decContext->sample_rate;
  }
 
  long now = this->GetCurrentTime();
  State prevState = GetState();
 
  // Stop and restart the video once the stream has been switched
  Stop();
 
  try
  {
    AllocResampler(mOutChannelLayout, mOutSampleFormat, mOutSampleRate, decContext);
  }
  catch (...)
  {
    avcodec_close(decContext);
    throw;
  }
 
  // No errors ? Apply changes.
  avcodec_close(mAudioCtx);
 
  mAudioStream = stream;
  mAudioCtx = decContext;
 
  if (prevState != STOPPED)
  {
    Play(now);
 
    if (prevState == PAUSED)
      Pause();
  }
 
  return stream;
}
 
int MediaPlayer::SetStream(AVMediaType type, int index)
{
  AVCodec* decoder = NULL;
  AVCodecContext* decContext = NULL;
 
  // Try to find audio and subtitles related to the current video
  int relatedStream = -1;
  if ((type == AVMEDIA_TYPE_AUDIO) || (type == AVMEDIA_TYPE_SUBTITLE))
    relatedStream = mVideoStream;
 
  int stream = av_find_best_stream(mContext, type, index, relatedStream, NULL, 0);
  if (stream < 0)
    throw std::runtime_error("No stream of type " + std::string(av_get_media_type_string(type)));
 
  // Stop here if we end up selecting an already selected stream.
  if (stream == mAudioStream || stream == mVideoStream)
    throw std::runtime_error("Stream already selected");
 
  decContext = mContext->streams[stream]->codec;
 
  decoder = avcodec_find_decoder(decContext->codec_id);
  if (decoder == NULL)
    throw std::runtime_error("Codec not found : " + std::string(mContext->streams[stream]->codec->codec->name));
 
  int ret = avcodec_open2(decContext, decoder, NULL);
  if (ret < 0)
    throw std::runtime_error("FFmpeg couldn't open context for codec " + std::string(decoder->name));
 
  return stream;
}
 
std::vector<std::string> MediaPlayer::ListStreams(AVMediaType type)
{
  std::vector<std::string> streamList;
  int nbStreams = 0;
 
  if (mContext == NULL)
    return streamList;
 
  for (unsigned int i = 0; i < mContext->nb_streams; i++)
  {
    AVStream* stream = mContext->streams[i];
    if (stream->codec->codec_type != type)
      continue;
 
    std::string description("");
 
    // Try to get stream name
    AVDictionaryEntry* title = av_dict_get(stream->metadata, "title", NULL, 0);
    if (title != NULL)
      description += std::string(title->value) + " ";
 
    // Try to get language info
    if (type == AVMEDIA_TYPE_AUDIO)
    {
      AVDictionaryEntry* lang = av_dict_get(stream->metadata, "language", NULL, 0);
      if (lang != NULL)
        description += std::string("Language: ") + lang->value;
    }
 
    if (description.empty())
      description = "(no info)";
 
    std::stringstream desc;
    desc << nbStreams << ". " << description;
    streamList.push_back(desc.str());
    nbStreams++;
  }
 
  return streamList;
}
 
int MediaPlayer::GetActualStreamIndex(int streamIndex, AVMediaType streamType)
{
  if (mContext == NULL)
    throw std::logic_error("No open video file");
 
  if (streamIndex < -1)
    throw std::logic_error("Wrong stream index");
 
  if (streamIndex == STREAM_UNDEFINED)
    return STREAM_UNDEFINED;
 
  for (unsigned int i = 0; i < mContext->nb_streams; i++)
  {
    if (mContext->streams[i]->codec->codec_type == streamType)
    {
      streamIndex--;
      if (streamIndex < 0)
        return i;
    }
  }
 
  throw std::logic_error("Stream not found");
}
 
long MediaPlayer::GetStreamDuration(int index)
{
  if (!IsReady())
    return 0;
 
  if (mContext->streams[index]->duration != AV_NOPTS_VALUE)
    return (long)av_rescale_q(mContext->streams[index]->duration, mContext->streams[index]->time_base, MediaPlayer::TIME_BASE);
  else if (mContext->duration != AV_NOPTS_VALUE)
    return (long)av_rescale_q(mContext->duration, FF_AV_TIME_BASE_Q, MediaPlayer::TIME_BASE);
 
  return -1;
}
 
void MediaPlayer::DecodingThread()
{
  if (HasVideo())
    mVideoThread = boost::thread(&MediaPlayer::VideoThread, this);
  if (HasAudio())
    mAudioThread = boost::thread(&MediaPlayer::AudioThread, this);
 
  bool eofReached = false;
  bool keepGoing = true;
  int readTries = MAX_READ_ERRORS;
  bool waitBuffer = !mIsLocal;
 
  try
  {
    while (!mStopped && keepGoing)
    {
      // Keep the thread going to respond to seeking and hold the media end event until playback is actually over
      long length = GetLength();
      if (length != -1 && !mLoop && !waitBuffer)
        keepGoing = (this->GetCurrentTime() < length) || !eofReached;
      else
        keepGoing = true;
 
      if (waitBuffer || mSystemClock.IsPaused())
      {
        if ((mSystemClock.IsPaused() && !mPaused && (!waitBuffer || eofReached))
           || (waitBuffer && (((HasVideo() && HasAudio()) && (mVideoPktQ.Size() >= (mVideoPktQ.MaxSize() / 100 * QUEUE_BUFFERING_RATIO)) && (mAudioPktQ.Size() >= (mAudioPktQ.MaxSize() / 100 * QUEUE_BUFFERING_RATIO)))
           || (HasVideo() && (mVideoPktQ.Size() >= (mVideoPktQ.MaxSize() / 100 * QUEUE_BUFFERING_RATIO)))
           || (HasAudio() && (mAudioPktQ.Size() >= (mAudioPktQ.MaxSize() / 100 * QUEUE_BUFFERING_RATIO))))))
        {
          mSystemClock.Resume();
          mAudioClock.Resume();
          waitBuffer = false;
          mPauseCond.notify_all();
        }
      }
 
      if (mSeekRequested)
      {
        // Using anything else than backward could put us after the requested PTS, which we don't want.
        int seekFlag = AVSEEK_FLAG_BACKWARD;
 
        // Seek to a position in the video stream if available, otherwise in the audio stream.
        int stream = HasVideo() ? mVideoStream : mAudioStream;
 
        int64_t seekPts = av_rescale_q(mSeekPts, MediaPlayer::TIME_BASE, mContext->streams[stream]->time_base);
        // This will seek only to a keyframe, we need to do additional decoding afterwards to get to the exact position
        int ret = av_seek_frame(mContext, stream, seekPts, seekFlag);
        if (ret < 0)
        {
          MMechostr(MSKRUNTIME, ">> MediaPlayer: Seek error: %s\n", av_err2str(ret));
          mSeekRequested = false;
          mSeekInProgressAudio = mSeekInProgressVideo = false;
          mSeekCompletedAudio = true;
          mSeekPts = AV_NOPTS_VALUE;
 
          continue;
        }
 
        mSeekRequested = false;
        eofReached = false;
 
        // Tell the audio and video threads to flush their packet queues
        if (HasVideo())
        {
          AVPacket* flushVideo = new AVPacket;
          flushVideo->data = PacketQueue::FLUSH_DATA;
          flushVideo->pts = mSeekPts;
          flushVideo->size = 0;
          mVideoPktQ.Flush(flushVideo);
        }
        if (HasAudio())
        {
          AVPacket* flushAudio = new AVPacket;
          flushAudio->data = PacketQueue::FLUSH_DATA;
          flushAudio->pts = mSeekPts;
          flushAudio->size = 0;
          mAudioPktQ.Flush(flushAudio);
        }
        // Momentarily unpause the video/audio threads so that they can display the frame we want to seek to
        if (mPaused || mSystemClock.IsPaused())
          mPauseCond.notify_all();
      }
 
      if (eofReached || (mAudioPktQ.Size() >= mAudioPktQ.MaxSize()) || (mVideoPktQ.Size() >= mVideoPktQ.MaxSize()))
      {
        boost::this_thread::sleep_for(boost::chrono::milliseconds(1));
        continue;
      }
 
      AVPacket* packet = new AVPacket;
      //av_init_packet(packet);
 
      int ret = av_read_frame(mContext, packet);
      if (ret < 0)
      {
        SAFE_DELETE(packet);
        if (ret == AVERROR_EOF && mLoop && IsSeekable())
        {
          // Wait for the video to be actually over before seeking to the beginning
          if (this->GetCurrentTime() >= GetLength())
            SetCurrentTime(0);
          else
            boost::this_thread::sleep_for(boost::chrono::microseconds(1));
 
          continue;
        }
 
        // Quit now on error, continue until playback is done on EOF (so that the user can still seek)
        if (ret != AVERROR_EOF)
        {
          readTries--;
          MMechostr(MSKRUNTIME, ">> MediaPlayer: Read error: %s, %d tries left\n", av_err2str(ret), readTries);
 
          if (readTries > 0)
            continue;
          else
            break;
        }
 
        eofReached = true;
        continue;
      }
      else if (!mIsLocal && keepGoing && !eofReached && !waitBuffer && ((HasVideo() && (mVideoPktQ.Size() == 0))
        || (!HasVideo() && HasAudio() && (mAudioPktQ.Size() == 0))))
      {
        waitBuffer = true; // buffering
        mSystemClock.Pause();
        mAudioClock.Pause();
      }
 
      // Re-init try count on successful read
      readTries = MAX_READ_ERRORS;
 
      if (packet->stream_index == mAudioStream)
        mAudioPktQ.Push(packet);
      else if (packet->stream_index == mVideoStream)
        mVideoPktQ.Push(packet);
      else
      {
        av_packet_unref(packet);
        SAFE_DELETE(packet);
        continue;
      }
 
      //prevent CPU burn
      boost::this_thread::sleep_for(boost::chrono::microseconds(1));
    }
  }
  catch (std::exception& e)
  {
    MMechostr(MSKRUNTIME, ">> MediaPlayer : exception : %s\n", e.what());
  }
 
  // trigger end event, if the video wasn't stopped prematurely
  if (eofReached && !mStopped)
    OBJpostEvent(MEDIAPLAYER_END_CB, SCOL_PTR this, 0);
 
  // We need to set this here if the video was ended by EOF or error.
  mStopped = true;
 
  // Terminate audio and video threads
  SendQuitPacket();
 
  try
  {
    if (HasVideo() && mVideoThread.joinable())
      mVideoThread.join();
 
    if (HasAudio() && mAudioThread.joinable())
      mAudioThread.join();
  }
  catch (...) {}
 
  // mSystemClock.Reset(0);
 
  MMechostr(MSKRUNTIME, ">> MediaPlayer : video ended\n");
}
 
int64_t MediaPlayer::SynchronizeVideo(AVFrame *srcFrame, int64_t pts)
{
 
  // If we have pts, set video clock to it
  if (pts != AV_NOPTS_VALUE)
    mVideoClock = pts;
  else
    pts = mVideoClock;
 
  if (srcFrame->repeat_pict != 0)
  {
    AVRational fps = av_guess_frame_rate(mContext, mContext->streams[mVideoStream], srcFrame);
    // If we are repeating a frame, adjust clock accordingly
    // Note : I changed the original math (dranger) to the one from FFmpeg doc (they should be equivalent?).
    double frame_delay = srcFrame->repeat_pict / (2 * av_q2d(fps));
    // Convert to milliseconds
    mVideoClock += (int64_t)std::floor(frame_delay * MediaPlayer::TIME_BASE.den);
  }
 
  return pts;
}
 
void MediaPlayer::SendQuitPacket()
{
  // Tell the audio thread to stop
  if (HasAudio())
  {
    AVPacket* quitPacketAudio = new AVPacket;
    quitPacketAudio->data = PacketQueue::QUIT_DATA;
    quitPacketAudio->size = 0;
    mAudioPktQ.Flush(quitPacketAudio);
  }
 
  // Tell the video thread to stop
  if (HasVideo())
  {
    AVPacket* quitPacketVideo = new AVPacket;
    quitPacketVideo->data = PacketQueue::QUIT_DATA;
    quitPacketVideo->size = 0;
    mVideoPktQ.Flush(quitPacketVideo);
  }
}
 
void MediaPlayer::ComputeSize(int sourceW, int sourceH)
{
  boost::mutex::scoped_lock lsize(mSizeMutex);
  boost::mutex::scoped_lock l(mVideoMutex);
 
  float ratio = (float)sourceW / (float)sourceH;
  // First, compute the final size
  if (mUserH == MediaPlayer::VIDEO_SIZE_AUTO && mUserW == MediaPlayer::VIDEO_SIZE_AUTO)
  {
    mFinalH = sourceH;
    mFinalW = sourceW;
  }
  else if (mUserH == MediaPlayer::VIDEO_SIZE_AUTO)
  {
    mFinalH = (int)((float)mUserW / ratio);
    mFinalW = mUserW;
  }
  else if (mUserW == MediaPlayer::VIDEO_SIZE_AUTO)
  {
    mFinalW = (int)((float)mUserH * ratio);
    mFinalH = mUserH;
  }
  else
  {
    mFinalW = mUserW;
    mFinalH = mUserH;
  }
 
  avpicture_free((AVPicture*)mVideoBuffer);
  int ret = avpicture_alloc((AVPicture*)mVideoBuffer, MediaPlayer::DEST_PIXEL_FORMAT, mFinalW, mFinalH);
  mVideoBuffer->width = mFinalW;
  mVideoBuffer->height = mFinalH;
  mVideoBuffer->format = MediaPlayer::DEST_PIXEL_FORMAT;
  if (ret < 0)
    throw std::runtime_error("Couldn't allocate RGB frame");
 
  sws_freeContext(mScalerCtx);
  mScalerCtx = sws_getContext(sourceW, sourceH, mVideoCtx->pix_fmt, mFinalW, mFinalH, MediaPlayer::DEST_PIXEL_FORMAT, SWS_FAST_BILINEAR, NULL, NULL, NULL);
 
  mFrameBuffer = cv::Mat(mFinalH, mFinalW, CV_8UC3);
  mFrameRetrieveBuffer = cv::Mat(mFinalH, mFinalW, CV_8UC3);
  mUpdated = false;
 
  if (mScalerCtx == NULL)
    throw std::runtime_error("Couldn't create swscale context");
 
  mSourceW = sourceW;
  mSourceH = sourceH;
}
 
void MediaPlayer::AllocResampler(uint64_t outChannelLayout, AVSampleFormat outSampleFormat, int outSampleRate, AVCodecContext* context)
{
  swr_free(&mResampleCtx);
 
  if (av_sample_fmt_is_planar(outSampleFormat))
    throw std::runtime_error("Planar formats are not supported");
 
  mResampleCtx = swr_alloc_set_opts(NULL, outChannelLayout, outSampleFormat, outSampleRate, context->channel_layout, context->sample_fmt, context->sample_rate, 0, NULL);
  if (mResampleCtx == NULL)
    throw std::runtime_error("Couldn't allocate resampler context");
 
  int ret = swr_init(mResampleCtx);
  if (ret < 0)
    throw std::runtime_error(std::string("Couldn't initialize resampler context: ") + av_err2str(ret));
}
 
void MediaPlayer::Reset()
{
  Stop();
 
  // Video cleanup
  avcodec_close(mVideoCtx);
  mVideoCtx = NULL;
  sws_freeContext(mScalerCtx);
  mScalerCtx = NULL;
  mFrameBuffer.release();
  mVideoStream = MediaPlayer::STREAM_UNDEFINED;
 
  // Audio cleanup
  avcodec_close(mAudioCtx);
  mAudioCtx = NULL;
 
  swr_free(&mResampleCtx);
 
  mAudioStream = MediaPlayer::STREAM_UNDEFINED;
}
 
void MediaPlayer::VideoThread()
{
  int64_t seekPts = AV_NOPTS_VALUE;
  // Timestamp (in ms) at which the last video frame was presented
  int64_t presentationTime = 0;
  bool skipNext = false;
  while (true)
  {
    AVPacket* packet = mVideoPktQ.Pop();
    if (packet->data == PacketQueue::FLUSH_DATA)
    {
      avcodec_flush_buffers(mVideoCtx);
      seekPts = packet->pts;
      SAFE_DELETE(packet);
      presentationTime = 0;
      mSeekInProgressVideo = false;
      continue;
    }
    else if (packet->data == PacketQueue::QUIT_DATA)
    {
      SAFE_DELETE(packet);
      break;
    }
 
    //skip outdated packet
    //if (HasAudio() && ((av_rescale_q(packet->pts, mContext->streams[mVideoStream]->time_base, MediaPlayer::TIME_BASE)) < (mAudioClock.Get() + MediaPlayer::AV_SYNC_THRESHOLD)))
    //{
    //  av_packet_unref(packet);
    //  SAFE_DELETE(packet);
    //  skipNext = true;
    //  continue;
    //}
 
    int ret = avcodec_send_packet(mVideoCtx, packet);
    av_packet_unref(packet);
    SAFE_DELETE(packet);
    while (ret >= 0)
    {
      ret = avcodec_receive_frame(mVideoCtx, mFrame);
      if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
      {
        break;
      }
      else if (ret < 0)
      {
        MMechostr(MSKDEBUG, ">> MediaPlayer: Decoding error: %s\n", av_err2str(ret));
        break;
      }
 
      if (ret < 0)
        // Decode packets until we have a whole decoded frame
        continue;
      else if (mSizeChanged || mFrame->width != mSourceW || mFrame->height != mSourceH)
      {
        ComputeSize(mFrame->width, mFrame->height);
        mSizeChanged = false;
      }
      
      // Synchronization
      int64_t pts = av_frame_get_best_effort_timestamp(mFrame);
      if (pts != AV_NOPTS_VALUE)
        pts = av_rescale_q(pts, mContext->streams[mVideoStream]->time_base, MediaPlayer::TIME_BASE);
 
      pts = SynchronizeVideo(mFrame, pts);
 
      // If a seek has been requested, decode until we get to the exact position
      if (seekPts != AV_NOPTS_VALUE)
      {
        if (pts < seekPts)
          continue;
        else
          seekPts = AV_NOPTS_VALUE;
      }
      
      //now wait for a real frame not a predicted one
      if (skipNext && (mFrame->pict_type == AV_PICTURE_TYPE_I))
      {
        skipNext = false;
        continue;
      }
 
      // Write the final image to buffer
      sws_scale(mScalerCtx, mFrame->data, mFrame->linesize, 0, mFrame->height, mVideoBuffer->data, mVideoBuffer->linesize);
 
      // Sync to audio
      if (HasAudio())
      {
        // Audio not ready yet (still seeking)
        while (!mSeekInProgressVideo && !mSeekCompletedAudio && !mSystemClock.IsPaused() && !mPaused && !mStopped)
          boost::this_thread::yield();
 
        int64_t clock = mAudioClock.Get();
 
        // Handle any ninja seek request
        if (mSeekInProgressVideo)
          continue;
 
        if (pts > (clock + MediaPlayer::AV_SYNC_THRESHOLD) && !mSystemClock.IsPaused() && !mPaused && !mStopped)
        {
          // secure if the audio didn't start yet
          if ((pts - clock) > 250)
            boost::this_thread::sleep_for(boost::chrono::milliseconds(250));
          else
            boost::this_thread::sleep_for(boost::chrono::milliseconds(pts - clock));
        }
      }
      else if (presentationTime != 0 && !mSystemClock.IsPaused())
      {
        int64_t elapsed = Clock::GetSysTime() - presentationTime;
        if (((pts - mVideoPts) - elapsed) > 250)
          boost::this_thread::sleep_for(boost::chrono::milliseconds(250));
        else
          boost::this_thread::sleep_for(boost::chrono::milliseconds((pts - mVideoPts) - elapsed));
      }
 
      {
        boost::mutex::scoped_lock l(mVideoMutex);
 
        if (mVideoBuffer->linesize[0] != mFrameBuffer.step)
          mFrameBuffer = cv::Mat(mVideoBuffer->height, mVideoBuffer->width, CV_8UC3, mVideoBuffer->data[0], mVideoBuffer->linesize[0]);
        else
          memcpy(mFrameBuffer.data, mVideoBuffer->data[0], mVideoBuffer->linesize[0] * mVideoBuffer->height);
 
        mVideoPts = pts;
        mUpdated = true;
 
        if ((mPaused || mSystemClock.IsPaused()) && !mStopped && !mSeekInProgressVideo)
        {
          mPauseCond.wait(l);
          presentationTime = 0;
        }
        else
          presentationTime = Clock::GetSysTime();
      }
    }    
 
    //prevent CPU burn
    boost::this_thread::sleep_for(boost::chrono::microseconds(1));
  }
}
 
MediaPlayer::AudioFrame::AudioFrame() :
  data(),
  size(0),
  pts(AV_NOPTS_VALUE)
{}
 
MediaPlayer::AudioFrame::AudioFrame(const AudioFrame& frame) :
  size(frame.size),
  pts(frame.pts)
{
  data.reset(new char[size]);
  memcpy(data.get(), frame.data.get(), size);
}
 
MediaPlayer::AudioFrame::AudioFrame(AudioFrame&& frame) :
  data(std::move(frame.data)),
  size(frame.size),
  pts(frame.pts)
{}
 
MediaPlayer::AudioFrame& MediaPlayer::AudioFrame::operator=(AudioFrame&& frame)
{
  size = frame.size;
  pts = frame.pts;
  data = std::move(frame.data);
  return *this;
}
 
void MediaPlayer::AudioThread()
{
  int64_t firstPts = AV_NOPTS_VALUE;
 
  AVFrame* frame = av_frame_alloc();
  if (frame == NULL)
    throw std::runtime_error("Out of memory");
 
  int64_t seekPts = AV_NOPTS_VALUE;
 
  while (true)
  {
    AVPacket* packet = mAudioPktQ.Pop();
    if (packet->data == PacketQueue::FLUSH_DATA)
    {
      avcodec_flush_buffers(mAudioCtx);
      seekPts = packet->pts;
      SAFE_DELETE(packet);
 
      boost::mutex::scoped_lock l(mAudioMutex);
      mAudioFrameQ.clear();
      mSeekCompletedAudio = false;
      continue;
    }
    else if (packet->data == PacketQueue::QUIT_DATA)
    {
      SAFE_DELETE(packet);
 
      boost::mutex::scoped_lock l(mAudioMutex);
      mAudioFrameQ.clear();
      break;
    }
 
    int ret = avcodec_send_packet(mAudioCtx, packet);
    av_packet_unref(packet);
    SAFE_DELETE(packet);
 
    while (ret >= 0 && !mStopped)
    {
      ret = avcodec_receive_frame(mAudioCtx, frame);
      if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
      {
        break;
      }
      else if (ret < 0)
      {
        MMechostr(MSKDEBUG, ">> MediaPlayer: Decoding error: %s\n", av_err2str(ret));
        break;
      }
 
      if (ret >= 0)
      {
        int64_t pts = av_frame_get_best_effort_timestamp(frame);
        if (pts == AV_NOPTS_VALUE)
          continue;
 
        pts = av_rescale_q(pts, mContext->streams[mAudioStream]->time_base, MediaPlayer::TIME_BASE);
 
        if (firstPts == AV_NOPTS_VALUE)
        {
          firstPts = pts;
          mAudioClock.Reset(firstPts);
        }
 
        if (seekPts != AV_NOPTS_VALUE)
        {
          if (pts < seekPts)
            continue;
          else
          {
            seekPts = AV_NOPTS_VALUE;
            mSeekInProgressAudio = false;
          }
        }
 
        AudioFrame destFrame;
        // Resample if needed
        if (mResampleCtx != NULL)
        {
          //int outSamples = av_rescale_rnd(frame->nb_samples, mAudioCtx->sample_rate, mAudioCtx->sample_rate, AV_ROUND_UP);
 
          int outSamples = swr_get_out_samples(mResampleCtx, frame->nb_samples);
          if (outSamples < 0)
            continue; // throw std::runtime_error(std::string("swr_get_out_samples : ") + av_err2str(outSamples));
 
          int outSamplesLines = 0;
          int buffSize = av_samples_get_buffer_size(&outSamplesLines, av_get_channel_layout_nb_channels(mOutChannelLayout), outSamples, mOutSampleFormat, 1);
 
          destFrame.data.reset(new char[buffSize]);
          char* convertedData = destFrame.data.get();
 
          // The actual number of output samples could be different from the upper bound given earlier
          int ilen = swr_convert(mResampleCtx, (uint8_t**)&convertedData, outSamples, (const uint8_t**)frame->extended_data, frame->nb_samples);
          //avresample_convert(mResampleCtx, (uint8_t**)&convertedData, 0, outSamples, (uint8_t **)frame->extended_data, 0, frame->nb_samples);
 
          if (ilen < 0)
            continue; //throw std::runtime_error(std::string("Error converting audio : ") + av_err2str(ilen));
 
          int outBytes = av_samples_get_buffer_size(&outSamplesLines, av_get_channel_layout_nb_channels(mOutChannelLayout), ilen, mOutSampleFormat, 1);
 
          if (outBytes < 0 || outBytes > buffSize)
            continue; //throw std::runtime_error(std::string("Error converting audio : Bad buffer size"));
 
          destFrame.size = outBytes;
        }
        else
        {
          destFrame.size = frame->nb_samples * av_get_channel_layout_nb_channels(mOutChannelLayout) * av_get_bytes_per_sample(mOutSampleFormat);
          destFrame.data.reset(new char[destFrame.size]);
          memcpy(destFrame.data.get(), frame->data[0], destFrame.size);
        }
        destFrame.pts = pts;
 
        // When the queue is full, pop the frame at the head if it's obsolete
        while (mAudioFrameQ.full() && !mStopped && !mPaused && !mSystemClock.IsPaused() && !mSeekInProgressAudio)
          boost::this_thread::yield();
 
        {
          boost::mutex::scoped_lock l(mAudioMutex);
          if ((mPaused || mSystemClock.IsPaused()) && !mStopped && !mSeekInProgressAudio)
            mPauseCond.wait(l);
 
          if (!mSeekInProgressAudio)
          {
            mAudioFrameQ.push_back(std::move(destFrame));
          }
        }
      }
    }
 
    //prevent CPU burn
    boost::this_thread::sleep_for(boost::chrono::microseconds(1));
  }
 
  av_frame_free(&frame);
}
 
int MediaPlayer::GetAudioThreaded(char* destBuffer, size_t length)
{
  size_t retrieved = 0;
  int64_t firstPts = AV_NOPTS_VALUE;
  if (mSeekInProgressAudio || mAudioClock.IsPaused())
    return 0;
 
  boost::mutex::scoped_lock l(mAudioMutex);
  while (!mAudioFrameQ.empty() && (retrieved < length) && !mStopped)
  {
    const AudioFrame frame = mAudioFrameQ.front();
 
    if (firstPts == AV_NOPTS_VALUE)
      firstPts = frame.pts;
 
    // We only copy whole frames, give up if frame is too large
    if (frame.size > length)
    {
      mAudioFrameQ.pop_front();
      break;
    }
 
    if (retrieved + frame.size > length)
      break;
 
    memcpy(destBuffer + retrieved, frame.data.get(), frame.size);
    retrieved += frame.size;
    mAudioFrameQ.pop_front();
  }
 
  if (firstPts != AV_NOPTS_VALUE)
    SynchronizeAudio(firstPts);
 
  return (int)retrieved;
}
 
void MediaPlayer::SynchronizeAudio(int64_t pts)
{
  /*
   * The audio clock should keep track of the current audio playback position.
   * If the given pts is ahead of the estimated playback time (= buffering), don't update it.
   * The only time when we update is if audio playback is too slow, or when seeking.
   */
  if (!mSeekCompletedAudio)
  {
    mAudioClock.Reset(pts);
    mSeekCompletedAudio = true;
  }
}
 
int MediaPlayer::FileRead(void* player, uint8_t* buf, int buf_size)
{
  return fread(buf, 1, buf_size, ((MediaPlayer*)player)->mFilePtr);
}
 
int MediaPlayer::FileWrite(void* player, uint8_t* buf, int buf_size)
{
  return fwrite(buf, 1, buf_size, ((MediaPlayer*)player)->mFilePtr);
}
 
int64_t MediaPlayer::FileSeek(void* player, int64_t offset, int whence)
{
  MediaPlayer* vp = (MediaPlayer*)player;
  // Disable "forced seek", we shouldn't need it
  whence &= ~AVSEEK_FORCE;
 
  if (whence == AVSEEK_SIZE)
  {
    int64_t prev = ftell(vp->mFilePtr);
    fseek(vp->mFilePtr, 0L, SEEK_END);
    int64_t sz = (int64_t)ftell(vp->mFilePtr);
    fseek(vp->mFilePtr, (long)prev, SEEK_SET);
    return sz;
  }
 
  if (fseek(vp->mFilePtr, (long)offset, whence) != 0)
    return -1;
 
  return ftell(vp->mFilePtr);
}
 
 
 
int64_t MediaPlayer::Clock::GetSysTime()
{
  return cv::getTickCount() / (int64_t)(cv::getTickFrequency() / MediaPlayer::TIME_BASE.den);
}
 
MediaPlayer::Clock::Clock() :
  mInitialTime(0),
  mPauseTime(0),
  mSystemTime(0),
  mRunning(false),
  mMutex()
{}
 
int64_t MediaPlayer::Clock::Get()
{
  boost::mutex::scoped_lock l(mMutex);
 
  if (!mRunning)
    return mPauseTime;
 
  return GetSysTime() - mSystemTime + mInitialTime;
}
 
void MediaPlayer::Clock::Reset(int64_t initialTime)
{
  boost::mutex::scoped_lock l(mMutex);
 
  mInitialTime = initialTime;
  mSystemTime = GetSysTime();
  mPauseTime = initialTime;
}
 
void MediaPlayer::Clock::Pause()
{
  boost::mutex::scoped_lock l(mMutex);
 
  if (mRunning)
  {
    mPauseTime = GetSysTime() - mSystemTime + mInitialTime;
    mRunning = false;
  }
}
 
void MediaPlayer::Clock::Resume()
{
  boost::mutex::scoped_lock l(mMutex);
 
  if (!mRunning)
  {
    mInitialTime = mPauseTime;
    mSystemTime = GetSysTime();
    mRunning = true;
  }
}
 
bool MediaPlayer::Clock::IsPaused()
{
  boost::mutex::scoped_lock l(mMutex);
  return !mRunning;
}
 
 
uint8_t* MediaPlayer::PacketQueue::FLUSH_DATA = (uint8_t*)"VP_FLUSH";
uint8_t* MediaPlayer::PacketQueue::QUIT_DATA = (uint8_t*)"VP_QUIT";
 
MediaPlayer::PacketQueue::PacketQueue(size_t capacity) :
  mCapacity(capacity),
  mSize(0)
{}
 
MediaPlayer::PacketQueue::~PacketQueue()
{
  Clear();
}
 
bool MediaPlayer::PacketQueue::Empty()
{
  boost::mutex::scoped_lock l(mMutex);
 
  return mQueue.empty();
}
 
bool MediaPlayer::PacketQueue::Push(AVPacket* packet)
{
  boost::mutex::scoped_lock l(mMutex);
 
  if (mSize >= mCapacity)
    return false;
 
  bool wasEmpty = mQueue.empty();
  mQueue.push(packet);
  mSize += packet->size;
 
  if (wasEmpty)
    mCond.notify_one();
 
  return true;
}
 
AVPacket* MediaPlayer::PacketQueue::Pop()
{
  boost::mutex::scoped_lock l(mMutex);
 
  while (mQueue.empty())
    mCond.wait(l);
 
  AVPacket* pkt = mQueue.front();
  mQueue.pop();
  mSize -= pkt->size;
 
  return pkt;
}
 
AVPacket* MediaPlayer::PacketQueue::TryPop()
{
  boost::mutex::scoped_lock l(mMutex);
 
  if (mQueue.empty())
    return NULL;
 
  AVPacket* pkt = mQueue.front();
  mQueue.pop();
  mSize -= pkt->size;
 
  return pkt;
}
 
void MediaPlayer::PacketQueue::Flush(AVPacket* flushPacket)
{
  boost::mutex::scoped_lock l(mMutex);
 
  bool wasEmpty = mQueue.empty();
 
  Clear();
 
  mQueue.push(flushPacket);
  if (wasEmpty)
    mCond.notify_one();
}
 
void MediaPlayer::PacketQueue::Clear()
{
  while (!mQueue.empty())
  {
    AVPacket* pkt = mQueue.front();
    mQueue.pop();
 
    if ((pkt->data != PacketQueue::FLUSH_DATA) && (pkt->data != PacketQueue::QUIT_DATA))
      av_packet_unref(pkt);
 
    SAFE_DELETE(pkt);
  }
  mSize = 0;
}
 
size_t MediaPlayer::PacketQueue::Size()
{
  return mSize;
}
 
size_t MediaPlayer::PacketQueue::MaxSize()
{
  return mCapacity;
}