vpVideoReader.cpp

/****************************************************************************
*
* $Id: vpImagePoint.h 2359 2009-11-24 15:09:25Z nmelchio $
*
* This file is part of the ViSP software.
* Copyright (C) 2005 - 2014 by INRIA. All rights reserved.
* 
* This software is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* ("GPL") version 2 as published by the Free Software Foundation.
* See the file LICENSE.txt at the root directory of this source
* distribution for additional information about the GNU GPL.
*
* For using ViSP with software that can not be combined with the GNU
* GPL, please contact INRIA about acquiring a ViSP Professional 
* Edition License.
*
* See http://www.irisa.fr/lagadic/visp/visp.html for more information.
* 
* This software was developed at:
* INRIA Rennes - Bretagne Atlantique
* Campus Universitaire de Beaulieu
* 35042 Rennes Cedex
* France
* http://www.irisa.fr/lagadic
*
* If you have questions regarding the use of this file, please contact
* INRIA at visp@inria.fr
* 
* This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
* WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*
*
* Description:
* Read videos and image sequences.
*
* Authors:
* Nicolas Melchior
* Fabien Spindler
*
*****************************************************************************/

#include <visp/vpDebug.h>
#include <visp/vpVideoReader.h>

#include <iostream>
#include <fstream>
#include <limits>   // numeric_limits

vpVideoReader::vpVideoReader()
    : imSequence(NULL),
#ifdef VISP_HAVE_FFMPEG
    ffmpeg(NULL),
#elif VISP_HAVE_OPENCV_VERSION >= 0x020100
  capture(), frame(),
#endif
    formatType(FORMAT_UNKNOWN), initFileName(false), isOpen(false), frameCount(0),
    firstFrame(0), lastFrame(0), firstFrameIndexIsSet(false), lastFrameIndexIsSet(false)
{
}

vpVideoReader::~vpVideoReader()
{
    if (imSequence != NULL)
    {
        delete imSequence;
    }
#ifdef VISP_HAVE_FFMPEG
    if (ffmpeg != NULL)
    {
        delete ffmpeg;
    }
#endif
}


void vpVideoReader::setFileName(const char *filename)
{
    if (!filename || *filename == '\0')
    {
        vpERROR_TRACE("filename empty ") ;
        throw (vpImageException(vpImageException::noFileNameError,"filename empty ")) ;
    }

    if (strlen( filename ) >= FILENAME_MAX) {
        throw(vpException(vpException::memoryAllocationError,
            "Not enough memory to intialize the file name"));
    }

    strcpy(this->fileName,filename);

    formatType = getFormat(fileName);

  if (formatType == FORMAT_UNKNOWN) {
    throw(vpException(vpException::badValue, "Filename extension not supported"));
  }

    initFileName = true;
}

void vpVideoReader::setFileName(const std::string &filename)
{
    setFileName(filename.c_str());
}

void vpVideoReader::open(vpImage< vpRGBa > &I)
{
    if (!initFileName)
    {
        vpERROR_TRACE("The generic filename has to be set");
        throw (vpImageException(vpImageException::noFileNameError,"filename empty"));
    }

    if (isImageExtensionSupported())
    {
        imSequence = new vpDiskGrabber;
        imSequence->setGenericName(fileName);
        if (firstFrameIndexIsSet)
            imSequence->setImageNumber(firstFrame);
    }
    else if (isVideoExtensionSupported())
    {
#ifdef VISP_HAVE_FFMPEG
        ffmpeg = new vpFFMPEG;
        if(!ffmpeg->openStream(fileName, vpFFMPEG::COLORED))
      throw (vpException(vpException::ioError ,"Could not open the video with ffmpeg"));
        ffmpeg->initStream();
#elif VISP_HAVE_OPENCV_VERSION >= 0x020100
        capture.open(fileName);

        if(!capture.isOpened())
        {
      throw (vpException(vpException::ioError ,"Could not open the video with opencv"));
        }
#else
    //vpERROR_TRACE("To read video files ViSP should be build with ffmpeg or opencv 3rd party libraries.");
    throw (vpException(vpException::fatalError ,"To read video files ViSP should be build with ffmpeg or opencv 3rd >= 2.1.0 party libraries."));
#endif
    }
    else if (formatType == FORMAT_UNKNOWN)
    {
    //vpERROR_TRACE("The format of the file does not correspond to a readable format.");
    throw (vpException(vpException::fatalError ,"The format of the file does not correspond to a readable format supported by ViSP."));
    }

    findFirstFrameIndex();
    frameCount = firstFrame;
    if(!getFrame(I, firstFrame))
    {
    //vpERROR_TRACE("Could not read the video first frame");
    throw (vpException(vpException::ioError ,"Could not read the video first frame"));
    }

    height = I.getHeight();
    width = I.getWidth();

    isOpen = true;
    findLastFrameIndex();
}


void vpVideoReader::open(vpImage<unsigned char> &I)
{
    if (!initFileName)
    {
        vpERROR_TRACE("The generic filename has to be set");
        throw (vpImageException(vpImageException::noFileNameError,"filename empty"));
    }

    if (isImageExtensionSupported())
    {
        imSequence = new vpDiskGrabber;
        imSequence->setGenericName(fileName);
        if (firstFrameIndexIsSet)
            imSequence->setImageNumber(firstFrame);
    }
    else if (isVideoExtensionSupported())
    {
#ifdef VISP_HAVE_FFMPEG
        ffmpeg = new vpFFMPEG;
        if (!ffmpeg->openStream(fileName, vpFFMPEG::GRAY_SCALED))
      throw (vpException(vpException::ioError ,"Could not open the video with ffmpeg"));
        ffmpeg->initStream();
#elif VISP_HAVE_OPENCV_VERSION >= 0x020100
        capture.open(fileName);

        if(!capture.isOpened())
        {
      throw (vpException(vpException::ioError ,"Could not open the video with opencv"));
        }
#else
    //vpERROR_TRACE("To read video files ViSP should be build with ffmpeg or opencv 3rd party libraries.");
    throw (vpException(vpException::fatalError ,"To read video files ViSP should be build with ffmpeg or opencv >= 2.1.0 3rd party libraries."));
#endif
    }
    else if (formatType == FORMAT_UNKNOWN)
    {
    //vpERROR_TRACE("The format of the file does not correspond to a readable format.");
    throw (vpException(vpException::fatalError ,"The format of the file does not correspond to a readable format supported by ViSP."));
  }

    findFirstFrameIndex();
    frameCount = firstFrame;
    if(!getFrame(I,firstFrame))
    {
    //vpERROR_TRACE("Could not read the video first frame");
    throw (vpException(vpException::ioError ,"Could not read the video first frame"));
  }

    height = I.getHeight();
    width = I.getWidth();

    isOpen = true;
    findLastFrameIndex();
}


void vpVideoReader::acquire(vpImage< vpRGBa > &I)
{
    if (!isOpen) {
        open(I);
    }

    //getFrame(I,frameCount);
    if (imSequence != NULL)
    {
        imSequence->acquire(I);
    frameCount++; // next index
  }
#ifdef VISP_HAVE_FFMPEG
    else if (ffmpeg !=NULL)
    {
        ffmpeg->acquire(I);
    frameCount++; // next index
  }
#elif VISP_HAVE_OPENCV_VERSION >= 0x020100
    else
    {
    capture >> frame;
#if VISP_HAVE_OPENCV_VERSION >= 0x030000
    frameCount = (long) capture.get(cv::CAP_PROP_POS_FRAMES); // next index
#else
    frameCount = (long) capture.get(CV_CAP_PROP_POS_FRAMES); // next index
#endif

    if(frame.empty())
      setLastFrameIndex(frameCount-1);
    else
      vpImageConvert::convert(frame, I);
    }
#endif
}


void vpVideoReader::acquire(vpImage< unsigned char > &I)
{
    if (!isOpen) {
        open(I);
    }

    if (imSequence != NULL)
    {
        imSequence->acquire(I);
    frameCount++; // next index
  }
#ifdef VISP_HAVE_FFMPEG
    else if (ffmpeg != NULL)
    {
        ffmpeg->acquire(I);
    frameCount++; // next index
  }
#elif VISP_HAVE_OPENCV_VERSION >= 0x020100
    else
    {
    capture >> frame;
#if VISP_HAVE_OPENCV_VERSION >= 0x030000
    frameCount = (long) capture.get(cv::CAP_PROP_POS_FRAMES); // next index
#else
    frameCount = (long) capture.get(CV_CAP_PROP_POS_FRAMES); // next index
#endif

    if(frame.empty())
      setLastFrameIndex(frameCount-1);
    else
      vpImageConvert::convert(frame, I);
  }
#endif
}


bool vpVideoReader::getFrame(vpImage<vpRGBa> &I, long frame_index)
{
    if (imSequence != NULL)
    {
        try
        {
      imSequence->acquire(I, frame_index);
      frameCount = frame_index + 1; // next index
    }
        catch(...)
        {
      vpERROR_TRACE("Couldn't find the %u th frame", frame_index) ;
            return false;
        }
    }
  else
  {
#ifdef VISP_HAVE_FFMPEG
    if(!ffmpeg->getFrame(I, (unsigned int)frame_index))
    {
      vpERROR_TRACE("Couldn't find the %ld th frame", frame_index) ;
      return false;
    }
    frameCount = frame_index + 1;  // next index
#elif defined(VISP_HAVE_OPENCV) && (VISP_HAVE_OPENCV_VERSION >= 0x030000)
    if(!capture.set(cv::CAP_PROP_POS_FRAMES, frame_index))
    {
      vpERROR_TRACE("Couldn't find the %ld th frame", frame_index) ;
      return false;
    }

    capture >> frame;
    frameCount = (long) capture.get(cv::CAP_PROP_POS_FRAMES); // next index
    if(frame.empty())
      setLastFrameIndex(frameCount-1);
    else
      vpImageConvert::convert(frame, I);
#elif defined(VISP_HAVE_OPENCV) && (VISP_HAVE_OPENCV_VERSION >= 0x020100)
    if(!capture.set(CV_CAP_PROP_POS_FRAMES, frame_index))
    {
      vpERROR_TRACE("Couldn't find the %ld th frame", frame_index) ;
      return false;
    }

    capture >> frame;
    frameCount = (long) capture.get(CV_CAP_PROP_POS_FRAMES); // next index
    if(frame.empty())
      setLastFrameIndex(frameCount-1);
    else
      vpImageConvert::convert(frame, I);
#endif
  }

    return true;
}


bool vpVideoReader::getFrame(vpImage<unsigned char> &I, long frame_index)
{
    if (imSequence != NULL)
    {
        try
        {
      imSequence->acquire(I, frame_index);
      frameCount = frame_index + 1;
    }
        catch(...)
        {
      vpERROR_TRACE("Couldn't find the %u th frame", frame_index) ;
            return false;
        }
    }
  else
  {
#ifdef VISP_HAVE_FFMPEG
    if(!ffmpeg->getFrame(I, (unsigned int)frame_index))
    {
      vpERROR_TRACE("Couldn't find the %ld th frame", frame_index) ;
      return false;
    }
    frameCount = frame_index + 1;  // next index
#elif VISP_HAVE_OPENCV_VERSION >= 0x030000
    if(!capture.set(cv::CAP_PROP_POS_FRAMES, frame_index))
    {
      vpERROR_TRACE("Couldn't find the %ld th frame", frame_index) ;
      return false;
    }
    capture >> frame;
    frameCount = (long) capture.get(cv::CAP_PROP_POS_FRAMES); // next index
    if(frame.empty())
      setLastFrameIndex(frameCount-1);
    else
      vpImageConvert::convert(frame, I);
#elif VISP_HAVE_OPENCV_VERSION >= 0x020100
    if(!capture.set(CV_CAP_PROP_POS_FRAMES, frame_index))
    {
      vpERROR_TRACE("Couldn't find the %ld th frame", frame_index); // next index
      return false;
    }
    capture >> frame;
    frameCount = (long) capture.get(CV_CAP_PROP_POS_FRAMES);
    if(frame.empty())
      setLastFrameIndex(frameCount-1);
    else
      vpImageConvert::convert(frame, I);
#endif
  }

    return true;
}


vpVideoReader::vpVideoFormatType
    vpVideoReader::getFormat(const char *filename)
{  
    std::string sfilename(filename);

    std::string ext = vpVideoReader::getExtension(sfilename);

    if (ext.compare(".PGM") == 0)
        return FORMAT_PGM;
    else if (ext.compare(".pgm") == 0)
        return FORMAT_PGM;
    else if (ext.compare(".PPM") == 0)
        return FORMAT_PPM;
    else if (ext.compare(".ppm") == 0)
        return FORMAT_PPM;
    else if (ext.compare(".JPG") == 0)
        return FORMAT_JPEG;
    else if (ext.compare(".jpg") == 0)
        return FORMAT_JPEG;
    else if (ext.compare(".JPEG") == 0)
        return FORMAT_JPEG;
    else if (ext.compare(".jpeg") == 0)
        return FORMAT_JPEG;
    else if (ext.compare(".PNG") == 0)
        return FORMAT_PNG;
    else if (ext.compare(".png") == 0)
        return FORMAT_PNG;
  else if (ext.compare(".TIFF") == 0)
    return FORMAT_TIFF;
  else if (ext.compare(".tiff") == 0)
    return FORMAT_TIFF;
  else if (ext.compare(".BMP") == 0)
    return FORMAT_BMP;
  else if (ext.compare(".bmp") == 0)
    return FORMAT_BMP;
  else if (ext.compare(".DIB") == 0)
    return FORMAT_DIB;
  else if (ext.compare(".dib") == 0)
    return FORMAT_DIB;
  else if (ext.compare(".PBM") == 0)
    return FORMAT_PBM;
  else if (ext.compare(".PBM") == 0)
    return FORMAT_PBM;
  else if (ext.compare(".SR") == 0)
    return FORMAT_PBM;
  else if (ext.compare(".sr") == 0)
    return FORMAT_PBM;
  else if (ext.compare(".RAS") == 0)
    return FORMAT_RASTER;
  else if (ext.compare(".ras") == 0)
    return FORMAT_RASTER;
  else if (ext.compare(".JP2") == 0)
    return FORMAT_JPEG2000;
  else if (ext.compare(".jp2") == 0)
    return FORMAT_JPEG2000;
  else if (ext.compare(".AVI") == 0)
        return FORMAT_AVI;
    else if (ext.compare(".avi") == 0)
        return FORMAT_AVI;
    else if (ext.compare(".MPEG") == 0)
        return FORMAT_MPEG;
    else if (ext.compare(".mpeg") == 0)
        return FORMAT_MPEG;
    else if (ext.compare(".MPG") == 0)
        return FORMAT_MPEG;
    else if (ext.compare(".mpg") == 0)
        return FORMAT_MPEG;
    else if (ext.compare(".MPEG4") == 0)
        return FORMAT_MPEG4;
    else if (ext.compare(".mpeg4") == 0)
        return FORMAT_MPEG4;
    else if (ext.compare(".MP4") == 0)
        return FORMAT_MPEG4;
    else if (ext.compare(".mp4") == 0)
        return FORMAT_MPEG4;
    else if (ext.compare(".MOV") == 0)
        return FORMAT_MOV;
    else if (ext.compare(".mov") == 0)
        return FORMAT_MOV;
    else if (ext.compare(".OGV") == 0)
        return FORMAT_OGV;
    else if (ext.compare(".ogv") == 0)
        return FORMAT_OGV;
    else if (ext.compare(".WMV") == 0)
        return FORMAT_WMV;
    else if (ext.compare(".wmv") == 0)
        return FORMAT_WMV;
    else if (ext.compare(".FLV") == 0)
        return FORMAT_FLV;
    else if (ext.compare(".flv") == 0)
        return FORMAT_FLV;
    else if (ext.compare(".MKV") == 0)
        return FORMAT_MKV;
    else if (ext.compare(".mkv") == 0)
        return FORMAT_MKV;
    else
        return FORMAT_UNKNOWN;
}

// return the extension of the file including the dot
std::string vpVideoReader::getExtension(const std::string &filename)
{
    // extract the extension
    size_t dot = filename.find_last_of(".");
    std::string ext = filename.substr(dot, filename.size()-1);
    return ext;
}


void
    vpVideoReader::findLastFrameIndex()
{
    if (!isOpen)
    {
        vpERROR_TRACE("Use the open method before");
        throw (vpException(vpException::notInitialized,"file not yet opened"));
    }

    if (imSequence != NULL)
    {
        if (! lastFrameIndexIsSet) {
            char name[FILENAME_MAX];
            int image_number = firstFrame;
            bool failed;
            do
            {
                std::fstream file;
                sprintf(name,fileName,image_number) ;
                file.open(name, std::ios::in);
                failed = file.fail();
        if (!failed) {
          file.close();
          image_number++;
        }
            }while(!failed);

            lastFrame = image_number;
        }
    }

#ifdef VISP_HAVE_FFMPEG
    else if (ffmpeg != NULL) {
        if (! lastFrameIndexIsSet) {
      lastFrame = (long)(ffmpeg->getFrameNumber());
        }
    }
#elif VISP_HAVE_OPENCV_VERSION >= 0x030000
  else if (! lastFrameIndexIsSet)
  {
    lastFrame = (long) capture.get(cv::CAP_PROP_FRAME_COUNT);
    if(lastFrame <= 2) // with tutorial/matching/video-postcard.mpeg it return 2 with OpenCV 3.0.0
    {
      //std::cout << "Warning: Problem with cv::CAP_PROP_FRAME_COUNT. We set video last frame to an arbitrary value (1000)." << std::endl;
      lastFrame = 100000; // Set lastFrame to an arbitrary value
    }
    lastFrame--; //Last frame index = total frame count - 1
  }
#elif VISP_HAVE_OPENCV_VERSION >= 0x020100
  else if (! lastFrameIndexIsSet)
  {
    lastFrame = (long) capture.get(CV_CAP_PROP_FRAME_COUNT);
    if(lastFrame <= 2) // with tutorial/matching/video-postcard.mpeg it return 2 with OpenCV 2.4.10
    {
      //std::cout << "Warning: Problem with CV_CAP_PROP_FRAME_COUNT. We set video last frame to an arbitrary value (1000)." << std::endl;
      lastFrame = 100000; // Set lastFrame to an arbitrary value
    }
    lastFrame--; //Last frame index = total frame count - 1
  }
#endif
}
void
    vpVideoReader::findFirstFrameIndex()
{
    if (imSequence != NULL)
    {
        if (! firstFrameIndexIsSet) {
            char name[FILENAME_MAX];
            int image_number = 0;
            bool failed;
            do {
                std::fstream file;
                sprintf(name, fileName, image_number) ;
                file.open(name, std::ios::in);
                failed = file.fail();
                if (!failed) file.close();
                image_number++;
            } while(failed);

            firstFrame = image_number - 1;
            imSequence->setImageNumber(firstFrame);
        }
    }
#ifdef VISP_HAVE_FFMPEG
    else if (ffmpeg != NULL) {
        if (! firstFrameIndexIsSet) {
            firstFrame = (long)(0);
        }
    }
#elif VISP_HAVE_OPENCV_VERSION >= 0x020100
    else if (! firstFrameIndexIsSet)
    {       
        firstFrame = (long) (0);        
    }
#endif
}

double vpVideoReader::getFramerate()
{
    double framerate = -1.;

#ifdef VISP_HAVE_FFMPEG
    if (ffmpeg != NULL)
    {
        framerate = ffmpeg->getFramerate();
    }
#elif VISP_HAVE_OPENCV_VERSION >= 0x030000
   framerate = capture.get(cv::CAP_PROP_FPS);
   // if(framerate == 0)
   if(std::fabs(framerate) <= std::numeric_limits<double>::epsilon())
   {
    vpERROR_TRACE("Problem with cv::CAP_PROP_FPS") ;
   }
#elif VISP_HAVE_OPENCV_VERSION >= 0x020100
   framerate = capture.get(CV_CAP_PROP_FPS);
   // if(framerate == 0)
   if(std::fabs(framerate) <= std::numeric_limits<double>::epsilon())
   {
    vpERROR_TRACE("Problem with CV_CAP_PROP_FPS") ;
   }
#endif
    return framerate;
}

bool vpVideoReader::isImageExtensionSupported()
{
  return (formatType == FORMAT_PGM ||
          formatType == FORMAT_PPM ||
          formatType == FORMAT_JPEG ||
          formatType == FORMAT_PNG ||
          formatType == FORMAT_TIFF ||
          formatType == FORMAT_BMP ||
          formatType == FORMAT_DIB ||
          formatType == FORMAT_PBM ||
          formatType == FORMAT_RASTER ||
          formatType == FORMAT_JPEG2000);
}

bool vpVideoReader::isVideoExtensionSupported()
{
    return (formatType == FORMAT_AVI ||
        formatType == FORMAT_MPEG ||
        formatType == FORMAT_MPEG4 ||
        formatType == FORMAT_MOV ||
        formatType == FORMAT_OGV || 
        formatType == FORMAT_WMV ||
        formatType == FORMAT_FLV ||
        formatType == FORMAT_MKV);
}