[Cast] EncodedAudioFrame+EncodedVideoFrame+reference_time --> EncodedFrame

media/cast/transport/cast_transport_config.h

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef MEDIA_CAST_TRANSPORT_CAST_TRANSPORT_CONFIG_H_
 #define MEDIA_CAST_TRANSPORT_CAST_TRANSPORT_CONFIG_H_
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/ref_counted.h"
+#include "base/stl_util.h"
 #include "media/cast/transport/cast_transport_defines.h"
 #include "net/base/ip_endpoint.h"
 
 namespace media {
 namespace cast {
 namespace transport {
 
 enum RtcpMode {
   kRtcpCompound,     // Compound RTCP mode is described by RFC 4585.
   kRtcpReducedSize,  // Reduced-size RTCP mode is described by RFC 5506.
@@ skipping 37 matching lines @@
 };
 
 struct CastTransportVideoConfig {
   CastTransportVideoConfig();
   ~CastTransportVideoConfig();
 
   CastTransportRtpConfig rtp;
   VideoCodec codec;
 };
 
-struct EncodedVideoFrame {
-  EncodedVideoFrame();
-  ~EncodedVideoFrame();
+// A combination of metadata and data for one encoded frame.  This can contain
+// audio data or video data or other.
+struct EncodedFrame {
+  EncodedFrame();
+  ~EncodedFrame();
 
-  VideoCodec codec;
-  bool key_frame;
+  // Convenience accessors to data as an array of uint8 elements.
+  const uint8* bytes() const {
+    return reinterpret_cast<uint8*>(string_as_array(
+        const_cast<std::string*>(&data)));
+  }
+  uint8* mutable_bytes() {
+    return reinterpret_cast<uint8*>(string_as_array(&data));
+  }
+
+  // The label associated with this frame.  Implies an ordering relative to
+  // other frames in the same stream.
   uint32 frame_id;
-  uint32 last_referenced_frame_id;
+
+  // The label associated with the frame upon which this frame is based.  If
+  // this frame does not require any other frame in order to become decodable
+  // (e.g., key frames), |base_frame_id| must equal |frame_id|.
+  uint32 base_frame_id;

[Alpha Left Google, 2014/05/15 22:11:23]

I actually prefer the name before, i.e. referenced_frame_id. Calling this
|base_something| doesn't describe it more accurately.

[miu, 2014/05/16 04:27:25]

Done.  After looking around more in the codec APIs, it looks like "reference
frame" is best for naming consistency.

+
+  // The stream timestamp, on the timeline of the signal data.  For example, RTP
+  // timestamps for audio are usually defined as the total number of audio
+  // samples encoded in all prior frames.  A playback system uses this value to
+  // detect gaps in the stream, and otherwise stretch the signal to match
+  // playout targets.
   uint32 rtp_timestamp;
+
+  // Reference time used for synchronization between streams.  In the sender

[Alpha Left Google, 2014/05/15 22:11:23]

In the sender the time is not used for synchronization. It is only used for
ordering between different streams in the pacer.

[miu, 2014/05/16 04:27:25]

I've clarified the comment (that the sender generates this value for the
purposes of lip sync in the receiver).

+  // implementation, this is the frame capture time.  In the receiver
+  // implementation, this is the target playout time.  Over a sequence of
+  // frames, this time value is expected to drift with respect to the elapsed
+  // time implied by the RTP timestamps; and it may not necessarily increment
+  // with precise regularity.
+  base::TimeTicks reference_time;

[Alpha Left Google, 2014/05/15 22:11:23]

Calling it reference_time doesn't seem to fit either of the purpose in sender
and receiver. Wouldn't |timestamp| be enough? 

[miu, 2014/05/16 04:27:25]

This is exactly the terminology used in Chapter 7 in the RTP book (see the
timing diagram on page 212).  I've reworked the comment a bit to clarify things,
but I think the naming of this field makes sense.

+
+  // The encoded signal data.
   std::string data;
 };
 
-struct EncodedAudioFrame {
-  EncodedAudioFrame();
-  ~EncodedAudioFrame();
-
-  AudioCodec codec;
-  uint32 frame_id;  // Needed to release the frame.
-  uint32 rtp_timestamp;
-  // Support for max sampling rate of 48KHz, 2 channels, 100 ms duration.
-  static const int kMaxNumberOfSamples = 48 * 2 * 100;
-  std::string data;
-};
-
 typedef std::vector<uint8> Packet;
 typedef scoped_refptr<base::RefCountedData<Packet> > PacketRef;
 typedef std::vector<PacketRef> PacketList;
 
 typedef base::Callback<void(scoped_ptr<Packet> packet)> PacketReceiverCallback;
 
 class PacketSender {
  public:
   // Send a packet to the network. Returns false if the network is blocked
   // and we should wait for |cb| to be called. It is not allowed to called
@@ skipping 52 matching lines @@
          lhs.rtp_timestamp == rhs.rtp_timestamp &&
          lhs.send_packet_count == rhs.send_packet_count &&
          lhs.send_octet_count == rhs.send_octet_count;
 }
 
 }  // namespace transport
 }  // namespace cast
 }  // namespace media
 
 #endif  // MEDIA_CAST_TRANSPORT_CAST_TRANSPORT_CONFIG_H_