WebRTC: Extract SrsRtcNetwork layer for UDP/TCP.

trunk/src/app/srs_app_conn.cpp

@@ -18,7 +18,7 @@ using namespace std;
 #include <srs_app_log.hpp>
 #include <srs_app_config.hpp>
 #include <srs_core_autofree.hpp>
-
+#include <srs_kernel_buffer.hpp>
 #include <srs_protocol_kbps.hpp>
 
 SrsPps* _srs_pps_ids = NULL;
@@ -417,7 +417,7 @@ ISrsExpire::~ISrsExpire()
 SrsTcpConnection::SrsTcpConnection(srs_netfd_t c)
 {
     stfd = c;
-    skt = new SrsStSocket();
+    skt = new SrsStSocket(c);
 }
 
 SrsTcpConnection::~SrsTcpConnection()
@@ -426,17 +426,6 @@ SrsTcpConnection::~SrsTcpConnection()
     srs_close_stfd(stfd);
 }
 
-srs_error_t SrsTcpConnection::initialize()
-{
-    srs_error_t err = srs_success;
-
-    if ((err = skt->initialize(stfd)) != srs_success) {
-        return srs_error_wrap(err, "init socket");
-    }
-
-    return err;
-}
-
 srs_error_t SrsTcpConnection::set_tcp_nodelay(bool v)
 {
     srs_error_t err = srs_success;
@@ -570,6 +559,130 @@ srs_error_t SrsTcpConnection::writev(const iovec *iov, int iov_size, ssize_t* nw
     return skt->writev(iov, iov_size, nwrite);
 }
 
+SrsBufferedReader::SrsBufferedReader(ISrsProtocolReadWriter* io)
+{
+    io_ = io;
+    buf_ = NULL;
+}
+
+SrsBufferedReader::~SrsBufferedReader()
+{
+    srs_freep(buf_);
+}
+
+srs_error_t SrsBufferedReader::peek(char* buf, int* size)
+{
+    srs_error_t err = srs_success;
+
+    if ((err = reload_buffer()) != srs_success) {
+        return srs_error_wrap(err, "reload buffer");
+    }
+
+    int nn = srs_min(buf_->left(), *size);
+    *size = nn;
+
+    if (nn) {
+        memcpy(buf, buf_->head(), nn);
+    }
+
+    return err;
+}
+
+srs_error_t SrsBufferedReader::reload_buffer()
+{
+    srs_error_t err = srs_success;
+
+    if (buf_ && !buf_->empty()) {
+        return err;
+    }
+
+    // We use read_fully to always full fill the cache, to avoid peeking failed.
+    ssize_t nread = 0;
+    if ((err = io_->read_fully(cache_, sizeof(cache_), &nread)) != srs_success) {
+        return srs_error_wrap(err, "read");
+    }
+
+    srs_freep(buf_);
+    buf_ = new SrsBuffer(cache_, nread);
+
+    return err;
+}
+
+srs_error_t SrsBufferedReader::read(void* buf, size_t size, ssize_t* nread)
+{
+    if (!buf_ || buf_->empty()) {
+        return io_->read(buf, size, nread);
+    }
+
+    int nn = srs_min(buf_->left(), size);
+    *nread = nn;
+
+    if (nn) {
+        buf_->read_bytes((char*)buf, nn);
+    }
+    return srs_success;
+}
+
+srs_error_t SrsBufferedReader::read_fully(void* buf, size_t size, ssize_t* nread)
+{
+    if (!buf_ || buf_->empty()) {
+        return io_->read_fully(buf, size, nread);
+    }
+
+    int nn = srs_min(buf_->left(), size);
+    if (nn) {
+        buf_->read_bytes((char*)buf, nn);
+    }
+
+    int left = size - nn;
+    *nread = size;
+
+    if (left) {
+        return io_->read_fully((char*)buf + nn, left, NULL);
+    }
+    return srs_success;
+}
+
+void SrsBufferedReader::set_recv_timeout(srs_utime_t tm)
+{
+    return io_->set_recv_timeout(tm);
+}
+
+srs_utime_t SrsBufferedReader::get_recv_timeout()
+{
+    return io_->get_recv_timeout();
+}
+
+int64_t SrsBufferedReader::get_recv_bytes()
+{
+    return io_->get_recv_bytes();
+}
+
+int64_t SrsBufferedReader::get_send_bytes()
+{
+    return io_->get_send_bytes();
+}
+
+void SrsBufferedReader::set_send_timeout(srs_utime_t tm)
+{
+    return io_->set_send_timeout(tm);
+}
+
+srs_utime_t SrsBufferedReader::get_send_timeout()
+{
+    return io_->get_send_timeout();
+}
+
+srs_error_t SrsBufferedReader::write(void* buf, size_t size, ssize_t* nwrite)
+{
+    return io_->write(buf, size, nwrite);
+}
+
+srs_error_t SrsBufferedReader::writev(const iovec *iov, int iov_size, ssize_t* nwrite)
+{
+    return io_->writev(iov, iov_size, nwrite);
+}
+
 SrsSslConnection::SrsSslConnection(ISrsProtocolReadWriter* c)
 {
     transport = c;