cam_gst.h

Go to the documentation of this file.

/*
 * \file    cam_gst.h
 *  
 * \brief   Allows to create a default GStreamer pipeline, which requests images using v4l2, 
 *          converts them to jpegs and gives access to the image data. 
 *          
 *          German Research Center for Artificial Intelligence\n
 *          Project: Rimres
 *
 * \date    23.11.11
 *
 * \author  Stefan.Haase@dfki.de
 */

#ifndef _CAM_GST_CONFIG_H_
#define _CAM_GST_CONFIG_H_

#include <glib.h>
#include <gst/app/gstappsink.h>
#include <gst/gst.h>

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include <time.h>

#include <iostream>

#include "cam_config.h"
#include <base/samples/Frame.hpp>

namespace camera 
{

class CamGstException : public std::runtime_error {
 public:
    CamGstException(const std::string& what_arg) : std::runtime_error(what_arg) {}
};

class CamGst {

 public: // CONSTANTS
    static const uint32_t DEFAULT_WIDTH = 640;
    static const uint32_t DEFAULT_HEIGHT = 480;
    static const uint32_t DEFAULT_FPS = 10;
    static const uint32_t DEFAULT_BPP = 24;
    static const uint32_t DEFAULT_JPEG_QUALITY = 85; // 0 to 100
    static const uint32_t DEFAULT_PIPELINE_TIMEOUT = 4000000; // 4 sec.

 public:
    CamGst(std::string const& device);

    ~CamGst();

    void createDefaultPipeline(bool check_for_valid_params=false,
            uint32_t width = DEFAULT_WIDTH, 
            uint32_t height = DEFAULT_HEIGHT, 
            uint32_t fps = DEFAULT_FPS,
            uint32_t bpp = DEFAULT_BPP,
            base::samples::frame::frame_mode_t mode = base::samples::frame::MODE_UNDEFINED,
            uint32_t jpeg_quality = DEFAULT_JPEG_QUALITY);

    void deletePipeline();

    bool startPipeline();

    void stopPipeline();

    bool getBuffer(std::vector<uint8_t>& buffer, 
            bool blocking_read=false, int32_t timeout=0);

    bool skipBuffer();

    bool storeImageToFile(std::vector<uint8_t> const& buffer, 
            std::string const& file_name);

    inline bool hasNewBuffer() {
        return mNewBuffer;
    }

    inline bool isPipelineRunning() {
        return mPipelineRunning;
    }

    inline int getFileDescriptor() {
        return mFileDescriptor;
    }

 private:
    CamGst();

    void setCameraParameters(uint32_t* width, uint32_t* height, uint32_t* fps);

    GstElement* createDefaultSource(std::string const& device);

    GstElement* createDefaultCap(uint32_t const width, uint32_t const height, uint32_t const fps, uint32_t bpp, base::samples::frame::frame_mode_t mode );

    GstElement* createDefaultEncoder(int32_t const jpeg_quality);

    GstElement* createDefaultSink();

    bool readFileDescriptor();

    inline void rmFileDescriptor() {
        mFileDescriptor = -1;
        std::cout << "FD set back to -1" << std::endl;
    }

 private: // STATIC METHODS
    static void* mainLoop(void* ptr);

    static gboolean callbackMessagesStatic(GstBus* bus, GstMessage* msg, gpointer data);

    gboolean callbackMessages(GstBus* bus, GstMessage* msg, gpointer data);

    static void callbackNewBufferStatic(GstElement* object, CamGst* cam_gst_p); 
    
    void callbackNewBuffer(GstElement* object, CamGst* cam_gst_p); 

    void printElementFactories();

 private:
    std::string mDevice;
    uint32_t mJpegQuality;
    GMainLoop* mLoop;
    pthread_t* mMainLoopThread;
    GstElement* mPipeline;
    GstBus* mGstPipelineBus;
    bool mPipelineRunning;

    pthread_mutex_t mMutexBuffer;
    GstBuffer* mBuffer;
    uint32_t mBufferSize;
    bool mNewBuffer;

    GstElement* mSource; // Used to request the fd.
    int mFileDescriptor; // File descriptor of the pipeline source. -1 if not available.
    
    base::samples::frame::frame_mode_t mRequestedFrameMode;

    class InitGuard {
    public:
        InitGuard();
        ~InitGuard();
    };

};

} // end namespace camera

#endif