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