Method thread

source/frontend/StarVoice.cpp:695–752

}

void Voice::thread() {
  while (true) {
    MutexLocker locker(m_threadMutex);

    m_threadCond.wait(m_threadMutex);
    if (m_stopThread)
      return;

    {
      MutexLocker locker(m_captureMutex);
      ByteArray encoded(VOICE_MAX_PACKET_SIZE, 0);
      size_t frameSamples = VOICE_FRAME_SIZE * (size_t)m_deviceChannels;
      while (m_capturedChunksFrames >= VOICE_FRAME_SIZE) {
        std::vector<opus_int16> samples;
        samples.reserve(frameSamples);
        size_t samplesLeft = frameSamples;
        while (samplesLeft && !m_capturedChunks.empty()) {
          auto& front = m_capturedChunks.front();
          if (front.exhausted())
            m_capturedChunks.pop();
          else
            samplesLeft -= front.takeSamples(samples, samplesLeft);
        }
        m_capturedChunksFrames -= VOICE_FRAME_SIZE;

        if (m_inputAmplitude != 1.0f) {
          for (size_t i = 0; i != samples.size(); ++i)
            samples[i] *= m_inputAmplitude;
        }

        if (int encodedSize = opus_encode(m_encoder.get(), samples.data(), VOICE_FRAME_SIZE, (unsigned char*)encoded.ptr(), encoded.size())) {
          if (encodedSize == 1)
            continue;

          encoded.resize(encodedSize);

          {
            MutexLocker locker(m_encodeMutex);
            m_encodedChunks.emplace_back(std::move(encoded));
            m_encodedChunksLength += encodedSize;

            encoded = ByteArray(VOICE_MAX_PACKET_SIZE, 0);
          }

          //Logger::info("Voice: encoded Opus chunk {} samples -> {} bytes", frameSamples, encodedSize);
        }
        else if (encodedSize < 0)
          Logger::error("Voice: Opus encode error {}", opus_strerror(encodedSize));
      }
    }

    continue;

    locker.unlock();
    Thread::yield();
  }
  return;
}