uvccamerasession.h

#ifndef UVCCAMERASESSION_H
#define UVCCAMERASESSION_H

#include <QObject>
#include <QTime>
#include <QUrl>
#include <QMutex>
#include <QThread>

#include <qcamera.h>
#include <QtMultimedia/qvideoframe.h>
#include <QtMultimedia/qabstractvideosurface.h>
#include <QtMultimedia/qvideosurfaceformat.h>
#include <QtMultimedia/qcameraimageprocessingcontrol.h>
#include <QtMultimedia/qabstractvideobuffer.h>
#include <QtMultimedia/qcameraexposurecontrol.h>

#include <QElapsedTimer>

#include <vector>
#include <atomic>

#include "libuvc/libuvc.h"

QT_BEGIN_NAMESPACE

// Maximum acceptable latency for calling the surface present method
#define MAX_LATENCY_MS 1.0e3/25

class UVCCameraSession : public QObject
{
    Q_OBJECT
public:
    UVCCameraSession(QObject *parent = 0);
    ~UVCCameraSession();

    QCamera::Status status() const { return m_status; }

    void setSurface(QAbstractVideoSurface* surface);

    QList<QCameraViewfinderSettings> supportedViewfinderSettings();
    QCameraViewfinderSettings viewfinderSettings();
    void setViewfinderSettings(const QCameraViewfinderSettings &settings);

	bool setDevice(const QString &device);

    bool load();
    bool unload();
    bool startPreview();
    bool stopPreview();
    void callback(uvc_frame_t *frame);

    bool streaming;
    uvc_stream_handle_t *strmh;
    QMutex getFrameMutex;
	double interval;

	// Image Processing
	template<typename T>
	QVariant uvc_get( uvc_device_handle_t *devh,
					  uvc_error_t (*get)( uvc_device_handle_t *, T *, enum uvc_req_code)
					  ) const {
		T mn, val, mx;
		get(devh, &mn,  UVC_GET_MIN);
		get(devh, &val, UVC_GET_CUR);
		get(devh, &mx,  UVC_GET_MAX);
		//qDebug() << mn << val << mx;
		return (val - mn) / (double) (mx - mn) ;
	}
	template<typename T>
	void uvc_set( uvc_device_handle_t *devh,
					  uvc_error_t (*set)( uvc_device_handle_t *, T),
					  QVariant val,
					  uvc_error_t (*get)( uvc_device_handle_t *, T *, enum uvc_req_code)
					  ) {
		T mn, mx;
		get(devh, &mn,  UVC_GET_MIN);
		get(devh, &mx,  UVC_GET_MAX);
		double value = val.toDouble();
		value = value * (mx - mn ) + mn;
		//qDebug() << val;
		set(devh, static_cast<T>(value));
	}

	// Image Processing
	bool isImageProcessingParameterSupported(QCameraImageProcessingControl::ProcessingParameter parameter) const;
	bool isImageProcessingParameterValueSupported(QCameraImageProcessingControl::ProcessingParameter parameter,
			const QVariant &value) const;
	QVariant imageProcessingParameter(QCameraImageProcessingControl::ProcessingParameter parameter) const;
	void setImageProcessingParameter(QCameraImageProcessingControl::ProcessingParameter parameter,
			const QVariant &value);

	// Exposure
	QVariant actualExposureValue(QCameraExposureControl::ExposureParameter parameter) const;
	bool isExposureParameterSupported(QCameraExposureControl::ExposureParameter parameter) const;
	QVariant requestedExposureValue(QCameraExposureControl::ExposureParameter parameter) const;
	bool setExposureValue(QCameraExposureControl::ExposureParameter parameter, const QVariant &value);
	QVariantList supportedExposureParameterRange(QCameraExposureControl::ExposureParameter parameter, bool *continuous) const;

private Q_SLOTS:
    void presentFrame(QVideoFrame frame, const qreal t);

private:
    float bandwidthFactor;
    QCamera::Status m_status;
    QAbstractVideoSurface *m_surface;
	QMutex surfaceMutex;
	QString deviceName;

    // Source (camera)
	uvc_context_t* ctx;
	uvc_device_t *dev;
    uvc_device_handle_t *devh;
    uvc_stream_ctrl_t ctrl;

    // Frame
    QVideoFrame currentFrame;
    unsigned char* yuvBuffer;
    long unsigned int yuvBufferSize;
    QElapsedTimer frameReference;

    // capabilities
    QList<QCameraViewfinderSettings> m_supportedViewfinderSettings;
    void updateSourceCapabilities();
	QCameraViewfinderSettings settings;
    bool qPixelFormat2UVCFrameFormat(const QVideoFrame::PixelFormat &qFormat, uvc_frame_format &uvcFormat);

    static QMutex sessionMutex;

	// device availability
	static QMap<QString,bool> UVCCameraSession::devices;
	static QMutex UVCCameraSession::devicesMutex;
	bool acquire(const QString &device);
	void release(const QString &device);
};

QT_END_NAMESPACE


#endif // UVCCAMERASESSION_H