1 /* 2 * Copyright (c) 2019 The WebRTC project authors. All Rights Reserved. 3 * 4 * Use of this source code is governed by a BSD-style license 5 * that can be found in the LICENSE file in the root of the source 6 * tree. An additional intellectual property rights grant can be found 7 * in the file PATENTS. All contributing project authors may 8 * be found in the AUTHORS file in the root of the source tree. 9 */ 10 11 #ifndef API_RTP_PACKET_INFOS_H_ 12 #define API_RTP_PACKET_INFOS_H_ 13 14 #include <cstdint> 15 #include <utility> 16 #include <vector> 17 18 #include "api/make_ref_counted.h" 19 #include "api/ref_counted_base.h" 20 #include "api/rtp_packet_info.h" 21 #include "api/scoped_refptr.h" 22 #include "rtc_base/system/rtc_export.h" 23 24 namespace webrtc { 25 26 // Semi-immutable structure to hold information about packets used to assemble 27 // an audio or video frame. Uses internal reference counting to make it very 28 // cheap to copy. 29 // 30 // We should ideally just use `std::vector<RtpPacketInfo>` and have it 31 // `std::move()`-ed as the per-packet information is transferred from one object 32 // to another. But moving the info, instead of copying it, is not easily done 33 // for the current video code. 34 class RTC_EXPORT RtpPacketInfos { 35 public: 36 using vector_type = std::vector<RtpPacketInfo>; 37 38 using value_type = vector_type::value_type; 39 using size_type = vector_type::size_type; 40 using difference_type = vector_type::difference_type; 41 using const_reference = vector_type::const_reference; 42 using const_pointer = vector_type::const_pointer; 43 using const_iterator = vector_type::const_iterator; 44 using const_reverse_iterator = vector_type::const_reverse_iterator; 45 46 using reference = const_reference; 47 using pointer = const_pointer; 48 using iterator = const_iterator; 49 using reverse_iterator = const_reverse_iterator; 50 RtpPacketInfos()51 RtpPacketInfos() {} RtpPacketInfos(const vector_type & entries)52 explicit RtpPacketInfos(const vector_type& entries) 53 : data_(Data::Create(entries)) {} 54 RtpPacketInfos(vector_type && entries)55 explicit RtpPacketInfos(vector_type&& entries) 56 : data_(Data::Create(std::move(entries))) {} 57 58 RtpPacketInfos(const RtpPacketInfos& other) = default; 59 RtpPacketInfos(RtpPacketInfos&& other) = default; 60 RtpPacketInfos& operator=(const RtpPacketInfos& other) = default; 61 RtpPacketInfos& operator=(RtpPacketInfos&& other) = default; 62 63 const_reference operator[](size_type pos) const { return entries()[pos]; } 64 at(size_type pos)65 const_reference at(size_type pos) const { return entries().at(pos); } front()66 const_reference front() const { return entries().front(); } back()67 const_reference back() const { return entries().back(); } 68 begin()69 const_iterator begin() const { return entries().begin(); } end()70 const_iterator end() const { return entries().end(); } rbegin()71 const_reverse_iterator rbegin() const { return entries().rbegin(); } rend()72 const_reverse_iterator rend() const { return entries().rend(); } 73 cbegin()74 const_iterator cbegin() const { return entries().cbegin(); } cend()75 const_iterator cend() const { return entries().cend(); } crbegin()76 const_reverse_iterator crbegin() const { return entries().crbegin(); } crend()77 const_reverse_iterator crend() const { return entries().crend(); } 78 empty()79 bool empty() const { return entries().empty(); } size()80 size_type size() const { return entries().size(); } 81 82 private: 83 class Data final : public rtc::RefCountedNonVirtual<Data> { 84 public: Create(const vector_type & entries)85 static rtc::scoped_refptr<Data> Create(const vector_type& entries) { 86 // Performance optimization for the empty case. 87 if (entries.empty()) { 88 return nullptr; 89 } 90 91 return rtc::make_ref_counted<Data>(entries); 92 } 93 Create(vector_type && entries)94 static rtc::scoped_refptr<Data> Create(vector_type&& entries) { 95 // Performance optimization for the empty case. 96 if (entries.empty()) { 97 return nullptr; 98 } 99 100 return rtc::make_ref_counted<Data>(std::move(entries)); 101 } 102 entries()103 const vector_type& entries() const { return entries_; } 104 Data(const vector_type & entries)105 explicit Data(const vector_type& entries) : entries_(entries) {} Data(vector_type && entries)106 explicit Data(vector_type&& entries) : entries_(std::move(entries)) {} 107 ~Data() = default; 108 109 private: 110 const vector_type entries_; 111 }; 112 empty_entries()113 static const vector_type& empty_entries() { 114 static const vector_type& value = *new vector_type(); 115 return value; 116 } 117 entries()118 const vector_type& entries() const { 119 if (data_ != nullptr) { 120 return data_->entries(); 121 } else { 122 return empty_entries(); 123 } 124 } 125 126 rtc::scoped_refptr<Data> data_; 127 }; 128 129 } // namespace webrtc 130 131 #endif // API_RTP_PACKET_INFOS_H_ 132