/*
   Copyright (C) 2011 Arnaud Champenois arthelion92@gmail.com

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 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 General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

/* FFMPEG C++ Wrapper
  Thanks to http://dranger.com/
  */

#ifndef FFMPEGDECODER_H
#define FFMPEGDECODER_H

#include <QImage>
#include "ffmpegpacket.h"
#include "ffmpegfileinfo.h"
#include "ffmpegutils.h"
#include "utils.h"
#include "vposition.h"

class FFMPEGDecoder
{
public:
    FFMPEGDecoder();
    ~FFMPEGDecoder();

    friend class FFMPEGOutput;

    typedef enum
    {
        FRAME_SEEK_CUR,
        FRAME_SEEK_SET
    } SeekMode;

    // File Management
    bool Open(const QString& aFileName,
              int aVideoStream = -1,
              int anAudioStream = -1);
    void Close();
    bool GetFileInfo(FFMPEGFileInfo&);

    // High level data management
    bool ReadNextImage(QImage&anImage,bool aNeedKeyFrame);
    bool SeekFrame(int64_t aMsPos,SeekMode);
    bool SeekFrame(VPosition aPos,SeekMode);
    bool SeekPosition(int64_t aPos);
    void Rewind();

    // Low level packet management
    bool ReadNextPacket(FFMPEGPacket&,bool aNeedKeyFrame);

    int64_t GetMSPosition() const;
    VPosition GetPosition() const
    { return VPosition(GetMSPosition(),mFilePosition); }
    int64_t GetFilePosition() const
    { return mFilePosition; }

    int64_t MSToPos(int64_t aMsValue) const;
    inline int64_t MSToTick(int64_t aMsValue) const
    {return av_rescale_q(aMsValue,millisecondbase,mFormatCtx->streams[mVideoStream]->time_base);}

    QString PosToString(int64_t aValue) const
    { return std::MsToString(PosToMS(aValue)); }

    int64_t MSToFilePos(int64_t aMsValue) const;

    inline int64_t TickToMS(int64_t aValue) const
    {return av_rescale_q(aValue,mFormatCtx->streams[mVideoStream]->time_base,millisecondbase);}

    inline int64_t PosToMS(int64_t aValue) const
    {return av_rescale_q(aValue-mFirstFrame,mFormatCtx->streams[mVideoStream]->time_base,millisecondbase);}

    void GetAspectRatio(int64_t&aNum,int64_t&aDen);

    inline VPosition GetVPosition(int64_t aMSValue) const
    { return VPosition(aMSValue,MSToFilePos(aMSValue)); }

    AVStream* GetVideoStream() { return mFormatCtx->streams[mVideoStream];}
    AVStream* GetAudioStream() { return mFormatCtx->streams[mAudioStream]; }

protected:

    void InitValues();

    AVFormatContext *mFormatCtx;
    AVCodecContext *mAudioCodecCtx;
    AVCodecContext *mVideoCodecCtx;
    AVFrame* mFrame;
    AVFrame* mFrameRGB;
    int mVideoStream;
    int mAudioStream;
    SwsContext      *mImgConvertCtx;
    int64_t mLastFrame,mFirstFrame,mFilePosition;
    static const AVRational millisecondbase;
    int64_t mBytesPerSec;
};

#endif // FFMPEGDECODER_H