Subversion Repositories tpanel

Rev

Rev 472 | Rev 474 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 472 Rev 473
Line 88... Line 88...
88 
            mUdpListener->close();
 88 
            mUdpListener->close();
89 
 
 89 
 
90 
        delete mUdpListener;
 90 
        delete mUdpListener;
91 
    }
 91 
    }
92 
 
 92 
 
93 
    if (mBuffer)
 - 
 
94 
    {
 - 
 
95 
        if (mBuffer->isOpen())
 - 
 
96 
            mBuffer->close();
 - 
 
97 
 
 - 
 
98 
        delete mBuffer;
 - 
 
99 
    }
 - 
 
100 
 
 - 
 
101 
    if (mPushTimer)
 93 
    if (mPushTimer)
102 
    {
 94 
    {
103 
        mPushTimer->stop();
 95 
        mPushTimer->stop();
104 
        mPushTimer->disconnect();
 96 
        mPushTimer->disconnect();
105 
        delete mPushTimer;
 97 
        delete mPushTimer;
106 
    }
 98 
    }
- 
 
 99 
 
- 
 
 100 
    if (mPullTimer)
- 
 
 101 
    {
- 
 
 102 
        mPullTimer->stop();
- 
 
 103 
        mPullTimer->disconnect();
- 
 
 104 
        delete mPullTimer;
- 
 
 105 
    }
107 
}
 106 
}
108 
 
 107 
 
109 
void TQIntercom::setIntercom(INTERCOM_t ic)
 108 
void TQIntercom::setIntercom(INTERCOM_t ic)
110 
{
 109 
{
111 
    DECL_TRACER("TQIntercom::setIntercom(INTERCOM_t ic)");
 110 
    DECL_TRACER("TQIntercom::setIntercom(INTERCOM_t ic)");
Line 256... Line 255...
256 
{
 255 
{
257 
    DECL_TRACER("TQIntercom::start()");
 256 
    DECL_TRACER("TQIntercom::start()");
258 
 
 257 
 
259 
    if ((mIntercom.mode == 0 || mIntercom.mode == 2) && mIntercom.rxPort)   // listen
 258 
    if ((mIntercom.mode == 0 || mIntercom.mode == 2) && mIntercom.rxPort)   // listen
260 
    {
 259 
    {
- 
 
 260 
        if (mPullTimer)
- 
 
 261 
            mPullTimer->stop();
- 
 
 262 
        else
- 
 
 263 
            mPullTimer = new QTimer();
- 
 
 264 
 
261 
        if (mRemote)
 265 
        if (mRemote)
262 
            delete mRemote;
 266 
            delete mRemote;
263 
 
 267 
 
264 
        mRemote = new QAudioSink(mAudioFormat, this);
 268 
        mRemote = new QAudioSink(mAudioFormat, this);
265 
        mRemote->setVolume(convertVolume(mSpkLevel));
 269 
        mRemote->setVolume(convertVolume(mSpkLevel));
266 
 
 270 
 
267 
        if (!spawnServer())
 271 
        if (!spawnServer())
268 
            return;
 272 
            return;
- 
 
 273 
 
- 
 
 274 
        if (mPullTimer)
- 
 
 275 
        {
- 
 
 276 
            mPullTimer->disconnect();
- 
 
 277 
            QIODevice *io = mRemote->start();
- 
 
 278 
 
- 
 
 279 
            connect(mPullTimer, &QTimer::timeout, [this, io]()
- 
 
 280 
            {
- 
 
 281 
                if (!io || !io->isOpen() || mReadBuffer.isEmpty())
- 
 
 282 
                    return;
- 
 
 283 
 
- 
 
 284 
                qint64 len = io->write(mReadBuffer);
- 
 
 285 
 
- 
 
 286 
                if (len > 0)
- 
 
 287 
                    mReadBuffer.remove(0, len);
- 
 
 288 
 
- 
 
 289 
                MSG_DEBUG("Played " << len << " bytes. " << mReadBuffer.size() << " remaining.");
- 
 
 290 
            });
- 
 
 291 
 
- 
 
 292 
            mPullTimer->start(10);
- 
 
 293 
        }
- 
 
 294 
 
269 
    }
 295 
    }
270 
 
 296 
 
271 
    if ((mIntercom.mode == 1 || mIntercom.mode == 2) && mIntercom.txPort) // talk
 297 
    if ((mIntercom.mode == 1 || mIntercom.mode == 2) && mIntercom.txPort) // talk
272 
    {
 298 
    {
273 
        if (mPushTimer)
 299 
        if (mPushTimer)
Line 319... Line 345...
319 
                        len = io->read(buffer.data(), PACKET_SIZE);
 345 
                        len = io->read(buffer.data(), PACKET_SIZE);
320 
 
 346 
 
321 
                        if (len > 0 && mTalkConnected)
 347 
                        if (len > 0 && mTalkConnected)
322 
                        {
 348 
                        {
323 
                            MSG_DEBUG("Writing bytes: " << len);
 349 
                            MSG_DEBUG("Writing bytes: " << len);
324 
                            TError::logHex(buffer.data(), len);
 - 
 
325 
                            mUdpTalker->write(buffer.data(), len);
 350 
                            mUdpTalker->write(buffer.data(), len);
326 
                        }
 351 
                        }
327 
                    }
 352 
                    }
328 
                }
 353 
                }
329 
                else if (len > 0)
 354 
                else if (len > 0)
Line 331... Line 356...
331 
                    QByteArray buffer(len, 0);
 356 
                    QByteArray buffer(len, 0);
332 
 
 357 
 
333 
                    if (mTalkConnected)
 358 
                    if (mTalkConnected)
334 
                    {
 359 
                    {
335 
                        MSG_DEBUG("Writing bytes: " << len);
 360 
                        MSG_DEBUG("Writing bytes: " << len);
336 
                        TError::logHex(buffer.data(), len);
 - 
 
337 
                        mUdpTalker->write(buffer.data(), len);
 361 
                        mUdpTalker->write(buffer.data(), len);
338 
                    }
 362 
                    }
339 
                }
 363 
                }
340 
            });
 364 
            });
341 
 
 365 
 
Line 350... Line 374...
350 
 
 374 
 
351 
    if ((mIntercom.mode == 0 || mIntercom.mode == 2) && mIntercom.rxPort)   // listen
 375 
    if ((mIntercom.mode == 0 || mIntercom.mode == 2) && mIntercom.rxPort)   // listen
352 
    {
 376 
    {
353 
        if (mRemote)
 377 
        if (mRemote)
354 
        {
 378 
        {
- 
 
 379 
            if (mPullTimer)
- 
 
 380 
            {
- 
 
 381 
                mPullTimer->stop();
- 
 
 382 
                mPullTimer->disconnect();
- 
 
 383 
            }
- 
 
 384 
 
355 
            mRemote->stop();
 385 
            mRemote->stop();
356 
            delete mRemote;
 386 
            delete mRemote;
357 
            mRemote = nullptr;
 387 
            mRemote = nullptr;
358 
 
 - 
 
359 
            if (mBuffer)
 - 
 
360 
            {
 - 
 
361 
                delete mBuffer;
 - 
 
362 
                mBuffer = nullptr;
 - 
 
363 
            }
 - 
 
364 
        }
 388 
        }
365 
 
 389 
 
366 
        if (mUdpListener)
 390 
        if (mUdpListener)
367 
        {
 391 
        {
368 
            mUdpListener->close();
 392 
            mUdpListener->close();
Line 477... Line 501...
477 
 
 501 
 
478 
void TQIntercom::onReadPendingDatagrams()
 502 
void TQIntercom::onReadPendingDatagrams()
479 
{
 503 
{
480 
    DECL_TRACER("TQIntercom::onReadPendingDatagrams()");
 504 
    DECL_TRACER("TQIntercom::onReadPendingDatagrams()");
481 
 
 505 
 
482 
    QIODevice *io = nullptr;
 - 
 
483 
 
 - 
 
484 
    if (mRemote)
 - 
 
485 
        io = mRemote->start();
 - 
 
486 
 
 - 
 
487 
    while (mUdpListener->hasPendingDatagrams())
 506 
    while (mUdpListener->hasPendingDatagrams())
488 
    {
 507 
    {
489 
        QNetworkDatagram datagram = mUdpListener->receiveDatagram();
 508 
        QNetworkDatagram datagram = mUdpListener->receiveDatagram();
490 
        QByteArray data = datagram.data();
 509 
        QByteArray data = datagram.data();
491 
 
 510 
 
492 
        if (mRemote)
 511 
        if (mRemote)
493 
        {
 512 
        {
494 
            mReadBuffer.clear();
 - 
 
495 
 
 - 
 
496 
            for (qsizetype i = 0; i < data.size(); ++i)
 513 
            for (qsizetype i = 0; i < data.size(); ++i)
497 
            {
 514 
            {
498 
                uint16_t word = uLawDecode(data[i]);
 515 
                uint16_t word = uLawDecode(data[i]);
499 
                uint8_t hbyte = word >> 8;
 516 
                uint8_t hbyte = word >> 8;
500 
                uint8_t lbyte = word;
 517 
                uint8_t lbyte = word;
501 
                mReadBuffer.append(hbyte);
 518 
                mReadBuffer.append(hbyte);
502 
                mReadBuffer.append(lbyte);
 519 
                mReadBuffer.append(lbyte);
503 
            }
 520 
            }
504 
 
 521 
 
505 
/*
 - 
 
506 
            QBuffer *buffer = new QBuffer(&mReadBuffer, this);
 - 
 
507 
            buffer->open(QIODevice::ReadOnly);
 - 
 
508 
            buffer->seek(0);
 - 
 
509 
 
 - 
 
510 
            if (mRemote->bytesFree() < buffer->size())
 522 
            TError::logHex(data.data(), data.size());
511 
                mRemote->setBufferSize(buffer->size() - mRemote->bytesFree());
 - 
 
512 
 
 - 
 
513 
            mRemote->start(buffer);
 - 
 
514 
*/
 - 
 
515 
            if (io)
 - 
 
516 
            {
 - 
 
517 
                if (!io->isOpen())
 - 
 
518 
                {
 - 
 
519 
                    io->open(QIODevice::ReadWrite);
 - 
 
520 
                    MSG_DEBUG("Opened device for read/write");
 - 
 
521 
                }
 - 
 
522 
 
 - 
 
523 
                qint64 len = 0;
 - 
 
524 
                qint64 pos = 0;
 - 
 
525 
                qint64 size = mReadBuffer.size();
 - 
 
526 
                int counter = 0;
 - 
 
527 
 
 - 
 
528 
                while ((len = io->write(mReadBuffer.mid(pos, size))) < size && counter < 100)
 - 
 
529 
                {
 - 
 
530 
                    MSG_DEBUG("Wrote " << len << " bytes");
 - 
 
531 
                    pos = len;
 - 
 
532 
                    size -= len;
 - 
 
533 
                    counter++;
 - 
 
534 
                }
 - 
 
535 
 
 - 
 
536 
                if (!counter)
 - 
 
537 
                {
 - 
 
538 
                    MSG_DEBUG("Wrote " << len << " bytes.");
 - 
 
539 
                }
 - 
 
540 
            }
 - 
 
541 
        }
 523 
        }
542 
    }
 524 
    }
543 
}
 525 
}
544 
 
 526 
 
545 
void TQIntercom::onInputStateChanged(QAbstractSocket::SocketState socketState)
 527 
void TQIntercom::onInputStateChanged(QAbstractSocket::SocketState socketState)