CVideoFileWriter.cpp

Go to the documentation of this file.

/* +------------------------------------------------------------------------+
   |                     Mobile Robot Programming Toolkit (MRPT)            |
   |                          http://www.mrpt.org/                          |
   |                                                                        |
   | Copyright (c) 2005-2018, Individual contributors, see AUTHORS file     |
   | See: http://www.mrpt.org/Authors - All rights reserved.                |
   | Released under BSD License. See details in http://www.mrpt.org/License |
   +------------------------------------------------------------------------+ */
 
#include "vision-precomp.h"  // Precompiled headers
 
#include <mrpt/vision/CVideoFileWriter.h>
 
// Universal include for all versions of OpenCV
#include <mrpt/otherlibs/do_opencv_includes.h>
 
#define M_WRITER                 \
    (const_cast<CvVideoWriter*>( \
        static_cast<const CvVideoWriter*>(m_video.get())))
#define M_WRITER_PTR (reinterpret_cast<CvVideoWriter**>(m_video.getPtrToPtr()))
 
using namespace mrpt;
using namespace mrpt::vision;
using namespace mrpt::img;
using namespace mrpt::system;
 
/* ----------------------------------------------------------
                        Ctor
   ---------------------------------------------------------- */
CVideoFileWriter::CVideoFileWriter() : m_video(), m_img_size(0, 0) {}
/* ----------------------------------------------------------
                        Dtor
   ---------------------------------------------------------- */
CVideoFileWriter::~CVideoFileWriter() { close(); }
/* ----------------------------------------------------------
                        open
   ---------------------------------------------------------- */
bool CVideoFileWriter::open(
    const std::string& out_file, double fps,
    const mrpt::img::TImageSize& frameSize, const std::string& fourcc,
    bool isColor)
{
#if MRPT_HAS_OPENCV
    close();
 
    int cc;
 
    if (fourcc.empty())
    {
#if MRPT_OPENCV_VERSION_NUM <= 0x100
        cc = 0;  // Default
#else
#ifdef _WIN32
        cc = CV_FOURCC_DEFAULT;  // Default CV_FOURCC_PROMPT;
#else
        cc = CV_FOURCC_DEFAULT;  // Default
#endif
#endif
    }
    else if (fourcc.size() == 4)
    {
        cc = CV_FOURCC(fourcc[0], fourcc[1], fourcc[2], fourcc[3]);
    }
    else
    {
        std::cerr << "[CVideoFileWriter::open] fourcc string must be four "
                     "character length or empty for default."
                  << std::endl;
        return false;
    }
 
    m_video = cvCreateVideoWriter(
        out_file.c_str(), cc, fps, cvSize(frameSize.x, frameSize.y),
        isColor ? 1 : 0);
 
    m_img_size = frameSize;
 
    return m_video.get() != nullptr;
#else
    std::cerr << "[CVideoFileWriter::open] ERROR: MRPT was compiled without "
                 "OpenCV support "
              << std::endl;
    return false;
#endif
}
 
/* ----------------------------------------------------------
                        close
   ---------------------------------------------------------- */
void CVideoFileWriter::close()
{
#if MRPT_HAS_OPENCV
    if (!M_WRITER) return;
    cvReleaseVideoWriter(M_WRITER_PTR);
    *M_WRITER_PTR = nullptr;
#endif
}
 
/* ----------------------------------------------------------
                        isOpen
   ---------------------------------------------------------- */
bool CVideoFileWriter::isOpen() const
{
#if MRPT_HAS_OPENCV
    return (M_WRITER != nullptr);
#else
    return false;
#endif
}
 
/* ----------------------------------------------------------
                        operator <<
   ---------------------------------------------------------- */
const CVideoFileWriter& CVideoFileWriter::operator<<(
    const mrpt::img::CImage& img) const
{
    if (!m_video.get()) THROW_EXCEPTION("Call open first");
 
    if ((size_t)m_img_size.x != img.getWidth() ||
        (size_t)m_img_size.y != img.getHeight())
        THROW_EXCEPTION(
            format(
                "Video frame size is %ix%i but image is %ux%u", m_img_size.x,
                m_img_size.y, (unsigned)img.getWidth(),
                (unsigned)img.getHeight()));
 
#if MRPT_HAS_OPENCV
    if (!cvWriteFrame(M_WRITER, img.getAs<IplImage>()))
        THROW_EXCEPTION("Error writing image frame to video file");
#endif
    return *this;
}
 
/* ----------------------------------------------------------
                        writeImage
   ---------------------------------------------------------- */
bool CVideoFileWriter::writeImage(const mrpt::img::CImage& img) const
{
    if (!m_video.get()) return false;
 
    if ((size_t)m_img_size.x != img.getWidth() ||
        (size_t)m_img_size.y != img.getHeight())
    {
        std::cout << format(
                         "[CVideoFileWriter::writeImage] Error: video frame "
                         "size is %ix%i but image is %ux%u",
                         m_img_size.x, m_img_size.y, (unsigned)img.getWidth(),
                         (unsigned)img.getHeight())
                  << std::endl;
        return false;
    }
 
#if MRPT_HAS_OPENCV
    return 0 != cvWriteFrame(M_WRITER, img.getAs<IplImage>());
#else
    return false;
#endif
}