Skip to content
  • Categories
  • Recent
  • Tags
  • Popular
  • Users
  • Groups
  • Search
  • Get Qt Extensions
  • Unsolved
Collapse
Brand Logo
  1. Home
  2. Qt Development
  3. General and Desktop
  4. Send raw data to QAudioOutput.
Forum Updated to NodeBB v4.3 + New Features

Send raw data to QAudioOutput.

Scheduled Pinned Locked Moved General and Desktop
21 Posts 4 Posters 15.7k Views 1 Watching
  • Oldest to Newest
  • Newest to Oldest
  • Most Votes
Reply
  • Reply as topic
Log in to reply
This topic has been deleted. Only users with topic management privileges can see it.
  • A Offline
    A Offline
    Anticross
    wrote on last edited by
    #10

    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 ?

    1 Reply Last reply
    0
    • A Offline
      A Offline
      Anticross
      wrote on last edited by
      #11

      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).

      1 Reply Last reply
      0
      • T Offline
        T Offline
        tobias.hunger
        wrote on last edited by
        #12

        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?

        1 Reply Last reply
        0
        • A Offline
          A Offline
          Anticross
          wrote on last edited by
          #13

          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.

          1 Reply Last reply
          0
          • A Offline
            A Offline
            Anticross
            wrote on last edited by
            #14

            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 = bufSize
            4;

                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 ?

            1 Reply Last reply
            0
            • A Offline
              A Offline
              Anticross
              wrote on last edited by
              #15

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

              1 Reply Last reply
              0
              • A Offline
                A Offline
                Anticross
                wrote on last edited by
                #16

                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.

                1 Reply Last reply
                0
                • B Offline
                  B Offline
                  billconan
                  wrote on last edited by
                  #17

                  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.

                  1 Reply Last reply
                  0
                  • B Offline
                    B Offline
                    billconan
                    wrote on last edited by
                    #18

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

                    1 Reply Last reply
                    0
                    • B Offline
                      B Offline
                      billconan
                      wrote on last edited by
                      #19

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

                      1 Reply Last reply
                      0
                      • L Offline
                        L Offline
                        lynic
                        wrote on last edited by
                        #20

                        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;
                        }@

                        1 Reply Last reply
                        0
                        • L Offline
                          L Offline
                          lynic
                          wrote on last edited by
                          #21

                          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;
                          }@

                          1 Reply Last reply
                          0

                          • Login

                          • Login or register to search.
                          • First post
                            Last post
                          0
                          • Categories
                          • Recent
                          • Tags
                          • Popular
                          • Users
                          • Groups
                          • Search
                          • Get Qt Extensions
                          • Unsolved