dspinterface.h

Go to the documentation of this file.

/*******************************************************************************
  Copyright(c) 2017 Ilia Platone, Jasem Mutlaq. All rights reserved.
 
 DSP plugin Interface
 
 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Library General Public
 License version 2 as published by the Free Software Foundation.
 
 This library 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
 Library General Public License for more details.
 
 You should have received a copy of the GNU Library General Public License
 along with this library; see the file COPYING.LIB.  If not, write to
 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 Boston, MA 02110-1301, USA.
*******************************************************************************/
 
#pragma once
 
#include "indidevapi.h"
#include "dsp.h"
 
#include <fitsio.h>
#include <functional>
#include <string>
#include <cstdint>
 
namespace INDI
{
class DefaultDevice;
}
 
namespace DSP
{
extern const char *DSP_TAB;
class Interface
{
    public:
        typedef enum
        {
            DSP_NONE = 0,
            DSP_DFT,
            DSP_IDFT,
            DSP_CONVOLUTION,
            DSP_WAVELETS,
            DSP_SPECTRUM,
            DSP_HISTOGRAM,
        } Type;
 
        virtual void ISGetProperties(const char *dev);
        virtual bool ISNewSwitch(const char *dev, const char *name, ISState *states, char *names[], int n);
        virtual bool ISNewNumber(const char *dev, const char *name, double values[], char *names[], int n);
        virtual bool ISNewText(const char *dev, const char *name, char *texts[], char *names[], int n);
        virtual bool ISNewBLOB(const char *dev, const char *name, int sizes[], int blobsizes[], char *blobs[], char *formats[],
                               char *names[], int n);
        virtual bool saveConfigItems(FILE *fp);
        virtual bool updateProperties();
 
        virtual bool processBLOB(uint8_t* buf, uint32_t ndims, int* dims, int bits_per_sample);
 
        void setSizes(uint32_t num, int* sizes)
        {
            BufferSizes = sizes;
            BufferSizesQty = num;
        }
 
        void getSizes(uint32_t *num, int** sizes)
        {
            *sizes = BufferSizes;
            *num = BufferSizesQty;
        }
 
        void setBPS(int bps)
        {
            BPS = bps;
        }
 
        int getBPS()
        {
            return BPS;
        }
 
        void setCaptureFileExtension(const char *ext);
 
    protected:
 
        virtual void Activated();
 
        virtual void Deactivated();
 
        virtual uint8_t* Callback(uint8_t* buf, uint32_t ndims, int* dims, int bits_per_sample);
 
        dsp_stream_p loadFITS(char* buf, int len);
 
        bool PluginActive;
 
        IBLOBVectorProperty FitsBP;
        IBLOB FitsB;
 
        ISwitchVectorProperty ActivateSP;
        ISwitch ActivateS[2];
 
        //  We are going to snoop these from a telescope
        INumberVectorProperty EqNP;
        INumber EqN[2];
 
        ITextVectorProperty ActiveDeviceTP;
        IText ActiveDeviceT[4] {};
 
        Interface(INDI::DefaultDevice *dev, Type type = DSP_NONE, const char *name = "DSP_PLUGIN",
                  const char *label = "DSP Plugin");
        virtual ~Interface();
 
        const char *getDeviceName();
        INDI::DefaultDevice *m_Device {  nullptr };
        const char *m_Name {  nullptr };
        const char *m_Label {  nullptr };
        Type m_Type {  DSP_NONE };
        bool setStream(void *buf, uint32_t dims, int *sizes, int bits_per_sample);
        bool setMagnitude(void *buf, uint32_t dims, int *sizes, int bits_per_sample);
        bool setPhase(void *buf, uint32_t dims, int *sizes, int bits_per_sample);
        bool setReal(void *buf, uint32_t dims, int *sizes, int bits_per_sample);
        bool setImaginary(void *buf, uint32_t dims, int *sizes, int bits_per_sample);
        uint8_t *getStream();
        uint8_t *getMagnitude();
        uint8_t *getPhase();
        uint8_t *getReal();
        uint8_t *getImaginary();
        uint8_t* getBuffer(dsp_stream_p in, uint32_t *dims, int **sizes);
        dsp_stream_p stream;
 
    private:
        char captureExtention[MAXINDIBLOBFMT] { "fits" };
        void *buffer { nullptr };
        uint32_t BufferSizesQty {0 };
        int *BufferSizes { nullptr };
        int BPS { 16 };
 
        void fits_update_key_s(fitsfile *fptr, int type, std::string name, void *p, std::string explanation, int *status);
        void addFITSKeywords(fitsfile *fptr);
        bool sendFITS(uint8_t *buf, bool sendCapture, bool saveCapture);
        bool uploadFile(const void *fitsData, size_t totalBytes, bool sendIntegration, bool saveIntegration, const char* format);
        int getFileIndex(const char *dir, const char *prefix, const char *ext);
};
}