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 #include <libsigrokdecode/libsigrokdecode.h>
  28
  29 namespace Srf
  30 {
  31
  32 using namespace std;
  33
  34 void init();
  35
  36 class Block
  37 {
  38         /* Config API etc goes here */
  39 };
  40
  41 class Sink :
  42         public Gst::BaseSink
  43 {
  44 protected:
  45         explicit Sink(GstBaseSink *gobj);
  46 };
  47
  48 class Device :
  49         public Gst::Element
  50 {
  51         /* Operations specific to hardware devices go here */
  52 protected:
  53         explicit Device(GstElement *gobj);
  54 };
  55
  56 class CaptureDevice :
  57         public Device
  58 {
  59         /* Operations specific to capture (source) devices go here */
  60 protected:
  61         explicit CaptureDevice(GstElement *gobj);
  62 };
  63
  64 class LegacyCaptureDevice :
  65         public CaptureDevice
  66 {
  67 public:
  68         /* Create from libsigrok device object */
  69         static Glib::RefPtr<LegacyCaptureDevice> create(
  70                 shared_ptr<sigrok::HardwareDevice> libsigrok_device);
  71
  72         /* Retrieve libsigrok device object */
  73         shared_ptr<sigrok::HardwareDevice> libsigrok_device();
  74
  75         /* Override state change */
  76         Gst::StateChangeReturn change_state_vfunc(Gst::StateChange transition);
  77
  78         /* Gst class init */
  79         static void class_init(Gst::ElementClass<LegacyCaptureDevice> *klass);
  80
  81         /* Register class with plugin */
  82         static bool register_element(Glib::RefPtr<Gst::Plugin> plugin);
  83
  84         /* Construcor used by element factory */
  85         explicit LegacyCaptureDevice(GstElement *gobj);
  86 private:
  87         shared_ptr<sigrok::HardwareDevice> _libsigrok_device;
  88         Glib::RefPtr<Gst::Pad> _src_pad;
  89         Glib::Threads::RecMutex _mutex;
  90         Glib::RefPtr<Gst::Task> _task;
  91         shared_ptr<sigrok::Session> _session;
  92
  93         void _datafeed_callback(shared_ptr<sigrok::Device> device,
  94                         shared_ptr<sigrok::Packet> packet);
  95         void _run();
  96 };
  97
  98 class LegacyOutput :
  99         public Sink
 100 {
 101 public:
 102         /* Create from libsigrok output object */
 103         static Glib::RefPtr<LegacyOutput> create(
 104                 shared_ptr<sigrok::OutputFormat> libsigrok_output_format,
 105                 shared_ptr<sigrok::Device> libsigrok_device,
 106                 map<string, Glib::VariantBase> options = map<string, Glib::VariantBase>());
 107
 108         /* Override start */
 109         bool start_vfunc();
 110
 111         /* Override render */
 112         Gst::FlowReturn render_vfunc(const Glib::RefPtr<Gst::Buffer> &buffer);
 113
 114         /* Override stop */
 115         bool stop_vfunc();
 116
 117         /* Gst class init */
 118         static void class_init(Gst::ElementClass<LegacyOutput> *klass);
 119
 120         /* Register class with plugin */
 121         static bool register_element(Glib::RefPtr<Gst::Plugin> plugin);
 122
 123         /* Constructor used by element factory */
 124         explicit LegacyOutput(GstBaseSink *gobj);
 125 private:
 126         shared_ptr<sigrok::OutputFormat> _libsigrok_output_format;
 127         shared_ptr<sigrok::Device> _libsigrok_device;
 128         shared_ptr<sigrok::Output> _libsigrok_output;
 129         map<string, Glib::VariantBase> _options;
 130 };
 131
 132 class LegacyDecoder :
 133         public Sink
 134 {
 135 public:
 136         static Glib::RefPtr<LegacyDecoder> create(
 137                 struct srd_session *libsigrokdecode_session, uint64_t unitsize);
 138
 139         /* Retrieve libsigrokdecode session */
 140         struct srd_session *libsigrokdecode_session();
 141
 142         /* Override start */
 143         bool start_vfunc();
 144
 145         /* Override render */
 146         Gst::FlowReturn render_vfunc(const Glib::RefPtr<Gst::Buffer> &buffer);
 147
 148         /* Override stop */
 149         bool stop_vfunc();
 150
 151         /* Gst class init */
 152         static void class_init(Gst::ElementClass<LegacyDecoder> *klass);
 153
 154         /* Register class with plugin */
 155         static bool register_element(Glib::RefPtr<Gst::Plugin> plugin);
 156
 157         /* Constructor used by element factory */
 158         explicit LegacyDecoder(GstBaseSink *gobj);
 159 private:
 160         struct srd_session *_session;
 161         uint64_t _abs_ss;
 162         uint64_t _unitsize;
 163 };
 164
 165 }
 166 #endif