RTC: Refine RTP packet api, keep shared message to private

trunk/src/kernel/srs_kernel_buffer.cpp

@@ -49,15 +49,19 @@ SrsBuffer::SrsBuffer(char* b, int nn)
 {
     p = bytes = b;
     nb_bytes = nn;
-    
-    // TODO: support both little and big endian.
-    srs_assert(srs_is_little_endian());
 }
 
 SrsBuffer::~SrsBuffer()
 {
 }
 
+SrsBuffer* SrsBuffer::copy()
+{
+    SrsBuffer* cp = new SrsBuffer(bytes, nb_bytes);
+    cp->p = p;
+    return cp;
+}
+
 char* SrsBuffer::data()
 {
     return bytes;

trunk/src/kernel/srs_kernel_buffer.hpp

@@ -109,6 +109,8 @@ public:
     SrsBuffer(char* b, int nn);
     ~SrsBuffer();
 public:
+    // Copy the object, keep position of buffer.
+    SrsBuffer* copy();
     // Get the data and head of buffer.
     //      current-bytes = head() = data() + pos()
     char* data();

trunk/src/kernel/srs_kernel_rtc_rtp.cpp

@@ -782,20 +782,39 @@ SrsRtpPacket2::~SrsRtpPacket2()
     srs_freep(cache_buffer_);
 }
 
-void SrsRtpPacket2::wrap(char* data, int size)
+char* SrsRtpPacket2::wrap(int size)
 {
     srs_freep(shared_msg);
     shared_msg = new SrsSharedPtrMessage();
 
     char* buf = new char[size];
-    memcpy(buf, data, size);
     shared_msg->wrap(buf, size);
 
     srs_freep(cache_buffer_);
     cache_buffer_ = new SrsBuffer(buf, size);
+
+    return buf;
 }
 
-SrsBuffer* SrsRtpPacket2::cache_buffer()
+char* SrsRtpPacket2::wrap(char* data, int size)
+{
+    char* buf = wrap(size);
+    memcpy(buf, data, size);
+    return buf;
+}
+
+char* SrsRtpPacket2::wrap(SrsSharedPtrMessage* msg)
+{
+    srs_freep(shared_msg);
+    shared_msg = msg->copy();
+
+    srs_freep(cache_buffer_);
+    cache_buffer_ = new SrsBuffer(msg->payload, msg->size);
+
+    return msg->payload;
+}
+
+SrsBuffer* SrsRtpPacket2::cache_buffer() const
 {
     return cache_buffer_;
 }
@@ -835,6 +854,7 @@ SrsRtpPacket2* SrsRtpPacket2::copy()
 
     cp->nalu_type = nalu_type;
     cp->shared_msg = shared_msg? shared_msg->copy():NULL;
+    cp->cache_buffer_ = cache_buffer_? cache_buffer_->copy():NULL;
     cp->frame_type = frame_type;
 
     cp->cached_payload_size = cached_payload_size;

trunk/src/kernel/srs_kernel_rtc_rtp.hpp

@@ -268,13 +268,15 @@ class SrsRtpPacket2
 public:
     SrsRtpHeader header;
     ISrsRtpPayloader* payload;
+private:
+    // The buffer bind to the shared message.
     SrsBuffer* cache_buffer_;
+    // The original shared message, all RTP packets can refer to its data.
+    SrsSharedPtrMessage* shared_msg;
 // Helper fields.
 public:
     // The first byte as nalu type, for video decoder only.
     SrsAvcNaluType nalu_type;
-    // The original shared message, all RTP packets can refer to its data.
-    SrsSharedPtrMessage* shared_msg;
     // The frame type, for RTMP bridger or SFU source.
     SrsFrameType frame_type;
 // Fast cache for performance.
@@ -288,8 +290,12 @@ public:
     virtual ~SrsRtpPacket2();
 public:
     // Wrap buffer to shared_message, which is managed by us.
-    void wrap(char* data, int size);
-    SrsBuffer* cache_buffer();
+    char* wrap(int size);
+    char* wrap(char* data, int size);
+    // Wrap the shared message, we copy it.
+    char* wrap(SrsSharedPtrMessage* msg);
+    // Get the cache buffer which binds to the shared message.
+    SrsBuffer* cache_buffer() const;
 public:
     // Set the padding of RTP packet.
     void set_padding(int size);