Opening multiple streams in a single connection

[alxlion]

Hello,

I'm trying to connect to a QUIC server and open two simultaneous streams:

  if (QUIC_FAILED(status = msQuicApi->StreamOpen(connection, QUIC_STREAM_OPEN_FLAG_UNIDIRECTIONAL, streamVideoCallback, this, &videoStream)))
  {
      qDebug() << "Failed to open video stream with status:" << status;
  }

  if (QUIC_FAILED(status = msQuicApi->StreamStart(videoStream, QUIC_STREAM_START_FLAG_IMMEDIATE)))
  {
      qDebug() << "StreamStart video failed with status:" << status;
      msQuicApi->StreamClose(videoStream);
      videoStream = nullptr;
  }

  // Open audio stream
  if (QUIC_FAILED(status = msQuicApi->StreamOpen(connection, QUIC_STREAM_OPEN_FLAG_UNIDIRECTIONAL, streamAudioCallback, this, &audioStream)))
  {
      qDebug() << "Failed to open audio stream with status:" << status;
      msQuicApi->StreamClose(audioStream);
      return false;
  }

  if (QUIC_FAILED(status = msQuicApi->StreamStart(audioStream, QUIC_STREAM_START_FLAG_IMMEDIATE)))
  {
      qDebug() << "StreamStart audio failed with status:" << status;
      msQuicApi->StreamClose(audioStream);
      audioStream = nullptr;
      return false;
  }

For each handlers (streamAudioCallback and streamVideoCallback) I have something like:

QuicClient *client = static_cast<QuicClient *>(context);

  switch (event->Type)
  {
  case QUIC_STREAM_EVENT_RECEIVE:
  {
      for (uint32_t i = 0; i < event->RECEIVE.BufferCount; ++i)
      {
          qDebug() << "Received video buffer size: " << event->RECEIVE.Buffers[i].Length;
          client->receivedVideoBuffer->append(reinterpret_cast<const char *>(event->RECEIVE.Buffers[i].Buffer),
                                              event->RECEIVE.Buffers[i].Length);
      }

      client->processVideoData();

      return QUIC_STATUS_CONTINUE;
  }
  break;
  case QUIC_STREAM_EVENT_PEER_SEND_SHUTDOWN:
      qDebug() << "StreamPeerSendShutdown video";
      break;
  case QUIC_STREAM_EVENT_PEER_SEND_ABORTED:
      qDebug() << "StreamPeerSendAborted video";
      break;
  case QUIC_STREAM_EVENT_START_COMPLETE:
      qDebug() << "StreamStartComplete video";
      break;
  case QUIC_STREAM_EVENT_SHUTDOWN_COMPLETE:
      qDebug() << "StreamShutdownComplete video";
      client->videoStream = nullptr;
      break;
  }
  return QUIC_STATUS_SUCCESS;

I open the streams when I get a QUIC_CONNECTION_EVENT_CONNECTED event in my connection handler.

This doesn't work, and I can't receive correctly without crashing (without any stacks).

Is there any example available to handle multiple streams (in a single thread or multiple one) ? What is the best way to implement it ?

Thanks

[nibanks]

What does your connection event handler for peer stream started look like? Having a callstack for the crash would help too.

[alxlion]

Thanks for the quick reply @nibanks .

The crash was due to the QUIC_CONNECTION_EVENT_PEER_STREAM_STARTED that I deleted from the connection handler because in the sample project it was only on the server side, so I thought it was useless for the client.

This works when only one stream is opened, but when I add the second stream (and thus a second handler), it looks like only one callback is called (streamAudioCallback).

QUIC_STATUS QuicClient::connectionCallback(HQUIC connection, void *context, QUIC_CONNECTION_EVENT *event)
{
    QuicClient *client = static_cast<QuicClient *>(context);
    switch (event->Type)
    {
    case QUIC_CONNECTION_EVENT_CONNECTED:
        qDebug() << "ConnectionConnected";
        emit client->connected();
        break;
    case QUIC_CONNECTION_EVENT_SHUTDOWN_INITIATED_BY_TRANSPORT:
    case QUIC_CONNECTION_EVENT_SHUTDOWN_INITIATED_BY_PEER:
        emit client->disconnected();
        break;
    case QUIC_CONNECTION_EVENT_SHUTDOWN_COMPLETE:
        qDebug() << "ConnectionShutdownComplete";
        break;
    case QUIC_CONNECTION_EVENT_RESUMPTION_TICKET_RECEIVED:
        qDebug() << "ConnectionResumptionTicketReceived";
        break;
    case QUIC_CONNECTION_EVENT_PEER_STREAM_STARTED:
        qDebug() << "ConnectionPeerStreamStarted";
        client->msQuicApi->SetCallbackHandler(event->PEER_STREAM_STARTED.Stream, (void *)streamVideoCallback, client);
        client->msQuicApi->SetCallbackHandler(event->PEER_STREAM_STARTED.Stream, (void *)streamAudioCallback, client);
        break;
    default:
        break;
    }
    return QUIC_STATUS_SUCCESS;
}

What is the real purpose of SetCallbackHandler if I have already declared my streams and their callback in StreamOpen ?

[nibanks]

You need to set callback handlers for streams your peer creates. The streams you create in StreamOpen are ones you create.

[alxlion]

I didn't catch that subtlety before, but now it's clear. Everything's working well, so thank you very much for your help with that!