include/libsigrokflow/libsigrokflow.hpp

   1 /*
   2  * This file is part of the libsigrokflow project.
   3  *
   4  * Copyright (C) 2018 Uwe Hermann <uwe@hermann-uwe.de>
   5  *
   6  * This program is free software: you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation, either version 3 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #ifndef LIBSIGROKFLOW_LIBSIGROKFLOW_HPP
  21 #define LIBSIGROKFLOW_LIBSIGROKFLOW_HPP
  22
  23 #include <gstreamermm.h>
  24 #include <gstreamermm/private/element_p.h>
  25 #include <gstreamermm/private/basesink_p.h>
  26 #include <libsigrokcxx/libsigrokcxx.hpp>
  27
  28 namespace Srf
  29 {
  30
  31 using namespace std;
  32
  33 void init();
  34
  35 class Block
  36 {
  37         /* Config API etc goes here */
  38 };
  39
  40 class Sink :
  41         public Gst::BaseSink
  42 {
  43 protected:
  44         explicit Sink(GstBaseSink *gobj);
  45 };
  46
  47 class Device :
  48         public Gst::Element
  49 {
  50         /* Operations specific to hardware devices go here */
  51 protected:
  52         explicit Device(GstElement *gobj);
  53 };
  54
  55 class CaptureDevice :
  56         public Device
  57 {
  58         /* Operations specific to capture (source) devices go here */
  59 protected:
  60         explicit CaptureDevice(GstElement *gobj);
  61 };
  62
  63 class LegacyCaptureDevice :
  64         public CaptureDevice
  65 {
  66 public:
  67         /* Create from libsigrok device object */
  68         static Glib::RefPtr<LegacyCaptureDevice> create(
  69                 shared_ptr<sigrok::HardwareDevice> libsigrok_device);
  70
  71         /* Retrieve libsigrok device object */
  72         shared_ptr<sigrok::HardwareDevice> libsigrok_device();
  73
  74         /* Override state change */
  75         Gst::StateChangeReturn change_state_vfunc(Gst::StateChange transition);
  76
  77         /* Gst class init */
  78         static void class_init(Gst::ElementClass<LegacyCaptureDevice> *klass);
  79
  80         /* Register class with plugin */
  81         static bool register_element(Glib::RefPtr<Gst::Plugin> plugin);
  82
  83         /* Construcor used by element factory */
  84         explicit LegacyCaptureDevice(GstElement *gobj);
  85 private:
  86         shared_ptr<sigrok::HardwareDevice> _libsigrok_device;
  87         Glib::RefPtr<Gst::Pad> _src_pad;
  88         Glib::Threads::RecMutex _mutex;
  89         Glib::RefPtr<Gst::Task> _task;
  90         shared_ptr<sigrok::Session> _session;
  91
  92         void _datafeed_callback(shared_ptr<sigrok::Device> device,
  93                         shared_ptr<sigrok::Packet> packet);
  94         void _run();
  95 };
  96
  97 class LegacyOutput :
  98         public Sink
  99 {
 100 public:
 101         /* Create from libsigrok output object */
 102         static Glib::RefPtr<LegacyOutput> create(
 103                 shared_ptr<sigrok::OutputFormat> libsigrok_output_format,
 104                 shared_ptr<sigrok::Device> libsigrok_device,
 105                 map<string, Glib::VariantBase> options = map<string, Glib::VariantBase>());
 106
 107         /* Override start */
 108         bool start_vfunc();
 109
 110         /* Override render */
 111         Gst::FlowReturn render_vfunc(const Glib::RefPtr<Gst::Buffer> &buffer);
 112
 113         /* Override stop */
 114         bool stop_vfunc();
 115
 116         /* Gst class init */
 117         static void class_init(Gst::ElementClass<LegacyOutput> *klass);
 118
 119         /* Register class with plugin */
 120         static bool register_element(Glib::RefPtr<Gst::Plugin> plugin);
 121
 122         /* Constructor used by element factory */
 123         explicit LegacyOutput(GstBaseSink *gobj);
 124 private:
 125         shared_ptr<sigrok::OutputFormat> _libsigrok_output_format;
 126         shared_ptr<sigrok::Device> _libsigrok_device;
 127         shared_ptr<sigrok::Output> _libsigrok_output;
 128         map<string, Glib::VariantBase> _options;
 129 };
 130
 131
 132 }
 133 #endif