Refine typo in service.

trunk/src/service/srs_service_conn.hpp

@@ -26,9 +26,7 @@
 
 #include <srs_core.hpp>
 
-/**
+// The connection interface for all HTTP/RTMP/RTSP object.
- * The connection interface for all HTTP/RTMP/RTSP object.
- */
 class ISrsConnection
 {
 public:
@@ -36,18 +34,14 @@ public:
     virtual ~ISrsConnection();
 };
 
-/**
+// The manager for connection.
- * the manager for connection.
- */
 class IConnectionManager
 {
 public:
     IConnectionManager();
     virtual ~IConnectionManager();
 public:
-    /**
+    // Remove then free the specified connection.
-     * Remove then free the specified connection.
-     */
     virtual void remove(ISrsConnection* c) = 0;
 };
 

trunk/src/service/srs_service_http_client.hpp

@@ -40,18 +40,16 @@ class SrsKbps;
 class SrsWallClock;
 class SrsTcpClient;
 
-// the default timeout for http client.
+// The default timeout for http client.
-#define SRS_HTTP_CLIENT_TIMEOUT (30 * SRS_UTIME_SECONDS)
+#define SRS_HTTP_CLIENT_TIMEOUT (30// SRS_UTIME_SECONDS)
 
-/**
+// The client to GET/POST/PUT/DELETE over HTTP.
- * The client to GET/POST/PUT/DELETE over HTTP.
+// @remark We will reuse the TCP transport until initialize or channel error,
- * @remark We will reuse the TCP transport until initialize or channel error,
+//      such as send/recv failed.
- *      such as send/recv failed.
+// Usage:
- * Usage:
+//      SrsHttpClient hc;
- *      SrsHttpClient hc;
+//      hc.initialize("127.0.0.1", 80, 9000);
- *      hc.initialize("127.0.0.1", 80, 9000);
+//      hc.post("/api/v1/version", "Hello world!", NULL);
- *      hc.post("/api/v1/version", "Hello world!", NULL);
- */
 class SrsHttpClient
 {
 private:
@@ -72,33 +70,25 @@ public:
     SrsHttpClient();
     virtual ~SrsHttpClient();
 public:
-    /**
+    // Initliaze the client, disconnect the transport, renew the HTTP parser.
-     * Initliaze the client, disconnect the transport, renew the HTTP parser.
+    // @param tm The underlayer TCP transport timeout in srs_utime_t.
-     * @param tm The underlayer TCP transport timeout in srs_utime_t.
+    // @remark we will set default values in headers, which can be override by set_header.
-     * @remark we will set default values in headers, which can be override by set_header.
-     */
     virtual srs_error_t initialize(std::string h, int p, srs_utime_t tm = SRS_HTTP_CLIENT_TIMEOUT);
-    /**
+    // Set HTTP request header in header[k]=v.
-     * Set HTTP request header in header[k]=v.
+    // @return the HTTP client itself.
-     * @return the HTTP client itself.
-     */
     virtual SrsHttpClient* set_header(std::string k, std::string v);
 public:
-    /**
+    // Post data to the uri.
-     * to post data to the uri.
+    // @param the path to request on.
-     * @param the path to request on.
+    // @param req the data post to uri. empty string to ignore.
-     * @param req the data post to uri. empty string to ignore.
+    // @param ppmsg output the http message to read the response.
-     * @param ppmsg output the http message to read the response.
+    // @remark user must free the ppmsg if not NULL.
-     * @remark user must free the ppmsg if not NULL.
-     */
     virtual srs_error_t post(std::string path, std::string req, ISrsHttpMessage** ppmsg);
-    /**
+    // Get data from the uri.
-     * to get data from the uri.
+    // @param the path to request on.
-     * @param the path to request on.
+    // @param req the data post to uri. empty string to ignore.
-     * @param req the data post to uri. empty string to ignore.
+    // @param ppmsg output the http message to read the response.
-     * @param ppmsg output the http message to read the response.
+    // @remark user must free the ppmsg if not NULL.
-     * @remark user must free the ppmsg if not NULL.
-     */
     virtual srs_error_t get(std::string path, std::string req, ISrsHttpMessage** ppmsg);
 private:
     virtual void set_recv_timeout(srs_utime_t tm);

trunk/src/service/srs_service_http_conn.hpp

@@ -37,18 +37,16 @@ class ISrsReader;
 class SrsHttpResponseReader;
 class SrsStSocket;
 
-/**
+// A wrapper for http-parser,
- * wrapper for http-parser,
+// provides HTTP message originted service.
- * provides HTTP message originted service.
- */
 class SrsHttpParser
 {
 private:
     http_parser_settings settings;
     http_parser parser;
-    // the global parse buffer.
+    // The global parse buffer.
     SrsFastStream* buffer;
-    // whether allow jsonp parse.
+    // Whether allow jsonp parse.
     bool jsonp;
 private:
     // http parse data, reset before parse message.
@@ -64,24 +62,18 @@ public:
     SrsHttpParser();
     virtual ~SrsHttpParser();
 public:
-    /**
+    // initialize the http parser with specified type,
-     * initialize the http parser with specified type,
+    // one parser can only parse request or response messages.
-     * one parser can only parse request or response messages.
+    // @param allow_jsonp whether allow jsonp parser, which indicates the method in query string.
-     * @param allow_jsonp whether allow jsonp parser, which indicates the method in query string.
-     */
     virtual srs_error_t initialize(enum http_parser_type type, bool allow_jsonp = false);
-    /**
+    // always parse a http message,
-     * always parse a http message,
+    // that is, the *ppmsg always NOT-NULL when return success.
-     * that is, the *ppmsg always NOT-NULL when return success.
+    // or error and *ppmsg must be NULL.
-     * or error and *ppmsg must be NULL.
+    // @remark, if success, *ppmsg always NOT-NULL, *ppmsg always is_complete().
-     * @remark, if success, *ppmsg always NOT-NULL, *ppmsg always is_complete().
+    // @remark user must free the ppmsg if not NULL.
-     * @remark user must free the ppmsg if not NULL.
-     */
     virtual srs_error_t parse_message(ISrsReader* reader, ISrsHttpMessage** ppmsg);
 private:
-    /**
+    // parse the HTTP message to member field: msg.
-     * parse the HTTP message to member field: msg.
-     */
     virtual srs_error_t parse_message_imp(ISrsReader* reader);
 private:
     static int on_message_begin(http_parser* parser);
@@ -105,62 +97,41 @@ typedef std::pair<std::string, std::string> SrsHttpHeaderField;
 class SrsHttpMessage : public ISrsHttpMessage
 {
 private:
-    /**
+    // The parsed url.
-     * parsed url.
-     */
     std::string _url;
-    /**
+    // The extension of file, for example, .flv
-     * the extension of file, for example, .flv
-     */
     std::string _ext;
-    /**
+    // parsed http header.
-     * parsed http header.
-     */
     http_parser _header;
-    /**
+    // The body object, reader object.
-     * body object, reader object.
+    // @remark, user can get body in string by get_body().
-     * @remark, user can get body in string by get_body().
-     */
     SrsHttpResponseReader* _body;
-    /**
+    // Whether the body is chunked.
-     * whether the body is chunked.
-     */
     bool chunked;
-    /**
+    // Whether the body is infinite chunked.
-     * whether the body is infinite chunked.
-     */
     bool infinite_chunked;
-    /**
+    // Whether the request indicates should keep alive for the http connection.
-     * whether the request indicates should keep alive
-     * for the http connection.
-     */
     bool keep_alive;
-    /**
+    // The uri parser
-     * uri parser
-     */
     SrsHttpUri* _uri;
-    /**
+    // Use a buffer to read and send ts file.
-     * use a buffer to read and send ts file.
-     */
     // TODO: FIXME: remove it.
     char* _http_ts_send_buffer;
-    // http headers
+    // The http headers
     std::vector<SrsHttpHeaderField> _headers;
-    // the query map
+    // The query map
     std::map<std::string, std::string> _query;
-    // the transport connection, can be NULL.
+    // The transport connection, can be NULL.
     SrsConnection* owner_conn;
-    // whether request is jsonp.
+    // Whether request is jsonp.
     bool jsonp;
-    // the method in QueryString will override the HTTP method.
+    // The method in QueryString will override the HTTP method.
     std::string jsonp_method;
 public:
     SrsHttpMessage(ISrsReader* io);
     virtual ~SrsHttpMessage();
 public:
-    /**
+    // set the original messages, then update the message.
-     * set the original messages, then update the message.
-     */
     virtual srs_error_t update(std::string url, bool allow_jsonp, http_parser* header, SrsFastStream* body, std::vector<SrsHttpHeaderField>& headers);
 public:
     // Get the owner connection, maybe NULL.
@@ -169,91 +140,62 @@ public:
 public:
     virtual uint8_t method();
     virtual uint16_t status_code();
-    /**
+    // The method helpers.
-     * method helpers.
-     */
     virtual std::string method_str();
     virtual bool is_http_get();
     virtual bool is_http_put();
     virtual bool is_http_post();
     virtual bool is_http_delete();
     virtual bool is_http_options();
-    /**
+    // Whether body is chunked encoding, for reader only.
-     * whether body is chunked encoding, for reader only.
-     */
     virtual bool is_chunked();
-    /**
+    // Whether body is infinite chunked encoding.
-     * whether body is infinite chunked encoding.
+    // @remark set by enter_infinite_chunked.
-     * @remark set by enter_infinite_chunked.
-     */
     virtual bool is_infinite_chunked();
-    /**
+    // Whether should keep the connection alive.
-     * whether should keep the connection alive.
-     */
     virtual bool is_keep_alive();
-    /**
+    // The uri contains the host and path.
-     * the uri contains the host and path.
-     */
     virtual std::string uri();
-    /**
+    // The url maybe the path.
-     * the url maybe the path.
-     */
     virtual std::string url();
     virtual std::string host();
     virtual std::string path();
     virtual std::string query();
     virtual std::string ext();
-    /**
+    // Get the RESTful matched id.
-     * get the RESTful matched id.
-     */
     virtual int parse_rest_id(std::string pattern);
 public:
     virtual srs_error_t enter_infinite_chunked();
 public:
-    /**
+    // Read body to string.
-     * read body to string.
+    // @remark for small http body.
-     * @remark for small http body.
-     */
     virtual srs_error_t body_read_all(std::string& body);
-    /**
+    // Get the body reader, to read one by one.
-     * get the body reader, to read one by one.
+    // @remark when body is very large, or chunked, use this.
-     * @remark when body is very large, or chunked, use this.
-     */
     virtual ISrsHttpResponseReader* body_reader();
-    /**
+    // The content length, -1 for chunked or not set.
-     * the content length, -1 for chunked or not set.
-     */
     virtual int64_t content_length();
-    /**
+    // Get the param in query string, for instance, query is "start=100&end=200",
-     * get the param in query string,
+    // then query_get("start") is "100", and query_get("end") is "200"
-     * for instance, query is "start=100&end=200",
-     * then query_get("start") is "100", and query_get("end") is "200"
-     */
     virtual std::string query_get(std::string key);
-    /**
+    // Get the headers.
-     * get the headers.
-     */
     virtual int request_header_count();
     virtual std::string request_header_key_at(int index);
     virtual std::string request_header_value_at(int index);
     virtual std::string get_request_header(std::string name);
 public:
-    /**
+    // Convert the http message to a request.
-     * convert the http message to a request.
+    // @remark user must free the return request.
-     * @remark user must free the return request.
-     */
     virtual SrsRequest* to_request(std::string vhost);
 public:
     virtual bool is_jsonp();
 };
 
-// the http chunked header size,
+// The http chunked header size,
 // for writev, there always one chunk to send it.
 #define SRS_HTTP_HEADER_CACHE_SIZE 64
 
-/**
+// Response writer use st socket
- * response writer use st socket
- */
 class SrsHttpResponseWriter : public ISrsHttpResponseWriter
 {
 private:
@@ -264,17 +206,17 @@ private:
     iovec* iovss_cache;
     int nb_iovss_cache;
 private:
-    // reply header has been (logically) written
+    // Reply header has been (logically) written
     bool header_wrote;
-    // status code passed to WriteHeader
+    // The status code passed to WriteHeader
     int status;
 private:
-    // explicitly-declared Content-Length; or -1
+    // The explicitly-declared Content-Length; or -1
     int64_t content_length;
-    // number of bytes written in body
+    // The number of bytes written in body
     int64_t written;
 private:
-    // wroteHeader tells whether the header's been written to "the
+    // The wroteHeader tells whether the header's been written to "the
     // wire" (or rather: w.conn.buf). this is unlike
     // (*response).wroteHeader, which tells only whether it was
     // logically written.
@@ -291,9 +233,7 @@ public:
     virtual srs_error_t send_header(char* data, int size);
 };
 
-/**
+// Response reader use st socket.
- * response reader use st socket.
- */
 class SrsHttpResponseReader : virtual public ISrsHttpResponseReader
 {
 private:
@@ -301,21 +241,19 @@ private:
     SrsHttpMessage* owner;
     SrsFastStream* buffer;
     bool is_eof;
-    // the left bytes in chunk.
+    // The left bytes in chunk.
     int nb_left_chunk;
-    // the number of bytes of current chunk.
+    // The number of bytes of current chunk.
     int nb_chunk;
-    // already read total bytes.
+    // Already read total bytes.
     int64_t nb_total_read;
 public:
     SrsHttpResponseReader(SrsHttpMessage* msg, ISrsReader* reader);
     virtual ~SrsHttpResponseReader();
 public:
-    /**
+    // Initialize the response reader with buffer.
-     * initialize the response reader with buffer.
-     */
     virtual srs_error_t initialize(SrsFastStream* buffer);
-    // interface ISrsHttpResponseReader
+// interface ISrsHttpResponseReader
 public:
     virtual bool eof();
     virtual srs_error_t read(char* data, int nb_data, int* nb_read);

trunk/src/service/srs_service_log.hpp

@@ -31,10 +31,8 @@
 #include <srs_service_st.hpp>
 #include <srs_kernel_log.hpp>
 
-/**
+// The st thread context, get_id will get the st-thread id,
- * st thread context, get_id will get the st-thread id,
+// which identify the client.
- * which identify the client.
- */
 class SrsThreadContext : public ISrsThreadContext
 {
 private:
@@ -50,9 +48,7 @@ public:
     virtual void clear_cid();
 };
 
-/**
+// The basic console log, which write log to console.
- * The basic console log, which write log to console.
- */
 class SrsConsoleLog : public ISrsLog
 {
 private:
@@ -74,13 +70,11 @@ public:
     virtual void error(const char* tag, int context_id, const char* fmt, ...);
 };
 
-/**
+// Generate the log header.
- * Generate the log header.
+// @param dangerous Whether log is warning or error, log the errno if true.
- * @param dangerous Whether log is warning or error, log the errno if true.
+// @param utc Whether use UTC time format in the log header.
- * @param utc Whether use UTC time format in the log header.
+// @param psize Output the actual header size.
- * @param psize Output the actual header size.
+// @remark It's a internal API.
- * @remark It's a internal API.
- */
 bool srs_log_header(char* buffer, int size, bool utc, bool dangerous, const char* tag, int cid, const char* level, int* psize);
 
 #endif

trunk/src/service/srs_service_rtmp_conn.hpp

@@ -37,15 +37,13 @@ class SrsPacket;
 class SrsKbps;
 class SrsWallClock;
 
-/**
+// The simple RTMP client, provides friendly APIs.
- * The simple RTMP client, provides friendly APIs.
+// @remark Should never use client when closed.
- * @remark Should never use client when closed.
+// Usage:
- * Usage:
+//      SrsBasicRtmpClient client("rtmp://127.0.0.1:1935/live/livestream", 3000, 9000);
- *      SrsBasicRtmpClient client("rtmp://127.0.0.1:1935/live/livestream", 3000, 9000);
+//      client.connect();
- *      client.connect();
+//      client.play();
- *      client.play();
+//      client.close();
- *      client.close();
- */
 class SrsBasicRtmpClient
 {
 private:

trunk/src/service/srs_service_st.hpp

@@ -36,10 +36,10 @@ typedef void* srs_thread_t;
 typedef void* srs_cond_t;
 typedef void* srs_mutex_t;
 
-// initialize st, requires epoll.
+// Initialize st, requires epoll.
 extern srs_error_t srs_st_init();
 
-// close the netfd, and close the underlayer fd.
+// Close the netfd, and close the underlayer fd.
 // @remark when close, user must ensure io completed.
 extern void srs_close_stfd(srs_netfd_t& stfd);
 
@@ -81,9 +81,7 @@ extern srs_netfd_t srs_accept(srs_netfd_t stfd, struct sockaddr *addr, int *addr
 
 extern ssize_t srs_read(srs_netfd_t stfd, void *buf, size_t nbyte, srs_utime_t timeout);
 
-/**
+// The mutex locker.
- * The mutex locker.
- */
 #define SrsLocker(instance) \
     impl__SrsLocker _srs_auto_free_##instance(&instance)
 
@@ -102,10 +100,8 @@ public:
     }
 };
 
-/**
+// the socket provides TCP socket over st,
- * the socket provides TCP socket over st,
+// that is, the sync socket mechanism.
- * that is, the sync socket mechanism.
- */
 class SrsStSocket : public ISrsProtocolReadWriter
 {
 private:
@@ -133,28 +129,22 @@ public:
     virtual int64_t get_recv_bytes();
     virtual int64_t get_send_bytes();
 public:
-    /**
+    // @param nread, the actual read bytes, ignore if NULL.
-     * @param nread, the actual read bytes, ignore if NULL.
-     */
     virtual srs_error_t read(void* buf, size_t size, ssize_t* nread);
     virtual srs_error_t read_fully(void* buf, size_t size, ssize_t* nread);
-    /**
+    // @param nwrite, the actual write bytes, ignore if NULL.
-     * @param nwrite, the actual write bytes, ignore if NULL.
-     */
     virtual srs_error_t write(void* buf, size_t size, ssize_t* nwrite);
     virtual srs_error_t writev(const iovec *iov, int iov_size, ssize_t* nwrite);
 };
 
-/**
+// The client to connect to server over TCP.
- * The client to connect to server over TCP.
+// User must never reuse the client when close it.
- * User must never reuse the client when close it.
+// Usage:
- * Usage:
+//      SrsTcpClient client("127.0.0.1", 1935, 9// SRS_UTIME_SECONDS);
- *      SrsTcpClient client("127.0.0.1", 1935, 9 * SRS_UTIME_SECONDS);
+//      client.connect();
- *      client.connect();
+//      client.write("Hello world!", 12, NULL);
- *      client.write("Hello world!", 12, NULL);
+//      client.read(buf, 4096, NULL);
- *      client.read(buf, 4096, NULL);
+// @remark User can directly free the object, which will close the fd.
- * @remark User can directly free the object, which will close the fd.
- */
 class SrsTcpClient : public ISrsProtocolReadWriter
 {
 private:
@@ -166,25 +156,19 @@ private:
     // The timeout in srs_utime_t.
     srs_utime_t timeout;
 public:
-    /**
+    // Constructor.
-     * Constructor.
+    // @param h the ip or hostname of server.
-     * @param h the ip or hostname of server.
+    // @param p the port to connect to.
-     * @param p the port to connect to.
+    // @param tm the timeout in srs_utime_t.
-     * @param tm the timeout in srs_utime_t.
-     */
     SrsTcpClient(std::string h, int p, srs_utime_t tm);
     virtual ~SrsTcpClient();
 public:
-    /**
+    // Connect to server over TCP.
-     * Connect to server over TCP.
+    // @remark We will close the exists connection before do connect.
-     * @remark We will close the exists connection before do connect.
-     */
     virtual srs_error_t connect();
 private:
-    /**
+    // Close the connection to server.
-     * Close the connection to server.
+    // @remark User should never use the client when close it.
-     * @remark User should never use the client when close it.
-     */
     virtual void close();
 // interface ISrsProtocolReadWriter
 public:

trunk/src/service/srs_service_utility.hpp

@@ -32,17 +32,17 @@
 
 #include <srs_service_st.hpp>
 
-// whether the url is starts with http:// or https://
+// Whether the url is starts with http:// or https://
 extern bool srs_string_is_http(std::string url);
 extern bool srs_string_is_rtmp(std::string url);
 
-// get local ip, fill to @param ips
+// Get local ip, fill to @param ips
 extern std::vector<std::string>& srs_get_local_ips();
 
-// get local public ip, empty string if no public internet address found.
+// Get local public ip, empty string if no public internet address found.
 extern std::string srs_get_public_internet_address();
 
-// detect whether specified device is internet public address.
+// Detect whether specified device is internet public address.
 extern bool srs_net_device_is_internet(std::string ifname);
 extern bool srs_net_device_is_internet(const sockaddr* addr);