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.

  serialplot 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 serialplot.  If not, see <http://www.gnu.org/licenses/>.

*/

#include <QtEndian>

#include <QtDebug>

#include "binarystreamreader.h"

#include "floatswap.h"

BinaryStreamReader::BinaryStreamReader(QIODevice* device, ChannelManager* channelMan, QObject *parent) :

    AbstractReader(device, channelMan, parent)

{

    paused = false;

    skipByteRequested = false;

    sampleCount = 0;

    _numOfChannels = _settingsWidget.numOfChannels();

    connect(&_settingsWidget, &BinaryStreamReaderSettings::numOfChannelsChanged,

            this, &BinaryStreamReader::numOfChannelsChanged);

    connect(&_settingsWidget, &BinaryStreamReaderSettings::numOfChannelsChanged,

            this, &BinaryStreamReader::onNumOfChannelsChanged);

    // initial number format selection

    onNumberFormatChanged(_settingsWidget.numberFormat());

    connect(&_settingsWidget, &BinaryStreamReaderSettings::numberFormatChanged,

            this, &BinaryStreamReader::onNumberFormatChanged);

    connect(&_settingsWidget, &BinaryStreamReaderSettings::skipByteRequested,

            [this]()

            {

                skipByteRequested = true;

            });

}

QWidget* BinaryStreamReader::settingsWidget()

{

    return &_settingsWidget;

}

unsigned BinaryStreamReader::numOfChannels()

{

    return _numOfChannels;

}

void BinaryStreamReader::enable(bool enabled)

{

    if (enabled)

    {

        QObject::connect(_device, &QIODevice::readyRead,

                         this, &BinaryStreamReader::onDataReady);

    }

    else

    {

        QObject::disconnect(_device, 0, this, 0);

    }

}

            readSample = &BinaryStreamReader::readSampleAs<quint32>;

            break;

        case NumberFormat_int32:

            sampleSize = 4;

            readSample = &BinaryStreamReader::readSampleAs<qint32>;

            break;

        case NumberFormat_float:

            sampleSize = 4;

            readSample = &BinaryStreamReader::readSampleAs<float>;

            break;

    }

}

void BinaryStreamReader::onNumOfChannelsChanged(unsigned value)

{

    _numOfChannels = value;

}

void BinaryStreamReader::onDataReady()

{

    // a package is a set of channel data like {CHAN0_SAMPLE, CHAN1_SAMPLE...}

    int packageSize = sampleSize * _numOfChannels;

    int bytesAvailable = _device->bytesAvailable();

    if (bytesAvailable > 0 && skipByteRequested)

    {

        _device->read(1);

        skipByteRequested = false;

        bytesAvailable--;

    }

    if (bytesAvailable < packageSize) return;

    int numOfPackagesToRead =

        (bytesAvailable - (bytesAvailable % packageSize)) / packageSize;

    if (paused)

    {

        // read and discard data

        _device->read(numOfPackagesToRead*packageSize);

        return;

    }

    double* channelSamples = new double[numOfPackagesToRead*_numOfChannels];

    for (int i = 0; i < numOfPackagesToRead; i++)

    {

        for (unsigned int ci = 0; ci < _numOfChannels; ci++)

        {

            // channelSamples[ci].replace(i, (this->*readSample)());

            channelSamples[ci*numOfPackagesToRead+i] = (this->*readSample)();

        }

    }

    for (unsigned int ci = 0; ci < _numOfChannels; ci++)

/**

 * Reads a simple stream of samples in binary form from the

 * device. There is no means of synchronization other than a button

 * that should be manually triggered by user.

 */

class BinaryStreamReader : public AbstractReader

{

    Q_OBJECT

public:

    explicit BinaryStreamReader(QIODevice* device, ChannelManager* channelMan, QObject *parent = 0);

    QWidget* settingsWidget();

    unsigned numOfChannels();

    void enable(bool enabled = true);

public slots:

    void pause(bool);

private:

    BinaryStreamReaderSettings _settingsWidget;

    unsigned _numOfChannels;

    unsigned sampleSize;

    bool paused;

    bool skipByteRequested;

    /// points to the readSampleAs function for currently selected number format

    double (BinaryStreamReader::*readSample)();

    /**

     * Reads 1 sample from the device in given format.

     *

     * @note Device should already have enough bytes present before

     * calling this function.

     */

    template<typename T> double readSampleAs();

    // `data` contains i th channels data

    void addChannelData(unsigned int channel, double* data, unsigned size);

private slots:

    void onNumberFormatChanged(NumberFormat numberFormat);

    void onNumOfChannelsChanged(unsigned value);

    void onDataReady();

};

#endif // BINARYSTREAMREADER_H

*/

#include "binarystreamreadersettings.h"

#include "ui_binarystreamreadersettings.h"

#include "utils.h"

BinaryStreamReaderSettings::BinaryStreamReaderSettings(QWidget *parent) :

    QWidget(parent),

    ui(new Ui::BinaryStreamReaderSettings)

{

    ui->setupUi(this);

    // Note: if directly connected we get a runtime warning on incompatible signal arguments

    connect(ui->spNumOfChannels, SELECT<int>::OVERLOAD_OF(&QSpinBox::valueChanged),

            [this](int value)

            {

                emit numOfChannelsChanged(value);

            });

    connect(ui->nfBox, SIGNAL(selectionChanged(NumberFormat)),

            this, SIGNAL(numberFormatChanged(NumberFormat)));

    connect(ui->pbSkipByte, SIGNAL(clicked()), this, SIGNAL(skipByteRequested()));

}

BinaryStreamReaderSettings::~BinaryStreamReaderSettings()

{

    delete ui;

}

unsigned BinaryStreamReaderSettings::numOfChannels()

{

    return ui->spNumOfChannels->value();

}

NumberFormat BinaryStreamReaderSettings::numberFormat()

{

    return ui->nfBox->currentSelection();

}

Endianness BinaryStreamReaderSettings::endianness()

{

    return ui->endiBox->currentSelection();

}

#include <QWidget>

#include "numberformatbox.h"

#include "endiannessbox.h"

namespace Ui {

class BinaryStreamReaderSettings;

}

class BinaryStreamReaderSettings : public QWidget

{

    Q_OBJECT

public:

    explicit BinaryStreamReaderSettings(QWidget *parent = 0);

    ~BinaryStreamReaderSettings();

    unsigned numOfChannels();

    NumberFormat numberFormat();

    Endianness endianness();

signals:

    void numOfChannelsChanged(unsigned);

    void numberFormatChanged(NumberFormat);

    void skipByteRequested();

private:

    Ui::BinaryStreamReaderSettings *ui;

};

#endif // BINARYSTREAMREADERSETTINGS_H

       <property name="minimum">

        <number>1</number>

       </property>

       <property name="maximum">

        <number>32</number>

       </property>

      </widget>

     </item>

     <item>

      <spacer name="horizontalSpacer">

       <property name="orientation">

        <enum>Qt::Horizontal</enum>

       </property>

       <property name="sizeHint" stdset="0">

        <size>

         <width>40</width>

         <height>20</height>

        </size>

       </property>

      </spacer>

     </item>

     <item>

      <widget class="QPushButton" name="pbSkipByte">

       <property name="toolTip">

       </property>

       <property name="text">

        <string>Skip Byte</string>

       </property>

      </widget>

     </item>

    </layout>

   </item>

   <item>

    <layout class="QFormLayout" name="formLayout">

     <property name="fieldGrowthPolicy">

      <enum>QFormLayout::FieldsStayAtSizeHint</enum>

     </property>

     <property name="horizontalSpacing">

      <number>3</number>

     </property>

     <item row="0" column="0">

      <widget class="QLabel" name="label_5">

       <property name="sizePolicy">

        <sizepolicy hsizetype="Minimum" vsizetype="Fixed">

         <horstretch>0</horstretch>

         <verstretch>0</verstretch>

        </sizepolicy>

       </property>

       <property name="text">

        <string>Number Type:</string>

       </property>

      </widget>

     </item>

     <item row="1" column="0">