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