1 /* 2 * Copyright (c) 2012 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 MODULES_AUDIO_CODING_NETEQ_PACKET_H_ 12 #define MODULES_AUDIO_CODING_NETEQ_PACKET_H_ 13 14 #include <stdint.h> 15 16 #include <list> 17 #include <memory> 18 19 #include "api/audio_codecs/audio_decoder.h" 20 #include "api/neteq/tick_timer.h" 21 #include "api/rtp_packet_info.h" 22 #include "rtc_base/buffer.h" 23 #include "rtc_base/checks.h" 24 25 namespace webrtc { 26 27 // Struct for holding RTP packets. 28 struct Packet { 29 struct Priority { PriorityPacket::Priority30 Priority() : codec_level(0), red_level(0) {} PriorityPacket::Priority31 Priority(int codec_level, int red_level) 32 : codec_level(codec_level), red_level(red_level) { 33 CheckInvariant(); 34 } 35 36 int codec_level; 37 int red_level; 38 39 // Priorities are sorted low-to-high, first on the level the codec 40 // prioritizes it, then on the level of RED packet it is; i.e. if it is a 41 // primary or secondary payload of a RED packet. For example: with Opus, an 42 // Fec packet (which the decoder prioritizes lower than a regular packet) 43 // will not be used if there is _any_ RED payload for the same 44 // timeframe. The highest priority packet will have levels {0, 0}. Negative 45 // priorities are not allowed. 46 bool operator<(const Priority& b) const { 47 CheckInvariant(); 48 b.CheckInvariant(); 49 if (codec_level == b.codec_level) 50 return red_level < b.red_level; 51 52 return codec_level < b.codec_level; 53 } 54 bool operator==(const Priority& b) const { 55 CheckInvariant(); 56 b.CheckInvariant(); 57 return codec_level == b.codec_level && red_level == b.red_level; 58 } 59 bool operator!=(const Priority& b) const { return !(*this == b); } 60 bool operator>(const Priority& b) const { return b < *this; } 61 bool operator<=(const Priority& b) const { return !(b > *this); } 62 bool operator>=(const Priority& b) const { return !(b < *this); } 63 64 private: CheckInvariantPacket::Priority65 void CheckInvariant() const { 66 RTC_DCHECK_GE(codec_level, 0); 67 RTC_DCHECK_GE(red_level, 0); 68 } 69 }; 70 71 uint32_t timestamp; 72 uint16_t sequence_number; 73 uint8_t payload_type; 74 // Datagram excluding RTP header and header extension. 75 rtc::Buffer payload; 76 Priority priority; 77 RtpPacketInfo packet_info; 78 std::unique_ptr<TickTimer::Stopwatch> waiting_time; 79 std::unique_ptr<AudioDecoder::EncodedAudioFrame> frame; 80 81 Packet(); 82 Packet(Packet&& b); 83 ~Packet(); 84 85 // Packets should generally be moved around but sometimes it's useful to make 86 // a copy, for example for testing purposes. NOTE: Will only work for 87 // un-parsed packets, i.e. |frame| must be unset. The payload will, however, 88 // be copied. |waiting_time| will also not be copied. 89 Packet Clone() const; 90 91 Packet& operator=(Packet&& b); 92 93 // Comparison operators. Establish a packet ordering based on (1) timestamp, 94 // (2) sequence number and (3) redundancy. 95 // Timestamp and sequence numbers are compared taking wrap-around into 96 // account. For two packets with the same sequence number and timestamp a 97 // primary payload is considered "smaller" than a secondary. 98 bool operator==(const Packet& rhs) const { 99 return (this->timestamp == rhs.timestamp && 100 this->sequence_number == rhs.sequence_number && 101 this->priority == rhs.priority); 102 } 103 bool operator!=(const Packet& rhs) const { return !operator==(rhs); } 104 bool operator<(const Packet& rhs) const { 105 if (this->timestamp == rhs.timestamp) { 106 if (this->sequence_number == rhs.sequence_number) { 107 // Timestamp and sequence numbers are identical - deem the left hand 108 // side to be "smaller" (i.e., "earlier") if it has higher priority. 109 return this->priority < rhs.priority; 110 } 111 return (static_cast<uint16_t>(rhs.sequence_number - 112 this->sequence_number) < 0xFFFF / 2); 113 } 114 return (static_cast<uint32_t>(rhs.timestamp - this->timestamp) < 115 0xFFFFFFFF / 2); 116 } 117 bool operator>(const Packet& rhs) const { return rhs.operator<(*this); } 118 bool operator<=(const Packet& rhs) const { return !operator>(rhs); } 119 bool operator>=(const Packet& rhs) const { return !operator<(rhs); } 120 emptyPacket121 bool empty() const { return !frame && payload.empty(); } 122 }; 123 124 // A list of packets. 125 typedef std::list<Packet> PacketList; 126 127 } // namespace webrtc 128 #endif // MODULES_AUDIO_CODING_NETEQ_PACKET_H_ 129