VideoSink_FFmpeg.hh

#ifndef __VIDEOSINK_FFMPEG_HH__
#define __VIDEOSINK_FFMPEG_HH__

#include <Base/Image/Image.hh>

// Check for FFmpeg libraries in BIAS
#ifndef BIAS_HAVE_FFMPEG
//#error BIAS was build without FFmpeg, please enable USE_FFMPEG and recompile BIAS.
#endif

// Fix for FFmpeg on 32 bit systems
#ifndef INT64_C
#define INT64_C(c) (c ## LL)
#define UINT64_C(c) (c ## ULL)
#endif

#ifdef __cplusplus
extern "C" {
#endif
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libavutil/avstring.h>
#include <libswscale/swscale.h>
#ifdef __cplusplus
}
#endif

namespace BIAS
{
  /**
   * @class VideoSink_FFmpeg
   * @author Carsten Heine <carstenheine@gmx.de>
   * @brief Video encoding using FFmpeg library.
   *
   * Supports realtime encoding.
   *
   * Usage:
   *
   * @code
   * // Create a video sink object
   * VideoSink_FFmpeg *vs;
   * vs = new VideoSink_FFmpeg;
   *
   * // Set some parameters
   * vs->SetSize(640, 480);
   * vs->SetEncoder(CODEC_ID_MPEG4);
   * vs->SetFPS(25.0);
   * vs->SetBitrate(600000);
   *
   * // Open output video file and write header
   * vs->Open("video.mkv");
   *
   * // Add some images to the file
   * for (int i=0; i<250; i++)
   *   vs->AddFrame(image[i]);
   *
   * // Write trailer and close the file
   * vs->Close
   * @endcode
   *
   * For more information about supported codecs and formats visit:
   * http://www.ffmpeg.org
   */
  class VideoSink_FFmpeg
  {
  public:

    /**
     * Standard constructor.
     */
    VideoSink_FFmpeg();

    /**
     * Clean up.
     */
    ~VideoSink_FFmpeg();

    /**
     * Reset all user parameters to default values.
     */
    void SetDefaults();

    /**
     * Set encoder. Tested with CODEC_ID_MPEG4, CODEC_ID_MPEG1VIDEO, CODEC_ID_MPEG2VIDEO,
     * CODEC_ID_FFV1 and some others. This has to be called before Open.
     */
    void SetEncoder(enum CodecID codecId);

    /**
     * Set frame size of video. Resolution has to be a multiple of two. This
     * has to be called before Open.
     */
    void SetSize(int width, int height);

    /**
     * Set framerate in frames per second. Not all encoders support all
     * framerates. For Mpeg1 and Mpeg2 this will try to get the best alternative,
     * if you specify an invalid value. Check Google if you have problems setting
     * a valid framerate. This has to be called before Open.
     */
    void SetFPS(float fps);

    /**
     * Set bitrate in bits per second. This has to be called before Open.
     */
    void SetBitrate(int bitrate);

    /**
     * Set the gop size of the video stream. This is the number of frames
     * between fully coded intra frames. Set this to -1 for intra only. Will
     * be ignored for encoders, that only support intra frames. This has to be
     * called before Open.
     */
    void SetGopSize(int gopSize);

    /**
     * Set maximal number of bidirectional frames. Set this to 0 for no B frames.
     * Will be ignored for encoders, that don't support B-frames. This has to be
     * called before Open.
     */
    void SetMaxBFrames(int maxBFrames);

    /**
     * Set realtime mode. This will set the presentation timestamps of the frames
     * based on the real time clock for live encoding. This will adjust different
     * time deltas between frames for playback in correct speed. This is only
     * supported for .mkv and .flv files at the moment. This has to be called
     * before Open.
     */
    void SetRealtime(bool realtime);

    /**
     * Set if the output file should be overridden if it already exists. This
     * has to be called before Open.
     */
    void SetOverride(bool override);

    /**
     * Open a file for video output and init the codec. The output format will
     * be determined by the file extension. Possible values are .mkv (Matroska),
     * .mpg (Mpeg), .mp4 (Mpeg4), .avi (Avi) and many others. The parameters set by
     * the user will be checked at this point. If another file is already opened for
     * output, it will be closed first. Setting any parameters after the file is
     * opened will have no effect.
     * @returns 0 on success, -1 on error.
     */
    int Open(std::string filename);

    /**
     * Close the video output file, write remaining frames and clean up. Parameters
     * set by the user will not be overridden, so you can encode another video with
     * the same settings. To reset all parameters call SetDefaults.
     * @returns 0 on success, -1 on error.
     */
    int Close();

    /**
     * Add an Image to the stream and write it to the video output file. Resampling
     * will be done automatically.
     * @returns 0 on success, -1 on error, 1 on non critical error.
     */
    int AddFrame(const ImageBase& image);

    /**
     * Load an Image from file and add it to the video output file.
     * @returns 0 on success, -1 on error, 1 on non critical error.
     */
    int AddFrame(std::string filename);

    /**
     * Load each Image from a list of files and add them to the video output file.
     * @returns 0 on success, -1 on error, 1 on non critical error.
     */
    int AddFrames(std::vector<std::string> filenames);

    /**
     * Get status of video output file.
     */
    inline bool IsOpened() { return pFormatCtx_; }

    /**
     * Get the last error message.
     */
    inline std::string GetError() { return errMsg_; }

  protected:

    /**
     * Called by constructor to init variables.
     */
    void Init_();

    /**
     * Get the pixel format from a given color model.
     * @returns pixel format or PIX_FMT_NONE if not found.
     */
    enum PixelFormat GetPixelFormat_(enum ImageBase::EColorModel colorModel);

    enum CodecID    codecId_;      ///< Codec ID (default: CODEC_ID_MPEG1VIDEO)
    int             width_;        ///< Frame width (default: 352)
    int             height_;       ///< Frame height (default: 288)
    AVRational      fps_;          ///< Framerate (default: 25)
    int             bitrate_;      ///< Bitrate (default: 1200000)
    int             gopSize_;      ///< Gop size (default: 12)
    int             maxBFrames_;   ///< Max B-frames (default: 0)
    bool            realtime_;     ///< Realtime flag (default: false)
    bool            override_;     ///< Override flag (default: true)

    AVFormatContext *pFormatCtx_;  ///< Format context for video encoder
    AVFrame         *pInputPict_;  ///< Input picture
    SwsContext      *pSwsCtx_;     ///< Color conversion context
    AVFrame         *pPict_;       ///< Output picture
    uint8_t         *pPictBuffer_; ///< Output picture buffer
    uint8_t         *pBuffer_;     ///< Encoding buffer
    uint64_t        bufferSize_;   ///< Encoding buffer size
    std::string     errMsg_;       ///< The last error message
    int64_t         pts_;          ///< Presentation timestamp
  };
}

#endif // __VIDEOSINK_FFMPEG_HH__