/****************************************************************************

**

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the examples of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include <stdlib.h>

#include <math.h>

#include <QDebug>

#include <QPainter>

#include <QVBoxLayout>

#include <QAudioDeviceInfo>

#include <QAudioInput>

#include "audioinput.h"

#define BUFFER_SIZE 4096

{

    input = device;

    m_maxValue = 0;

}

AudioInfo::~AudioInfo()

{

}

void AudioInfo::start()

{

    open(QIODevice::WriteOnly);

}

void AudioInfo::stop()

{

    close();

}

qint64 AudioInfo::readData(char *data, qint64 maxlen)

{

    Q_UNUSED(data)

    Q_UNUSED(maxlen)

    return 0;

}

qint64 AudioInfo::writeData(const char *data, qint64 len)

{

    int samples = len/2; // 2 bytes per sample

    int maxAmp = 32768; // max for S16 samples

    bool clipping = false;

    m_maxValue = 0;

    // sample format is S16LE, only!

        qint16 sample = *s;

        s++;

    }

    // check for clipping

    float value = ((float)m_maxValue/(float)maxAmp);

    emit update();

    return len;

}

int AudioInfo::LinearMax()

{

    return m_maxValue;

}

RenderArea::RenderArea(QWidget *parent)

    : QWidget(parent)

{

    setBackgroundRole(QPalette::Base);

    setAutoFillBackground(true);

    level = 0;

    setMinimumHeight(30);

    setMinimumWidth(200);

}

void RenderArea::paintEvent(QPaintEvent * /* event */)

{

    QPainter painter(this);

    painter.setPen(Qt::black);

        return;

    painter.setPen(Qt::red);

    int pos = ((painter.viewport().right()-20)-(painter.viewport().left()+11))*level/100;

            x2 = painter.viewport().left()+10;

    }

}

void RenderArea::setLevel(int value)

{

    level = value;

    repaint();

}

InputTest::InputTest()

{

    QWidget *window = new QWidget;

    QVBoxLayout* layout = new QVBoxLayout;

    canvas = new RenderArea;

    layout->addWidget(canvas);

    deviceBox = new QComboBox(this);

    QList<QAudioDeviceInfo> devices = QAudioDeviceInfo::availableDevices(QAudio::AudioInput);

        deviceBox->addItem(devices.at(i).deviceName(), qVariantFromValue(devices.at(i)));

    layout->addWidget(deviceBox);

    button = new QPushButton(this);

    button->setText(tr("Click for Push Mode"));

    layout->addWidget(button);

    button2 = new QPushButton(this);

    button2->setText(tr("Click To Suspend"));

    layout->addWidget(button2);

    window->setLayout(layout);

    setCentralWidget(window);

    window->show();

    buffer = new char[BUFFER_SIZE];

    pullMode = true;

    format.setFrequency(8000);

    format.setChannels(1);

    format.setSampleSize(16);

    format.setSampleType(QAudioFormat::SignedInt);

    format.setByteOrder(QAudioFormat::LittleEndian);

    format.setCodec("audio/pcm");

    QAudioDeviceInfo info(QAudioDeviceInfo::defaultInputDevice());

    if (!info.isFormatSupported(format)) {

        qWarning()<<"default format not supported try to use nearest";

        format = info.nearestFormat(format);

    }

    if(format.sampleSize() != 16) {

        qWarning()<<"audio device doesn't support 16 bit samples, example cannot run";

        return;

    }

    audioInput = new QAudioInput(format,this);

    audioinfo  = new AudioInfo(this,audioInput);

    audioinfo->start();

    audioInput->start(audioinfo);

}

InputTest::~InputTest() {}

void InputTest::status()

{

    qWarning()<<"bytesReady = "<<audioInput->bytesReady()<<" bytes, elapsedUSecs = "<<audioInput->elapsedUSecs()<<", processedUSecs = "<<audioInput->processedUSecs();

}

void InputTest::readMore()

{

    if(!audioInput)

        return;

    qint64 len = audioInput->bytesReady();

    if(len > 4096)

        len = 4096;

    qint64 l = input->read(buffer,len);

    if(l > 0) {

        audioinfo->write(buffer,l);

    }

}

void InputTest::toggleMode()

{

    // Change bewteen pull and push modes

    audioInput->stop();

    if (pullMode) {

        button->setText(tr("Click for Pull Mode"));

        input = audioInput->start();

        pullMode = false;

    } else {

        button->setText(tr("Click for Push Mode"));

        pullMode = true;

        audioInput->start(audioinfo);

    }

}

void InputTest::toggleSuspend()

{

    // toggle suspend/resume

    if(audioInput->state() == QAudio::SuspendedState) {

        audioInput->resume();

        button2->setText("Click To Suspend");

    } else if (audioInput->state() == QAudio::ActiveState) {

        audioInput->suspend();

        button2->setText("Click To Resume");

    } else if (audioInput->state() == QAudio::StoppedState) {

        audioInput->resume();

        button2->setText("Click To Suspend");

    } else if (audioInput->state() == QAudio::IdleState) {

    }

}

void InputTest::state(QAudio::State state)

{

}

void InputTest::refreshDisplay()

{

    canvas->setLevel(audioinfo->LinearMax());

    canvas->repaint();

}

void InputTest::deviceChanged(int idx)

{

    audioinfo->stop();

    audioInput->stop();

    audioInput->disconnect(this);

    delete audioInput;

    device = deviceBox->itemData(idx).value<QAudioDeviceInfo>();

    audioInput = new QAudioInput(device, format, this);

    audioinfo->start();

    audioInput->start(audioinfo);

}