Home | History | Annotate | Download | only in include 
      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:
     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