Send raw data to QAudioOutput.

[tobias.hunger]

RTP defines all values to be transmitted in big-endian, so no surprise there;-)

http://developer.qt.nokia.com/doc/qt-4.8/qtendian.html to the rescue.

[Anticross]

OK, thanks. Another question: I have @unsigned char const* data@ with size @unsigned dataSize@ , qFromBigEndian needs to chose type (qInt16,qInt32,qInt64), and returns value of it's type, but how can I put this data back into unsigned char const* array with size of dataSize ?

[Anticross]

This does not helped:
@
char * dt = new char[dataSize];
itoa(qFromBigEndian<qint16>(data),dt,2);
m_buf->writeData((const char*)dt,dataSize);
delete dt;
@

[Anticross]

Edited to :
@qint16 val = qFromBigEndian<qint16>(data);
uchar* dt = new uchar[dataSize];
qToLittleEndian<qint16>(val,dt);
m_buf->writeData((const char*)dt,dataSize);
delete dt;@
But the quality of audio is worse then without conversation.

[Anticross]

I write function:
@bool SpeakerSink::toLittleEndian( const char * src, int size, int nBits)
{
if(src == NULL)
return false;

for (int i = 0; i < size; i+=nBits) {
    qint16 val = qFromBigEndian<qint16>((const uchar*)(src+i));
    qMemCopy((void*)(src+i),&val,nBits);
}

return true;

}@
It solve task of converting from big-endian to little-endian and in headphones I get the same result(I mean sound is recognizable but bad quality) as if my server will transmit data without conversation to big-endian. But sound still distorted and interrupts.

[Anticross]

I open VLC player and receive this stream normally, then I look at codec details and see some PCM S16BE(twos). So what is it and can I transform data to play normal PCM on QAudioOutput ? So is it 16-bit Big-endian pcm or something else? What means S ?

[Anticross]

I record output of my sound card when receiving stream with sine of 1000 Hz. After opening it in Sound Forge I see pauses in this sine with delays from 5 ms to 25 ms but sine has the same shape(I mean no distortions).

[tobias.hunger]

Sorry, no idea what kind of data you send around your network;-)

Why do you have nBits in the toLittleEndian method shown above? Anything but nBits == 2 breaks the method, doesn't it? The name is rather confusing, too... shouldn't it at least be nBytes?

[Anticross]

You're right the name must be at least nBytes :) Maybe QAudioOutput reads the buffer faster than it writes by receiving data from network, and I just need to wait some time before playing.

[Anticross]

I rewrite my audio buffer class. Now it looks like this:
@#ifndef AUDIOBUFFER_H
#define AUDIOBUFFER_H

#include <QAudioFormat>
#include <QIODevice>
#include <QMutex>
#include <QDebug>

class AudioBuffer : public QIODevice
{
Q_OBJECT

public:
//----------------------------------------------------------------------------------------------------------------------------------
AudioBuffer(/const QAudioFormat &format,/ QObject parent = NULL, int bufSize = 1400) : QIODevice(parent)
{
m_bufSize = bufSize4;

    m_buffer1 = new const char[m_bufSize];
    m_buffer2 = new const char[m_bufSize];

    m_rightOffset = 0;
    m_leftOffset  = 0;
    m_cursor      = 0;

    qMemSet((void *)m_buffer1,0,m_bufSize);

}

//----------------------------------------------------------------------------------------------------------------------------------
~AudioBuffer()
{
delete m_buffer1;
delete m_buffer2;
}
//----------------------------------------------------------------------------------------------------------------------------------
void start()
{
if(!isOpen())
open(QIODevice::ReadWrite);
}
//----------------------------------------------------------------------------------------------------------------------------------
void stop()
{
close();
}
//----------------------------------------------------------------------------------------------------------------------------------
qint64 readData(char * data, qint64 len)
{
int free2end = m_bufSize-m_cursor;

    if(len <= free2end){
        qMemCopy(data,m_buffer1+m_cursor,len);

        m_rightOffset += len;
        m_cursor += len;

        return len;
    }
    else
    {
        qMemCopy(data,m_buffer1+m_cursor,free2end);

        m_cursor = 0;

        qMemCopy(data+free2end,m_buffer1,len-free2end);

        m_rightOffset = len-free2end;
        m_leftOffset = 0;
        m_cursor += m_rightOffset;

        return len;
    }

    return 0;
}

//----------------------------------------------------------------------------------------------------------------------------------
qint64 writeData(const char *data, qint64 len)
{
int free2end = m_bufSize-m_rightOffset;

    if(len <= free2end) // if we don't reach end of buffer
    {
        qMemCopy((void*)(m_buffer1+m_rightOffset),data,len);
        m_rightOffset += len;

        qDebug() << m_buffer1;

        return len;
    }
    else if(len <= (m_leftOffset+free2end))
    {
        qMemCopy((void*)(m_buffer1+m_rightOffset),data,free2end); //write to end
        m_leftOffset = len-free2end; // need to write more from source and set new left offset
        qMemCopy((void*)m_buffer1,data+free2end,m_leftOffset); //write lefted part 
        m_rightOffset = m_leftOffset; // set new right offset value
        m_leftOffset  = 0; // set new left offset value

        qDebug() << m_buffer1;

        return len;
    }
    else
    {
        qMemCopy((void*)(m_buffer1+m_rightOffset),data,free2end); //write to end
        m_rightOffset += len-free2end; // need to write more from source

        len -= free2end;

        qMemCopy((void*)m_buffer1,data+free2end,m_leftOffset); //write lefted part 
        m_rightOffset = 0; // set new right offset value

        len -= m_leftOffset;

        m_leftOffset = 0;

        qDebug() << m_buffer1;

        return len;
    }

    return 0;
}

//----------------------------------------------------------------------------------------------------------------------------------
private:
const char * m_buffer1;
const char * m_buffer2;
int m_rightOffset;
int m_leftOffset;
int m_cursor;
int m_bufSize;
};

#endif//AUDIOBUFFER_H@
And now I'm using it like this:
@m_output->start(m_buf);@
and it enters write data functions, but doesn't reads data. So question: How QAudioOutput asks for the data to play from QIODevice ? Is it call readData function or not ? And one more question: Is it possible to play rtsp stream using Phonon ?

[Anticross]

One more question whats the main difference between push and pull mode of playing ?

[Anticross]

Interesting thing: when I play 22050 Hz 16 bit 2 channels audio stream - it plays normally without interruptions, but when playing 44100 Hz 16 bit stereo - not. If I open same stream(44 kHz) in VLC player or any other it plays normally without interruptions.

[billconan]

this is an interesting thread. a QAudioOuput from a buffer example should be added to the document.

too bad the document only has an example of playing a file.

[billconan]

has this issue been resolved yet? I also need to achieve the same thing?

[billconan]

has this issue been resolved yet? I also need to achieve the same thing?

[lynic]

I had a similar problem using a ringbuffer as a QIODevice backend for which I spent a whole day. The solution was to override the following method:

@bool isSequential() const
{
return true;
}@

[lynic]

I had a similar problem using a ringbuffer as a QIODevice backend for which I spent a whole day. The solution was to override the following method:

@bool isSequential() const
{
return true;
}@