VideoInputGst.h

Go to the documentation of this file.

// VideoInput.h: Video input processing using Gstreamer
// 
//   Copyright (C) 2007, 2008, 2009, 2010, 2011, 2012
//   Free Software Foundation, Inc.
// 
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

#ifndef GNASH_VIDEOINPUTGST_H
#define GNASH_VIDEOINPUTGST_H

#include <vector>
#include <boost/cstdint.hpp> // for C99 int types
#include "VideoInput.h"
#include "gst/gst.h"

namespace gnash {
namespace media {
namespace gst {

class GnashWebcam;
class GnashWebcamPrivate;

class FramerateFraction
{
public:
    gint numerator;
    gint denominator;
    
    FramerateFraction(gint num, gint denom);
    
    FramerateFraction();
};

class WebcamVidFormat
{
public:
    gchar *mimetype;
    
    gint   width;
    
    gint   height;
    
    gint   numFramerates;
    
    FramerateFraction *framerates;
    
    FramerateFraction highestFramerate;
    
    WebcamVidFormat();
};


class VideoInputGst : public VideoInput
{
public:
 
    VideoInputGst();
    
    ~VideoInputGst();
    
    static void getNames(std::vector<std::string>& names);
    
    //
    double activityLevel () const { return _activityLevel; }
    
    //
    size_t bandwidth() const { return _bandwidth; }
    
    void setBandwidth(size_t bandwidth) {
        _bandwidth = bandwidth;
    }

    //
    double currentFPS() const { return _currentFPS; }
    
    //
    double fps() const { return _fps; }

    size_t height() const { return _height; }
    
    size_t width() const { return _width; }
    
    size_t index() const { return _index; }
    
    //
    void requestMode(size_t width, size_t height, double fps, bool favorArea);

    void setMotionLevel(int m) { _motionLevel = m; }

    int motionLevel() const { return _motionLevel; }
    
    void setMotionTimeout(int m) { _motionTimeout = m; }

    int motionTimeout() const { return _motionTimeout; }
    
    void mute(bool m) { _muted = m; }
    bool muted() const { return _muted; }
    
    //
    const std::string& name() const { return _name; }

    void setQuality(int q) { _quality = q; }

    int quality() const { return _quality; }
    
    bool play();
    
    bool stop();
    

    //
    bool setWebcam(size_t index);
    
    //
    //
    bool init();
    
    int makeWebcamDeviceSelection();
    
    
    gboolean webcamMakeVideoSaveLink();

    gboolean webcamBreakVideoSaveLink();

    gboolean webcamCreateSaveBin();
    
    gboolean webcamMakeVideoDisplayLink();
    
    gboolean webcamBreakVideoDisplayLink();

private:

    
    void getSelectedCaps(gint dev_select);
    
    void getSupportedFormats(GnashWebcam *cam, GstCaps *caps);
    
    void addSupportedFormat(GnashWebcam *cam, WebcamVidFormat *video_format,
        GstStructure *format_structure);
    
    void getSupportedFramerates(WebcamVidFormat *video_format,
            GstStructure *structure);

    gboolean checkForSupportedFramerate (GnashWebcamPrivate *webcam, int fps);

    void findHighestFramerate(WebcamVidFormat *format);
    
    gboolean webcamCreateSourceBin();
    
    gboolean webcamChangeSourceBin();
    
    gboolean webcamCreateMainBin();
    
    gboolean webcamCreateDisplayBin();
    
    
    
    GnashWebcamPrivate* getGlobalWebcam() {return _globalWebcam;}
    
    //
    static void findVidDevs(std::vector<GnashWebcam*>& cams);
    
    std::vector<GnashWebcam*> _vidVect;
    
    int _devSelection;
    
    gint _numdevs;
    
    GnashWebcamPrivate *_globalWebcam;


    double _activityLevel;

    size_t _bandwidth;

    double _currentFPS;

    double _fps;

    size_t _height;

    size_t _width;

    size_t _index;

    int _motionLevel;

    int _motionTimeout;

    bool _muted;

    std::string _name;

    int _quality;

};




} //gst namespace
} // gnash.media namespace 
} // gnash namespace

#endif