move some consts to kernel consts

trunk/src/app/srs_app_config.cpp

@@ -1405,8 +1405,8 @@ SrsConfDirective* SrsConfig::get_vhost(string vhost)
         }
     }
     
-    if (vhost != RTMP_VHOST_DEFAULT) {
-        return get_vhost(RTMP_VHOST_DEFAULT);
+    if (vhost != SRS_CONSTS_RTMP_DEFAULT_VHOST) {
+        return get_vhost(SRS_CONSTS_RTMP_DEFAULT_VHOST);
     }
     
     return NULL;
@@ -1575,7 +1575,7 @@ int SrsConfig::get_chunk_size(string vhost)
     SrsConfDirective* conf = get_vhost(vhost);
 
     if (!conf) {
-        return SRS_CONF_DEFAULT_CHUNK_SIZE;
+        return SRS_CONSTS_RTMP_SRS_CHUNK_SIZE;
     }
 
     conf = conf->get("chunk_size");
@@ -1584,7 +1584,7 @@ int SrsConfig::get_chunk_size(string vhost)
         // use the global instead.
         conf = root->get("chunk_size");
         if (!conf) {
-            return SRS_CONF_DEFAULT_CHUNK_SIZE;
+            return SRS_CONSTS_RTMP_SRS_CHUNK_SIZE;
         }
         
         return ::atoi(conf->arg0().c_str());

trunk/src/app/srs_app_config.hpp

@@ -34,12 +34,6 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 #include <srs_app_reload.hpp>
 
-///////////////////////////////////////////////////////////
-// the value consts
-///////////////////////////////////////////////////////////
-#define SRS_CONSTS_NULL_FILE "/dev/null"
-#define SRS_CONSTS_LOCALHOST "127.0.0.1"
-
 ///////////////////////////////////////////////////////////
 // default consts values
 ///////////////////////////////////////////////////////////

trunk/src/app/srs_app_edge.cpp

@@ -285,8 +285,8 @@ int SrsEdgeIngester::connect_server()
     std::string server = conf->args.at(origin_index % conf->args.size());
     origin_index = (origin_index + 1) % conf->args.size();
     
-    std::string s_port = RTMP_DEFAULT_PORT;
-    int port = ::atoi(RTMP_DEFAULT_PORT);
+    std::string s_port = SRS_CONSTS_RTMP_DEFAULT_PORT;
+    int port = ::atoi(SRS_CONSTS_RTMP_DEFAULT_PORT);
     size_t pos = server.find(":");
     if (pos != std::string::npos) {
         s_port = server.substr(pos + 1);
@@ -538,8 +538,8 @@ int SrsEdgeForwarder::connect_server()
     std::string server = conf->args.at(origin_index % conf->args.size());
     origin_index = (origin_index + 1) % conf->args.size();
     
-    std::string s_port = RTMP_DEFAULT_PORT;
-    int port = ::atoi(RTMP_DEFAULT_PORT);
+    std::string s_port = SRS_CONSTS_RTMP_DEFAULT_PORT;
+    int port = ::atoi(SRS_CONSTS_RTMP_DEFAULT_PORT);
     size_t pos = server.find(":");
     if (pos != std::string::npos) {
         s_port = server.substr(pos + 1);

trunk/src/app/srs_app_encoder.cpp

@@ -34,6 +34,7 @@ using namespace std;
 #include <srs_protocol_stack.hpp>
 #include <srs_app_ffmpeg.hpp>
 #include <srs_kernel_utility.hpp>
+#include <srs_kernel_consts.hpp>
 
 #ifdef SRS_AUTO_TRANSCODE
 

trunk/src/app/srs_app_forward.cpp

@@ -86,8 +86,8 @@ int SrsForwarder::on_publish(SrsRequest* req, std::string forward_server)
     
     stream_name = req->stream;
     server = forward_server;
-    std::string s_port = RTMP_DEFAULT_PORT;
-    port = ::atoi(RTMP_DEFAULT_PORT);
+    std::string s_port = SRS_CONSTS_RTMP_DEFAULT_PORT;
+    port = ::atoi(SRS_CONSTS_RTMP_DEFAULT_PORT);
     
     // TODO: FIXME: parse complex params
     size_t pos = forward_server.find(":");

trunk/src/app/srs_app_ingest.cpp

@@ -33,6 +33,7 @@ using namespace std;
 #include <srs_app_ffmpeg.hpp>
 #include <srs_app_pithy_print.hpp>
 #include <srs_kernel_utility.hpp>
+#include <srs_kernel_consts.hpp>
 
 // when error, ingester sleep for a while and retry.
 // ingest never sleep a long time, for we must start the stream ASAP.

trunk/src/app/srs_app_rtmp_conn.cpp

@@ -933,8 +933,8 @@ int SrsRtmpConn::connect_server(int origin_index, st_netfd_t* pstsock)
     std::string server = conf->args.at(origin_index % conf->args.size());
     origin_index = (origin_index + 1) % conf->args.size();
     
-    std::string s_port = RTMP_DEFAULT_PORT;
-    int port = ::atoi(RTMP_DEFAULT_PORT);
+    std::string s_port = SRS_CONSTS_RTMP_DEFAULT_PORT;
+    int port = ::atoi(SRS_CONSTS_RTMP_DEFAULT_PORT);
     size_t pos = server.find(":");
     if (pos != std::string::npos) {
         s_port = server.substr(pos + 1);

trunk/src/app/srs_app_utility.cpp

@@ -36,6 +36,7 @@ using namespace std;
 #include <srs_kernel_error.hpp>
 #include <srs_app_kbps.hpp>
 #include <srs_app_json.hpp>
+#include <srs_kernel_consts.hpp>
 
 int srs_socket_connect(std::string server, int port, int64_t timeout, st_netfd_t* pstfd)
 {

trunk/src/kernel/srs_kernel_consts.hpp

@@ -30,4 +30,24 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 #include <srs_core.hpp>
 
+///////////////////////////////////////////////////////////
+// RTMP consts values
+///////////////////////////////////////////////////////////
+// default vhost of rtmp
+#define SRS_CONSTS_RTMP_DEFAULT_VHOST "__defaultVhost__"
+// default port of rtmp
+#define SRS_CONSTS_RTMP_DEFAULT_PORT "1935"
+
+// the default chunk size for system.
+#define SRS_CONSTS_RTMP_SRS_CHUNK_SIZE 60000
+// 6. Chunking, RTMP protocol default chunk size.
+#define SRS_CONSTS_RTMP_PROTOCOL_CHUNK_SIZE 128
+
+///////////////////////////////////////////////////////////
+// SRS consts values
+///////////////////////////////////////////////////////////
+#define SRS_CONSTS_NULL_FILE "/dev/null"
+#define SRS_CONSTS_LOCALHOST "127.0.0.1"
+
+
 #endif

trunk/src/rtmp/srs_protocol_rtmp.cpp

@@ -605,11 +605,11 @@ int SrsRtmpClient::play(string stream, int stream_id)
     // SetChunkSize
     if (true) {
         SrsSetChunkSizePacket* pkt = new SrsSetChunkSizePacket();
-        pkt->chunk_size = SRS_CONF_DEFAULT_CHUNK_SIZE;
+        pkt->chunk_size = SRS_CONSTS_RTMP_SRS_CHUNK_SIZE;
         if ((ret = protocol->send_and_free_packet(pkt, 0)) != ERROR_SUCCESS) {
             srs_error("send set chunk size failed. "
                 "stream=%s, chunk_size=%d, ret=%d", 
-                stream.c_str(), SRS_CONF_DEFAULT_CHUNK_SIZE, ret);
+                stream.c_str(), SRS_CONSTS_RTMP_SRS_CHUNK_SIZE, ret);
             return ret;
         }
     }
@@ -624,11 +624,11 @@ int SrsRtmpClient::publish(string stream, int stream_id)
     // SetChunkSize
     if (true) {
         SrsSetChunkSizePacket* pkt = new SrsSetChunkSizePacket();
-        pkt->chunk_size = SRS_CONF_DEFAULT_CHUNK_SIZE;
+        pkt->chunk_size = SRS_CONSTS_RTMP_SRS_CHUNK_SIZE;
         if ((ret = protocol->send_and_free_packet(pkt, 0)) != ERROR_SUCCESS) {
             srs_error("send set chunk size failed. "
                 "stream=%s, chunk_size=%d, ret=%d", 
-                stream.c_str(), SRS_CONF_DEFAULT_CHUNK_SIZE, ret);
+                stream.c_str(), SRS_CONSTS_RTMP_SRS_CHUNK_SIZE, ret);
             return ret;
         }
     }

trunk/src/rtmp/srs_protocol_stack.cpp

@@ -31,6 +31,7 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include <srs_kernel_stream.hpp>
 #include <srs_core_autofree.hpp>
 #include <srs_kernel_utility.hpp>
+#include <srs_kernel_consts.hpp>
 
 using namespace std;
 
@@ -177,7 +178,6 @@ messages.
 * good for high-bit rate streaming. Chunk size is maintained
 * independently for each direction.
 */
-#define RTMP_DEFAULT_CHUNK_SIZE                 128
 #define RTMP_MIN_CHUNK_SIZE                     128
 #define RTMP_MAX_CHUNK_SIZE                     65536
 
@@ -299,7 +299,7 @@ SrsProtocol::SrsProtocol(ISrsProtocolReaderWriter* io)
     in_buffer = new SrsBuffer();
     skt = io;
     
-    in_chunk_size = out_chunk_size = RTMP_DEFAULT_CHUNK_SIZE;
+    in_chunk_size = out_chunk_size = SRS_CONSTS_RTMP_PROTOCOL_CHUNK_SIZE;
 }
 
 SrsProtocol::~SrsProtocol()
@@ -3704,7 +3704,7 @@ int SrsAcknowledgementPacket::encode_packet(SrsStream* stream)
 
 SrsSetChunkSizePacket::SrsSetChunkSizePacket()
 {
-    chunk_size = RTMP_DEFAULT_CHUNK_SIZE;
+    chunk_size = SRS_CONSTS_RTMP_PROTOCOL_CHUNK_SIZE;
 }
 
 SrsSetChunkSizePacket::~SrsSetChunkSizePacket()

trunk/src/rtmp/srs_protocol_utility.cpp

@@ -49,7 +49,7 @@ void srs_discovery_tc_url(
         srs_info("discovery host=%s", host.c_str());
     }
 
-    port = RTMP_DEFAULT_PORT;
+    port = SRS_CONSTS_RTMP_DEFAULT_PORT;
     if ((pos = host.find(":")) != std::string::npos) {
         port = host.substr(pos + 1);
         host = host.substr(0, pos);
@@ -117,13 +117,13 @@ string srs_generate_tc_url(string ip, string vhost, string app, string port, str
 {
     string tcUrl = "rtmp://";
     
-    if (vhost == RTMP_VHOST_DEFAULT) {
+    if (vhost == SRS_CONSTS_RTMP_DEFAULT_VHOST) {
         tcUrl += ip;
     } else {
         tcUrl += vhost;
     }
     
-    if (port != RTMP_DEFAULT_PORT) {
+    if (port != SRS_CONSTS_RTMP_DEFAULT_PORT) {
         tcUrl += ":";
         tcUrl += port;
     }

trunk/src/rtmp/srs_protocol_utility.hpp

@@ -31,13 +31,7 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 #include <string>
 
-// default vhost of rtmp
-#define RTMP_VHOST_DEFAULT "__defaultVhost__"
-// default port of rtmp
-#define RTMP_DEFAULT_PORT "1935"
-
-// the default chunk size for system.
-#define SRS_CONF_DEFAULT_CHUNK_SIZE 60000
+#include <srs_kernel_consts.hpp>
 
 /**
 * parse the tcUrl, output the schema, host, vhost, app and port.