src/media/cast/transport/rtp_sender/rtp_packetizer/rtp_packetizer.h

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef MEDIA_CAST_TRANSPORT_RTP_SENDER_RTP_PACKETIZER_RTP_PACKETIZER_H_
   6 #define MEDIA_CAST_TRANSPORT_RTP_SENDER_RTP_PACKETIZER_RTP_PACKETIZER_H_
   7
   8 #include <cmath>
   9 #include <list>
  10 #include <map>
  11
  12 #include "base/time/time.h"
  13 #include "media/cast/transport/rtp_sender/packet_storage/packet_storage.h"
  14
  15 namespace media {
  16 namespace cast {
  17 namespace transport {
  18
  19 class PacedSender;
  20
  21 struct RtpPacketizerConfig {
  22   RtpPacketizerConfig();
  23   ~RtpPacketizerConfig();
  24
  25   // General.
  26   bool audio;
  27   int payload_type;
  28   uint16 max_payload_length;
  29   uint16 sequence_number;
  30   int frequency;
  31
  32   // SSRC.
  33   unsigned int ssrc;
  34
  35   // Video.
  36   VideoCodec video_codec;
  37
  38   // Audio.
  39   uint8 channels;
  40   AudioCodec audio_codec;
  41 };
  42
  43 // This object is only called from the main cast thread.
  44 // This class break encoded audio and video frames into packets and add an RTP
  45 // header to each packet.
  46 class RtpPacketizer {
  47  public:
  48   RtpPacketizer(PacedSender* const transport,
  49                 PacketStorage* packet_storage,
  50                 RtpPacketizerConfig rtp_packetizer_config);
  51   ~RtpPacketizer();
  52
  53   // The video_frame objects ownership is handled by the main cast thread.
  54   void IncomingEncodedVideoFrame(const EncodedVideoFrame* video_frame,
  55                                  const base::TimeTicks& capture_time);
  56
  57   // The audio_frame objects ownership is handled by the main cast thread.
  58   void IncomingEncodedAudioFrame(const EncodedAudioFrame* audio_frame,
  59                                  const base::TimeTicks& recorded_time);
  60
  61   bool LastSentTimestamp(base::TimeTicks* time_sent,
  62                          uint32* rtp_timestamp) const;
  63
  64   // Return the next sequence number, and increment by one. Enables unique
  65   // incremental sequence numbers for every packet (including retransmissions).
  66   uint16 NextSequenceNumber();
  67
  68   int send_packets_count() { return send_packets_count_; }
  69
  70   size_t send_octet_count() { return send_octet_count_; }
  71
  72  private:
  73   void Cast(bool is_key,
  74             uint32 frame_id,
  75             uint32 reference_frame_id,
  76             uint32 timestamp,
  77             const std::string& data);
  78
  79   void BuildCommonRTPheader(Packet* packet, bool marker_bit, uint32 time_stamp);
  80
  81   RtpPacketizerConfig config_;
  82   PacedSender* const transport_;  // Not owned by this class.
  83   PacketStorage* packet_storage_;
  84
  85   base::TimeTicks time_last_sent_rtp_timestamp_;
  86   uint16 sequence_number_;
  87   uint32 rtp_timestamp_;
  88   uint16 packet_id_;
  89
  90   int send_packets_count_;
  91   size_t send_octet_count_;
  92 };
  93
  94 }  // namespace transport
  95 }  // namespace cast
  96 }  // namespace media
  97
  98 #endif  // MEDIA_CAST_TRANSPORT_RTP_SENDER_RTP_PACKETIZER_RTP_PACKETIZER_H_