videofile.h

/****************************************************************************
 * Copyright (c) 2014, Joel Kivelä, Erkki Koskenkorva, Oskari Leppäaho,
 * Mika Lehtinen and Petri Partanen.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the copyright holders nor the names of its
 *       contributors may be used to endorse or promote products derived from
 *       this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
****************************************************************************/
#ifndef VIDEOFILE_H
#define VIDEOFILE_H

#include <string>

#include "opencvcapture.h"
#include "source.h"

namespace cavapa_gui
{
class VideoFile : public Source
{
public:
    VideoFile(SourceID desired_id = UNDEFINED_SOURCE) : Source(desired_id) {}

    bool canRecord() const override final { return false; }

    virtual void fetchFirstFrame();

    virtual FrameCapture get(FrameTime passed_time) override;

    virtual double getBarrelCorrection() override
        { return source ? source->getBarrelCorrection() : 0.0; }

    int getCurrentFrame() const { return current_frame; }

    virtual std::string getDescription() const override;

    virtual std::vector<std::string> getFilenames() const
        { return {source->getPath()}; }

    virtual double getFramerate() const override
        { return source ? source->getFramerate() : 0.0; }

    virtual FrameTime getLength() const final
        { return (totalFrames() * 1000.0) / getFramerate(); }

    virtual FrameTime getPosition() const override final
        { return currentFrameTime(); }

    virtual cv::Size getResolution() const override
        { return source ? source->getResolution() : cv::Size(0, 0); }

    virtual SourceType getSourceType() const override
        { return SourceType::VIDEO; }

    virtual SourceStats getStats() override;

    virtual bool hasNew() override
        { return source ? source->hasNew() : false; }

    virtual bool isOpen() const override { return opened; }

    virtual bool isPlaying() const override { return playing; }

    virtual bool open(const std::string& filename, bool get_first,
                      FrameTime start_point);

    virtual void play() override { playing = true; }

    bool record(const std::string& filename,
                const std::string& codec = "") override final
        { Q_UNUSED(filename); Q_UNUSED(codec); return false; }

    virtual void release() { if (source) source->release(); }

    bool seekTime(FrameTime pos);

    virtual bool skipFrame(int step);

    virtual void setBarrelCorrection(double amount) override
        { source->setBarrelCorrection(amount); }

    void setCurrentAsStartPoint() { initial_position = currentFrameTime(); }

    bool setResolution(const cv::Size &new_size) override final
            { Q_UNUSED(new_size); return false; }

    static void setSpeed(double multiplier)
        { speed_ratio = multiplier; }

    virtual FrameTime startPoint() const final { return initial_position; }

    virtual void stop() override { playing = false; }

    int totalFrames() const { return total_frames; }

protected:
    FrameTime currentFrameTime() const
        { return frameTimeFromFrame(current_frame); }

    int frameFromFrameTime(FrameTime time) const
    { return std::floor(static_cast<double>(time) / getFrameDifference()); }

    FrameTime frameTimeFromFrame(int frame) const
        { return static_cast<FrameTime>(getFrameDifference() * frame); }

    int current_frame;

    FrameTime initial_position;

    bool opened = false;

    bool playing = false;

    static double speed_ratio;

    int total_frames = 0;

    FrameTime video_time = 0;

private:
    double getFrameDifference() const
        { return 1000.0 / getFramerate(); }

    FrameTime nextFrameTime() const
        { return currentFrameTime() + getFrameDifference(); }

    std::unique_ptr<OpenCVCapture> source = nullptr;     // Capturing device.
};
} // namespace

#endif // VIDEOFILE_H