extract http static and http stream from http conn.

trunk/configure

@@ -169,11 +169,11 @@ if [ $SRS_EXPORT_LIBRTMP_PROJECT = NO ]; then
     MODULE_DEPENDS=("CORE" "KERNEL" "PROTOCOL") 
     ModuleLibIncs=(${LibSTRoot} ${LibHttpParserRoot} ${SRS_OBJS_DIR})
     MODULE_FILES=("srs_app_server" "srs_app_conn" "srs_app_rtmp_conn" "srs_app_source" 
-            "srs_app_refer" "srs_app_hls" "srs_app_forward" "srs_app_encoder"
+            "srs_app_refer" "srs_app_hls" "srs_app_forward" "srs_app_encoder" "srs_app_http_stream"
             "srs_app_thread" "srs_app_bandwidth" "srs_app_st" "srs_app_log" "srs_app_config" 
             "srs_app_pithy_print" "srs_app_reload" "srs_app_http_api" "srs_app_http_conn" "srs_app_http_hooks" 
             "srs_app_json" "srs_app_ingest" "srs_app_ffmpeg" "srs_app_utility" "srs_app_dvr" "srs_app_edge"
-            "srs_app_heartbeat" "srs_app_empty" "srs_app_http_client"
+            "srs_app_heartbeat" "srs_app_empty" "srs_app_http_client" "srs_app_http_static"
             "srs_app_recv_thread" "srs_app_security" "srs_app_statistic" "srs_app_hds"
             "srs_app_mpegts_udp" "srs_app_rtsp" "srs_app_listener" "srs_app_async_call"
             "srs_app_caster_flv")

trunk/ide/srs_upp/srs_upp.upp

@@ -103,6 +103,10 @@ file
 	../../src/app/srs_app_http_conn.cpp,
 	../../src/app/srs_app_http_hooks.hpp,
 	../../src/app/srs_app_http_hooks.cpp,
+        ../../src/app/srs_app_http_stream.hpp,
+        ../../src/app/srs_app_http_stream.cpp,
+        ../../src/app/srs_app_http_static.hpp,
+        ../../src/app/srs_app_http_static.cpp,
 	../../src/app/srs_app_ingest.hpp,
 	../../src/app/srs_app_ingest.cpp,
 	../../src/app/srs_app_json.hpp,

trunk/ide/srs_vs2010/srs.vcxproj

@@ -77,6 +77,8 @@
     <ClInclude Include="..\..\src\app\srs_app_http_api.hpp" />
     <ClInclude Include="..\..\src\app\srs_app_http_client.hpp" />
     <ClInclude Include="..\..\src\app\srs_app_http_conn.hpp" />
+    <ClInclude Include="..\..\src\app\srs_app_http_static.hpp" />
+    <ClInclude Include="..\..\src\app\srs_app_http_stream.hpp" />
     <ClInclude Include="..\..\src\app\srs_app_http_hooks.hpp" />
     <ClInclude Include="..\..\src\app\srs_app_ingest.hpp" />
     <ClInclude Include="..\..\src\app\srs_app_json.hpp" />
@@ -157,6 +159,8 @@
     <ClCompile Include="..\..\src\app\srs_app_http_api.cpp" />
     <ClCompile Include="..\..\src\app\srs_app_http_client.cpp" />
     <ClCompile Include="..\..\src\app\srs_app_http_conn.cpp" />
+    <ClCompile Include="..\..\src\app\srs_app_http_static.cpp" />
+    <ClCompile Include="..\..\src\app\srs_app_http_stream.cpp" />
     <ClCompile Include="..\..\src\app\srs_app_http_hooks.cpp" />
     <ClCompile Include="..\..\src\app\srs_app_ingest.cpp" />
     <ClCompile Include="..\..\src\app\srs_app_json.cpp" />

trunk/ide/srs_vs2010/srs.vcxproj.filters

@@ -64,6 +64,12 @@
     <ClCompile Include="..\..\src\app\srs_app_http_conn.cpp">
       <Filter>srs</Filter>
     </ClCompile>
+    <ClCompile Include="..\..\src\app\srs_app_http_static.cpp">
+      <Filter>srs</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\app\srs_app_http_stream.cpp">
+      <Filter>srs</Filter>
+    </ClCompile>
     <ClCompile Include="..\..\src\app\srs_app_http_hooks.cpp">
       <Filter>srs</Filter>
     </ClCompile>

trunk/ide/srs_xcode/srs_xcode.xcodeproj/project.pbxproj

@@ -7,6 +7,8 @@
 	objects = {
 
 /* Begin PBXBuildFile section */
+		3C036B551B2D0AC10078E2E0 /* srs_app_http_static.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 3C036B511B2D0AC10078E2E0 /* srs_app_http_static.cpp */; };
+		3C036B561B2D0AC10078E2E0 /* srs_app_http_stream.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 3C036B531B2D0AC10078E2E0 /* srs_app_http_stream.cpp */; };
 		3C068D6A1B10149F00AA722C /* srs_protocol_kbps.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 3C068D681B10149F00AA722C /* srs_protocol_kbps.cpp */; };
 		3C068D6D1B10175500AA722C /* srs_protocol_buffer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 3C068D6B1B10175500AA722C /* srs_protocol_buffer.cpp */; };
 		3C0E1B8D1B0F5ADF003ADEF7 /* srs_http_stack.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 3C0E1B8B1B0F5ADF003ADEF7 /* srs_http_stack.cpp */; };
@@ -121,6 +123,10 @@
 /* End PBXCopyFilesBuildPhase section */
 
 /* Begin PBXFileReference section */
+		3C036B511B2D0AC10078E2E0 /* srs_app_http_static.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = srs_app_http_static.cpp; path = ../../../src/app/srs_app_http_static.cpp; sourceTree = "<group>"; };
+		3C036B521B2D0AC10078E2E0 /* srs_app_http_static.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = srs_app_http_static.hpp; path = ../../../src/app/srs_app_http_static.hpp; sourceTree = "<group>"; };
+		3C036B531B2D0AC10078E2E0 /* srs_app_http_stream.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = srs_app_http_stream.cpp; path = ../../../src/app/srs_app_http_stream.cpp; sourceTree = "<group>"; };
+		3C036B541B2D0AC10078E2E0 /* srs_app_http_stream.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = srs_app_http_stream.hpp; path = ../../../src/app/srs_app_http_stream.hpp; sourceTree = "<group>"; };
 		3C068D681B10149F00AA722C /* srs_protocol_kbps.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = srs_protocol_kbps.cpp; path = ../../../src/protocol/srs_protocol_kbps.cpp; sourceTree = "<group>"; };
 		3C068D691B10149F00AA722C /* srs_protocol_kbps.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = srs_protocol_kbps.hpp; path = ../../../src/protocol/srs_protocol_kbps.hpp; sourceTree = "<group>"; };
 		3C068D6B1B10175500AA722C /* srs_protocol_buffer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = srs_protocol_buffer.cpp; path = ../../../src/protocol/srs_protocol_buffer.cpp; sourceTree = "<group>"; };
@@ -551,6 +557,10 @@
 				3C1232671AAE81D900CE8F6C /* srs_app_http_conn.hpp */,
 				3C1232681AAE81D900CE8F6C /* srs_app_http_hooks.cpp */,
 				3C1232691AAE81D900CE8F6C /* srs_app_http_hooks.hpp */,
+				3C036B511B2D0AC10078E2E0 /* srs_app_http_static.cpp */,
+				3C036B521B2D0AC10078E2E0 /* srs_app_http_static.hpp */,
+				3C036B531B2D0AC10078E2E0 /* srs_app_http_stream.cpp */,
+				3C036B541B2D0AC10078E2E0 /* srs_app_http_stream.hpp */,
 				3C12326C1AAE81D900CE8F6C /* srs_app_ingest.cpp */,
 				3C12326D1AAE81D900CE8F6C /* srs_app_ingest.hpp */,
 				3C12326E1AAE81D900CE8F6C /* srs_app_json.cpp */,
@@ -907,10 +917,12 @@
 				3C1232461AAE81A400CE8F6C /* srs_rtmp_msg_array.cpp in Sources */,
 				3C1232A71AAE81D900CE8F6C /* srs_app_listener.cpp in Sources */,
 				3C1232261AAE814D00CE8F6C /* srs_kernel_flv.cpp in Sources */,
+				3C036B551B2D0AC10078E2E0 /* srs_app_http_static.cpp in Sources */,
 				3C663F1A1AB0155100286D8B /* srs_rtmp_dump.c in Sources */,
 				3CE6CD311AE4AFB800706E07 /* srs_main_ingest_hls.cpp in Sources */,
 				3C28EDDF1AF5C43F00A3AEAC /* srs_app_caster_flv.cpp in Sources */,
 				3C1232241AAE814D00CE8F6C /* srs_kernel_error.cpp in Sources */,
+				3C036B561B2D0AC10078E2E0 /* srs_app_http_stream.cpp in Sources */,
 				3C068D6D1B10175500AA722C /* srs_protocol_buffer.cpp in Sources */,
 				3C1232441AAE81A400CE8F6C /* srs_rtmp_handshake.cpp in Sources */,
 				3C1232291AAE814D00CE8F6C /* srs_kernel_stream.cpp in Sources */,

trunk/src/app/srs_app_http_conn.hpp

@@ -67,10 +67,8 @@ class SrsFastBuffer;
 class SrsHttpUri;
 class SrsConnection;
 class SrsHttpMessage;
-
+class SrsHttpStreamServer;
-#endif
+class SrsHttpStaticServer;
-
-#ifdef SRS_AUTO_HTTP_CORE
 
 // the http chunked header size,
 // for writev, there always one chunk to send it.
@@ -371,363 +369,13 @@ private:
     virtual std::string get_uri_field(std::string uri, http_parser_url* hp_u, http_parser_url_fields field);
 };
 
-#endif
-
-#ifdef SRS_AUTO_HTTP_SERVER
-
-/**
-* the flv vod stream supports flv?start=offset-bytes.
-* for example, http://server/file.flv?start=10240
-* server will write flv header and sequence header, 
-* then seek(10240) and response flv tag data.
-*/
-class SrsVodStream : public SrsHttpFileServer
-{
-public:
-    SrsVodStream(std::string root_dir);
-    virtual ~SrsVodStream();
-protected:
-    virtual int serve_flv_stream(ISrsHttpResponseWriter* w, ISrsHttpMessage* r, std::string fullpath, int offset);
-    virtual int serve_mp4_stream(ISrsHttpResponseWriter* w, ISrsHttpMessage* r, std::string fullpath, int start, int end);
-};
-
-/**
-* for the srs http stream cache, 
-* for example, the audio stream cache to make android(weixin) happy.
-* we start a thread to shrink the queue.
-*/
-class SrsStreamCache : public ISrsEndlessThreadHandler
-{
-private:
-    SrsMessageQueue* queue;
-    SrsSource* source;
-    SrsRequest* req;
-    SrsEndlessThread* pthread;
-public:
-    SrsStreamCache(SrsSource* s, SrsRequest* r);
-    virtual ~SrsStreamCache();
-public:
-    virtual int start();
-    virtual int dump_cache(SrsConsumer* consumer, SrsRtmpJitterAlgorithm jitter);
-// interface ISrsEndlessThreadHandler.
-public:
-    virtual int cycle();
-};
-
-/**
-* the stream encoder in some codec, for example, flv or aac.
-*/
-class ISrsStreamEncoder
-{
-public:
-    ISrsStreamEncoder();
-    virtual ~ISrsStreamEncoder();
-public:
-    /**
-    * initialize the encoder with file writer(to http response) and stream cache.
-    * @param w the writer to write to http response.
-    * @param c the stream cache for audio stream fast startup.
-    */
-    virtual int initialize(SrsFileWriter* w, SrsStreamCache* c) = 0;
-    /**
-    * write rtmp video/audio/metadata.
-    */
-    virtual int write_audio(int64_t timestamp, char* data, int size) = 0;
-    virtual int write_video(int64_t timestamp, char* data, int size) = 0;
-    virtual int write_metadata(int64_t timestamp, char* data, int size) = 0;
-public:
-    /**
-    * for some stream, for example, mp3 and aac, the audio stream,
-    * we use large gop cache in encoder, for the gop cache of SrsSource is ignore audio.
-    * @return true to use gop cache of encoder; otherwise, use SrsSource.
-    */
-    virtual bool has_cache() = 0;
-    /**
-    * dumps the cache of encoder to consumer.
-    */
-    virtual int dump_cache(SrsConsumer* consumer, SrsRtmpJitterAlgorithm jitter) = 0;
-};
-
-/**
-* the flv stream encoder, remux rtmp stream to flv stream.
-*/
-class SrsFlvStreamEncoder : public ISrsStreamEncoder
-{
-protected:
-    SrsFlvEncoder* enc;
-public:
-    SrsFlvStreamEncoder();
-    virtual ~SrsFlvStreamEncoder();
-public:
-    virtual int initialize(SrsFileWriter* w, SrsStreamCache* c);
-    virtual int write_audio(int64_t timestamp, char* data, int size);
-    virtual int write_video(int64_t timestamp, char* data, int size);
-    virtual int write_metadata(int64_t timestamp, char* data, int size);
-public:
-    virtual bool has_cache();
-    virtual int dump_cache(SrsConsumer* consumer, SrsRtmpJitterAlgorithm jitter);
-};
-
-#ifdef SRS_PERF_FAST_FLV_ENCODER
-/**
- * the fast flv stream encoder.
- * @see https://github.com/simple-rtmp-server/srs/issues/405
- */
-class SrsFastFlvStreamEncoder : public SrsFlvStreamEncoder
-{
-public:
-    SrsFastFlvStreamEncoder();
-    virtual ~SrsFastFlvStreamEncoder();
-public:
-    /**
-     * write the tags in a time.
-     */
-    virtual int write_tags(SrsSharedPtrMessage** msgs, int count);
-};
-#endif
-
-/**
-* the ts stream encoder, remux rtmp stream to ts stream.
-*/
-class SrsTsStreamEncoder : public ISrsStreamEncoder
-{
-private:
-    SrsTsEncoder* enc;
-public:
-    SrsTsStreamEncoder();
-    virtual ~SrsTsStreamEncoder();
-public:
-    virtual int initialize(SrsFileWriter* w, SrsStreamCache* c);
-    virtual int write_audio(int64_t timestamp, char* data, int size);
-    virtual int write_video(int64_t timestamp, char* data, int size);
-    virtual int write_metadata(int64_t timestamp, char* data, int size);
-public:
-    virtual bool has_cache();
-    virtual int dump_cache(SrsConsumer* consumer, SrsRtmpJitterAlgorithm jitter);
-};
-
-/**
-* the aac stream encoder, remux rtmp stream to aac stream.
-*/
-class SrsAacStreamEncoder : public ISrsStreamEncoder
-{
-private:
-    SrsAacEncoder* enc;
-    SrsStreamCache* cache;
-public:
-    SrsAacStreamEncoder();
-    virtual ~SrsAacStreamEncoder();
-public:
-    virtual int initialize(SrsFileWriter* w, SrsStreamCache* c);
-    virtual int write_audio(int64_t timestamp, char* data, int size);
-    virtual int write_video(int64_t timestamp, char* data, int size);
-    virtual int write_metadata(int64_t timestamp, char* data, int size);
-public:
-    virtual bool has_cache();
-    virtual int dump_cache(SrsConsumer* consumer, SrsRtmpJitterAlgorithm jitter);
-};
-
-/**
-* the mp3 stream encoder, remux rtmp stream to mp3 stream.
-*/
-class SrsMp3StreamEncoder : public ISrsStreamEncoder
-{
-private:
-    SrsMp3Encoder* enc;
-    SrsStreamCache* cache;
-public:
-    SrsMp3StreamEncoder();
-    virtual ~SrsMp3StreamEncoder();
-public:
-    virtual int initialize(SrsFileWriter* w, SrsStreamCache* c);
-    virtual int write_audio(int64_t timestamp, char* data, int size);
-    virtual int write_video(int64_t timestamp, char* data, int size);
-    virtual int write_metadata(int64_t timestamp, char* data, int size);
-public:
-    virtual bool has_cache();
-    virtual int dump_cache(SrsConsumer* consumer, SrsRtmpJitterAlgorithm jitter);
-};
-
-/**
-* write stream to http response direclty.
-*/
-class SrsStreamWriter : public SrsFileWriter
-{
-private:
-    ISrsHttpResponseWriter* writer;
-public:
-    SrsStreamWriter(ISrsHttpResponseWriter* w);
-    virtual ~SrsStreamWriter();
-public:
-    virtual int open(std::string file);
-    virtual void close();
-public:
-    virtual bool is_open();
-    virtual int64_t tellg();
-public:
-    virtual int write(void* buf, size_t count, ssize_t* pnwrite);
-    virtual int writev(iovec* iov, int iovcnt, ssize_t* pnwrite);
-};
-
-/**
-* the flv live stream supports access rtmp in flv over http.
-* srs will remux rtmp to flv streaming.
-*/
-class SrsLiveStream : public ISrsHttpHandler
-{
-private:
-    SrsRequest* req;
-    SrsSource* source;
-    SrsStreamCache* cache;
-public:
-    SrsLiveStream(SrsSource* s, SrsRequest* r, SrsStreamCache* c);
-    virtual ~SrsLiveStream();
-public:
-    virtual int serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r);
-private:
-    virtual int streaming_send_messages(ISrsStreamEncoder* enc, SrsSharedPtrMessage** msgs, int nb_msgs);
-};
-
-/**
-* the srs live entry
-*/
-struct SrsLiveEntry
-{
-private:
-    bool _is_flv;
-    bool _is_ts;
-    bool _is_aac;
-    bool _is_mp3;
-public:
-    // for template, the mount contains variables.
-    // for concrete stream, the mount is url to access.
-    std::string mount;
-    // whether hstrs(http stream trigger rtmp source)
-    bool hstrs;
-    
-    SrsLiveStream* stream;
-    SrsStreamCache* cache;
-    
-    SrsLiveEntry(std::string m, bool h);
-    
-    bool is_flv();
-    bool is_ts();
-    bool is_mp3();
-    bool is_aac();
-};
-
-/**
-* the m3u8 stream handler.
-*/
-class SrsHlsM3u8Stream : public ISrsHttpHandler
-{
-private:
-    std::string m3u8;
-public:
-    SrsHlsM3u8Stream();
-    virtual ~SrsHlsM3u8Stream();
-public:
-    virtual void set_m3u8(std::string v);
-public:
-    virtual int serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r);
-};
-
-/**
-* the ts stream handler.
-*/
-class SrsHlsTsStream : public ISrsHttpHandler
-{
-private:
-    std::string ts;
-public:
-    SrsHlsTsStream();
-    virtual ~SrsHlsTsStream();
-public:
-    virtual void set_ts(std::string v);
-public:
-    virtual int serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r);
-};
-
-/**
-* the srs hls entry.
-*/
-// TODO: FIXME: use hte hls template and entry.
-struct SrsHlsEntry
-{
-    // for template, the mount contains variables.
-    // for concrete stream, the mount is url to access.
-    std::string mount;
-    
-    // the template to create the entry
-    SrsHlsEntry* tmpl;
-
-    // key: the m3u8/ts file path.
-    // value: the http handler.
-    std::map<std::string, ISrsHttpHandler*> streams;
-    
-    SrsHlsEntry();
-};
-
-/**
-* the http server instance,
-* serve http static file, flv vod stream and flv live stream.
-*/
-class SrsHttpServer : virtual public ISrsReloadHandler
-    , virtual public ISrsHttpMatchHijacker
-{
-private:
-    SrsServer* server;
-public:
-    SrsHttpServeMux mux;
-    // the http live streaming template, to create streams.
-    std::map<std::string, SrsLiveEntry*> tflvs;
-    // the http live streaming streams, crote by template.
-    std::map<std::string, SrsLiveEntry*> sflvs;
-    // the hls live streaming template, to create streams.
-    std::map<std::string, SrsHlsEntry*> thls;
-    // the hls live streaming streams, crote by template.
-    std::map<std::string, SrsHlsEntry*> shls;
-public:
-    SrsHttpServer(SrsServer* svr);
-    virtual ~SrsHttpServer();
-public:
-    virtual int initialize();
-// http flv/ts/mp3/aac stream
-public:
-    virtual int http_mount(SrsSource* s, SrsRequest* r);
-    virtual void http_unmount(SrsSource* s, SrsRequest* r);
-// hls stream
-public:
-    virtual int mount_hls(SrsRequest* r);
-    virtual int hls_update_m3u8(SrsRequest* r, std::string m3u8);
-    virtual int hls_update_ts(SrsRequest* r, std::string uri, std::string ts);
-    virtual int hls_remove_ts(SrsRequest* r, std::string uri);
-    virtual void unmount_hls(SrsRequest* r);
-// interface ISrsReloadHandler.
-public:
-    virtual int on_reload_vhost_http_updated();
-    virtual int on_reload_vhost_http_remux_updated();
-    virtual int on_reload_vhost_hls(std::string vhost);
-// interface ISrsHttpMatchHijacker
-public:
-    virtual int hijack(ISrsHttpMessage* request, ISrsHttpHandler** ph);
-private:
-    virtual int initialize_static_file();
-    virtual int initialize_flv_streaming();
-    virtual int initialize_hls_streaming();
-    virtual std::string hls_mount_generate(SrsRequest* r, std::string uri, std::string tmpl);
-};
-
-#endif
-
-#ifdef SRS_AUTO_HTTP_CORE
 class SrsHttpConn : public SrsConnection
 {
 private:
     SrsHttpParser* parser;
-    SrsHttpServeMux* http_mux;
+    ISrsHttpServeMux* http_mux;
 public:
-    SrsHttpConn(IConnectionManager* cm, st_netfd_t fd, SrsHttpServeMux* m);
+    SrsHttpConn(IConnectionManager* cm, st_netfd_t fd, ISrsHttpServeMux* m);
     virtual ~SrsHttpConn();
 // interface IKbpsDelta
 public:
@@ -746,15 +394,46 @@ private:
     virtual int process_request(ISrsHttpResponseWriter* w, ISrsHttpMessage* r);
 };
 
+// TODO: FIXME: rename to SrsResponseOnlyHttpConn.
 class SrsStaticHttpConn : public SrsHttpConn
 {
 public:
-    SrsStaticHttpConn(IConnectionManager* cm, st_netfd_t fd, SrsHttpServeMux* m);
+    SrsStaticHttpConn(IConnectionManager* cm, st_netfd_t fd, ISrsHttpServeMux* m);
     virtual ~SrsStaticHttpConn();
 public:
     virtual int on_got_http_message(ISrsHttpMessage* msg);
 };
 
+/**
+ * the http server, use http stream or static server to serve requests.
+ */
+class SrsHttpServer : public ISrsHttpServeMux
+{
+private:
+    SrsServer* server;
+    SrsHttpStaticServer* http_static;
+    SrsHttpStreamServer* http_stream;
+public:
+    SrsHttpServer(SrsServer* svr);
+    virtual ~SrsHttpServer();
+public:
+    virtual int initialize();
+// ISrsHttpServeMux
+public:
+    virtual int serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r);
+// http flv/ts/mp3/aac stream
+public:
+    virtual int http_mount(SrsSource* s, SrsRequest* r);
+    virtual void http_unmount(SrsSource* s, SrsRequest* r);
+// hls stream
+public:
+    virtual int mount_hls(SrsRequest* r);
+    virtual int hls_update_m3u8(SrsRequest* r, std::string m3u8);
+    virtual int hls_update_ts(SrsRequest* r, std::string uri, std::string ts);
+    virtual int hls_remove_ts(SrsRequest* r, std::string uri);
+    virtual void unmount_hls(SrsRequest* r);
+};
+
 #endif
 
 #endif

trunk/src/app/srs_app_http_static.cpp

@@ -0,0 +1,283 @@
+/*
+The MIT License (MIT)
+
+Copyright (c) 2013-2015 SRS(simple-rtmp-server)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+#include <srs_app_http_static.hpp>
+
+#if defined(SRS_AUTO_HTTP_CORE)
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <stdlib.h>
+
+#include <sstream>
+using namespace std;
+
+#include <srs_protocol_buffer.hpp>
+#include <srs_rtmp_utility.hpp>
+#include <srs_kernel_log.hpp>
+#include <srs_kernel_error.hpp>
+#include <srs_app_st.hpp>
+#include <srs_core_autofree.hpp>
+#include <srs_app_config.hpp>
+#include <srs_kernel_utility.hpp>
+#include <srs_kernel_file.hpp>
+#include <srs_kernel_flv.hpp>
+#include <srs_rtmp_stack.hpp>
+#include <srs_app_source.hpp>
+#include <srs_rtmp_msg_array.hpp>
+#include <srs_kernel_aac.hpp>
+#include <srs_kernel_mp3.hpp>
+#include <srs_kernel_ts.hpp>
+#include <srs_app_pithy_print.hpp>
+#include <srs_app_source.hpp>
+#include <srs_app_server.hpp>
+
+#endif
+
+#ifdef SRS_AUTO_HTTP_SERVER
+
+SrsVodStream::SrsVodStream(string root_dir)
+    : SrsHttpFileServer(root_dir)
+{
+}
+
+SrsVodStream::~SrsVodStream()
+{
+}
+
+int SrsVodStream::serve_flv_stream(ISrsHttpResponseWriter* w, ISrsHttpMessage* r, string fullpath, int offset)
+{
+    int ret = ERROR_SUCCESS;
+    
+    SrsFileReader fs;
+    
+    // open flv file
+    if ((ret = fs.open(fullpath)) != ERROR_SUCCESS) {
+        return ret;
+    }
+    
+    if (offset > fs.filesize()) {
+        ret = ERROR_HTTP_REMUX_OFFSET_OVERFLOW;
+        srs_warn("http flv streaming %s overflow. size=%"PRId64", offset=%d, ret=%d", 
+            fullpath.c_str(), fs.filesize(), offset, ret);
+        return ret;
+    }
+    
+    SrsFlvVodStreamDecoder ffd;
+    
+    // open fast decoder
+    if ((ret = ffd.initialize(&fs)) != ERROR_SUCCESS) {
+        return ret;
+    }
+    
+    // save header, send later.
+    char flv_header[13];
+    
+    // send flv header
+    if ((ret = ffd.read_header_ext(flv_header)) != ERROR_SUCCESS) {
+        return ret;
+    }
+    
+    // save sequence header, send later
+    char* sh_data = NULL;
+    int sh_size = 0;
+    
+    if (true) {
+        // send sequence header
+        int64_t start = 0;
+        if ((ret = ffd.read_sequence_header_summary(&start, &sh_size)) != ERROR_SUCCESS) {
+            return ret;
+        }
+        if (sh_size <= 0) {
+            ret = ERROR_HTTP_REMUX_SEQUENCE_HEADER;
+            srs_warn("http flv streaming no sequence header. size=%d, ret=%d", sh_size, ret);
+            return ret;
+        }
+    }
+    sh_data = new char[sh_size];
+    SrsAutoFree(char, sh_data);
+    if ((ret = fs.read(sh_data, sh_size, NULL)) != ERROR_SUCCESS) {
+        return ret;
+    }
+
+    // seek to data offset
+    int64_t left = fs.filesize() - offset;
+
+    // write http header for ts.
+    w->header()->set_content_length((int)(sizeof(flv_header) + sh_size + left));
+    w->header()->set_content_type("video/x-flv");
+    
+    // write flv header and sequence header.
+    if ((ret = w->write(flv_header, sizeof(flv_header))) != ERROR_SUCCESS) {
+        return ret;
+    }
+    if (sh_size > 0 && (ret = w->write(sh_data, sh_size)) != ERROR_SUCCESS) {
+        return ret;
+    }
+    
+    // write body.
+    if ((ret = ffd.lseek(offset)) != ERROR_SUCCESS) {
+        return ret;
+    }
+    
+    // send data
+    if ((ret = copy(w, &fs, r, (int)left)) != ERROR_SUCCESS) {
+        srs_warn("read flv=%s size=%d failed, ret=%d", fullpath.c_str(), left, ret);
+        return ret;
+    }
+    
+    return ret;
+}
+
+int SrsVodStream::serve_mp4_stream(ISrsHttpResponseWriter* w, ISrsHttpMessage* r, string fullpath, int start, int end)
+{
+    int ret = ERROR_SUCCESS;
+
+    srs_assert(start >= 0);
+    srs_assert(end == -1 || end >= 0);
+    
+    SrsFileReader fs;
+    
+    // open flv file
+    if ((ret = fs.open(fullpath)) != ERROR_SUCCESS) {
+        return ret;
+    }
+
+    // parse -1 to whole file.
+    if (end == -1) {
+        end = (int)fs.filesize();
+    }
+    
+    if (end > fs.filesize() || start > end) {
+        ret = ERROR_HTTP_REMUX_OFFSET_OVERFLOW;
+        srs_warn("http mp4 streaming %s overflow. size=%"PRId64", offset=%d, ret=%d", 
+            fullpath.c_str(), fs.filesize(), start, ret);
+        return ret;
+    }
+
+    // seek to data offset, [start, end] for range.
+    int64_t left = end - start + 1;
+
+    // write http header for ts.
+    w->header()->set_content_length(left);
+    w->header()->set_content_type("video/mp4");
+
+    // status code 206 to make dash.as happy.
+    w->write_header(SRS_CONSTS_HTTP_PartialContent);
+
+    // response the content range header.
+    std::stringstream content_range;
+    content_range << "bytes " << start << "-" << end << "/" << fs.filesize();
+    w->header()->set("Content-Range", content_range.str());
+    
+    // write body.
+    fs.lseek(start);
+    
+    // send data
+    if ((ret = copy(w, &fs, r, (int)left)) != ERROR_SUCCESS) {
+        srs_warn("read mp4=%s size=%d failed, ret=%d", fullpath.c_str(), left, ret);
+        return ret;
+    }
+    
+    return ret;
+}
+
+SrsHttpStaticServer::SrsHttpStaticServer(SrsServer* svr)
+{
+    server = svr;
+}
+
+SrsHttpStaticServer::~SrsHttpStaticServer()
+{
+}
+
+int SrsHttpStaticServer::initialize()
+{
+    int ret = ERROR_SUCCESS;
+    
+    bool default_root_exists = false;
+    
+    // http static file and flv vod stream mount for each vhost.
+    SrsConfDirective* root = _srs_config->get_root();
+    for (int i = 0; i < (int)root->directives.size(); i++) {
+        SrsConfDirective* conf = root->at(i);
+        
+        if (!conf->is_vhost()) {
+            continue;
+        }
+        
+        std::string vhost = conf->arg0();
+        if (!_srs_config->get_vhost_http_enabled(vhost)) {
+            continue;
+        }
+        
+        std::string mount = _srs_config->get_vhost_http_mount(vhost);
+        std::string dir = _srs_config->get_vhost_http_dir(vhost);
+        
+        // replace the vhost variable
+        mount = srs_string_replace(mount, "[vhost]", vhost);
+        
+        // remove the default vhost mount
+        mount = srs_string_replace(mount, SRS_CONSTS_RTMP_DEFAULT_VHOST"/", "/");
+        
+        // the dir mount must always ends with "/"
+        if (mount != "/" && mount.rfind("/") != mount.length() - 1) {
+            mount += "/";
+        }
+        
+        // mount the http of vhost.
+        if ((ret = mux.handle(mount, new SrsVodStream(dir))) != ERROR_SUCCESS) {
+            srs_error("http: mount dir=%s for vhost=%s failed. ret=%d", dir.c_str(), vhost.c_str(), ret);
+            return ret;
+        }
+        
+        if (mount == "/") {
+            default_root_exists = true;
+            srs_warn("http: root mount to %s", dir.c_str());
+        }
+        srs_trace("http: vhost=%s mount to %s", vhost.c_str(), mount.c_str());
+    }
+    
+    if (!default_root_exists) {
+        // add root
+        std::string dir = _srs_config->get_http_stream_dir();
+        if ((ret = mux.handle("/", new SrsVodStream(dir))) != ERROR_SUCCESS) {
+            srs_error("http: mount root dir=%s failed. ret=%d", dir.c_str(), ret);
+            return ret;
+        }
+        srs_trace("http: root mount to %s", dir.c_str());
+    }
+    
+    return ret;
+}
+
+int SrsHttpStaticServer::on_reload_vhost_http_updated()
+{
+    int ret = ERROR_SUCCESS;
+    // TODO: FIXME: implements it.
+    return ret;
+}
+
+#endif
+

trunk/src/app/srs_app_http_static.hpp

@@ -0,0 +1,76 @@
+/*
+The MIT License (MIT)
+
+Copyright (c) 2013-2015 SRS(simple-rtmp-server)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+#ifndef SRS_APP_HTTP_STATIC_HPP
+#define SRS_APP_HTTP_STATIC_HPP
+
+/*
+#include <srs_app_http_static.hpp>
+*/
+
+#include <srs_core.hpp>
+
+#include <srs_app_http_conn.hpp>
+
+#ifdef SRS_AUTO_HTTP_SERVER
+
+/**
+ * the flv vod stream supports flv?start=offset-bytes.
+ * for example, http://server/file.flv?start=10240
+ * server will write flv header and sequence header,
+ * then seek(10240) and response flv tag data.
+ */
+class SrsVodStream : public SrsHttpFileServer
+{
+public:
+    SrsVodStream(std::string root_dir);
+    virtual ~SrsVodStream();
+protected:
+    virtual int serve_flv_stream(ISrsHttpResponseWriter* w, ISrsHttpMessage* r, std::string fullpath, int offset);
+    virtual int serve_mp4_stream(ISrsHttpResponseWriter* w, ISrsHttpMessage* r, std::string fullpath, int start, int end);
+};
+
+/**
+* the http static server instance,
+* serve http static file and flv/mp4 vod stream.
+*/
+class SrsHttpStaticServer : virtual public ISrsReloadHandler
+{
+private:
+    SrsServer* server;
+public:
+    SrsHttpServeMux mux;
+public:
+    SrsHttpStaticServer(SrsServer* svr);
+    virtual ~SrsHttpStaticServer();
+public:
+    virtual int initialize();
+// interface ISrsReloadHandler.
+public:
+    virtual int on_reload_vhost_http_updated();
+};
+
+#endif
+
+#endif
+

trunk/src/app/srs_app_http_stream.hpp

@@ -0,0 +1,365 @@
+/*
+The MIT License (MIT)
+
+Copyright (c) 2013-2015 SRS(simple-rtmp-server)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+#ifndef SRS_APP_HTTP_STREAM_HPP
+#define SRS_APP_HTTP_STREAM_HPP
+
+/*
+#include <srs_app_http_stream.hpp>
+*/
+
+#include <srs_core.hpp>
+
+#include <srs_app_http_conn.hpp>
+
+#ifdef SRS_AUTO_HTTP_SERVER
+
+/**
+* for the srs http stream cache, 
+* for example, the audio stream cache to make android(weixin) happy.
+* we start a thread to shrink the queue.
+*/
+class SrsStreamCache : public ISrsEndlessThreadHandler
+{
+private:
+    SrsMessageQueue* queue;
+    SrsSource* source;
+    SrsRequest* req;
+    SrsEndlessThread* pthread;
+public:
+    SrsStreamCache(SrsSource* s, SrsRequest* r);
+    virtual ~SrsStreamCache();
+public:
+    virtual int start();
+    virtual int dump_cache(SrsConsumer* consumer, SrsRtmpJitterAlgorithm jitter);
+// interface ISrsEndlessThreadHandler.
+public:
+    virtual int cycle();
+};
+
+/**
+* the stream encoder in some codec, for example, flv or aac.
+*/
+class ISrsStreamEncoder
+{
+public:
+    ISrsStreamEncoder();
+    virtual ~ISrsStreamEncoder();
+public:
+    /**
+    * initialize the encoder with file writer(to http response) and stream cache.
+    * @param w the writer to write to http response.
+    * @param c the stream cache for audio stream fast startup.
+    */
+    virtual int initialize(SrsFileWriter* w, SrsStreamCache* c) = 0;
+    /**
+    * write rtmp video/audio/metadata.
+    */
+    virtual int write_audio(int64_t timestamp, char* data, int size) = 0;
+    virtual int write_video(int64_t timestamp, char* data, int size) = 0;
+    virtual int write_metadata(int64_t timestamp, char* data, int size) = 0;
+public:
+    /**
+    * for some stream, for example, mp3 and aac, the audio stream,
+    * we use large gop cache in encoder, for the gop cache of SrsSource is ignore audio.
+    * @return true to use gop cache of encoder; otherwise, use SrsSource.
+    */
+    virtual bool has_cache() = 0;
+    /**
+    * dumps the cache of encoder to consumer.
+    */
+    virtual int dump_cache(SrsConsumer* consumer, SrsRtmpJitterAlgorithm jitter) = 0;
+};
+
+/**
+* the flv stream encoder, remux rtmp stream to flv stream.
+*/
+class SrsFlvStreamEncoder : public ISrsStreamEncoder
+{
+protected:
+    SrsFlvEncoder* enc;
+public:
+    SrsFlvStreamEncoder();
+    virtual ~SrsFlvStreamEncoder();
+public:
+    virtual int initialize(SrsFileWriter* w, SrsStreamCache* c);
+    virtual int write_audio(int64_t timestamp, char* data, int size);
+    virtual int write_video(int64_t timestamp, char* data, int size);
+    virtual int write_metadata(int64_t timestamp, char* data, int size);
+public:
+    virtual bool has_cache();
+    virtual int dump_cache(SrsConsumer* consumer, SrsRtmpJitterAlgorithm jitter);
+};
+
+#ifdef SRS_PERF_FAST_FLV_ENCODER
+/**
+ * the fast flv stream encoder.
+ * @see https://github.com/simple-rtmp-server/srs/issues/405
+ */
+class SrsFastFlvStreamEncoder : public SrsFlvStreamEncoder
+{
+public:
+    SrsFastFlvStreamEncoder();
+    virtual ~SrsFastFlvStreamEncoder();
+public:
+    /**
+     * write the tags in a time.
+     */
+    virtual int write_tags(SrsSharedPtrMessage** msgs, int count);
+};
+#endif
+
+/**
+* the ts stream encoder, remux rtmp stream to ts stream.
+*/
+class SrsTsStreamEncoder : public ISrsStreamEncoder
+{
+private:
+    SrsTsEncoder* enc;
+public:
+    SrsTsStreamEncoder();
+    virtual ~SrsTsStreamEncoder();
+public:
+    virtual int initialize(SrsFileWriter* w, SrsStreamCache* c);
+    virtual int write_audio(int64_t timestamp, char* data, int size);
+    virtual int write_video(int64_t timestamp, char* data, int size);
+    virtual int write_metadata(int64_t timestamp, char* data, int size);
+public:
+    virtual bool has_cache();
+    virtual int dump_cache(SrsConsumer* consumer, SrsRtmpJitterAlgorithm jitter);
+};
+
+/**
+* the aac stream encoder, remux rtmp stream to aac stream.
+*/
+class SrsAacStreamEncoder : public ISrsStreamEncoder
+{
+private:
+    SrsAacEncoder* enc;
+    SrsStreamCache* cache;
+public:
+    SrsAacStreamEncoder();
+    virtual ~SrsAacStreamEncoder();
+public:
+    virtual int initialize(SrsFileWriter* w, SrsStreamCache* c);
+    virtual int write_audio(int64_t timestamp, char* data, int size);
+    virtual int write_video(int64_t timestamp, char* data, int size);
+    virtual int write_metadata(int64_t timestamp, char* data, int size);
+public:
+    virtual bool has_cache();
+    virtual int dump_cache(SrsConsumer* consumer, SrsRtmpJitterAlgorithm jitter);
+};
+
+/**
+* the mp3 stream encoder, remux rtmp stream to mp3 stream.
+*/
+class SrsMp3StreamEncoder : public ISrsStreamEncoder
+{
+private:
+    SrsMp3Encoder* enc;
+    SrsStreamCache* cache;
+public:
+    SrsMp3StreamEncoder();
+    virtual ~SrsMp3StreamEncoder();
+public:
+    virtual int initialize(SrsFileWriter* w, SrsStreamCache* c);
+    virtual int write_audio(int64_t timestamp, char* data, int size);
+    virtual int write_video(int64_t timestamp, char* data, int size);
+    virtual int write_metadata(int64_t timestamp, char* data, int size);
+public:
+    virtual bool has_cache();
+    virtual int dump_cache(SrsConsumer* consumer, SrsRtmpJitterAlgorithm jitter);
+};
+
+/**
+* write stream to http response direclty.
+*/
+class SrsStreamWriter : public SrsFileWriter
+{
+private:
+    ISrsHttpResponseWriter* writer;
+public:
+    SrsStreamWriter(ISrsHttpResponseWriter* w);
+    virtual ~SrsStreamWriter();
+public:
+    virtual int open(std::string file);
+    virtual void close();
+public:
+    virtual bool is_open();
+    virtual int64_t tellg();
+public:
+    virtual int write(void* buf, size_t count, ssize_t* pnwrite);
+    virtual int writev(iovec* iov, int iovcnt, ssize_t* pnwrite);
+};
+
+/**
+* the flv live stream supports access rtmp in flv over http.
+* srs will remux rtmp to flv streaming.
+*/
+class SrsLiveStream : public ISrsHttpHandler
+{
+private:
+    SrsRequest* req;
+    SrsSource* source;
+    SrsStreamCache* cache;
+public:
+    SrsLiveStream(SrsSource* s, SrsRequest* r, SrsStreamCache* c);
+    virtual ~SrsLiveStream();
+public:
+    virtual int serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r);
+private:
+    virtual int streaming_send_messages(ISrsStreamEncoder* enc, SrsSharedPtrMessage** msgs, int nb_msgs);
+};
+
+/**
+* the srs live entry
+*/
+struct SrsLiveEntry
+{
+private:
+    bool _is_flv;
+    bool _is_ts;
+    bool _is_aac;
+    bool _is_mp3;
+public:
+    // for template, the mount contains variables.
+    // for concrete stream, the mount is url to access.
+    std::string mount;
+    // whether hstrs(http stream trigger rtmp source)
+    bool hstrs;
+    
+    SrsLiveStream* stream;
+    SrsStreamCache* cache;
+    
+    SrsLiveEntry(std::string m, bool h);
+    
+    bool is_flv();
+    bool is_ts();
+    bool is_mp3();
+    bool is_aac();
+};
+
+/**
+* the m3u8 stream handler.
+*/
+class SrsHlsM3u8Stream : public ISrsHttpHandler
+{
+private:
+    std::string m3u8;
+public:
+    SrsHlsM3u8Stream();
+    virtual ~SrsHlsM3u8Stream();
+public:
+    virtual void set_m3u8(std::string v);
+public:
+    virtual int serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r);
+};
+
+/**
+* the ts stream handler.
+*/
+class SrsHlsTsStream : public ISrsHttpHandler
+{
+private:
+    std::string ts;
+public:
+    SrsHlsTsStream();
+    virtual ~SrsHlsTsStream();
+public:
+    virtual void set_ts(std::string v);
+public:
+    virtual int serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r);
+};
+
+/**
+* the srs hls entry.
+*/
+// TODO: FIXME: use hte hls template and entry.
+struct SrsHlsEntry
+{
+    // for template, the mount contains variables.
+    // for concrete stream, the mount is url to access.
+    std::string mount;
+    
+    // the template to create the entry
+    SrsHlsEntry* tmpl;
+
+    // key: the m3u8/ts file path.
+    // value: the http handler.
+    std::map<std::string, ISrsHttpHandler*> streams;
+    
+    SrsHlsEntry();
+};
+
+/**
+* the http stream server instance,
+* serve http stream, for example, flv/ts/mp3/aac live stream.
+*/
+class SrsHttpStreamServer : virtual public ISrsReloadHandler
+    , virtual public ISrsHttpMatchHijacker
+{
+private:
+    SrsServer* server;
+public:
+    SrsHttpServeMux mux;
+    // the http live streaming template, to create streams.
+    std::map<std::string, SrsLiveEntry*> tflvs;
+    // the http live streaming streams, crote by template.
+    std::map<std::string, SrsLiveEntry*> sflvs;
+    // the hls live streaming template, to create streams.
+    std::map<std::string, SrsHlsEntry*> thls;
+    // the hls live streaming streams, crote by template.
+    std::map<std::string, SrsHlsEntry*> shls;
+public:
+    SrsHttpStreamServer(SrsServer* svr);
+    virtual ~SrsHttpStreamServer();
+public:
+    virtual int initialize();
+// http flv/ts/mp3/aac stream
+public:
+    virtual int http_mount(SrsSource* s, SrsRequest* r);
+    virtual void http_unmount(SrsSource* s, SrsRequest* r);
+// hls stream
+public:
+    virtual int mount_hls(SrsRequest* r);
+    virtual int hls_update_m3u8(SrsRequest* r, std::string m3u8);
+    virtual int hls_update_ts(SrsRequest* r, std::string uri, std::string ts);
+    virtual int hls_remove_ts(SrsRequest* r, std::string uri);
+    virtual void unmount_hls(SrsRequest* r);
+// interface ISrsReloadHandler.
+public:
+    virtual int on_reload_vhost_http_remux_updated();
+    virtual int on_reload_vhost_hls(std::string vhost);
+// interface ISrsHttpMatchHijacker
+public:
+    virtual int hijack(ISrsHttpMessage* request, ISrsHttpHandler** ph);
+private:
+    virtual int initialize_flv_streaming();
+    virtual int initialize_hls_streaming();
+    virtual std::string hls_mount_generate(SrsRequest* r, std::string uri, std::string tmpl);
+};
+
+#endif
+
+#endif
+

trunk/src/app/srs_app_server.cpp

@@ -496,7 +496,7 @@ SrsServer::SrsServer()
     http_api_mux = new SrsHttpServeMux();
 #endif
 #ifdef SRS_AUTO_HTTP_SERVER
-    http_stream_mux = new SrsHttpServer(this);
+    http_server = new SrsHttpServer(this);
 #endif
 #ifdef SRS_AUTO_HTTP_CORE
     http_heartbeat = NULL;
@@ -522,7 +522,7 @@ void SrsServer::destroy()
 #endif
 
 #ifdef SRS_AUTO_HTTP_SERVER
-    srs_freep(http_stream_mux);
+    srs_freep(http_server);
 #endif
 
 #ifdef SRS_AUTO_HTTP_CORE
@@ -602,8 +602,8 @@ int SrsServer::initialize(ISrsServerCycle* cycle_handler)
 #endif
 
 #ifdef SRS_AUTO_HTTP_SERVER
-    srs_assert(http_stream_mux);
+    srs_assert(http_server);
-    if ((ret = http_stream_mux->initialize()) != ERROR_SUCCESS) {
+    if ((ret = http_server->initialize()) != ERROR_SUCCESS) {
         return ret;
     }
 #endif
@@ -810,13 +810,6 @@ int SrsServer::http_handle()
         return ret;
     }
 #endif
-    
-#if defined(SRS_AUTO_HTTP_SERVER) && defined(SRS_AUTO_HTTP_API)
-    // for SRS go-sharp to detect the status of HTTP server of SRS HTTP FLV Cluster.
-    if ((ret = http_stream_mux->mux.handle("/api/v1/versions", new SrsGoApiVersion())) != ERROR_SUCCESS) {
-        return ret;
-    }
-#endif
 
     return ret;
 }
@@ -1226,7 +1219,7 @@ int SrsServer::accept_client(SrsListenerType type, st_netfd_t client_stfd)
 #endif
     } else if (type == SrsListenerHttpStream) {
 #ifdef SRS_AUTO_HTTP_SERVER
-        conn = new SrsStaticHttpConn(this, client_stfd, &http_stream_mux->mux);
+        conn = new SrsStaticHttpConn(this, client_stfd, http_server);
 #else
         srs_warn("close http client for server not support http-server");
         srs_close_stfd(client_stfd);
@@ -1364,7 +1357,7 @@ int SrsServer::on_publish(SrsSource* s, SrsRequest* r)
     int ret = ERROR_SUCCESS;
     
 #ifdef SRS_AUTO_HTTP_SERVER
-    if ((ret = http_stream_mux->http_mount(s, r)) != ERROR_SUCCESS) {
+    if ((ret = http_server->http_mount(s, r)) != ERROR_SUCCESS) {
         return ret;
     }
 #endif
@@ -1375,7 +1368,7 @@ int SrsServer::on_publish(SrsSource* s, SrsRequest* r)
 void SrsServer::on_unpublish(SrsSource* s, SrsRequest* r)
 {
 #ifdef SRS_AUTO_HTTP_SERVER
-    http_stream_mux->http_unmount(s, r);
+    http_server->http_unmount(s, r);
 #endif
 }
 
@@ -1384,7 +1377,7 @@ int SrsServer::on_hls_publish(SrsRequest* r)
     int ret = ERROR_SUCCESS;
     
 #ifdef SRS_AUTO_HTTP_SERVER
-    if ((ret = http_stream_mux->mount_hls(r)) != ERROR_SUCCESS) {
+    if ((ret = http_server->mount_hls(r)) != ERROR_SUCCESS) {
         return ret;
     }
 #endif
@@ -1397,7 +1390,7 @@ int SrsServer::on_update_m3u8(SrsRequest* r, string m3u8)
     int ret = ERROR_SUCCESS;
     
 #ifdef SRS_AUTO_HTTP_SERVER
-    if ((ret = http_stream_mux->hls_update_m3u8(r, m3u8)) != ERROR_SUCCESS) {
+    if ((ret = http_server->hls_update_m3u8(r, m3u8)) != ERROR_SUCCESS) {
         return ret;
     }
 #endif
@@ -1410,7 +1403,7 @@ int SrsServer::on_update_ts(SrsRequest* r, string uri, string ts)
     int ret = ERROR_SUCCESS;
     
 #ifdef SRS_AUTO_HTTP_SERVER
-    if ((ret = http_stream_mux->hls_update_ts(r, uri, ts)) != ERROR_SUCCESS) {
+    if ((ret = http_server->hls_update_ts(r, uri, ts)) != ERROR_SUCCESS) {
         return ret;
     }
 #endif
@@ -1424,7 +1417,7 @@ int SrsServer::on_remove_ts(SrsRequest* r, string uri)
     int ret = ERROR_SUCCESS;
     
 #ifdef SRS_AUTO_HTTP_SERVER
-    if ((ret = http_stream_mux->hls_remove_ts(r, uri)) != ERROR_SUCCESS) {
+    if ((ret = http_server->hls_remove_ts(r, uri)) != ERROR_SUCCESS) {
         return ret;
     }
 #endif
@@ -1437,7 +1430,7 @@ int SrsServer::on_hls_unpublish(SrsRequest* r)
     int ret = ERROR_SUCCESS;
     
 #ifdef SRS_AUTO_HTTP_SERVER
-    http_stream_mux->unmount_hls(r);
+    http_server->unmount_hls(r);
 #endif
     
     return ret;

trunk/src/app/srs_app_server.hpp

@@ -235,10 +235,11 @@ class SrsServer : virtual public ISrsReloadHandler
 {
 private:
 #ifdef SRS_AUTO_HTTP_API
+    // TODO: FIXME: rename to http_api
     SrsHttpServeMux* http_api_mux;
 #endif
 #ifdef SRS_AUTO_HTTP_SERVER
-    SrsHttpServer* http_stream_mux;
+    SrsHttpServer* http_server;
 #endif
 #ifdef SRS_AUTO_HTTP_CORE
     SrsHttpHeartbeat* http_heartbeat;

trunk/src/protocol/srs_http_stack.cpp

@@ -228,6 +228,11 @@ ISrsHttpHandler::~ISrsHttpHandler()
 {
 }
 
+bool ISrsHttpHandler::is_not_found()
+{
+    return false;
+}
+
 SrsHttpRedirectHandler::SrsHttpRedirectHandler(string u, int c)
 {
     url = u;
@@ -253,6 +258,11 @@ SrsHttpNotFoundHandler::~SrsHttpNotFoundHandler()
 {
 }
 
+bool SrsHttpNotFoundHandler::is_not_found()
+{
+    return true;
+}
+
 int SrsHttpNotFoundHandler::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
 {
     return srs_go_http_error(w, SRS_CONSTS_HTTP_NotFound, SRS_CONSTS_HTTP_NotFound_str);
@@ -487,6 +497,14 @@ ISrsHttpMatchHijacker::~ISrsHttpMatchHijacker()
 {
 }
 
+ISrsHttpServeMux::ISrsHttpServeMux()
+{
+}
+
+ISrsHttpServeMux::~ISrsHttpServeMux()
+{
+}
+
 SrsHttpServeMux::SrsHttpServeMux()
 {
 }
@@ -604,6 +622,19 @@ int SrsHttpServeMux::handle(std::string pattern, ISrsHttpHandler* handler)
     return ret;
 }
 
+bool SrsHttpServeMux::can_serve(ISrsHttpMessage* r)
+{
+    int ret = ERROR_SUCCESS;
+    
+    ISrsHttpHandler* h = NULL;
+    if ((ret = find_handler(r, &h)) != ERROR_SUCCESS) {
+        return false;
+    }
+    
+    srs_assert(h);
+    return !h->is_not_found();
+}
+
 int SrsHttpServeMux::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
 {
     int ret = ERROR_SUCCESS;
@@ -654,9 +685,9 @@ int SrsHttpServeMux::find_handler(ISrsHttpMessage* r, ISrsHttpHandler** ph)
         }
     }
     
+    static ISrsHttpHandler* h404 = new SrsHttpNotFoundHandler();
     if (*ph == NULL) {
-        // TODO: FIXME: memory leak.
+        *ph = h404;
-        *ph = new SrsHttpNotFoundHandler();
     }
     
     return ret;

trunk/src/protocol/srs_http_stack.hpp

@@ -247,6 +247,7 @@ public:
     ISrsHttpHandler();
     virtual ~ISrsHttpHandler();
 public:
+    virtual bool is_not_found();
     virtual int serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r) = 0;
 };
 
@@ -270,6 +271,7 @@ public:
     SrsHttpNotFoundHandler();
     virtual ~SrsHttpNotFoundHandler();
 public:
+    virtual bool is_not_found();
     virtual int serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r);
 };
 
@@ -347,6 +349,18 @@ public:
     virtual int hijack(ISrsHttpMessage* request, ISrsHttpHandler** ph) = 0;
 };
 
+/**
+ * the server mux, all http server should implements it.
+ */
+class ISrsHttpServeMux
+{
+public:
+    ISrsHttpServeMux();
+    virtual ~ISrsHttpServeMux();
+public:
+    virtual int serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r) = 0;
+};
+
 // ServeMux is an HTTP request multiplexer.
 // It matches the URL of each incoming request against a list of registered
 // patterns and calls the handler for the pattern that
@@ -374,7 +388,7 @@ public:
 // ServeMux also takes care of sanitizing the URL request path,
 // redirecting any request containing . or .. elements to an
 // equivalent .- and ..-free URL.
-class SrsHttpServeMux
+class SrsHttpServeMux : public ISrsHttpServeMux
 {
 private:
     // the pattern handler, to handle the http request.
@@ -406,7 +420,10 @@ public:
     // Handle registers the handler for the given pattern.
     // If a handler already exists for pattern, Handle panics.
     virtual int handle(std::string pattern, ISrsHttpHandler* handler);
-    // interface ISrsHttpHandler
+    // whether the http muxer can serve the specified message,
+    // if not, user can try next muxer.
+    virtual bool can_serve(ISrsHttpMessage* r);
+// interface ISrsHttpServeMux
 public:
     virtual int serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r);
 private: