WebSVN – tpanel – Diff – /trunk/src/tqintercom.cpp

 #       include <QPermissions>
 #   endif   // QT_VERSION_CHECK(6, 6, 0)
 #endif  // defined(Q_OS_ANDROID) || defined(Q_OS_IOS)
 #include "tqintercom.h"
+#include "tresources.h"
 #include "tconfig.h"
 #include "terror.h"
 #define PACKET_SIZE     172
+#define DATA_SIZE       160
+#define HEADER_SIZE     12
 using std::string;
 using std::min;
 TQIntercom::TQIntercom(QObject *parent)
                 if (mUdpTalker->state() != QUdpSocket::ConnectedState || io == nullptr)
                     return;
                 int len = io->bytesAvailable();
                 MSG_DEBUG(len << " bytes available");
-                int chunks = len / PACKET_SIZE;
+                int chunks = len / DATA_SIZE;
                 if (chunks > 0)
+                {
+                    mMicOpen = true;
                     for (int i = 0; i < chunks; ++i)
+                    {
+                        QByteArray buffer(DATA_SIZE, 0);
-                        QByteArray buffer(PACKET_SIZE, 0);
+                        QByteArray wbuf(PACKET_SIZE, 0);
-                        len = io->read(buffer.data(), PACKET_SIZE);
+                        len = io->read(buffer.data(), DATA_SIZE);
                         if (len > 0 && mTalkConnected)
+                        {
+                            len = getNextBlock(&wbuf, buffer);
                             MSG_DEBUG("Writing bytes: " << len);
-                            mUdpTalker->write(buffer.data(), len);
+                            mUdpTalker->write(wbuf.data(), len);
+                            TError::logHex(wbuf.data(), len);
+                        }
+                    }
+                }
-                else if (len > 0)
+                else if (len == 0)
+                {
+                    if (!mMicOpen)
+                    {
+                        QByteArray buffer(DATA_SIZE, uLawEncode(0));
+                        QByteArray wbuf(PACKET_SIZE, 0);
+                        len = getNextBlock(&wbuf, buffer);
+                        MSG_DEBUG("Writing bytes: " << len);
+                        mUdpTalker->write(wbuf.data(), len);
+                        TError::logHex(wbuf.data(), len);
+                    }
+                }
+                else
+                {
+                    mMicOpen = true;
                     QByteArray buffer(len, 0);
+                    QByteArray wbuf(HEADER_SIZE + len, 0);
                     if (mTalkConnected)
+                    {
+                        len = getNextBlock(&wbuf, buffer);
                         MSG_DEBUG("Writing bytes: " << len);
-                        mUdpTalker->write(buffer.data(), len);
+                        mUdpTalker->write(wbuf.data(), len);
+                    }
+                }
             });
             mPushTimer->start(10);
             mPushTimer->stop();
             mPushTimer->disconnect();
+        }
         if (mMicDevice)
+        {
             mMicDevice->stop();
+            mMicOpen = false;
+        }
         if (mMicrophone)
+        {
             mMicrophone->stop();
             delete mMicrophone;
         if (mRemote)
+        {
             for (qsizetype i = 0; i < data.size(); ++i)
+            {
+                if (i < HEADER_SIZE)
+                    continue;
                 uint16_t word = uLawDecode(data[i]);
                 uint8_t hbyte = word >> 8;
                 uint8_t lbyte = word;
                 mReadBuffer.append(hbyte);
                 mReadBuffer.append(lbyte);
     lsb = (number >> (position - 4)) & 0x0f;
     return (~(sign | ((position - 5) << 4) | lsb));
+}
+long TQIntercom::getNextBlock(QByteArray* target, const QByteArray& data)
+{
+    DECL_TRACER("TQIntercom::getNextBlock(QByteArray* target, const QByteArray& data)");
+    if (!target)
+        return 0;
+    long size = qMin(data.size(), DATA_SIZE);
+    mHeader.counter++;
+    mHeader.position += size;
+    unsigned char bytes[10];
+    if (target)
+    {
+        target->clear();
+        uint16ToBytes(mHeader.ident, bytes);
+        target->append(reinterpret_cast<char *>(bytes), 2);
+        uint16ToBytes(mHeader.counter, bytes);
+        target->append(reinterpret_cast<char *>(bytes), 2);
+        uint32ToBytes(mHeader.position, bytes);
+        target->append(reinterpret_cast<char *>(bytes), 4);
+        uint16ToBytes(mHeader.unk1, bytes);
+        target->append(reinterpret_cast<char *>(bytes), 2);
+        uint16ToBytes(mHeader.unk2, bytes);
+        target->append(reinterpret_cast<char *>(bytes), 2);
+        target->append(data.right(size));
+    }
+    return size + HEADER_SIZE;
+}
 /*******************************************************************************
  * Methods of class _audioWrite start here
  ******************************************************************************/
 TMicrophone::TMicrophone()
     if (!mBuffer.isEmpty())
+    {
         qint64 posBuffer = 0;
         qint64 posData = 0;
         qint64 size = qMin(len, mBuffer.size());
+        qint16 hbyte, lbyte, word;
+        bool bigEndian = isBigEndian();
         while (posData < size)
+        {
             if (posBuffer >= mBuffer.size())
                 break;
-            qint16 hbyte = mBuffer[posBuffer];
+            hbyte = mBuffer[posBuffer];
             posBuffer++;
-            qint16 lbyte = mBuffer[posBuffer];
+            lbyte = mBuffer[posBuffer];
             posBuffer++;
+            if (bigEndian)
-            qint16 word = ((hbyte << 8) & 0xff00) | lbyte;
+                word = ((hbyte << 8) & 0xff00) | lbyte;
+            else
+                word = ((lbyte << 8) & 0xff00) | hbyte;
             *(data+posData) = uLawEncode(word);
             posData++;
+        }
         mBuffer.remove(0, posBuffer);
     for (; ((number & mask) != mask && position >= 5); mask >>= 1, position--)
+        ;
     lsb = (number >> (position - 4)) & 0x0f;
-    return (~(sign | ((position - 5) << 4) | lsb));
+    return (~(sign | (((position - 5) << 4) & 0xf0) | lsb));
-}
-int16_t TMicrophone::uLawDecode(int8_t number)
-{
-    DECL_TRACER("_audioIO::uLawDecode(int8_t number)");
-    const uint16_t MULAW_BIAS = 33;
-    uint8_t sign = 0, position = 0;
-    int16_t decoded = 0;
-    number = ~number;
-    if (number & 0x80)
-    {
-        number &= ~(1 << 7);
-        sign = -1;
-    }
-    position = ((number & 0xF0) >> 4) + 5;
-    decoded = ((1 << position) | ((number & 0x0F) << (position - 4)) | (1 << (position - 5))) - MULAW_BIAS;
-    return (sign == 0) ? (decoded) : (-(decoded));
+}

Subversion Repositories tpanel

(root)/trunk/src/tqintercom.cpp – Rev 473 → 474