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 WEBRTC_MODULES_PACED_SENDER_H_ 12 #define WEBRTC_MODULES_PACED_SENDER_H_ 13 14 #include <list> 15 #include <set> 16 17 #include "webrtc/modules/interface/module.h" 18 #include "webrtc/system_wrappers/interface/scoped_ptr.h" 19 #include "webrtc/system_wrappers/interface/tick_util.h" 20 #include "webrtc/typedefs.h" 21 22 namespace webrtc { 23 class CriticalSectionWrapper; 24 namespace paced_sender { 25 class IntervalBudget; 26 struct Packet; 27 class PacketList; 28 } // namespace paced_sender 29 30 class PacedSender : public Module { 31 public: 32 enum Priority { 33 kHighPriority = 0, // Pass through; will be sent immediately. 34 kNormalPriority = 2, // Put in back of the line. 35 kLowPriority = 3, // Put in back of the low priority line. 36 }; 37 // Low priority packets are mixed with the normal priority packets 38 // while we are paused. 39 40 class Callback { 41 public: 42 // Note: packets sent as a result of a callback should not pass by this 43 // module again. 44 // Called when it's time to send a queued packet. 45 // Returns false if packet cannot be sent. 46 virtual bool TimeToSendPacket(uint32_t ssrc, 47 uint16_t sequence_number, 48 int64_t capture_time_ms, 49 bool retransmission) = 0; 50 // Called when it's a good time to send a padding data. 51 virtual int TimeToSendPadding(int bytes) = 0; 52 53 protected: ~Callback()54 virtual ~Callback() {} 55 }; 56 57 static const int kDefaultMaxQueueLengthMs = 2000; 58 59 PacedSender(Callback* callback, int max_bitrate_kbps, int min_bitrate_kbps); 60 61 virtual ~PacedSender(); 62 63 // Enable/disable pacing. 64 void SetStatus(bool enable); 65 66 bool Enabled() const; 67 68 // Temporarily pause all sending. 69 void Pause(); 70 71 // Resume sending packets. 72 void Resume(); 73 74 // Set target bitrates for the pacer. Padding packets will be utilized to 75 // reach |min_bitrate| unless enough media packets are available. 76 void UpdateBitrate(int max_bitrate_kbps, int min_bitrate_kbps); 77 78 // Returns true if we send the packet now, else it will add the packet 79 // information to the queue and call TimeToSendPacket when it's time to send. 80 virtual bool SendPacket(Priority priority, 81 uint32_t ssrc, 82 uint16_t sequence_number, 83 int64_t capture_time_ms, 84 int bytes, 85 bool retransmission); 86 87 // Sets the max length of the pacer queue in milliseconds. 88 // A negative queue size is interpreted as infinite. 89 virtual void set_max_queue_length_ms(int max_queue_length_ms); 90 91 // Returns the time since the oldest queued packet was enqueued. 92 virtual int QueueInMs() const; 93 94 // Returns the number of milliseconds until the module want a worker thread 95 // to call Process. 96 virtual int32_t TimeUntilNextProcess() OVERRIDE; 97 98 // Process any pending packets in the queue(s). 99 virtual int32_t Process() OVERRIDE; 100 101 private: 102 // Return true if next packet in line should be transmitted. 103 // Return packet list that contains the next packet. 104 bool ShouldSendNextPacket(paced_sender::PacketList** packet_list); 105 106 // Local helper function to GetNextPacket. 107 paced_sender::Packet GetNextPacketFromList(paced_sender::PacketList* packets); 108 109 bool SendPacketFromList(paced_sender::PacketList* packet_list); 110 111 // Updates the number of bytes that can be sent for the next time interval. 112 void UpdateBytesPerInterval(uint32_t delta_time_in_ms); 113 114 // Updates the buffers with the number of bytes that we sent. 115 void UpdateMediaBytesSent(int num_bytes); 116 117 Callback* callback_; 118 bool enabled_; 119 bool paused_; 120 int max_queue_length_ms_; 121 scoped_ptr<CriticalSectionWrapper> critsect_; 122 // This is the media budget, keeping track of how many bits of media 123 // we can pace out during the current interval. 124 scoped_ptr<paced_sender::IntervalBudget> media_budget_; 125 // This is the padding budget, keeping track of how many bits of padding we're 126 // allowed to send out during the current interval. This budget will be 127 // utilized when there's no media to send. 128 scoped_ptr<paced_sender::IntervalBudget> padding_budget_; 129 130 TickTime time_last_update_; 131 TickTime time_last_send_; 132 int64_t capture_time_ms_last_queued_; 133 int64_t capture_time_ms_last_sent_; 134 135 scoped_ptr<paced_sender::PacketList> high_priority_packets_; 136 scoped_ptr<paced_sender::PacketList> normal_priority_packets_; 137 scoped_ptr<paced_sender::PacketList> low_priority_packets_; 138 }; 139 } // namespace webrtc 140 #endif // WEBRTC_MODULES_PACED_SENDER_H_ 141