OLD | NEW |
1 /* | 1 /* |
2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. | 2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license | 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 | 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 | 6 * tree. An additional intellectual property rights grant can be found |
7 * in the file PATENTS. All contributing project authors may | 7 * in the file PATENTS. All contributing project authors may |
8 * be found in the AUTHORS file in the root of the source tree. | 8 * be found in the AUTHORS file in the root of the source tree. |
9 */ | 9 */ |
10 | 10 |
11 #ifndef WEBRTC_MODULES_RTP_RTCP_SOURCE_FORWARD_ERROR_CORRECTION_H_ | 11 #ifndef WEBRTC_MODULES_RTP_RTCP_SOURCE_FORWARD_ERROR_CORRECTION_H_ |
12 #define WEBRTC_MODULES_RTP_RTCP_SOURCE_FORWARD_ERROR_CORRECTION_H_ | 12 #define WEBRTC_MODULES_RTP_RTCP_SOURCE_FORWARD_ERROR_CORRECTION_H_ |
13 | 13 |
14 #include <stdint.h> | 14 #include <stdint.h> |
15 | 15 |
16 #include <list> | 16 #include <list> |
| 17 #include <map> |
17 #include <memory> | 18 #include <memory> |
| 19 #include <tuple> |
18 #include <vector> | 20 #include <vector> |
19 | 21 |
| 22 #include "webrtc/base/basictypes.h" |
| 23 #include "webrtc/base/constructormagic.h" |
20 #include "webrtc/base/refcount.h" | 24 #include "webrtc/base/refcount.h" |
21 #include "webrtc/base/scoped_ref_ptr.h" | 25 #include "webrtc/base/scoped_ref_ptr.h" |
22 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h" | 26 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h" |
23 #include "webrtc/modules/rtp_rtcp/source/forward_error_correction_internal.h" | 27 #include "webrtc/modules/rtp_rtcp/source/forward_error_correction_internal.h" |
24 #include "webrtc/typedefs.h" | |
25 | 28 |
26 namespace webrtc { | 29 namespace webrtc { |
27 | 30 |
| 31 class FecHeaderReader; |
| 32 class FecHeaderWriter; |
| 33 |
28 // Performs codec-independent forward error correction (FEC), based on RFC 5109. | 34 // Performs codec-independent forward error correction (FEC), based on RFC 5109. |
29 // Option exists to enable unequal protection (UEP) across packets. | 35 // Option exists to enable unequal protection (UEP) across packets. |
30 // This is not to be confused with protection within packets | 36 // This is not to be confused with protection within packets |
31 // (referred to as uneven level protection (ULP) in RFC 5109). | 37 // (referred to as uneven level protection (ULP) in RFC 5109). |
32 class ForwardErrorCorrection { | 38 class ForwardErrorCorrection { |
33 public: | 39 public: |
34 // Maximum number of media packets we can protect | |
35 static constexpr size_t kMaxMediaPackets = 48u; | |
36 | |
37 // TODO(holmer): As a next step all these struct-like packet classes should be | 40 // TODO(holmer): As a next step all these struct-like packet classes should be |
38 // refactored into proper classes, and their members should be made private. | 41 // refactored into proper classes, and their members should be made private. |
39 // This will require parts of the functionality in forward_error_correction.cc | 42 // This will require parts of the functionality in forward_error_correction.cc |
40 // and receiver_fec.cc to be refactored into the packet classes. | 43 // and receiver_fec.cc to be refactored into the packet classes. |
41 class Packet { | 44 class Packet { |
42 public: | 45 public: |
43 Packet() : length(0), data(), ref_count_(0) {} | 46 Packet() : length(0), data(), ref_count_(0) {} |
44 virtual ~Packet() {} | 47 virtual ~Packet() {} |
45 | 48 |
46 // Add a reference. | 49 // Add a reference. |
(...skipping 25 matching lines...) Expand all Loading... |
72 | 75 |
73 // The received list parameter of DecodeFec() references structs of this type. | 76 // The received list parameter of DecodeFec() references structs of this type. |
74 // | 77 // |
75 // The ssrc member is needed to ensure that we can restore the SSRC field of | 78 // The ssrc member is needed to ensure that we can restore the SSRC field of |
76 // recovered packets. In most situations this could be retrieved from other | 79 // recovered packets. In most situations this could be retrieved from other |
77 // media packets, but in the case of an FEC packet protecting a single | 80 // media packets, but in the case of an FEC packet protecting a single |
78 // missing media packet, we have no other means of obtaining it. | 81 // missing media packet, we have no other means of obtaining it. |
79 // TODO(holmer): Refactor into a proper class. | 82 // TODO(holmer): Refactor into a proper class. |
80 class ReceivedPacket : public SortablePacket { | 83 class ReceivedPacket : public SortablePacket { |
81 public: | 84 public: |
82 ReceivedPacket(); | |
83 ~ReceivedPacket(); | |
84 | |
85 uint32_t ssrc; // SSRC of the current frame. Must be set for FEC | 85 uint32_t ssrc; // SSRC of the current frame. Must be set for FEC |
86 // packets, but not required for media packets. | 86 // packets, but not required for media packets. |
87 bool is_fec; // Set to true if this is an FEC packet and false | 87 bool is_fec; // Set to true if this is an FEC packet and false |
88 // otherwise. | 88 // otherwise. |
89 rtc::scoped_refptr<Packet> pkt; // Pointer to the packet storage. | 89 rtc::scoped_refptr<Packet> pkt; // Pointer to the packet storage. |
90 }; | 90 }; |
91 | 91 |
92 // The recovered list parameter of #DecodeFec() references structs of | 92 // The recovered list parameter of DecodeFec() references structs of |
93 // this type. | 93 // this type. |
94 // TODO(holmer): Refactor into a proper class. | 94 // TODO(holmer): Refactor into a proper class. |
95 class RecoveredPacket : public SortablePacket { | 95 class RecoveredPacket : public SortablePacket { |
96 public: | 96 public: |
97 RecoveredPacket(); | |
98 ~RecoveredPacket(); | |
99 | |
100 bool was_recovered; // Will be true if this packet was recovered by | 97 bool was_recovered; // Will be true if this packet was recovered by |
101 // the FEC. Otherwise it was a media packet passed in | 98 // the FEC. Otherwise it was a media packet passed in |
102 // through the received packet list. | 99 // through the received packet list. |
103 bool returned; // True when the packet already has been returned to the | 100 bool returned; // True when the packet already has been returned to the |
104 // caller through the callback. | 101 // caller through the callback. |
105 uint8_t length_recovery[2]; // Two bytes used for recovering the packet | |
106 // length with XOR operations. | |
107 rtc::scoped_refptr<Packet> pkt; // Pointer to the packet storage. | 102 rtc::scoped_refptr<Packet> pkt; // Pointer to the packet storage. |
108 }; | 103 }; |
109 | 104 |
| 105 // Used to link media packets to their protecting FEC packets. |
| 106 // |
| 107 // TODO(holmer): Refactor into a proper class. |
| 108 class ProtectedPacket : public ForwardErrorCorrection::SortablePacket { |
| 109 public: |
| 110 rtc::scoped_refptr<ForwardErrorCorrection::Packet> pkt; |
| 111 }; |
| 112 |
| 113 using ProtectedPacketList = std::list<std::unique_ptr<ProtectedPacket>>; |
| 114 |
| 115 // Used for internal storage of received FEC packets in a list. |
| 116 // |
| 117 // TODO(holmer): Refactor into a proper class. |
| 118 class ReceivedFecPacket : public ForwardErrorCorrection::SortablePacket { |
| 119 public: |
| 120 ProtectedPacketList protected_packets; |
| 121 // RTP header fields. |
| 122 uint32_t rtp_ssrc; |
| 123 // FEC header fields. |
| 124 size_t fec_header_size; |
| 125 size_t protection_length; |
| 126 // Packet masks metadata. |
| 127 // SSRC -> [SN base, packet mask offset, packet mask size (bytes)] |
| 128 std::map<uint32_t, std::tuple<uint16_t, size_t, size_t>> packet_mask_info; |
| 129 // Raw data. |
| 130 rtc::scoped_refptr<ForwardErrorCorrection::Packet> pkt; |
| 131 }; |
| 132 |
110 using PacketList = std::list<std::unique_ptr<Packet>>; | 133 using PacketList = std::list<std::unique_ptr<Packet>>; |
111 using ReceivedPacketList = std::list<std::unique_ptr<ReceivedPacket>>; | 134 using ReceivedPacketList = std::list<std::unique_ptr<ReceivedPacket>>; |
112 using RecoveredPacketList = std::list<std::unique_ptr<RecoveredPacket>>; | 135 using RecoveredPacketList = std::list<std::unique_ptr<RecoveredPacket>>; |
| 136 using ReceivedFecPacketList = std::list<std::unique_ptr<ReceivedFecPacket>>; |
113 | 137 |
114 ForwardErrorCorrection(); | 138 ForwardErrorCorrection(ForwardErrorCorrection&&) = default; |
115 virtual ~ForwardErrorCorrection(); | |
116 | 139 |
117 // | 140 // Creates a ForwardErrorCorrection tailored for a specific FEC scheme. |
| 141 static ForwardErrorCorrection CreateUlpfec(); |
| 142 |
118 // Generates a list of FEC packets from supplied media packets. | 143 // Generates a list of FEC packets from supplied media packets. |
119 // | 144 // |
120 // Input: media_packets List of media packets to protect, of type | 145 // Input: media_packets List of media packets to protect, of type |
121 // Packet. All packets must belong to the | 146 // Packet. All packets must belong to the |
122 // same frame and the list must not be empty. | 147 // same frame and the list must not be empty. |
123 // Input: protection_factor FEC protection overhead in the [0, 255] | 148 // Input: protection_factor FEC protection overhead in the [0, 255] |
124 // domain. To obtain 100% overhead, or an | 149 // domain. To obtain 100% overhead, or an |
125 // equal number of FEC packets as | 150 // equal number of FEC packets as |
126 // media packets, use 255. | 151 // media packets, use 255. |
127 // Input: num_important_packets The number of "important" packets in the | 152 // Input: num_important_packets The number of "important" packets in the |
(...skipping 23 matching lines...) Expand all Loading... |
151 // | 176 // |
152 // Returns 0 on success, -1 on failure. | 177 // Returns 0 on success, -1 on failure. |
153 // | 178 // |
154 int EncodeFec(const PacketList& media_packets, | 179 int EncodeFec(const PacketList& media_packets, |
155 uint8_t protection_factor, | 180 uint8_t protection_factor, |
156 int num_important_packets, | 181 int num_important_packets, |
157 bool use_unequal_protection, | 182 bool use_unequal_protection, |
158 FecMaskType fec_mask_type, | 183 FecMaskType fec_mask_type, |
159 std::list<Packet*>* fec_packets); | 184 std::list<Packet*>* fec_packets); |
160 | 185 |
161 // | |
162 // Decodes a list of received media and FEC packets. It will parse the | 186 // Decodes a list of received media and FEC packets. It will parse the |
163 // |received_packets|, storing FEC packets internally, and move | 187 // |received_packets|, storing FEC packets internally, and move |
164 // media packets to |recovered_packets|. The recovered list will be | 188 // media packets to |recovered_packets|. The recovered list will be |
165 // sorted by ascending sequence number and have duplicates removed. | 189 // sorted by ascending sequence number and have duplicates removed. |
166 // The function should be called as new packets arrive, and | 190 // The function should be called as new packets arrive, and |
167 // |recovered_packets| will be progressively assembled with each call. | 191 // |recovered_packets| will be progressively assembled with each call. |
168 // When the function returns, |received_packets| will be empty. | 192 // When the function returns, |received_packets| will be empty. |
169 // | 193 // |
170 // The caller will allocate packets submitted through |received_packets|. | 194 // The caller will allocate packets submitted through |received_packets|. |
171 // The function will handle allocation of recovered packets. | 195 // The function will handle allocation of recovered packets. |
(...skipping 19 matching lines...) Expand all Loading... |
191 static int NumFecPackets(int num_media_packets, int protection_factor); | 215 static int NumFecPackets(int num_media_packets, int protection_factor); |
192 | 216 |
193 // Gets the maximum size of the FEC headers in bytes, which must be | 217 // Gets the maximum size of the FEC headers in bytes, which must be |
194 // accounted for as packet overhead. | 218 // accounted for as packet overhead. |
195 size_t MaxPacketOverhead() const; | 219 size_t MaxPacketOverhead() const; |
196 | 220 |
197 // Reset internal states from last frame and clear |recovered_packets|. | 221 // Reset internal states from last frame and clear |recovered_packets|. |
198 // Frees all memory allocated by this class. | 222 // Frees all memory allocated by this class. |
199 void ResetState(RecoveredPacketList* recovered_packets); | 223 void ResetState(RecoveredPacketList* recovered_packets); |
200 | 224 |
| 225 // TODO(brandtr): Remove these functions when the Packet classes |
| 226 // have been refactored. |
| 227 static uint16_t ParseSequenceNumber(uint8_t* packet); |
| 228 static uint32_t ParseSsrc(uint8_t* packet); |
| 229 |
201 private: | 230 private: |
202 // Used to link media packets to their protecting FEC packets. | 231 ForwardErrorCorrection(std::unique_ptr<FecHeaderReader> fec_header_reader, |
203 // | 232 std::unique_ptr<FecHeaderWriter> fec_header_writer); |
204 // TODO(holmer): Refactor into a proper class. | |
205 class ProtectedPacket : public ForwardErrorCorrection::SortablePacket { | |
206 public: | |
207 rtc::scoped_refptr<ForwardErrorCorrection::Packet> pkt; | |
208 }; | |
209 | |
210 using ProtectedPacketList = std::list<std::unique_ptr<ProtectedPacket>>; | |
211 | |
212 // Used for internal storage of received FEC packets in a list. | |
213 // | |
214 // TODO(holmer): Refactor into a proper class. | |
215 class ReceivedFecPacket : public ForwardErrorCorrection::SortablePacket { | |
216 public: | |
217 ProtectedPacketList protected_packets; | |
218 uint32_t ssrc; // SSRC of the current frame. | |
219 rtc::scoped_refptr<ForwardErrorCorrection::Packet> pkt; | |
220 }; | |
221 | |
222 using ReceivedFecPacketList = std::list<std::unique_ptr<ReceivedFecPacket>>; | |
223 | 233 |
224 // Analyzes |media_packets| for holes in the sequence and inserts zero columns | 234 // Analyzes |media_packets| for holes in the sequence and inserts zero columns |
225 // into the |packet_mask| where those holes are found. Zero columns means that | 235 // into the |packet_mask| where those holes are found. Zero columns means that |
226 // those packets will have no protection. | 236 // those packets will have no protection. |
227 // Returns the number of bits used for one row of the new packet mask. | 237 // Returns the number of bits used for one row of the new packet mask. |
228 // Requires that |packet_mask| has at least 6 * |num_fec_packets| bytes | 238 // Requires that |packet_mask| has at least 6 * |num_fec_packets| bytes |
229 // allocated. | 239 // allocated. |
230 int InsertZerosInBitMasks(const PacketList& media_packets, | 240 int InsertZerosInPacketMasks(const PacketList& media_packets, |
231 uint8_t* packet_mask, int num_mask_bytes, | 241 size_t num_fec_packets); |
232 int num_fec_packets); | |
233 | 242 |
| 243 // Writes FEC payload and some recovery fields in the FEC headers. |
| 244 void GenerateFecPayloads(const PacketList& media_packets, |
| 245 size_t num_fec_packets); |
234 | 246 |
235 void GenerateFecUlpHeaders(const PacketList& media_packets, | 247 // Writes the FEC header fields that are not written by GenerateFecPayloads. |
236 uint8_t* packet_mask, int num_fec_packets, | 248 // This includes writing the packet masks. |
237 bool l_bit); | 249 void FinalizeFecHeaders(const PacketList& media_packets, |
238 | 250 size_t num_fec_packets); |
239 void GenerateFecBitStrings(const PacketList& media_packets, | |
240 uint8_t* packet_mask, int num_fec_packets, | |
241 bool l_bit); | |
242 | 251 |
243 // Inserts the |received_packets| into the internal received FEC packet list | 252 // Inserts the |received_packets| into the internal received FEC packet list |
244 // or into |recovered_packets|. | 253 // or into |recovered_packets|. |
245 void InsertPackets(ReceivedPacketList* received_packets, | 254 void InsertPackets(ReceivedPacketList* received_packets, |
246 RecoveredPacketList* recovered_packets); | 255 RecoveredPacketList* recovered_packets); |
247 | 256 |
248 // Inserts the |received_packet| into |recovered_packets|. Deletes duplicates. | 257 // Inserts the |received_packet| into |recovered_packets|. Deletes duplicates. |
249 void InsertMediaPacket(ReceivedPacket* received_packet, | 258 void InsertMediaPacket(ReceivedPacket* received_packet, |
250 RecoveredPacketList* recovered_packets); | 259 RecoveredPacketList* recovered_packets); |
251 | 260 |
252 // Assigns pointers to the recovered packet from all FEC packets which cover | 261 // Assigns pointers to the recovered packet from all FEC packets which cover |
253 // it. | 262 // it. |
254 // Note: This reduces the complexity when we want to try to recover a packet | 263 // Note: This reduces the complexity when we want to try to recover a packet |
255 // since we don't have to find the intersection between recovered packets and | 264 // since we don't have to find the intersection between recovered packets and |
256 // packets covered by the FEC packet. | 265 // packets covered by the FEC packet. |
257 void UpdateCoveringFecPackets(RecoveredPacket* packet); | 266 void UpdateCoveringFecPackets(RecoveredPacket* packet); |
258 | 267 |
259 // Insert |received_packet| into internal FEC list. Deletes duplicates. | 268 // Insert |received_packet| into internal FEC list. Deletes duplicates. |
260 void InsertFecPacket(ReceivedPacket* received_packet, | 269 void InsertFecPacket(ReceivedPacket* received_packet, |
261 const RecoveredPacketList* recovered_packets); | 270 const RecoveredPacketList* recovered_packets); |
262 | 271 |
263 // Assigns pointers to already recovered packets covered by |fec_packet|. | 272 // Assigns pointers to already recovered packets covered by |fec_packet|. |
264 static void AssignRecoveredPackets( | 273 static void AssignRecoveredPackets( |
265 ReceivedFecPacket* fec_packet, | 274 ReceivedFecPacket* fec_packet, |
266 const RecoveredPacketList* recovered_packets); | 275 const RecoveredPacketList* recovered_packets); |
267 | 276 |
268 // Insert |rec_packet_to_insert| into |recovered_packets| in correct position. | |
269 void InsertRecoveredPacket(RecoveredPacket* rec_packet_to_insert, | |
270 RecoveredPacketList* recovered_packets); | |
271 | |
272 // Attempt to recover missing packets, using the internally stored | 277 // Attempt to recover missing packets, using the internally stored |
273 // received FEC packets. | 278 // received FEC packets. |
274 void AttemptRecover(RecoveredPacketList* recovered_packets); | 279 void AttemptRecovery(RecoveredPacketList* recovered_packets); |
275 | |
276 // Initializes packet recovery using the received |fec_packet|. | |
277 static bool StartPacketRecovery(const ReceivedFecPacket* fec_packet, | |
278 RecoveredPacket* recovered_packet); | |
279 | 280 |
280 // Performs XOR between |src| and |dst| and stores the result in |dst|. | 281 // Performs XOR between |src| and |dst| and stores the result in |dst|. |
281 static void XorPackets(const Packet* src, RecoveredPacket* dst); | 282 // The parameters |src_offset| and |dst_offset| determines at what byte |
| 283 // the XOR operation starts in |src| and |dst|, respectively. In total, |
| 284 // |payload_length| bytes are XORed. |
| 285 static void XorPackets(const Packet* src, |
| 286 size_t src_offset, |
| 287 size_t payload_length, |
| 288 size_t dst_offset, |
| 289 Packet* dst); |
282 | 290 |
283 // Finish up the recovery of a packet. | 291 // Initializes headers and payload before the XOR operation |
284 static bool FinishPacketRecovery(RecoveredPacket* recovered_packet); | 292 // that recovers a packet. |
| 293 bool StartPacketRecovery(ReceivedFecPacket* fec_packet, |
| 294 RecoveredPacket* recovered_packet) const; |
| 295 |
| 296 // Finalizes recovery of packet by setting RTP header fields. |
| 297 // This is not specific to the FEC scheme used. |
| 298 static bool FinishPacketRecovery(const ReceivedFecPacket* fec_packet, |
| 299 RecoveredPacket* recovered_packet); |
285 | 300 |
286 // Recover a missing packet. | 301 // Recover a missing packet. |
287 bool RecoverPacket(const ReceivedFecPacket* fec_packet, | 302 bool RecoverPacket(ReceivedFecPacket* fec_packet, |
288 RecoveredPacket* rec_packet_to_insert); | 303 RecoveredPacket* recovered_packet); |
289 | 304 |
290 // Get the number of missing media packets which are covered by |fec_packet|. | 305 // Get the number of missing media packets which are covered by |fec_packet|. |
291 // An FEC packet can recover at most one packet, and if zero packets are | 306 // An FEC packet can recover at most one packet, and if zero packets are |
292 // missing the FEC packet can be discarded. This function returns 2 when two | 307 // missing the FEC packet can be discarded. This function returns 2 when two |
293 // or more packets are missing. | 308 // or more packets are missing. |
294 static int NumCoveredPacketsMissing(const ReceivedFecPacket* fec_packet); | 309 static int NumCoveredPacketsMissing(const ReceivedFecPacket* fec_packet); |
295 | 310 |
296 // Discards old packets in |recovered_packets|, which are no longer relevant | 311 // Discards old packets in |recovered_packets|, which are no longer relevant |
297 // for recovering lost packets. | 312 // for recovering lost packets. |
298 static void DiscardOldRecoveredPackets( | 313 void DiscardOldRecoveredPackets(RecoveredPacketList* recovered_packets); |
299 RecoveredPacketList* recovered_packets); | 314 |
300 static uint16_t ParseSequenceNumber(uint8_t* packet); | 315 std::unique_ptr<FecHeaderReader> fec_header_reader_; |
| 316 std::unique_ptr<FecHeaderWriter> fec_header_writer_; |
301 | 317 |
302 std::vector<Packet> generated_fec_packets_; | 318 std::vector<Packet> generated_fec_packets_; |
303 ReceivedFecPacketList received_fec_packets_; | 319 ReceivedFecPacketList received_fec_packets_; |
304 | 320 |
305 // Arrays used to avoid dynamically allocating memory when generating | 321 // Arrays used to avoid dynamically allocating memory when generating |
306 // the packet masks in the ULPFEC headers. | 322 // the packet masks. |
307 // (There are never more than |kMaxMediaPackets| FEC packets generated.) | 323 // (There are never more than |kUlpfecMaxMediaPackets| FEC packets generated.) |
308 uint8_t packet_mask_[kMaxMediaPackets * kMaskSizeLBitSet]; | 324 uint8_t packet_masks_[kUlpfecMaxMediaPackets * kUlpfecPacketMaskSizeLBitSet]; |
309 uint8_t tmp_packet_mask_[kMaxMediaPackets * kMaskSizeLBitSet]; | 325 uint8_t |
| 326 tmp_packet_masks_[kUlpfecMaxMediaPackets * kUlpfecPacketMaskSizeLBitSet]; |
| 327 size_t packet_mask_size_; |
| 328 |
| 329 // Moveable, but not copyable or assignable. |
| 330 RTC_DISALLOW_COPY_AND_ASSIGN(ForwardErrorCorrection); |
310 }; | 331 }; |
| 332 |
| 333 // Classes derived from FecHeader{Reader,Writer} encapsulate the |
| 334 // specifics of reading and writing FEC header for, e.g., ULPFEC |
| 335 // and FlexFEC. |
| 336 class FecHeaderReader { |
| 337 public: |
| 338 virtual ~FecHeaderReader(); |
| 339 |
| 340 // The maximum number of media packets that can be covered by one FEC packet. |
| 341 size_t MaxMediaPackets() const; |
| 342 |
| 343 // The maximum number of FEC packets that is supported, per call |
| 344 // to ForwardErrorCorrection::EncodeFec(). |
| 345 size_t MaxFecPackets() const; |
| 346 |
| 347 // Parses FEC header and stores information in ReceivedFecPacket members. |
| 348 virtual bool ReadFecHeader( |
| 349 ForwardErrorCorrection::ReceivedFecPacket* fec_packet) const = 0; |
| 350 |
| 351 protected: |
| 352 FecHeaderReader(size_t max_media_packets, size_t max_fec_packets); |
| 353 |
| 354 const size_t max_media_packets_; |
| 355 const size_t max_fec_packets_; |
| 356 }; |
| 357 |
| 358 class FecHeaderWriter { |
| 359 public: |
| 360 FecHeaderWriter(size_t max_media_packets, size_t max_fec_packets); |
| 361 virtual ~FecHeaderWriter(); |
| 362 |
| 363 // The maximum number of media packets that can be covered by one FEC packet. |
| 364 size_t MaxMediaPackets() const; |
| 365 |
| 366 // The maximum number of FEC packets that is supported, per call |
| 367 // to ForwardErrorCorrection::EncodeFec(). |
| 368 size_t MaxFecPackets() const; |
| 369 |
| 370 // The maximum overhead (in bytes) per packet, due to FEC headers. |
| 371 size_t MaxPacketOverhead() const; |
| 372 |
| 373 // Calculates the minimum packet mask size needed (in bytes), |
| 374 // given the discrete options of the ULPFEC masks and the bits |
| 375 // set in the current packet mask. |
| 376 virtual size_t MinPacketMaskSize(const uint8_t* packet_mask, |
| 377 size_t packet_mask_size) const = 0; |
| 378 |
| 379 // The header size (in bytes), given the packet mask size. |
| 380 virtual size_t FecHeaderSize(size_t packet_mask_size) const = 0; |
| 381 |
| 382 // Writes FEC header. |
| 383 virtual void FinalizeFecHeader( |
| 384 const ForwardErrorCorrection::PacketList& media_packets, |
| 385 const uint8_t* packet_mask, |
| 386 size_t packet_mask_size, |
| 387 ForwardErrorCorrection::Packet* fec_packet) const = 0; |
| 388 |
| 389 protected: |
| 390 FecHeaderWriter(size_t max_media_packets, |
| 391 size_t max_fec_packets, |
| 392 size_t max_packet_overhead_); |
| 393 |
| 394 const size_t max_media_packets_; |
| 395 const size_t max_fec_packets_; |
| 396 const size_t max_packet_overhead_; |
| 397 }; |
| 398 |
311 } // namespace webrtc | 399 } // namespace webrtc |
| 400 |
312 #endif // WEBRTC_MODULES_RTP_RTCP_SOURCE_FORWARD_ERROR_CORRECTION_H_ | 401 #endif // WEBRTC_MODULES_RTP_RTCP_SOURCE_FORWARD_ERROR_CORRECTION_H_ |
OLD | NEW |