| /* |
| * 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/rtp_rtcp/source/rtp_format_vp8.h" |
| |
| #include <string.h> // memcpy |
| |
| #include <limits> |
| #include <utility> |
| #include <vector> |
| |
| #include "modules/rtp_rtcp/source/rtp_packet_to_send.h" |
| #include "rtc_base/checks.h" |
| #include "rtc_base/logging.h" |
| |
| namespace webrtc { |
| namespace { |
| int ParseVP8PictureID(RTPVideoHeaderVP8* vp8, |
| const uint8_t** data, |
| size_t* data_length, |
| size_t* parsed_bytes) { |
| if (*data_length == 0) |
| return -1; |
| |
| vp8->pictureId = (**data & 0x7F); |
| if (**data & 0x80) { |
| (*data)++; |
| (*parsed_bytes)++; |
| if (--(*data_length) == 0) |
| return -1; |
| // PictureId is 15 bits |
| vp8->pictureId = (vp8->pictureId << 8) + **data; |
| } |
| (*data)++; |
| (*parsed_bytes)++; |
| (*data_length)--; |
| return 0; |
| } |
| |
| int ParseVP8Tl0PicIdx(RTPVideoHeaderVP8* vp8, |
| const uint8_t** data, |
| size_t* data_length, |
| size_t* parsed_bytes) { |
| if (*data_length == 0) |
| return -1; |
| |
| vp8->tl0PicIdx = **data; |
| (*data)++; |
| (*parsed_bytes)++; |
| (*data_length)--; |
| return 0; |
| } |
| |
| int ParseVP8TIDAndKeyIdx(RTPVideoHeaderVP8* vp8, |
| const uint8_t** data, |
| size_t* data_length, |
| size_t* parsed_bytes, |
| bool has_tid, |
| bool has_key_idx) { |
| if (*data_length == 0) |
| return -1; |
| |
| if (has_tid) { |
| vp8->temporalIdx = ((**data >> 6) & 0x03); |
| vp8->layerSync = (**data & 0x20) ? true : false; // Y bit |
| } |
| if (has_key_idx) { |
| vp8->keyIdx = (**data & 0x1F); |
| } |
| (*data)++; |
| (*parsed_bytes)++; |
| (*data_length)--; |
| return 0; |
| } |
| |
| int ParseVP8Extension(RTPVideoHeaderVP8* vp8, |
| const uint8_t* data, |
| size_t data_length) { |
| RTC_DCHECK_GT(data_length, 0); |
| size_t parsed_bytes = 0; |
| // Optional X field is present. |
| bool has_picture_id = (*data & 0x80) ? true : false; // I bit |
| bool has_tl0_pic_idx = (*data & 0x40) ? true : false; // L bit |
| bool has_tid = (*data & 0x20) ? true : false; // T bit |
| bool has_key_idx = (*data & 0x10) ? true : false; // K bit |
| |
| // Advance data and decrease remaining payload size. |
| data++; |
| parsed_bytes++; |
| data_length--; |
| |
| if (has_picture_id) { |
| if (ParseVP8PictureID(vp8, &data, &data_length, &parsed_bytes) != 0) { |
| return -1; |
| } |
| } |
| |
| if (has_tl0_pic_idx) { |
| if (ParseVP8Tl0PicIdx(vp8, &data, &data_length, &parsed_bytes) != 0) { |
| return -1; |
| } |
| } |
| |
| if (has_tid || has_key_idx) { |
| if (ParseVP8TIDAndKeyIdx(vp8, &data, &data_length, &parsed_bytes, has_tid, |
| has_key_idx) != 0) { |
| return -1; |
| } |
| } |
| return static_cast<int>(parsed_bytes); |
| } |
| |
| int ParseVP8FrameSize(RtpDepacketizer::ParsedPayload* parsed_payload, |
| const uint8_t* data, |
| size_t data_length) { |
| if (parsed_payload->frame_type != kVideoFrameKey) { |
| // Included in payload header for I-frames. |
| return 0; |
| } |
| if (data_length < 10) { |
| // For an I-frame we should always have the uncompressed VP8 header |
| // in the beginning of the partition. |
| return -1; |
| } |
| parsed_payload->type.Video.width = ((data[7] << 8) + data[6]) & 0x3FFF; |
| parsed_payload->type.Video.height = ((data[9] << 8) + data[8]) & 0x3FFF; |
| return 0; |
| } |
| |
| bool ValidateHeader(const RTPVideoHeaderVP8& hdr_info) { |
| if (hdr_info.pictureId != kNoPictureId) { |
| RTC_DCHECK_GE(hdr_info.pictureId, 0); |
| RTC_DCHECK_LE(hdr_info.pictureId, 0x7FFF); |
| } |
| if (hdr_info.tl0PicIdx != kNoTl0PicIdx) { |
| RTC_DCHECK_GE(hdr_info.tl0PicIdx, 0); |
| RTC_DCHECK_LE(hdr_info.tl0PicIdx, 0xFF); |
| } |
| if (hdr_info.temporalIdx != kNoTemporalIdx) { |
| RTC_DCHECK_GE(hdr_info.temporalIdx, 0); |
| RTC_DCHECK_LE(hdr_info.temporalIdx, 3); |
| } else { |
| RTC_DCHECK(!hdr_info.layerSync); |
| } |
| if (hdr_info.keyIdx != kNoKeyIdx) { |
| RTC_DCHECK_GE(hdr_info.keyIdx, 0); |
| RTC_DCHECK_LE(hdr_info.keyIdx, 0x1F); |
| } |
| return true; |
| } |
| |
| } // namespace |
| |
| RtpPacketizerVp8::RtpPacketizerVp8(const RTPVideoHeaderVP8& hdr_info, |
| size_t max_payload_len, |
| size_t last_packet_reduction_len) |
| : payload_data_(NULL), |
| payload_size_(0), |
| vp8_fixed_payload_descriptor_bytes_(1), |
| hdr_info_(hdr_info), |
| max_payload_len_(max_payload_len), |
| last_packet_reduction_len_(last_packet_reduction_len) { |
| RTC_DCHECK(ValidateHeader(hdr_info)); |
| } |
| |
| RtpPacketizerVp8::~RtpPacketizerVp8() {} |
| |
| size_t RtpPacketizerVp8::SetPayloadData( |
| const uint8_t* payload_data, |
| size_t payload_size, |
| const RTPFragmentationHeader* /* fragmentation */) { |
| payload_data_ = payload_data; |
| payload_size_ = payload_size; |
| if (GeneratePackets() < 0) { |
| return 0; |
| } |
| return packets_.size(); |
| } |
| |
| bool RtpPacketizerVp8::NextPacket(RtpPacketToSend* packet) { |
| RTC_DCHECK(packet); |
| if (packets_.empty()) { |
| return false; |
| } |
| InfoStruct packet_info = packets_.front(); |
| packets_.pop(); |
| |
| uint8_t* buffer = packet->AllocatePayload( |
| packets_.empty() ? max_payload_len_ - last_packet_reduction_len_ |
| : max_payload_len_); |
| int bytes = WriteHeaderAndPayload(packet_info, buffer, max_payload_len_); |
| if (bytes < 0) { |
| return false; |
| } |
| packet->SetPayloadSize(bytes); |
| packet->SetMarker(packets_.empty()); |
| return true; |
| } |
| |
| std::string RtpPacketizerVp8::ToString() { |
| return "RtpPacketizerVp8"; |
| } |
| |
| int RtpPacketizerVp8::GeneratePackets() { |
| if (max_payload_len_ < vp8_fixed_payload_descriptor_bytes_ + |
| PayloadDescriptorExtraLength() + 1 + |
| last_packet_reduction_len_) { |
| // The provided payload length is not long enough for the payload |
| // descriptor and one payload byte in the last packet. |
| // Return an error. |
| return -1; |
| } |
| |
| size_t per_packet_capacity = |
| max_payload_len_ - |
| (vp8_fixed_payload_descriptor_bytes_ + PayloadDescriptorExtraLength()); |
| |
| GeneratePacketsSplitPayloadBalanced(payload_size_, per_packet_capacity); |
| return 0; |
| } |
| |
| void RtpPacketizerVp8::GeneratePacketsSplitPayloadBalanced(size_t payload_len, |
| size_t capacity) { |
| // Last packet of the last partition is smaller. Pretend that it's the same |
| // size, but we must write more payload to it. |
| size_t total_bytes = payload_len + last_packet_reduction_len_; |
| // Integer divisions with rounding up. |
| size_t num_packets_left = (total_bytes + capacity - 1) / capacity; |
| size_t bytes_per_packet = total_bytes / num_packets_left; |
| size_t num_larger_packets = total_bytes % num_packets_left; |
| size_t remaining_data = payload_len; |
| while (remaining_data > 0) { |
| // Last num_larger_packets are 1 byte wider than the rest. Increase |
| // per-packet payload size when needed. |
| if (num_packets_left == num_larger_packets) |
| ++bytes_per_packet; |
| size_t current_packet_bytes = bytes_per_packet; |
| if (current_packet_bytes > remaining_data) { |
| current_packet_bytes = remaining_data; |
| } |
| // This is not the last packet in the whole payload, but there's no data |
| // left for the last packet. Leave at least one byte for the last packet. |
| if (num_packets_left == 2 && current_packet_bytes == remaining_data) { |
| --current_packet_bytes; |
| } |
| QueuePacket(payload_len - remaining_data, current_packet_bytes, |
| remaining_data == payload_len); |
| remaining_data -= current_packet_bytes; |
| --num_packets_left; |
| } |
| } |
| |
| void RtpPacketizerVp8::QueuePacket(size_t start_pos, |
| size_t packet_size, |
| bool first_packet) { |
| // Write info to packet info struct and store in packet info queue. |
| InfoStruct packet_info; |
| packet_info.payload_start_pos = start_pos; |
| packet_info.size = packet_size; |
| packet_info.first_packet = first_packet; |
| packets_.push(packet_info); |
| } |
| |
| int RtpPacketizerVp8::WriteHeaderAndPayload(const InfoStruct& packet_info, |
| uint8_t* buffer, |
| size_t buffer_length) const { |
| // Write the VP8 payload descriptor. |
| // 0 |
| // 0 1 2 3 4 5 6 7 8 |
| // +-+-+-+-+-+-+-+-+-+ |
| // |X| |N|S| PART_ID | |
| // +-+-+-+-+-+-+-+-+-+ |
| // X: |I|L|T|K| | (mandatory if any of the below are used) |
| // +-+-+-+-+-+-+-+-+-+ |
| // I: |PictureID (8/16b)| (optional) |
| // +-+-+-+-+-+-+-+-+-+ |
| // L: | TL0PIC_IDX | (optional) |
| // +-+-+-+-+-+-+-+-+-+ |
| // T/K: |TID:Y| KEYIDX | (optional) |
| // +-+-+-+-+-+-+-+-+-+ |
| |
| RTC_DCHECK_GT(packet_info.size, 0); |
| buffer[0] = 0; |
| if (XFieldPresent()) |
| buffer[0] |= kXBit; |
| if (hdr_info_.nonReference) |
| buffer[0] |= kNBit; |
| if (packet_info.first_packet) |
| buffer[0] |= kSBit; |
| |
| const int extension_length = WriteExtensionFields(buffer, buffer_length); |
| if (extension_length < 0) |
| return -1; |
| |
| memcpy(&buffer[vp8_fixed_payload_descriptor_bytes_ + extension_length], |
| &payload_data_[packet_info.payload_start_pos], packet_info.size); |
| |
| // Return total length of written data. |
| return packet_info.size + vp8_fixed_payload_descriptor_bytes_ + |
| extension_length; |
| } |
| |
| int RtpPacketizerVp8::WriteExtensionFields(uint8_t* buffer, |
| size_t buffer_length) const { |
| size_t extension_length = 0; |
| if (XFieldPresent()) { |
| uint8_t* x_field = buffer + vp8_fixed_payload_descriptor_bytes_; |
| *x_field = 0; |
| extension_length = 1; // One octet for the X field. |
| if (PictureIdPresent()) { |
| if (WritePictureIDFields(x_field, buffer, buffer_length, |
| &extension_length) < 0) { |
| return -1; |
| } |
| } |
| if (TL0PicIdxFieldPresent()) { |
| if (WriteTl0PicIdxFields(x_field, buffer, buffer_length, |
| &extension_length) < 0) { |
| return -1; |
| } |
| } |
| if (TIDFieldPresent() || KeyIdxFieldPresent()) { |
| if (WriteTIDAndKeyIdxFields(x_field, buffer, buffer_length, |
| &extension_length) < 0) { |
| return -1; |
| } |
| } |
| RTC_DCHECK_EQ(extension_length, PayloadDescriptorExtraLength()); |
| } |
| return static_cast<int>(extension_length); |
| } |
| |
| int RtpPacketizerVp8::WritePictureIDFields(uint8_t* x_field, |
| uint8_t* buffer, |
| size_t buffer_length, |
| size_t* extension_length) const { |
| *x_field |= kIBit; |
| RTC_DCHECK_GE(buffer_length, |
| vp8_fixed_payload_descriptor_bytes_ + *extension_length); |
| const int pic_id_length = WritePictureID( |
| buffer + vp8_fixed_payload_descriptor_bytes_ + *extension_length, |
| buffer_length - vp8_fixed_payload_descriptor_bytes_ - *extension_length); |
| if (pic_id_length < 0) |
| return -1; |
| *extension_length += pic_id_length; |
| return 0; |
| } |
| |
| int RtpPacketizerVp8::WritePictureID(uint8_t* buffer, |
| size_t buffer_length) const { |
| const uint16_t pic_id = static_cast<uint16_t>(hdr_info_.pictureId); |
| size_t picture_id_len = PictureIdLength(); |
| if (picture_id_len > buffer_length) |
| return -1; |
| if (picture_id_len == 2) { |
| buffer[0] = 0x80 | ((pic_id >> 8) & 0x7F); |
| buffer[1] = pic_id & 0xFF; |
| } else if (picture_id_len == 1) { |
| buffer[0] = pic_id & 0x7F; |
| } |
| return static_cast<int>(picture_id_len); |
| } |
| |
| int RtpPacketizerVp8::WriteTl0PicIdxFields(uint8_t* x_field, |
| uint8_t* buffer, |
| size_t buffer_length, |
| size_t* extension_length) const { |
| if (buffer_length < |
| vp8_fixed_payload_descriptor_bytes_ + *extension_length + 1) { |
| return -1; |
| } |
| *x_field |= kLBit; |
| buffer[vp8_fixed_payload_descriptor_bytes_ + *extension_length] = |
| hdr_info_.tl0PicIdx; |
| ++*extension_length; |
| return 0; |
| } |
| |
| int RtpPacketizerVp8::WriteTIDAndKeyIdxFields(uint8_t* x_field, |
| uint8_t* buffer, |
| size_t buffer_length, |
| size_t* extension_length) const { |
| if (buffer_length < |
| vp8_fixed_payload_descriptor_bytes_ + *extension_length + 1) { |
| return -1; |
| } |
| uint8_t* data_field = |
| &buffer[vp8_fixed_payload_descriptor_bytes_ + *extension_length]; |
| *data_field = 0; |
| if (TIDFieldPresent()) { |
| *x_field |= kTBit; |
| *data_field |= hdr_info_.temporalIdx << 6; |
| *data_field |= hdr_info_.layerSync ? kYBit : 0; |
| } |
| if (KeyIdxFieldPresent()) { |
| *x_field |= kKBit; |
| *data_field |= (hdr_info_.keyIdx & kKeyIdxField); |
| } |
| ++*extension_length; |
| return 0; |
| } |
| |
| size_t RtpPacketizerVp8::PayloadDescriptorExtraLength() const { |
| size_t length_bytes = PictureIdLength(); |
| if (TL0PicIdxFieldPresent()) |
| ++length_bytes; |
| if (TIDFieldPresent() || KeyIdxFieldPresent()) |
| ++length_bytes; |
| if (length_bytes > 0) |
| ++length_bytes; // Include the extension field. |
| return length_bytes; |
| } |
| |
| size_t RtpPacketizerVp8::PictureIdLength() const { |
| if (hdr_info_.pictureId == kNoPictureId) { |
| return 0; |
| } |
| return 2; |
| } |
| |
| bool RtpPacketizerVp8::XFieldPresent() const { |
| return (TIDFieldPresent() || TL0PicIdxFieldPresent() || PictureIdPresent() || |
| KeyIdxFieldPresent()); |
| } |
| |
| bool RtpPacketizerVp8::TIDFieldPresent() const { |
| return (hdr_info_.temporalIdx != kNoTemporalIdx); |
| } |
| |
| bool RtpPacketizerVp8::KeyIdxFieldPresent() const { |
| return (hdr_info_.keyIdx != kNoKeyIdx); |
| } |
| |
| bool RtpPacketizerVp8::TL0PicIdxFieldPresent() const { |
| return (hdr_info_.tl0PicIdx != kNoTl0PicIdx); |
| } |
| |
| // |
| // VP8 format: |
| // |
| // Payload descriptor |
| // 0 1 2 3 4 5 6 7 |
| // +-+-+-+-+-+-+-+-+ |
| // |X|R|N|S|PartID | (REQUIRED) |
| // +-+-+-+-+-+-+-+-+ |
| // X: |I|L|T|K| RSV | (OPTIONAL) |
| // +-+-+-+-+-+-+-+-+ |
| // I: | PictureID | (OPTIONAL) |
| // +-+-+-+-+-+-+-+-+ |
| // L: | TL0PICIDX | (OPTIONAL) |
| // +-+-+-+-+-+-+-+-+ |
| // T/K: |TID:Y| KEYIDX | (OPTIONAL) |
| // +-+-+-+-+-+-+-+-+ |
| // |
| // Payload header (considered part of the actual payload, sent to decoder) |
| // 0 1 2 3 4 5 6 7 |
| // +-+-+-+-+-+-+-+-+ |
| // |Size0|H| VER |P| |
| // +-+-+-+-+-+-+-+-+ |
| // | ... | |
| // + + |
| bool RtpDepacketizerVp8::Parse(ParsedPayload* parsed_payload, |
| const uint8_t* payload_data, |
| size_t payload_data_length) { |
| RTC_DCHECK(parsed_payload); |
| if (payload_data_length == 0) { |
| RTC_LOG(LS_ERROR) << "Empty payload."; |
| return false; |
| } |
| |
| // Parse mandatory first byte of payload descriptor. |
| bool extension = (*payload_data & 0x80) ? true : false; // X bit |
| bool beginning_of_partition = (*payload_data & 0x10) ? true : false; // S bit |
| int partition_id = (*payload_data & 0x0F); // PartID field |
| |
| parsed_payload->type.Video.width = 0; |
| parsed_payload->type.Video.height = 0; |
| parsed_payload->type.Video.is_first_packet_in_frame = |
| beginning_of_partition && (partition_id == 0); |
| parsed_payload->type.Video.simulcastIdx = 0; |
| parsed_payload->type.Video.codec = kVideoCodecVP8; |
| parsed_payload->type.Video.codecHeader.VP8.nonReference = |
| (*payload_data & 0x20) ? true : false; // N bit |
| parsed_payload->type.Video.codecHeader.VP8.partitionId = partition_id; |
| parsed_payload->type.Video.codecHeader.VP8.beginningOfPartition = |
| beginning_of_partition; |
| parsed_payload->type.Video.codecHeader.VP8.pictureId = kNoPictureId; |
| parsed_payload->type.Video.codecHeader.VP8.tl0PicIdx = kNoTl0PicIdx; |
| parsed_payload->type.Video.codecHeader.VP8.temporalIdx = kNoTemporalIdx; |
| parsed_payload->type.Video.codecHeader.VP8.layerSync = false; |
| parsed_payload->type.Video.codecHeader.VP8.keyIdx = kNoKeyIdx; |
| |
| if (partition_id > 8) { |
| // Weak check for corrupt payload_data: PartID MUST NOT be larger than 8. |
| return false; |
| } |
| |
| // Advance payload_data and decrease remaining payload size. |
| payload_data++; |
| if (payload_data_length <= 1) { |
| RTC_LOG(LS_ERROR) << "Error parsing VP8 payload descriptor!"; |
| return false; |
| } |
| payload_data_length--; |
| |
| if (extension) { |
| const int parsed_bytes = |
| ParseVP8Extension(&parsed_payload->type.Video.codecHeader.VP8, |
| payload_data, payload_data_length); |
| if (parsed_bytes < 0) |
| return false; |
| payload_data += parsed_bytes; |
| payload_data_length -= parsed_bytes; |
| if (payload_data_length == 0) { |
| RTC_LOG(LS_ERROR) << "Error parsing VP8 payload descriptor!"; |
| return false; |
| } |
| } |
| |
| // Read P bit from payload header (only at beginning of first partition). |
| if (beginning_of_partition && partition_id == 0) { |
| parsed_payload->frame_type = |
| (*payload_data & 0x01) ? kVideoFrameDelta : kVideoFrameKey; |
| } else { |
| parsed_payload->frame_type = kVideoFrameDelta; |
| } |
| |
| if (ParseVP8FrameSize(parsed_payload, payload_data, payload_data_length) != |
| 0) { |
| return false; |
| } |
| |
| parsed_payload->payload = payload_data; |
| parsed_payload->payload_length = payload_data_length; |
| return true; |
| } |
| } // namespace webrtc |
