C++ NLPacket::readPrimitive方法代码示例

int InboundAudioStream::parseData(NLPacket& packet) {

    // parse sequence number and track it
    quint16 sequence;
    packet.readPrimitive(&sequence);
    SequenceNumberStats::ArrivalInfo arrivalInfo = _incomingSequenceNumberStats.sequenceNumberReceived(sequence,
            packet.getSourceID());

    packetReceivedUpdateTimingStats();

    int networkSamples;

    // parse the info after the seq number and before the audio data (the stream properties)
    int prePropertyPosition = packet.pos();
    int propertyBytes = parseStreamProperties(packet.getType(), packet.read(packet.bytesLeftToRead()), networkSamples);
    packet.seek(prePropertyPosition + propertyBytes);

    // handle this packet based on its arrival status.
    switch (arrivalInfo._status) {
    case SequenceNumberStats::Early: {
        // Packet is early; write droppable silent samples for each of the skipped packets.
        // NOTE: we assume that each dropped packet contains the same number of samples
        // as the packet we just received.
        int packetsDropped = arrivalInfo._seqDiffFromExpected;
        writeSamplesForDroppedPackets(packetsDropped * networkSamples);

        // fall through to OnTime case
    }
    case SequenceNumberStats::OnTime: {
        // Packet is on time; parse its data to the ringbuffer
        if (packet.getType() == PacketType::SilentAudioFrame) {
            writeDroppableSilentSamples(networkSamples);
        } else {
            parseAudioData(packet.getType(), packet.read(packet.bytesLeftToRead()), networkSamples);
        }
        break;
    }
    default: {
        // For now, late packets are ignored.  It may be good in the future to insert the late audio packet data
        // into the ring buffer to fill in the missing frame if it hasn't been mixed yet.
        break;
    }
    }

    int framesAvailable = _ringBuffer.framesAvailable();
    // if this stream was starved, check if we're still starved.
    if (_isStarved && framesAvailable >= _desiredJitterBufferFrames) {
        _isStarved = false;
    }
    // if the ringbuffer exceeds the desired size by more than the threshold specified,
    // drop the oldest frames so the ringbuffer is down to the desired size.
    if (framesAvailable > _desiredJitterBufferFrames + _maxFramesOverDesired) {
        int framesToDrop = framesAvailable - (_desiredJitterBufferFrames + DESIRED_JITTER_BUFFER_FRAMES_PADDING);
        _ringBuffer.shiftReadPosition(framesToDrop * _ringBuffer.getNumFrameSamples());

        _framesAvailableStat.reset();
        _currentJitterBufferFrames = 0;

        _oldFramesDropped += framesToDrop;
    }

    framesAvailableChanged();

    return packet.pos();
}

int AudioMixerClientData::parseData(NLPacket& packet) {
    PacketType packetType = packet.getType();
    
    if (packetType == PacketType::AudioStreamStats) {

        // skip over header, appendFlag, and num stats packed
        packet.seek(sizeof(quint8) + sizeof(quint16));

        // read the downstream audio stream stats
        packet.readPrimitive(&_downstreamAudioStreamStats);

        return packet.pos();

    } else {
        PositionalAudioStream* matchingStream = NULL;

        if (packetType == PacketType::MicrophoneAudioWithEcho
            || packetType == PacketType::MicrophoneAudioNoEcho
            || packetType == PacketType::SilentAudioFrame) {

            QUuid nullUUID = QUuid();
            if (!_audioStreams.contains(nullUUID)) {
                // we don't have a mic stream yet, so add it

                // read the channel flag to see if our stream is stereo or not
                packet.seek(sizeof(quint16));

                quint8 channelFlag;
                packet.readPrimitive(&channelFlag);

                bool isStereo = channelFlag == 1;

                _audioStreams.insert(nullUUID, matchingStream = new AvatarAudioStream(isStereo, AudioMixer::getStreamSettings()));
            } else {
                matchingStream = _audioStreams.value(nullUUID);
            }
        } else if (packetType == PacketType::InjectAudio) {
            // this is injected audio

            // grab the stream identifier for this injected audio
            packet.seek(sizeof(quint16));
            QUuid streamIdentifier = QUuid::fromRfc4122(packet.readWithoutCopy(NUM_BYTES_RFC4122_UUID));

            bool isStereo;
            packet.readPrimitive(&isStereo);

            if (!_audioStreams.contains(streamIdentifier)) {
                // we don't have this injected stream yet, so add it
                _audioStreams.insert(streamIdentifier,
                        matchingStream = new InjectedAudioStream(streamIdentifier, isStereo, AudioMixer::getStreamSettings()));
            } else {
                matchingStream = _audioStreams.value(streamIdentifier);
            }
        }

        // seek to the beginning of the packet so that the next reader is in the right spot
        packet.seek(0);

        return matchingStream->parseData(packet);
    }
    return 0;
}