Rawaudio dev

ChangeLog

@@ -1,3 +1,7 @@
+### 3.11.1dev ###
+
+- Add uncompressed audio transmission - dedicated to the memory of Hans Petter Selasky (1982 - 2023)
+
 ### 3.11.0dev <- NOTE: the release version number will be 3.12.0 ###
 
 - Extended SRV record support (#3556).

Jamulus.pro

@@ -1,4 +1,4 @@
-VERSION = 3.11.0dev
+VERSION = 3.11.1dev
 
 # Using lrelease and embed_translations only works for Qt 5.12 or later.
 # See https://github.com/jamulussoftware/jamulus/pull/3288 for these changes.

src/client.cpp

@@ -70,7 +70,8 @@ CClient::CClient ( const quint16  iPortNumber,
     bJitterBufferOK ( true ),
     bEnableIPv6 ( bNEnableIPv6 ),
     bMuteMeInPersonalMix ( bNMuteMeInPersonalMix ),
-    iServerSockBufNumFrames ( DEF_NET_BUF_SIZE_NUM_BL )
+    iServerSockBufNumFrames ( DEF_NET_BUF_SIZE_NUM_BL ),
+    bRawAudioIsSupported ( false )
 {
     int iOpusError;
 
@@ -135,7 +136,7 @@ CClient::CClient ( const quint16  iPortNumber,
 
     QObject::connect ( &Channel, &CChannel::LicenceRequired, this, &CClient::LicenceRequired );
 
-    QObject::connect ( &Channel, &CChannel::VersionAndOSReceived, this, &CClient::VersionAndOSReceived );
+    QObject::connect ( &Channel, &CChannel::VersionAndOSReceived, this, &CClient::OnVersionAndOSReceived );
 
     QObject::connect ( &Channel, &CChannel::RecorderStateReceived, this, &CClient::RecorderStateReceived );
 
@@ -395,6 +396,32 @@ void CClient::OnConClientListMesReceived ( CVector<CChannelInfo> vecChanInfo )
     emit ConClientListMesReceived ( vecChanInfo );
 }
 
+void CClient::OnVersionAndOSReceived ( COSUtil::EOpSystemType eOSType, QString strVersion )
+{
+#if QT_VERSION >= QT_VERSION_CHECK( 5, 6, 0 )
+    const bool bWasRunning = Sound.IsRunning();
+    if ( bWasRunning )
+    {
+        Sound.Stop();
+    }
+    if ( QVersionNumber::compare ( QVersionNumber::fromString ( strVersion ), QVersionNumber ( 3, 11, 1 ) ) == 0 )
+    {
+        bRawAudioIsSupported = true;
+        Init();
+    }
+    else
+    {
+        bRawAudioIsSupported = false;
+        Init();
+    }
+    if ( bWasRunning )
+    {
+        Sound.Start();
+    }
+#endif
+    emit VersionAndOSReceived ( eOSType, strVersion );
+}
+
 void CClient::CreateServerJitterBufferMessage()
 {
     // per definition in the client: if auto jitter buffer is enabled, both,
@@ -1017,6 +1044,10 @@ void CClient::Stop()
     // disable channel
     Channel.SetEnable ( false );
 
+    // Fall back to opus in case raw was used
+    bRawAudioIsSupported = false;
+    Init();
+
     // wait for approx. 100 ms to make sure no audio packet is still in the
     // network queue causing the channel to be reconnected right after having
     // received the disconnect message (seems not to gain much, disconnect is
@@ -1156,6 +1187,16 @@ void CClient::Init()
             case AQ_HIGH:
                 iCeltNumCodedBytes = OPUS_NUM_BYTES_MONO_HIGH_QUALITY_DBLE_FRAMESIZE;
                 break;
+            case AQ_RAW:
+                if ( bRawAudioIsSupported && Channel.IsEnabled() )
+                {
+                    iCeltNumCodedBytes = iNumAudioChannels * iOPUSFrameSizeSamples * sizeof ( int16_t );
+                }
+                else
+                {
+                    iCeltNumCodedBytes = OPUS_NUM_BYTES_MONO_HIGH_QUALITY_DBLE_FRAMESIZE;
+                }
+                break;
             }
         }
         else
@@ -1175,6 +1216,16 @@ void CClient::Init()
             case AQ_HIGH:
                 iCeltNumCodedBytes = OPUS_NUM_BYTES_STEREO_HIGH_QUALITY_DBLE_FRAMESIZE;
                 break;
+            case AQ_RAW:
+                if ( bRawAudioIsSupported && Channel.IsEnabled() )
+                {
+                    iCeltNumCodedBytes = iNumAudioChannels * iOPUSFrameSizeSamples * sizeof ( int16_t );
+                }
+                else
+                {
+                    iCeltNumCodedBytes = OPUS_NUM_BYTES_STEREO_HIGH_QUALITY_DBLE_FRAMESIZE;
+                }
+                break;
             }
         }
     }
@@ -1199,6 +1250,16 @@ void CClient::Init()
             case AQ_HIGH:
                 iCeltNumCodedBytes = OPUS_NUM_BYTES_MONO_HIGH_QUALITY;
                 break;
+            case AQ_RAW:
+                if ( bRawAudioIsSupported && Channel.IsEnabled() )
+                {
+                    iCeltNumCodedBytes = iNumAudioChannels * iOPUSFrameSizeSamples * sizeof ( int16_t );
+                }
+                else
+                {
+                    iCeltNumCodedBytes = OPUS_NUM_BYTES_MONO_HIGH_QUALITY;
+                }
+                break;
             }
         }
         else
@@ -1218,6 +1279,16 @@ void CClient::Init()
             case AQ_HIGH:
                 iCeltNumCodedBytes = OPUS_NUM_BYTES_STEREO_HIGH_QUALITY;
                 break;
+            case AQ_RAW:
+                if ( bRawAudioIsSupported && Channel.IsEnabled() )
+                {
+                    iCeltNumCodedBytes = iNumAudioChannels * iOPUSFrameSizeSamples * sizeof ( int16_t );
+                }
+                else
+                {
+                    iCeltNumCodedBytes = OPUS_NUM_BYTES_STEREO_HIGH_QUALITY;
+                }
+                break;
             }
         }
     }
@@ -1229,8 +1300,11 @@ void CClient::Init()
     vecZeros.Init ( iStereoBlockSizeSam, 0 );
     vecsStereoSndCrdMuteStream.Init ( iStereoBlockSizeSam );
 
-    opus_custom_encoder_ctl ( CurOpusEncoder,
-                              OPUS_SET_BITRATE ( CalcBitRateBitsPerSecFromCodedBytes ( iCeltNumCodedBytes, iOPUSFrameSizeSamples ) ) );
+    if ( !bRawAudioIsSupported )
+    {
+        opus_custom_encoder_ctl ( CurOpusEncoder,
+                                  OPUS_SET_BITRATE ( CalcBitRateBitsPerSecFromCodedBytes ( iCeltNumCodedBytes, iOPUSFrameSizeSamples ) ) );
+    }
 
     // inits for network and channel
     vecbyNetwData.Init ( iCeltNumCodedBytes );
@@ -1391,19 +1465,33 @@ void CClient::ProcessAudioDataIntern ( CVector<int16_t>& vecsStereoSndCrd )
 
     for ( i = 0, j = 0; i < iSndCrdFrameSizeFactor; i++, j += iNumAudioChannels * iOPUSFrameSizeSamples )
     {
-        // OPUS encoding
-        if ( CurOpusEncoder != nullptr )
+        if ( eAudioQuality != AQ_RAW || !bRawAudioIsSupported )
+        {
+            // OPUS encoding
+            if ( CurOpusEncoder != nullptr )
+            {
+                if ( bMuteOutStream )
+                {
+                    iUnused = opus_custom_encode ( CurOpusEncoder, &vecZeros[j], iOPUSFrameSizeSamples, &vecCeltData[0], iCeltNumCodedBytes );
+                }
+                else
+                {
+                    iUnused = opus_custom_encode ( CurOpusEncoder, &vecsStereoSndCrd[j], iOPUSFrameSizeSamples, &vecCeltData[0], iCeltNumCodedBytes );
+                }
+            }
+        }
+        else
         {
             if ( bMuteOutStream )
             {
-                iUnused = opus_custom_encode ( CurOpusEncoder, &vecZeros[j], iOPUSFrameSizeSamples, &vecCeltData[0], iCeltNumCodedBytes );
+                memset ( &vecCeltData[0], 0, iCeltNumCodedBytes );
             }
             else
             {
-                iUnused = opus_custom_encode ( CurOpusEncoder, &vecsStereoSndCrd[j], iOPUSFrameSizeSamples, &vecCeltData[0], iCeltNumCodedBytes );
+                // Send raw samples instead of OPUS
+                memcpy ( &vecCeltData[0], &vecsStereoSndCrd[j], iCeltNumCodedBytes );
             }
         }
-
         // send coded audio through the network
         Channel.PrepAndSendPacket ( &Socket, vecCeltData, iCeltNumCodedBytes );
     }
@@ -1423,23 +1511,33 @@ void CClient::ProcessAudioDataIntern ( CVector<int16_t>& vecsStereoSndCrd )
         // get pointer to coded data and manage the flags
         if ( bReceiveDataOk )
         {
-            pCurCodedData = &vecbyNetwData[0];
-
+            if ( eAudioQuality == AQ_RAW && bRawAudioIsSupported )
+            {
+                memcpy ( &vecsStereoSndCrd[j], &vecbyNetwData[0], iCeltNumCodedBytes );
+                pCurCodedData = nullptr;
+            }
+            else
+            {
+                pCurCodedData = &vecbyNetwData[0];
+            }
             // on any valid received packet, we clear the initialization phase flag
             bIsInitializationPhase = false;
         }
         else
         {
+            if ( eAudioQuality == AQ_RAW && bRawAudioIsSupported )
+            {
+                memset ( &vecsStereoSndCrd[j], 0, iCeltNumCodedBytes );
+            }
             // for lost packets use null pointer as coded input data
             pCurCodedData = nullptr;
-
             // invalidate the buffer OK status flag
             bJitterBufferOK = false;
         }
 
-        // OPUS decoding
-        if ( CurOpusDecoder != nullptr )
+        if ( ( eAudioQuality != AQ_RAW || !bRawAudioIsSupported ) && CurOpusDecoder != nullptr )
         {
+            // OPUS decoding
             iUnused = opus_custom_decode ( CurOpusDecoder, pCurCodedData, iCeltNumCodedBytes, &vecsStereoSndCrd[j], iOPUSFrameSizeSamples );
         }
     }
@@ -1519,7 +1617,7 @@ int CClient::EstimatedOverallDelay ( const int iPingTimeMs )
     const float fDelayToFillNetworkPacketsMs = GetSystemMonoBlSize() * 1000.0f / SYSTEM_SAMPLE_RATE_HZ;
 
     // OPUS additional delay at small frame sizes is half a frame size
-    const float fAdditionalAudioCodecDelayMs = fSystemBlockDurationMs / 2;
+    const float fAdditionalAudioCodecDelayMs = ( eAudioQuality == AQ_RAW && bRawAudioIsSupported ) ? 0.0f : fSystemBlockDurationMs / 2;
 
     const float fTotalBufferDelayMs =
         fDelayToFillNetworkPacketsMs + fTotalJitterBufferDelayMs + fTotalSoundCardDelayMs + fAdditionalAudioCodecDelayMs;

src/client.h

@@ -410,7 +410,8 @@ class CClient : public QObject
     QMutex MutexDriverReinit;
 
     // server settings
-    int iServerSockBufNumFrames;
+    int  iServerSockBufNumFrames;
+    bool bRawAudioIsSupported;
 
     // for ping measurement
     QElapsedTimer PreciseTime;
@@ -456,6 +457,7 @@ protected slots:
     void OnMuteStateHasChangedReceived ( int iServerChanID, bool bIsMuted );
     void OnCLChannelLevelListReceived ( CHostAddress InetAddr, CVector<uint16_t> vecLevelList );
     void OnConClientListMesReceived ( CVector<CChannelInfo> vecChanInfo );
+    void OnVersionAndOSReceived ( COSUtil::EOpSystemType eOSType, QString strVersion );
 
 signals:
     void ConClientListMesReceived ( CVector<CChannelInfo> vecChanInfo );

src/clientsettingsdlg.cpp

@@ -494,6 +494,7 @@ CClientSettingsDlg::CClientSettingsDlg ( CClient* pNCliP, CClientSettings* pNSet
     cbxAudioQuality->addItem ( tr ( "Low" ) );    // AQ_LOW
     cbxAudioQuality->addItem ( tr ( "Normal" ) ); // AQ_NORMAL
     cbxAudioQuality->addItem ( tr ( "High" ) );   // AQ_HIGH
+    cbxAudioQuality->addItem ( tr ( "Max" ) );    // AQ_RAW
     cbxAudioQuality->setCurrentIndex ( static_cast<int> ( pClient->GetAudioQuality() ) );
 
     // GUI design (skin) combo box

src/server.cpp

@@ -874,22 +874,44 @@ void CServer::DecodeReceiveData ( const int iChanCnt, const int iNumClients )
                 return;
             }
 
+            const int iOffset = iB * SYSTEM_FRAME_SIZE_SAMPLES * vecNumAudioChannels[iChanCnt];
+            // Recognise a raw audio packet by its size:
+            // The client doesn't pass a value for the selected audio quality implicitly.
+            // Rather the server is passed the length of the data sent by the client in iClientFrameSizeSamples.
+            // We know the exact size to expect from a client sending raw audio packets.
+            // The length is calculated in the client by: iNumAudioChannels * iOPUSFrameSizeSamples * sizeof ( int16_t )
+            // iOPUSFrameSizeSamples can be either 64 or 128 (small network buffers enabled|disabled)
+            // iNumAudioChannels is either 1 for mono or 2 for stereo and mono-in/stereo-out
+            // sizeof ( int16_t ) is the size in bytes for the raw pcm audio data = 2
+            // Sizes other than that are considered OPUS coded because those depend on hardcoded sizes in client.h
+            const bool bIsRawAudio =
+                ( iCeltNumCodedBytes == static_cast<int> ( iClientFrameSizeSamples * vecNumAudioChannels[iChanCnt] * sizeof ( int16_t ) ) );
+
             // get pointer to coded data
             if ( eGetStat == GS_BUFFER_OK )
             {
-                pCurCodedData = &vecvecbyCodedData[iChanCnt][0];
+                if ( bIsRawAudio )
+                {
+                    memcpy ( &vecvecsData[iChanCnt][iOffset], &vecvecbyCodedData[iChanCnt][0], iCeltNumCodedBytes );
+                    pCurCodedData = nullptr;
+                }
+                else
+                {
+                    pCurCodedData = &vecvecbyCodedData[iChanCnt][0];
+                }
             }
             else
             {
+                if ( bIsRawAudio )
+                {
+                    memset ( &vecvecsData[iChanCnt][iOffset], 0, iCeltNumCodedBytes );
+                }
                 // for lost packets use null pointer as coded input data
                 pCurCodedData = nullptr;
             }
 
-            // OPUS decode received data stream
-            if ( CurOpusDecoder != nullptr )
+            if ( !bIsRawAudio && CurOpusDecoder != nullptr )
             {
-                const int iOffset = iB * SYSTEM_FRAME_SIZE_SAMPLES * vecNumAudioChannels[iChanCnt];
-
                 iUnused = opus_custom_decode ( CurOpusDecoder,
                                                pCurCodedData,
                                                iCeltNumCodedBytes,
@@ -1154,30 +1176,41 @@ void CServer::MixEncodeTransmitData ( const int iChanCnt, const int iNumClients
             DoubleFrameSizeConvBufOut[iCurChanID].GetAll ( vecsSendData, DOUBLE_SYSTEM_FRAME_SIZE_SAMPLES * vecNumAudioChannels[iChanCnt] );
         }
 
-        // OPUS encoding
-        if ( pCurOpusEncoder != nullptr )
+        if ( iCeltNumCodedBytes != static_cast<int> ( iClientFrameSizeSamples * vecNumAudioChannels[iChanCnt] * sizeof ( int16_t ) ) )
         {
-            //### TODO: BEGIN ###//
-            // find a better place than this: the setting does not change all the time so for speed
-            // optimization it would be better to set it only if the network frame size is changed
-            opus_custom_encoder_ctl ( pCurOpusEncoder,
-                                      OPUS_SET_BITRATE ( CalcBitRateBitsPerSecFromCodedBytes ( iCeltNumCodedBytes, iClientFrameSizeSamples ) ) );
-            //### TODO: END ###//
+            // OPUS encoding
+            if ( pCurOpusEncoder != nullptr )
+            {
+                //### TODO: BEGIN ###//
+                // find a better place than this: the setting does not change all the time so for speed
+                // optimization it would be better to set it only if the network frame size is changed
+                opus_custom_encoder_ctl ( pCurOpusEncoder,
+                                          OPUS_SET_BITRATE ( CalcBitRateBitsPerSecFromCodedBytes ( iCeltNumCodedBytes, iClientFrameSizeSamples ) ) );
+                //### TODO: END ###//
+
+                for ( int iB = 0; iB < vecNumFrameSizeConvBlocks[iChanCnt]; iB++ )
+                {
+                    const int iOffset = iB * SYSTEM_FRAME_SIZE_SAMPLES * vecNumAudioChannels[iChanCnt];
 
+                    iUnused = opus_custom_encode ( pCurOpusEncoder,
+                                                   &vecsSendData[iOffset],
+                                                   iClientFrameSizeSamples,
+                                                   &vecvecbyCodedData[iChanCnt][0],
+                                                   iCeltNumCodedBytes );
+                }
+            }
+        }
+        else
+        {
             for ( int iB = 0; iB < vecNumFrameSizeConvBlocks[iChanCnt]; iB++ )
             {
                 const int iOffset = iB * SYSTEM_FRAME_SIZE_SAMPLES * vecNumAudioChannels[iChanCnt];
 
-                iUnused = opus_custom_encode ( pCurOpusEncoder,
-                                               &vecsSendData[iOffset],
-                                               iClientFrameSizeSamples,
-                                               &vecvecbyCodedData[iChanCnt][0],
-                                               iCeltNumCodedBytes );
-
-                // send separate mix to current clients
-                vecChannels[iCurChanID].PrepAndSendPacket ( &Socket, vecvecbyCodedData[iChanCnt], iCeltNumCodedBytes );
+                memcpy ( &vecvecbyCodedData[iChanCnt][0], &vecsSendData[iOffset], iCeltNumCodedBytes );
             }
         }
+        // send separate mix to current clients
+        vecChannels[iCurChanID].PrepAndSendPacket ( &Socket, vecvecbyCodedData[iChanCnt], iCeltNumCodedBytes );
     }
 
     Q_UNUSED ( iUnused )

src/settings.cpp

@@ -605,7 +605,7 @@ void CClientSettings::ReadSettingsFromXML ( const QDomDocument& IniXMLDocument,
     }
 
     // audio quality
-    if ( GetNumericIniSet ( IniXMLDocument, "client", "audioquality", 0, 2 /* AQ_HIGH */, iValue ) )
+    if ( GetNumericIniSet ( IniXMLDocument, "client", "audioquality", 0, 3 /* AQ_RAW */, iValue ) )
     {
         pClient->SetAudioQuality ( static_cast<EAudioQuality> ( iValue ) );
     }

src/util.h

@@ -505,7 +505,8 @@ enum EAudioQuality
     // used for settings and the comobo box index -> enum values must be fixed!
     AQ_LOW    = 0,
     AQ_NORMAL = 1,
-    AQ_HIGH   = 2
+    AQ_HIGH   = 2,
+    AQ_RAW    = 3
 };
 
 // Get data status enum --------------------------------------------------------