httpcapture.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 HTTPCAPTURE_H
#define HTTPCAPTURE_H

#include <condition_variable>
#include <mutex>
#include <string>
#include <thread>
#include <vector>

#include <curl/curl.h>

#include "captureinterface.h"
#include "common.h"

namespace cavapa_gui
{
class HTTPCapture : public CaptureInterface
{
public:
    HTTPCapture() {}
    virtual ~HTTPCapture();

    DISALLOW_COPY_AND_ASSIGN(HTTPCapture);

    double getBarrelCorrection() override { return 0.0; }

    FrameCapture getBuffered() override;

    std::string getDescription() const override { return url; }

    int getDeviceID() const override { return UNKNOWN_DEVICE; }

    double getFramerate() const override { return 0.0; }

    int getMissedFrames() const override { return missed_frames; }

    FrameCapture getNext(bool skip, bool* error) override;

    std::string getPath() const override { return url; }

    cv::Size getResolution() const override;

    int getRetrievedFrames() const override { return retrieved_frames; }

    INTERFACE_TYPE getType() const override { return INTERFACE_TYPE::HTTP; }

    bool hasNew() override { return true; }

    bool isOpen() const override { return image_size_known && curl_open; }

    bool open(const std::string& path) override;

    void resetStats() override;

    void setBarrelCorrection(double amount) override { Q_UNUSED(amount); }

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

private:
    void retrieve();

    inline bool retrieve_next(std::unique_lock<std::mutex>& guard);

    static size_t writeCallback(char* buf, size_t size, size_t nmemb, void* up);

    // Variables that can be used by the main thread.
    std::condition_variable capture_next;   // Conditional for next retrieve
    bool curl_open = false;     // Flag to indicate CURL state.
    bool image_size_known = false; // Indicates if we know the true image size.
    cv::Size image_size;        // Size of the image
    std::mutex lock;
    int missed_frames = 0;      // Missed frame count by getNext()
    int retrieved_frames = 0;   // Total frame count by getNext()
    std::unique_ptr<std::thread> retriever = nullptr; // Retrieval thread
    std::string url = "";       // Url for the HTTP source.

    // Variables that are protected by mutex.
    FrameCapture buffer;        // Buffered image.
    bool capture = false;       // If retrieval is in progress
    CURL* curl = nullptr;       // CURL library.
    bool first_capture = true;  // Indicates if first capture is happening.
    bool read_error = false;    // Indicates retrieval error
    std::vector<char> temp_buffer;
    bool terminate = false;     // Terminate message for thread
};
} // namespace

#endif // HTTPCAPTURE_H