src/third_party/webrtc/modules/audio_coding/neteq/tools/packet.h

   1 /*
   2  *  Copyright (c) 2014 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_AUDIO_CODING_NETEQ_TOOLS_PACKET_H_
  12 #define WEBRTC_MODULES_AUDIO_CODING_NETEQ_TOOLS_PACKET_H_
  13
  14 #include <list>
  15
  16 #include "webrtc/base/constructormagic.h"
  17 #include "webrtc/common_types.h"
  18 #include "webrtc/system_wrappers/interface/scoped_ptr.h"
  19 #include "webrtc/typedefs.h"
  20
  21 namespace webrtc {
  22
  23 class RtpHeaderParser;
  24 struct WebRtcRTPHeader;
  25
  26 namespace test {
  27
  28 // Class for handling RTP packets in test applications.
  29 class Packet {
  30  public:
  31   // Creates a packet, with the packet payload (including header bytes) in
  32   // |packet_memory|. The length of |packet_memory| is |allocated_bytes|.
  33   // The new object assumes ownership of |packet_memory| and will delete it
  34   // when the Packet object is deleted. The |time_ms| is an extra time
  35   // associated with this packet, typically used to denote arrival time.
  36   // The first bytes in |packet_memory| will be parsed using |parser|.
  37   Packet(uint8_t* packet_memory,
  38          size_t allocated_bytes,
  39          double time_ms,
  40          const RtpHeaderParser& parser);
  41
  42   // Same as above, but with the extra argument |virtual_packet_length_bytes|.
  43   // This is typically used when reading RTP dump files that only contain the
  44   // RTP headers, and no payload (a.k.a RTP dummy files or RTP light). The
  45   // |virtual_packet_length_bytes| tells what size the packet had on wire,
  46   // including the now discarded payload, whereas |allocated_bytes| is the
  47   // length of the remaining payload (typically only the RTP header).
  48   Packet(uint8_t* packet_memory,
  49          size_t allocated_bytes,
  50          size_t virtual_packet_length_bytes,
  51          double time_ms,
  52          const RtpHeaderParser& parser);
  53
  54   // The following two constructors are the same as above, but without a
  55   // parser. Note that when the object is constructed using any of these
  56   // methods, the header will be parsed using a default RtpHeaderParser object.
  57   // In particular, RTP header extensions won't be parsed.
  58   Packet(uint8_t* packet_memory, size_t allocated_bytes, double time_ms);
  59
  60   Packet(uint8_t* packet_memory,
  61          size_t allocated_bytes,
  62          size_t virtual_packet_length_bytes,
  63          double time_ms);
  64
  65   virtual ~Packet() {}
  66
  67   // Parses the first bytes of the RTP payload, interpreting them as RED headers
  68   // according to RFC 2198. The headers will be inserted into |headers|. The
  69   // caller of the method assumes ownership of the objects in the list, and
  70   // must delete them properly.
  71   bool ExtractRedHeaders(std::list<RTPHeader*>* headers) const;
  72
  73   // Deletes all RTPHeader objects in |headers|, but does not delete |headers|
  74   // itself.
  75   static void DeleteRedHeaders(std::list<RTPHeader*>* headers);
  76
  77   const uint8_t* payload() const { return payload_; }
  78
  79   size_t packet_length_bytes() const { return packet_length_bytes_; }
  80
  81   size_t payload_length_bytes() const { return payload_length_bytes_; }
  82
  83   size_t virtual_packet_length_bytes() const {
  84     return virtual_packet_length_bytes_;
  85   }
  86
  87   size_t virtual_payload_length_bytes() const {
  88     return virtual_payload_length_bytes_;
  89   }
  90
  91   const RTPHeader& header() const { return header_; }
  92
  93   // Copies the packet header information, converting from the native RTPHeader
  94   // type to WebRtcRTPHeader.
  95   void ConvertHeader(WebRtcRTPHeader* copy_to) const;
  96
  97   void set_time_ms(double time) { time_ms_ = time; }
  98   double time_ms() const { return time_ms_; }
  99   bool valid_header() const { return valid_header_; }
 100
 101  private:
 102   bool ParseHeader(const RtpHeaderParser& parser);
 103   void CopyToHeader(RTPHeader* destination) const;
 104
 105   RTPHeader header_;
 106   scoped_ptr<uint8_t[]> payload_memory_;
 107   const uint8_t* payload_;            // First byte after header.
 108   const size_t packet_length_bytes_;  // Total length of packet.
 109   size_t payload_length_bytes_;  // Length of the payload, after RTP header.
 110                                  // Zero for dummy RTP packets.
 111   // Virtual lengths are used when parsing RTP header files (dummy RTP files).
 112   const size_t virtual_packet_length_bytes_;
 113   size_t virtual_payload_length_bytes_;
 114   double time_ms_;     // Used to denote a packet's arrival time.
 115   bool valid_header_;  // Set by the RtpHeaderParser.
 116
 117   DISALLOW_COPY_AND_ASSIGN(Packet);
 118 };
 119
 120 }  // namespace test
 121 }  // namespace webrtc
 122 #endif  // WEBRTC_MODULES_AUDIO_CODING_NETEQ_TOOLS_PACKET_H_