| /* |
| * Copyright (c) 2011 The WebRTC project authors. All Rights Reserved. |
| * |
| * Use of this source code is governed by a BSD-style license |
| * that can be found in the LICENSE file in the root of the source |
| * tree. An additional intellectual property rights grant can be found |
| * in the file PATENTS. All contributing project authors may |
| * be found in the AUTHORS file in the root of the source tree. |
| */ |
| |
| #include "modules/video_coding/main/source/session_info.h" |
| |
| #include "modules/video_coding/main/source/packet.h" |
| |
| namespace webrtc { |
| |
| VCMSessionInfo::VCMSessionInfo() |
| : session_nack_(false), |
| complete_(false), |
| decodable_(false), |
| frame_type_(kVideoFrameDelta), |
| previous_frame_loss_(false), |
| packets_(), |
| empty_seq_num_low_(-1), |
| empty_seq_num_high_(-1), |
| packets_not_decodable_(0) { |
| } |
| |
| void VCMSessionInfo::UpdateDataPointers(const uint8_t* old_base_ptr, |
| const uint8_t* new_base_ptr) { |
| for (PacketIterator it = packets_.begin(); it != packets_.end(); ++it) |
| if ((*it).dataPtr != NULL) { |
| assert(old_base_ptr != NULL && new_base_ptr != NULL); |
| (*it).dataPtr = new_base_ptr + ((*it).dataPtr - old_base_ptr); |
| } |
| } |
| |
| int VCMSessionInfo::LowSequenceNumber() const { |
| if (packets_.empty()) |
| return empty_seq_num_low_; |
| return packets_.front().seqNum; |
| } |
| |
| int VCMSessionInfo::HighSequenceNumber() const { |
| if (packets_.empty()) |
| return empty_seq_num_high_; |
| return LatestSequenceNumber(packets_.back().seqNum, empty_seq_num_high_, |
| NULL); |
| } |
| |
| int VCMSessionInfo::PictureId() const { |
| if (packets_.empty() || |
| packets_.front().codecSpecificHeader.codec != kRTPVideoVP8) |
| return kNoPictureId; |
| return packets_.front().codecSpecificHeader.codecHeader.VP8.pictureId; |
| } |
| |
| int VCMSessionInfo::TemporalId() const { |
| if (packets_.empty() || |
| packets_.front().codecSpecificHeader.codec != kRTPVideoVP8) |
| return kNoTemporalIdx; |
| return packets_.front().codecSpecificHeader.codecHeader.VP8.temporalIdx; |
| } |
| |
| bool VCMSessionInfo::LayerSync() const { |
| if (packets_.empty() || |
| packets_.front().codecSpecificHeader.codec != kRTPVideoVP8) |
| return false; |
| return packets_.front().codecSpecificHeader.codecHeader.VP8.layerSync; |
| } |
| |
| int VCMSessionInfo::Tl0PicId() const { |
| if (packets_.empty() || |
| packets_.front().codecSpecificHeader.codec != kRTPVideoVP8) |
| return kNoTl0PicIdx; |
| return packets_.front().codecSpecificHeader.codecHeader.VP8.tl0PicIdx; |
| } |
| |
| bool VCMSessionInfo::NonReference() const { |
| if (packets_.empty() || |
| packets_.front().codecSpecificHeader.codec != kRTPVideoVP8) |
| return false; |
| return packets_.front().codecSpecificHeader.codecHeader.VP8.nonReference; |
| } |
| |
| void VCMSessionInfo::Reset() { |
| session_nack_ = false; |
| complete_ = false; |
| decodable_ = false; |
| frame_type_ = kVideoFrameDelta; |
| previous_frame_loss_ = false; |
| packets_.clear(); |
| empty_seq_num_low_ = -1; |
| empty_seq_num_high_ = -1; |
| packets_not_decodable_ = 0; |
| } |
| |
| int VCMSessionInfo::SessionLength() const { |
| int length = 0; |
| for (PacketIteratorConst it = packets_.begin(); it != packets_.end(); ++it) |
| length += (*it).sizeBytes; |
| return length; |
| } |
| |
| int VCMSessionInfo::InsertBuffer(uint8_t* frame_buffer, |
| PacketIterator packet_it) { |
| VCMPacket& packet = *packet_it; |
| PacketIterator it; |
| |
| int packet_size = packet.sizeBytes; |
| packet_size += (packet.insertStartCode ? kH264StartCodeLengthBytes : 0); |
| |
| // Calculate the offset into the frame buffer for this packet. |
| int offset = 0; |
| for (it = packets_.begin(); it != packet_it; ++it) |
| offset += (*it).sizeBytes; |
| |
| // Set the data pointer to pointing to the start of this packet in the |
| // frame buffer. |
| const uint8_t* data = packet.dataPtr; |
| packet.dataPtr = frame_buffer + offset; |
| packet.sizeBytes = packet_size; |
| |
| ShiftSubsequentPackets(packet_it, packet_size); |
| |
| const unsigned char startCode[] = {0, 0, 0, 1}; |
| if (packet.insertStartCode) { |
| memcpy(const_cast<uint8_t*>(packet.dataPtr), startCode, |
| kH264StartCodeLengthBytes); |
| } |
| memcpy(const_cast<uint8_t*>(packet.dataPtr |
| + (packet.insertStartCode ? kH264StartCodeLengthBytes : 0)), |
| data, |
| packet.sizeBytes); |
| |
| return packet_size; |
| } |
| |
| void VCMSessionInfo::ShiftSubsequentPackets(PacketIterator it, |
| int steps_to_shift) { |
| ++it; |
| if (it == packets_.end()) |
| return; |
| uint8_t* first_packet_ptr = const_cast<WebRtc_UWord8*>((*it).dataPtr); |
| int shift_length = 0; |
| // Calculate the total move length and move the data pointers in advance. |
| for (; it != packets_.end(); ++it) { |
| shift_length += (*it).sizeBytes; |
| if ((*it).dataPtr != NULL) |
| (*it).dataPtr += steps_to_shift; |
| } |
| memmove(first_packet_ptr + steps_to_shift, first_packet_ptr, shift_length); |
| } |
| |
| void VCMSessionInfo::UpdateCompleteSession() { |
| if (packets_.front().isFirstPacket && packets_.back().markerBit) { |
| // Do we have all the packets in this session? |
| bool complete_session = true; |
| PacketIterator it = packets_.begin(); |
| PacketIterator prev_it = it; |
| ++it; |
| for (; it != packets_.end(); ++it) { |
| if (!InSequence(it, prev_it)) { |
| complete_session = false; |
| break; |
| } |
| prev_it = it; |
| } |
| complete_ = complete_session; |
| } |
| } |
| |
| void VCMSessionInfo::UpdateDecodableSession(int rttMs) { |
| // Irrelevant if session is already complete or decodable |
| if (complete_ || decodable_) |
| return; |
| // First iteration - do nothing |
| } |
| |
| bool VCMSessionInfo::complete() const { |
| return complete_; |
| } |
| |
| bool VCMSessionInfo::decodable() const { |
| return decodable_; |
| } |
| |
| // Find the end of the NAL unit which the packet pointed to by |packet_it| |
| // belongs to. Returns an iterator to the last packet of the frame if the end |
| // of the NAL unit wasn't found. |
| VCMSessionInfo::PacketIterator VCMSessionInfo::FindNaluEnd( |
| PacketIterator packet_it) const { |
| if ((*packet_it).completeNALU == kNaluEnd || |
| (*packet_it).completeNALU == kNaluComplete) { |
| return packet_it; |
| } |
| // Find the end of the NAL unit. |
| for (; packet_it != packets_.end(); ++packet_it) { |
| if (((*packet_it).completeNALU == kNaluComplete && |
| (*packet_it).sizeBytes > 0) || |
| // Found next NALU. |
| (*packet_it).completeNALU == kNaluStart) |
| return --packet_it; |
| if ((*packet_it).completeNALU == kNaluEnd) |
| return packet_it; |
| } |
| // The end wasn't found. |
| return --packet_it; |
| } |
| |
| int VCMSessionInfo::DeletePacketData(PacketIterator start, |
| PacketIterator end) { |
| int bytes_to_delete = 0; // The number of bytes to delete. |
| PacketIterator packet_after_end = end; |
| ++packet_after_end; |
| |
| // Get the number of bytes to delete. |
| // Clear the size of these packets. |
| for (PacketIterator it = start; it != packet_after_end; ++it) { |
| bytes_to_delete += (*it).sizeBytes; |
| (*it).sizeBytes = 0; |
| (*it).dataPtr = NULL; |
| ++packets_not_decodable_; |
| } |
| if (bytes_to_delete > 0) |
| ShiftSubsequentPackets(end, -bytes_to_delete); |
| return bytes_to_delete; |
| } |
| |
| int VCMSessionInfo::BuildVP8FragmentationHeader( |
| uint8_t* frame_buffer, |
| int frame_buffer_length, |
| RTPFragmentationHeader* fragmentation) { |
| int new_length = 0; |
| // Allocate space for max number of partitions |
| fragmentation->VerifyAndAllocateFragmentationHeader(kMaxVP8Partitions); |
| fragmentation->fragmentationVectorSize = 0; |
| memset(fragmentation->fragmentationLength, 0, |
| kMaxVP8Partitions * sizeof(WebRtc_UWord32)); |
| if (packets_.empty()) |
| return new_length; |
| PacketIterator it = FindNextPartitionBeginning(packets_.begin(), |
| &packets_not_decodable_); |
| while (it != packets_.end()) { |
| const int partition_id = |
| (*it).codecSpecificHeader.codecHeader.VP8.partitionId; |
| PacketIterator partition_end = FindPartitionEnd(it); |
| fragmentation->fragmentationOffset[partition_id] = |
| (*it).dataPtr - frame_buffer; |
| assert(fragmentation->fragmentationOffset[partition_id] < |
| static_cast<WebRtc_UWord32>(frame_buffer_length)); |
| fragmentation->fragmentationLength[partition_id] = |
| (*partition_end).dataPtr + (*partition_end).sizeBytes - (*it).dataPtr; |
| assert(fragmentation->fragmentationLength[partition_id] <= |
| static_cast<WebRtc_UWord32>(frame_buffer_length)); |
| new_length += fragmentation->fragmentationLength[partition_id]; |
| ++partition_end; |
| it = FindNextPartitionBeginning(partition_end, &packets_not_decodable_); |
| if (partition_id + 1 > fragmentation->fragmentationVectorSize) |
| fragmentation->fragmentationVectorSize = partition_id + 1; |
| } |
| // Set all empty fragments to start where the previous fragment ends, |
| // and have zero length. |
| if (fragmentation->fragmentationLength[0] == 0) |
| fragmentation->fragmentationOffset[0] = 0; |
| for (int i = 1; i < fragmentation->fragmentationVectorSize; ++i) { |
| if (fragmentation->fragmentationLength[i] == 0) |
| fragmentation->fragmentationOffset[i] = |
| fragmentation->fragmentationOffset[i - 1] + |
| fragmentation->fragmentationLength[i - 1]; |
| assert(i == 0 || |
| fragmentation->fragmentationOffset[i] >= |
| fragmentation->fragmentationOffset[i - 1]); |
| } |
| assert(new_length <= frame_buffer_length); |
| return new_length; |
| } |
| |
| VCMSessionInfo::PacketIterator VCMSessionInfo::FindNextPartitionBeginning( |
| PacketIterator it, int* packets_skipped) const { |
| while (it != packets_.end()) { |
| if ((*it).codecSpecificHeader.codecHeader.VP8.beginningOfPartition) { |
| return it; |
| } else if (packets_skipped != NULL) { |
| // This packet belongs to a partition with a previous loss and can't |
| // be decoded. |
| ++(*packets_skipped); |
| } |
| ++it; |
| } |
| return it; |
| } |
| |
| VCMSessionInfo::PacketIterator VCMSessionInfo::FindPartitionEnd( |
| PacketIterator it) const { |
| assert((*it).codec == kVideoCodecVP8); |
| PacketIterator prev_it = it; |
| const int partition_id = |
| (*it).codecSpecificHeader.codecHeader.VP8.partitionId; |
| while (it != packets_.end()) { |
| bool beginning = |
| (*it).codecSpecificHeader.codecHeader.VP8.beginningOfPartition; |
| int current_partition_id = |
| (*it).codecSpecificHeader.codecHeader.VP8.partitionId; |
| bool packet_loss_found = (!beginning && !InSequence(it, prev_it)); |
| if (packet_loss_found || |
| (beginning && current_partition_id != partition_id)) { |
| // Missing packet, the previous packet was the last in sequence. |
| return prev_it; |
| } |
| prev_it = it; |
| ++it; |
| } |
| return prev_it; |
| } |
| |
| bool VCMSessionInfo::InSequence(const PacketIterator& packet_it, |
| const PacketIterator& prev_packet_it) { |
| // If the two iterators are pointing to the same packet they are considered |
| // to be in sequence. |
| return (packet_it == prev_packet_it || |
| (static_cast<WebRtc_UWord16>((*prev_packet_it).seqNum + 1) == |
| (*packet_it).seqNum)); |
| } |
| |
| int VCMSessionInfo::MakeDecodable() { |
| int return_length = 0; |
| PacketIterator it = packets_.begin(); |
| // Make sure we remove the first NAL unit if it's not decodable. |
| if ((*it).completeNALU == kNaluIncomplete || |
| (*it).completeNALU == kNaluEnd) { |
| PacketIterator nalu_end = FindNaluEnd(it); |
| return_length += DeletePacketData(it, nalu_end); |
| it = nalu_end; |
| } |
| PacketIterator prev_it = it; |
| // Take care of the rest of the NAL units. |
| for (; it != packets_.end(); ++it) { |
| bool start_of_nalu = ((*it).completeNALU == kNaluStart || |
| (*it).completeNALU == kNaluComplete); |
| if (!start_of_nalu && !InSequence(it, prev_it)) { |
| // Found a sequence number gap due to packet loss. |
| PacketIterator nalu_end = FindNaluEnd(it); |
| return_length += DeletePacketData(it, nalu_end); |
| it = nalu_end; |
| } |
| prev_it = it; |
| } |
| return return_length; |
| } |
| |
| int VCMSessionInfo::BuildHardNackList(int* seq_num_list, |
| int seq_num_list_length) { |
| if (NULL == seq_num_list || seq_num_list_length < 1) { |
| return -1; |
| } |
| if (packets_.empty()) { |
| return 0; |
| } |
| |
| // Find end point (index of entry equals the sequence number of the first |
| // packet). |
| int index = 0; |
| for (; index < seq_num_list_length; ++index) { |
| if (seq_num_list[index] == packets_.front().seqNum) { |
| seq_num_list[index] = -1; |
| ++index; |
| break; |
| } |
| } |
| |
| // Zero out between the first entry and the end point. |
| PacketIterator it = packets_.begin(); |
| PacketIterator prev_it = it; |
| ++it; |
| while (it != packets_.end() && index < seq_num_list_length) { |
| if (!InSequence(it, prev_it)) { |
| // Found a sequence number gap due to packet loss. |
| index += PacketsMissing(it, prev_it); |
| session_nack_ = true; |
| } |
| seq_num_list[index] = -1; |
| ++index; |
| prev_it = it; |
| ++it; |
| } |
| if (!packets_.front().isFirstPacket) |
| session_nack_ = true; |
| return 0; |
| } |
| |
| int VCMSessionInfo::BuildSoftNackList(int* seq_num_list, |
| int seq_num_list_length, |
| int rtt_ms) { |
| if (NULL == seq_num_list || seq_num_list_length < 1) { |
| return -1; |
| } |
| if (packets_.empty() && empty_seq_num_low_ == -1) { |
| return 0; |
| } |
| |
| int index = 0; |
| int low_seq_num = (packets_.empty()) ? empty_seq_num_low_: |
| packets_.front().seqNum; |
| // Find entrance point (index of entry equals the sequence number of the |
| // first packet). |
| for (; index < seq_num_list_length; ++index) { |
| if (seq_num_list[index] == low_seq_num) { |
| seq_num_list[index] = -1; |
| break; |
| } |
| } |
| |
| // TODO(mikhal): 1. Update score based on RTT value 2. Add partition data. |
| // Use the previous available. |
| bool base_available = false; |
| if ((index > 0) && (seq_num_list[index] == -1)) { |
| // Found first packet, for now let's go only one back. |
| if ((seq_num_list[index - 1] == -1) || (seq_num_list[index - 1] == -2)) { |
| // This is indeed the first packet, as previous packet was populated. |
| base_available = true; |
| } |
| } |
| bool allow_nack = (!packets_.front().isFirstPacket || !base_available); |
| |
| // Zero out between first entry and end point. |
| |
| int media_high_seq_num; |
| if (HaveLastPacket()) { |
| media_high_seq_num = packets_.back().seqNum; |
| } else { |
| // Estimation. |
| if (empty_seq_num_low_ >= 0) { |
| // Assuming empty packets have later sequence numbers than media packets. |
| media_high_seq_num = empty_seq_num_low_ - 1; |
| } else { |
| // Since this frame doesn't have the marker bit we can assume it should |
| // contain at least one more packet. |
| media_high_seq_num = static_cast<uint16_t>(packets_.back().seqNum + 1); |
| } |
| } |
| |
| // Compute session/packet scores and thresholds: |
| // based on RTT and layer info (when available). |
| float nack_score_threshold = 0.25f; |
| float layer_score = TemporalId() > 0 ? 0.0f : 1.0f; |
| float rtt_score = 1.0f; |
| float score_multiplier = rtt_score * layer_score; |
| // Zero out between first entry and end point. |
| PacketIterator it = packets_.begin(); |
| PacketIterator prev_it = it; |
| ++index; |
| ++it; |
| // TODO(holmer): Rewrite this in a way which better makes use of the list. |
| while (it != packets_.end() && index < seq_num_list_length) { |
| // Only process media packet sequence numbers. |
| if (LatestSequenceNumber((*it).seqNum, media_high_seq_num, NULL) == |
| (*it).seqNum && (*it).seqNum != media_high_seq_num) |
| break; |
| if (!InSequence(it, prev_it)) { |
| // Found a sequence number gap due to packet loss. |
| int num_lost = PacketsMissing(it, prev_it); |
| for (int i = 0 ; i < num_lost; ++i) { |
| // Compute score of the packet. |
| float score = 1.0f; |
| // Multiply internal score (packet) by score multiplier. |
| score *= score_multiplier; |
| if (score > nack_score_threshold) { |
| allow_nack = true; |
| } else { |
| seq_num_list[index] = -1; |
| } |
| ++index; |
| } |
| } |
| seq_num_list[index] = -1; |
| ++index; |
| prev_it = it; |
| ++it; |
| } |
| |
| // Empty packets follow the data packets, and therefore have a higher |
| // sequence number. We do not want to NACK empty packets. |
| if ((empty_seq_num_low_ != -1) && (empty_seq_num_high_ != -1) && |
| (index < seq_num_list_length)) { |
| // First make sure that we are at least at the minimum value (if not we are |
| // missing last packet(s)). |
| while (seq_num_list[index] < empty_seq_num_low_ && |
| index < seq_num_list_length) { |
| ++index; |
| } |
| |
| // Mark empty packets. |
| while (seq_num_list[index] <= empty_seq_num_high_ && |
| index < seq_num_list_length) { |
| seq_num_list[index] = -2; |
| ++index; |
| } |
| } |
| |
| session_nack_ = allow_nack; |
| return 0; |
| } |
| |
| int VCMSessionInfo::PacketsMissing(const PacketIterator& packet_it, |
| const PacketIterator& prev_packet_it) { |
| if (packet_it == prev_packet_it) |
| return 0; |
| if ((*prev_packet_it).seqNum > (*packet_it).seqNum) // Wrap. |
| return static_cast<WebRtc_UWord16>( |
| static_cast<WebRtc_UWord32>((*packet_it).seqNum + 0x10000) - |
| (*prev_packet_it).seqNum) - 1; |
| else |
| return (*packet_it).seqNum - (*prev_packet_it).seqNum - 1; |
| } |
| |
| bool |
| VCMSessionInfo::HaveLastPacket() const { |
| return (!packets_.empty() && packets_.back().markerBit); |
| } |
| |
| bool |
| VCMSessionInfo::session_nack() const { |
| return session_nack_; |
| } |
| |
| int VCMSessionInfo::InsertPacket(const VCMPacket& packet, |
| uint8_t* frame_buffer, |
| bool enable_decodable_state, |
| int rtt_ms) { |
| // Check if this is first packet (only valid for some codecs) |
| if (packet.isFirstPacket) { |
| // The first packet in a frame signals the frame type. |
| frame_type_ = packet.frameType; |
| } else if (frame_type_ == kFrameEmpty && packet.frameType != kFrameEmpty) { |
| // Update the frame type with the first media packet. |
| frame_type_ = packet.frameType; |
| } |
| if (packet.frameType == kFrameEmpty) { |
| // Update sequence number of an empty packet. |
| // Only media packets are inserted into the packet list. |
| InformOfEmptyPacket(packet.seqNum); |
| return 0; |
| } |
| |
| if (packets_.size() == kMaxPacketsInSession) |
| return -1; |
| |
| // Find the position of this packet in the packet list in sequence number |
| // order and insert it. Loop over the list in reverse order. |
| ReversePacketIterator rit = packets_.rbegin(); |
| for (; rit != packets_.rend(); ++rit) |
| if (LatestSequenceNumber((*rit).seqNum, packet.seqNum, NULL) == |
| packet.seqNum) |
| break; |
| |
| // Check for duplicate packets. |
| if (rit != packets_.rend() && |
| (*rit).seqNum == packet.seqNum && (*rit).sizeBytes > 0) |
| return -2; |
| |
| // The insert operation invalidates the iterator |rit|. |
| PacketIterator packet_list_it = packets_.insert(rit.base(), packet); |
| |
| int returnLength = InsertBuffer(frame_buffer, packet_list_it); |
| UpdateCompleteSession(); |
| if (enable_decodable_state) |
| UpdateDecodableSession(rtt_ms); |
| return returnLength; |
| } |
| |
| void VCMSessionInfo::InformOfEmptyPacket(uint16_t seq_num) { |
| // Empty packets may be FEC or filler packets. They are sequential and |
| // follow the data packets, therefore, we should only keep track of the high |
| // and low sequence numbers and may assume that the packets in between are |
| // empty packets belonging to the same frame (timestamp). |
| empty_seq_num_high_ = LatestSequenceNumber(seq_num, empty_seq_num_high_, |
| NULL); |
| if (empty_seq_num_low_ == -1 || |
| LatestSequenceNumber(seq_num, empty_seq_num_low_, NULL) == |
| empty_seq_num_low_) |
| empty_seq_num_low_ = seq_num; |
| } |
| |
| int VCMSessionInfo::packets_not_decodable() const { |
| return packets_not_decodable_; |
| } |
| |
| } // namespace webrtc |