添加win测试程序

bin_lib/windows/ZLMediaKit/include/ZLMediaKit/Codec/AACEncoder.h

+/*
+ * AACEncoder.h
+ *
+ *  Created on: 2016年8月11日
+ *      Author: xzl
+ */
+
+#ifndef CODEC_AACENCODER_H_
+#define CODEC_AACENCODER_H_
+
+namespace ZL {
+namespace Codec {
+
+class AACEncoder {
+public:
+	AACEncoder(void);
+	virtual ~AACEncoder(void);
+	bool init(int iSampleRate, int iAudioChannel, int iAudioSampleBit);
+	int inputData(char *pcData, int iLen, unsigned char **ppucOutBuffer);
+
+private:
+	unsigned char *m_pucPcmBuf = nullptr;
+	unsigned int m_uiPcmLen = 0;
+
+	unsigned char *m_pucAacBuf = nullptr;
+	void *m_hEncoder = nullptr;
+
+	unsigned long m_ulInputSamples = 0;
+	unsigned long m_ulMaxInputBytes = 0;
+	unsigned long m_ulMaxOutputBytes = 0;
+
+};
+
+} /* namespace Codec */
+} /* namespace ZL */
+
+#endif /* CODEC_AACENCODER_H_ */

bin_lib/windows/ZLMediaKit/include/ZLMediaKit/Codec/H264Encoder.h

+/*
+ * H264Encoder.h
+ *
+ *  Created on: 2016年8月11日
+ *      Author: xzl
+ */
+
+#ifndef CODEC_H264ENCODER_H_
+#define CODEC_H264ENCODER_H_
+
+#include <cstdint>
+
+#ifdef __cplusplus
+extern "C" {
+#endif //__cplusplus
+#include <x264.h>
+#ifdef __cplusplus
+}
+#endif //__cplusplus
+
+namespace ZL {
+namespace Codec {
+
+class H264Encoder {
+public:
+	typedef struct {
+		int iType;
+		int iLength;
+		uint8_t *pucData;
+	} H264Frame;
+
+	H264Encoder(void);
+	virtual ~H264Encoder(void);
+	bool init(int iWidth, int iHeight, int iFps);
+	int inputData(char *apcYuv[3], int aiYuvLen[3], int64_t i64Pts, H264Frame **ppFrame);
+private:
+	x264_t* m_pX264Handle = nullptr;
+	x264_picture_t* m_pPicIn = nullptr;
+	x264_picture_t* m_pPicOut = nullptr;
+	H264Frame m_aFrames[10];
+};
+
+} /* namespace Codec */
+} /* namespace ZL */
+
+#endif /* CODEC_H264ENCODER_H_ */

bin_lib/windows/ZLMediaKit/include/ZLMediaKit/Common/MediaSender.h

+/*
+ * MediaSender.h
+ *
+ *  Created on: 2016年9月1日
+ *      Author: xzl
+ */
+
+#ifndef SRC_MEDIASENDER_H_
+#define SRC_MEDIASENDER_H_
+
+#include "Thread/ThreadPool.h"
+using namespace ZL::Thread;
+
+class MediaSender {
+public:
+	static ThreadPool & sendThread() {
+		static ThreadPool pool(1);
+		return pool;
+	}
+private:
+	MediaSender();
+	virtual ~MediaSender();
+};
+
+#endif /* SRC_MEDIASENDER_H_ */

bin_lib/windows/ZLMediaKit/include/ZLMediaKit/Common/config.h

+//
+//  appConfig.h
+//  ZLMedia
+//
+//  Created by lyl on 16/10/22.
+//  Copyright © 2016年 jizan. All rights reserved.
+//
+
+#ifndef appConfig_h
+#define appConfig_h
+
+#include "Util/mini.h"
+using namespace ZL::Util;
+
+namespace Config {
+
+void loaIniConfig();
+////////////TCP最大连接数///////////
+#ifdef __x86_64__
+#define MAX_TCP_SESSION 100000
+#else
+#define MAX_TCP_SESSION 128
+#endif
+
+////////////其他宏定义///////////
+#ifndef MAX
+#define MAX(a,b) ((a) > (b) ? (a) : (b) )
+#endif //MAX
+
+#ifndef MIN
+#define MIN(a,b) ((a) < (b) ? (a) : (b) )
+#endif //MIN
+
+#ifndef CLEAR_ARR
+#define CLEAR_ARR(arr) for(auto &item : arr){ item = 0;}
+#endif //CLEAR_ARR
+
+
+////////////广播名称///////////
+namespace Broadcast {
+extern const char kBroadcastRtspSessionPlay[];
+#define BroadcastRtspSessionPlayArgs const char *app,const char *stream
+
+extern const char kBroadcastRtspSrcRegisted[];
+#define BroadcastRtspSrcRegistedArgs const char *app,const char *stream
+
+extern const char kBroadcastRtmpSrcRegisted[];
+#define BroadcastRtmpSrcRegistedArgs const char *app,const char *stream
+
+extern const char kBroadcastRecordMP4[];
+#define BroadcastRecordMP4Args const Mp4Info &info
+
+extern const char kBroadcastHttpRequest[];
+#define BroadcastHttpRequestArgs const Parser &parser,HttpSession::HttpResponseInvoker &invoker
+
+} //namespace Broadcast
+
+//代理失败最大重试次数
+namespace Proxy {
+extern const char kReplayCount[];
+}//namespace Proxy
+
+
+////////////HTTP配置///////////
+namespace Http {
+extern const char kPort[];
+extern const char kSSLPort[];
+//http 文件发送缓存大小
+extern const char kSendBufSize[];
+//http 最大请求字节数
+extern const char kMaxReqSize[];
+//http keep-alive秒数
+extern const char kKeepAliveSecond[];
+//http keep-alive最大请求数
+extern const char kMaxReqCount[];
+//http 字符编码
+extern const char kCharSet[];
+//http 服务器名称
+extern const char kServerName[];
+//http 服务器根目录
+extern const char kRootPath[];
+//http 404错误提示内容
+extern const char kNotFound[];
+//HTTP访问url前缀
+extern const char kHttpPrefix[];
+}//namespace Http
+
+////////////SHELL配置///////////
+namespace Shell {
+extern const char kServerName[];
+extern const char kMaxReqSize[];
+extern const char kPort[];
+} //namespace Shell
+
+////////////RTSP服务器配置///////////
+namespace Rtsp {
+#define RTSP_VERSION 1.30
+#define RTSP_BUILDTIME __DATE__" CST"
+
+extern const char kServerName[];
+extern const char kPort[];
+} //namespace Rtsp
+
+////////////RTMP服务器配置///////////
+namespace Rtmp {
+extern const char kPort[];
+} //namespace RTMP
+
+
+////////////RTP配置///////////
+namespace Rtp {
+//RTP打包最大MTU,公网情况下更小
+extern const char kVideoMtuSize[];
+//RTP打包最大MTU,公网情况下更小
+extern const char kAudioMtuSize[];
+//udp方式接受RTP包的最大缓存
+extern const char kUdpBufSize[];
+//RTP排序缓存最大个数
+extern const char kMaxRtpCount[];
+//如果RTP序列正确次数累计达到该数字就启动清空排序缓存
+extern const char kClearCount[];
+//最大RTP时间为13个小时，每13小时回环一次
+extern const char kCycleMS[];
+} //namespace Rtsp
+
+////////////组播配置///////////
+namespace MultiCast {
+//组播分配起始地址
+extern const char kAddrMin[];
+//组播分配截止地址
+extern const char kAddrMax[];
+//组播TTL
+extern const char kUdpTTL[];
+} //namespace MultiCast
+
+////////////录像配置///////////
+namespace Record {
+//查看录像的应用名称
+extern const char kAppName[];
+//每次流化MP4文件的时长,单位毫秒
+extern const char kSampleMS[];
+//MP4文件录制大小,不能太大,否则MP4Close函数执行事件太长
+extern const char kFileSecond[];
+//Rtsp访问url前缀
+extern const char kRtspPrefix[];
+//录制文件路径
+extern const char kFilePath[];
+} //namespace Record
+
+////////////HLS相关配置///////////
+namespace Hls {
+//HLS切片时长,单位秒
+extern const char kSegmentDuration[];
+//HLS切片个数
+extern const char kSegmentNum[];
+//HLS文件写缓存大小
+extern const char kFileBufSize[];
+//录制文件路径
+extern const char kFilePath[];
+} //namespace Hls
+
+}  // namespace Config
+
+#endif /* appConfig_h */

bin_lib/windows/ZLMediaKit/include/ZLMediaKit/Device/Device.h

+/*
+ * Device.h
+ *
+ *  Created on: 2016年8月10日
+ *      Author: xzl
+ */
+
+#ifndef DEVICE_DEVICE_H_
+#define DEVICE_DEVICE_H_
+
+#include <memory>
+#include <string>
+#include <functional>
+#include "Util/util.h"
+#include "RTP/RtpMakerAAC.h"
+#include "RTP/RtpMakerH264.h"
+#include "Rtsp/RtspToRtmpMediaSource.h"
+
+using namespace std;
+using namespace ZL::Rtsp;
+using namespace ZL::Util;
+
+#ifdef ENABLE_FAAC
+#include "Codec/AACEncoder.h"
+using namespace ZL::Codec;
+#endif //ENABLE_FAAC
+
+#ifdef ENABLE_X264
+#include "Codec/H264Encoder.h"
+using namespace ZL::Codec;
+#endif //ENABLE_X264
+
+namespace ZL {
+namespace DEV {
+
+class VideoInfo {
+public:
+	int iWidth;
+	int iHeight;
+	float iFrameRate;
+};
+class AudioInfo {
+public:
+	int iChannel;
+	int iSampleBit;
+	int iSampleRate;
+};
+
+class DevChannel {
+public:
+	typedef std::shared_ptr<DevChannel> Ptr;
+	DevChannel(const char *strApp, const char *strId,float fDuration = 0,bool bLiveStream = true);
+	virtual ~DevChannel();
+
+	void initVideo(const VideoInfo &info);
+	void initAudio(const AudioInfo &info);
+
+	void inputYUV(char *apcYuv[3], int aiYuvLen[3], uint32_t uiStamp);
+	void inputPCM(char *pcData, int iDataLen, uint32_t uiStamp);
+
+	void inputH264(char *pcData, int iDataLen, uint32_t uiStamp);
+	void inputAAC(char *pcData, int iDataLen, uint32_t uiStamp);
+#ifdef ENABLE_RTSP2RTMP
+	int readerCount() {
+		return m_mediaSrc ? m_mediaSrc->readerCount() : 0;
+	}
+	void updateTimeStamp(uint32_t uiStamp){
+		m_mediaSrc->updateTimeStamp(uiStamp);
+	}
+#endif //ENABLE_RTSP2RTMP
+	void setOnSeek(const function<bool(uint32_t)> &onSeek){
+		m_mediaSrc->setOnSeek(onSeek);
+	}
+	void setOnStamp(const function<uint32_t()> &cb) {
+		m_mediaSrc->setOnStamp(cb);
+	}
+private:
+	inline void makeSDP_264(unsigned char *pucData, int iDataLen);
+	inline void makeSDP_AAC(unsigned char *pucData, int iDataLen);
+	inline void makeSDP(const string& strSdp);
+#ifdef ENABLE_X264
+	std::shared_ptr<H264Encoder> m_pH264Enc;
+#endif //ENABLE_X264
+
+#ifdef ENABLE_FAAC
+	std::shared_ptr<AACEncoder> m_pAacEnc;
+#endif //ENABLE_FAAC
+	RtpMaker_AAC::Ptr m_pRtpMaker_aac;
+	RtpMaker_H264::Ptr m_pRtpMaker_h264;
+	RtspToRtmpMediaSource::Ptr m_mediaSrc;
+	string m_strSDP;
+	bool m_bSdp_gotH264 = false;
+	bool m_bSdp_gotAAC = false;
+
+	unsigned char m_aucSPS[256];
+	unsigned int m_uiSPSLen = 0;
+	unsigned char m_aucPPS[256];
+	unsigned int m_uiPPSLen = 0;
+	std::shared_ptr<VideoInfo> m_video;
+	std::shared_ptr<AudioInfo> m_audio;
+};
+
+
+} /* namespace DEV */
+} /* namespace ZL */
+
+#endif /* DEVICE_DEVICE_H_ */

bin_lib/windows/ZLMediaKit/include/ZLMediaKit/Device/PlayerProxy.h

+/*
+ * PlyerProxy.h
+ *
+ *  Created on: 2016年12月6日
+ *      Author: xzl
+ */
+
+#ifndef SRC_DEVICE_PLAYERPROXY_H_
+#define SRC_DEVICE_PLAYERPROXY_H_
+
+#include <memory>
+#include "Device.h"
+#include "Player/MediaPlayer.h"
+#include "Util/TimeTicker.h"
+
+using namespace std;
+using namespace ZL::Player;
+
+namespace ZL {
+namespace DEV {
+
+class PlayerProxy :public MediaPlayer, public std::enable_shared_from_this<PlayerProxy>{
+public:
+	typedef std::shared_ptr<PlayerProxy> Ptr;
+	//设置代理时间，0为永久，其他为代理秒数
+	//设置方法：proxy[PlayerProxy::kAliveSecond] = 100;
+	static const char kAliveSecond[];
+
+	PlayerProxy(const char *strApp, const char *strSrc);
+	virtual ~PlayerProxy();
+	void play(const char* strUrl) override;
+	void setOnExpired(const function<void()> &cb){
+		onExpired = cb;
+	}
+private :
+	DevChannel::Ptr m_pChn;
+	Ticker m_aliveTicker;
+	uint32_t m_aliveSecond = 0;
+	function<void()> onExpired;
+	string m_strApp;
+	string m_strSrc;
+	void initMedia();
+	void rePlay(const string &strUrl,uint64_t iFailedCnt);
+	void checkExpired();
+	void expired();
+};
+
+} /* namespace Player */
+} /* namespace ZL */
+
+#endif /* SRC_DEVICE_PLAYERPROXY_H_ */

bin_lib/windows/ZLMediaKit/include/ZLMediaKit/Device/base64.h

+/*
+ * Copyright (c) 2006 Ryan Martell. (rdm4@martellventures.com)
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#define FF_ARRAY_ELEMS(a) (sizeof(a) / sizeof((a)[0]))
+#ifndef AVUTIL_BASE64_H
+#define AVUTIL_BASE64_H
+
+#include <stdint.h>
+
+/**
+ * Decode a base64-encoded string.
+ *
+ * @param out      buffer for decoded data
+ * @param in       null-terminated input string
+ * @param out_size size in bytes of the out buffer, must be at
+ *                 least 3/4 of the length of in
+ * @return         number of bytes written, or a negative value in case of
+ *                 invalid input
+ */
+int av_base64_decode(uint8_t *out, const char *in, int out_size);
+
+/**
+ * Encode data to base64 and null-terminate.
+ *
+ * @param out      buffer for encoded data
+ * @param out_size size in bytes of the output buffer, must be at
+ *                 least AV_BASE64_SIZE(in_size)
+ * @param in_size  size in bytes of the 'in' buffer
+ * @return         'out' or NULL in case of error
+ */
+char *av_base64_encode(char *out, int out_size, const uint8_t *in, int in_size);
+
+/**
+ * Calculate the output size needed to base64-encode x bytes.
+ */
+#define AV_BASE64_SIZE(x)  (((x)+2) / 3 * 4 + 1)
+
+#endif /* AVUTIL_BASE64_H */

bin_lib/windows/ZLMediaKit/include/ZLMediaKit/H264/H264Parser.h

+//
+//  H264Parser.h
+//  MediaPlayer
+//
+//  Created by xzl on 2017/1/16.
+//  Copyright © 2017年 jizan. All rights reserved.
+//
+
+#ifndef H264Parser_h
+#define H264Parser_h
+
+#include <stdio.h>
+#include <string>
+#include "h264_poc.h"
+#include "h264_parser.h"
+using namespace std;
+
+#ifndef INT32_MAX
+#define INT32_MAX 0x7FFFFFFF
+#endif//INT32_MAX
+
+class H264Parser{
+public:
+    H264Parser();
+    virtual ~H264Parser();
+    void inputH264(const string &h264,uint32_t dts);
+
+    int32_t getPOC() const{
+        return m_iNowPOC;
+    }
+    int getSliceType() const{
+        return m_shdr.slice_type;
+    }
+    int getNaluType() const{
+        return m_nalu.nal_unit_type;
+    }
+    uint32_t getPts() const{
+    		return m_iNowPTS;
+    }
+private:
+    media::H264Parser m_parser;
+    media::H264POC m_poc;
+    media::H264NALU m_nalu;
+    media::H264SliceHeader m_shdr;
+
+    int32_t m_iNowPOC = INT32_MAX;
+    int32_t m_iLastPOC = INT32_MAX;
+
+    uint32_t m_iNowPTS = INT32_MAX;
+    uint32_t m_iLastPTS = INT32_MAX;
+    int32_t m_iMsPerPOC = 30;
+
+    void computePts(uint32_t dts);
+
+
+};
+
+#endif /* H264Parser_hpp */

bin_lib/windows/ZLMediaKit/include/ZLMediaKit/H264/SPSParser.h

+/***************************************************************************************
+ ***************************************************************************************/
+#ifndef _JZAN_SPS_PPS_H_
+#define _JZAN_SPS_PPS_H_
+
+#if defined (__cplusplus)
+    extern "C" {
+#endif
+
+#define QP_MAX_NUM (51 + 6*6)           // The maximum supported qp
+
+/**
+  * Chromaticity coordinates of the source primaries.
+  */
+enum T_AVColorPrimaries {
+    AVCOL_PRI_RESERVED0   = 0,
+    AVCOL_PRI_BT709       = 1, ///< also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP177 Annex B
+    AVCOL_PRI_UNSPECIFIED = 2,
+    AVCOL_PRI_RESERVED    = 3,
+    AVCOL_PRI_BT470M      = 4, ///< also FCC Title 47 Code of Federal Regulations 73.682 (a)(20)
+
+    AVCOL_PRI_BT470BG     = 5, ///< also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM
+    AVCOL_PRI_SMPTE170M   = 6, ///< also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC
+    AVCOL_PRI_SMPTE240M   = 7, ///< functionally identical to above
+    AVCOL_PRI_FILM        = 8, ///< colour filters using Illuminant C
+    AVCOL_PRI_BT2020      = 9, ///< ITU-R BT2020
+    AVCOL_PRI_NB,              ///< Not part of ABI
+};
+
+/**
+ * Color Transfer Characteristic.
+ */
+enum T_AVColorTransferCharacteristic {
+    AVCOL_TRC_RESERVED0    = 0,
+    AVCOL_TRC_BT709        = 1,  ///< also ITU-R BT1361
+    AVCOL_TRC_UNSPECIFIED  = 2,
+    AVCOL_TRC_RESERVED     = 3,
+    AVCOL_TRC_GAMMA22      = 4,  ///< also ITU-R BT470M / ITU-R BT1700 625 PAL & SECAM
+    AVCOL_TRC_GAMMA28      = 5,  ///< also ITU-R BT470BG
+    AVCOL_TRC_SMPTE170M    = 6,  ///< also ITU-R BT601-6 525 or 625 / ITU-R BT1358 525 or 625 / ITU-R BT1700 NTSC
+    AVCOL_TRC_SMPTE240M    = 7,
+    AVCOL_TRC_LINEAR       = 8,  ///< "Linear transfer characteristics"
+    AVCOL_TRC_LOG          = 9,  ///< "Logarithmic transfer characteristic (100:1 range)"
+    AVCOL_TRC_LOG_SQRT     = 10, ///< "Logarithmic transfer characteristic (100 * Sqrt(10) : 1 range)"
+    AVCOL_TRC_IEC61966_2_4 = 11, ///< IEC 61966-2-4
+    AVCOL_TRC_BT1361_ECG   = 12, ///< ITU-R BT1361 Extended Colour Gamut
+    AVCOL_TRC_IEC61966_2_1 = 13, ///< IEC 61966-2-1 (sRGB or sYCC)
+    AVCOL_TRC_BT2020_10    = 14, ///< ITU-R BT2020 for 10 bit system
+    AVCOL_TRC_BT2020_12    = 15, ///< ITU-R BT2020 for 12 bit system
+    AVCOL_TRC_NB,                ///< Not part of ABI
+};
+
+/**
+ * YUV tColorspace type.
+ */
+enum T_AVColorSpace {
+    AVCOL_SPC_RGB         = 0,  ///< order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB)
+    AVCOL_SPC_BT709       = 1,  ///< also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / SMPTE RP177 Annex B
+    AVCOL_SPC_UNSPECIFIED = 2,
+    AVCOL_SPC_RESERVED    = 3,
+    AVCOL_SPC_FCC         = 4,  ///< FCC Title 47 Code of Federal Regulations 73.682 (a)(20)
+    AVCOL_SPC_BT470BG     = 5,  ///< also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601
+    AVCOL_SPC_SMPTE170M   = 6,  ///< also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC / functionally identical to above
+    AVCOL_SPC_SMPTE240M   = 7,
+    AVCOL_SPC_YCOCG       = 8,  ///< Used by Dirac / VC-2 and H.264 FRext, see ITU-T SG16
+    AVCOL_SPC_BT2020_NCL  = 9,  ///< ITU-R BT2020 non-constant luminance system
+    AVCOL_SPC_BT2020_CL   = 10, ///< ITU-R BT2020 constant luminance system
+    AVCOL_SPC_NB,               ///< Not part of ABI
+};
+
+
+/**
+ * rational number numerator/denominator
+ */
+typedef struct T_AVRational{
+    int num; ///< numerator
+    int den; ///< denominator
+} T_AVRational;
+
+
+/***
+ * Sequence parameter set
+ * ¿É²Î¿¼H264±ê×¼µÚ7½ÚºÍ¸½Â¼D E
+ */
+#define Extended_SAR 255
+
+/**
+ * Sequence parameter set
+ */
+typedef struct T_SPS {
+    unsigned int uiSpsId;
+    int iProfileIdc;
+    int iLevelIdc;
+    int iChromaFormatIdc;
+    int iTransformBypass;              ///< qpprime_y_zero_transform_bypass_flag
+    int iLog2MaxFrameNum;            ///< log2_max_frame_num_minus4 + 4
+    int iPocType;                      ///< pic_order_cnt_type
+    int iLog2MaxPocLsb;              ///< log2_max_pic_order_cnt_lsb_minus4
+    int iDeltaPicOrderAlwaysZeroFlag;
+    int iOffsetForNonRefPic;
+    int iOffsetForTopToBottomField;
+    int iPocCycleLength;              ///< num_ref_frames_in_pic_order_cnt_cycle
+    int iRefFrameCount;               ///< num_ref_frames
+    int iGapsInFrameNumAllowedFlag;
+    int iMbWidth;                      ///< pic_width_in_mbs_minus1 + 1
+    int iMbHeight;                     ///< pic_height_in_map_units_minus1 + 1
+    int iFrameMbsOnlyFlag;
+    int iMbAff;                        ///< mb_adaptive_frame_field_flag
+    int iDirect8x8InferenceFlag;
+    int iCrop;                          ///< frame_cropping_flag
+
+    /* those 4 are already in luma samples */
+    unsigned int uiCropLeft;            ///< frame_cropping_rect_left_offset
+    unsigned int uiCropRight;           ///< frame_cropping_rect_right_offset
+    unsigned int uiCropTop;             ///< frame_cropping_rect_top_offset
+    unsigned int uiCropBottom;          ///< frame_cropping_rect_bottom_offset
+    int iVuiParametersPresentFlag;
+    T_AVRational tSar;
+    int iVideoSignalTypePresentFlag;
+    int iFullRange;
+    int iColourDescriptionPresentFlag;
+    enum T_AVColorPrimaries tColorPrimaries;
+    enum T_AVColorTransferCharacteristic tColorTrc;
+    enum T_AVColorSpace tColorspace;
+    int iTimingInfoPresentFlag;
+    uint32_t u32NumUnitsInTick;
+    uint32_t u32TimeScale;
+    int iFixedFrameRateFlag;
+    short asOffsetForRefFrame[256]; // FIXME dyn aloc?
+    int iBitstreamRestrictionFlag;
+    int iNumReorderFrames;
+    int iScalingMatrixPresent;
+    uint8_t aau8ScalingMatrix4[6][16];
+    uint8_t aau8ScalingMatrix8[6][64];
+    int iNalHrdParametersPresentFlag;
+    int iVclHrdParametersPresentFlag;
+    int iPicStructPresentFlag;
+    int iTimeOffsetLength;
+    int iCpbCnt;                          ///< See H.264 E.1.2
+    int iInitialCpbRemovalDelayLength; ///< initial_cpb_removal_delay_length_minus1 + 1
+    int iCpbRemovalDelayLength;         ///< cpb_removal_delay_length_minus1 + 1
+    int iDpbOutputDelayLength;          ///< dpb_output_delay_length_minus1 + 1
+    int iBitDepthLuma;                   ///< bit_depth_luma_minus8 + 8
+    int iBitDepthChroma;                 ///< bit_depth_chroma_minus8 + 8
+    int iResidualColorTransformFlag;    ///< residual_colour_transform_flag
+    int iConstraintSetFlags;             ///< constraint_set[0-3]_flag
+    int iNew;                              ///< flag to keep track if the decoder context needs re-init due to changed SPS
+} T_SPS;
+
+/**
+ * Picture parameter set
+ */
+typedef struct T_PPS {
+    unsigned int uiSpsId;
+    int iCabac;                  ///< entropy_coding_mode_flag
+    int iPicOrderPresent;      ///< pic_order_present_flag
+    int iSliceGroupCount;      ///< num_slice_groups_minus1 + 1
+    int iMbSliceGroupMapType;
+    unsigned int auiRefCount[2];  ///< num_ref_idx_l0/1_active_minus1 + 1
+    int iWeightedPred;          ///< weighted_pred_flag
+    int iWeightedBipredIdc;
+    int iInitQp;                ///< pic_init_qp_minus26 + 26
+    int iInitQs;                ///< pic_init_qs_minus26 + 26
+    int aiChromaQpIndexOffset[2];
+    int iDeblockingFilterParametersPresent; ///< deblocking_filter_parameters_present_flag
+    int iConstrainedIntraPred;     ///< constrained_intra_pred_flag
+    int iRedundantPicCntPresent;  ///< redundant_pic_cnt_present_flag
+    int iTransform8x8Mode;         ///< transform_8x8_mode_flag
+    uint8_t aau8ScalingMatrix4[6][16];
+    uint8_t aau8ScalingMatrix8[6][64];
+    uint8_t u8ChromaQpTable[2][QP_MAX_NUM+1];  ///< pre-scaled (with aiChromaQpIndexOffset) version of qp_table
+    int iChromaQpDiff;
+} T_PPS;
+
+typedef struct T_GetBitContext{
+    uint8_t *pu8Buf;         /*Ö¸ÏòSPS start*/
+    int     iBufSize;     /*SPS ³¤¶È*/
+    int     iBitPos;      /*bitÒѶÁȡλÖÃ*/
+    int     iTotalBit;    /*bit×ܳ¤¶È*/
+    int     iCurBitPos;  /*µ±Ç°¶ÁȡλÖÃ*/
+}T_GetBitContext;
+
+
+int h264DecSeqParameterSet(void *pvBuf, T_SPS *ptSps);
+void h264GetWidthHeight(T_SPS *ptSps, int *piWidth, int *piHeight);
+void h264GeFramerate(T_SPS *ptSps, float *pfFramerate);
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif

bin_lib/windows/ZLMediaKit/include/ZLMediaKit/H264/h264_bit_reader.h

+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// This file contains an implementation of an H264 Annex-B video stream parser.
+
+#ifndef MEDIA_FILTERS_H264_BIT_READER_H_
+#define MEDIA_FILTERS_H264_BIT_READER_H_
+
+#include <stddef.h>
+#include <stdint.h>
+#include <sys/types.h>
+#include "macros.h"
+
+using namespace std;
+
+namespace media {
+    
+    // A class to provide bit-granularity reading of H.264 streams.
+    // This is not a generic bit reader class, as it takes into account
+    // H.264 stream-specific constraints, such as skipping emulation-prevention
+    // bytes and stop bits. See spec for more details.
+    class MEDIA_EXPORT H264BitReader {
+    public:
+        H264BitReader();
+        ~H264BitReader();
+        
+        // Initialize the reader to start reading at |data|, |size| being size
+        // of |data| in bytes.
+        // Return false on insufficient size of stream..
+        // TODO(posciak,fischman): consider replacing Initialize() with
+        // heap-allocating and creating bit readers on demand instead.
+        bool Initialize(const uint8_t* data, off_t size);
+        
+        // Read |num_bits| next bits from stream and return in |*out|, first bit
+        // from the stream starting at |num_bits| position in |*out|.
+        // |num_bits| may be 1-32, inclusive.
+        // Return false if the given number of bits cannot be read (not enough
+        // bits in the stream), true otherwise.
+        bool ReadBits(int num_bits, int* out);
+        
+        // Return the number of bits left in the stream.
+        off_t NumBitsLeft();
+        
+        // See the definition of more_rbsp_data() in spec.
+        bool HasMoreRBSPData();
+        
+        // Return the number of emulation prevention bytes already read.
+        size_t NumEmulationPreventionBytesRead();
+        
+    private:
+        // Advance to the next byte, loading it into curr_byte_.
+        // Return false on end of stream.
+        bool UpdateCurrByte();
+        
+        // Pointer to the next unread (not in curr_byte_) byte in the stream.
+        const uint8_t* data_;
+        
+        // Bytes left in the stream (without the curr_byte_).
+        off_t bytes_left_;
+        
+        // Contents of the current byte; first unread bit starting at position
+        // 8 - num_remaining_bits_in_curr_byte_ from MSB.
+        int curr_byte_;
+        
+        // Number of bits remaining in curr_byte_
+        int num_remaining_bits_in_curr_byte_;
+        
+        // Used in emulation prevention three byte detection (see spec).
+        // Initially set to 0xffff to accept all initial two-byte sequences.
+        int prev_two_bytes_;
+        
+        // Number of emulation preventation bytes (0x000003) we met.
+        size_t emulation_prevention_bytes_;
+        
+        DISALLOW_COPY_AND_ASSIGN(H264BitReader);
+    };
+    
+}  // namespace media
+
+#endif  // MEDIA_FILTERS_H264_BIT_READER_H_

bin_lib/windows/ZLMediaKit/include/ZLMediaKit/H264/h264_poc.h

+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef MEDIA_VIDEO_H264_POC_H_
+#define MEDIA_VIDEO_H264_POC_H_
+
+#include <stdint.h>
+#include "macros.h"
+
+using namespace std;
+
+namespace media {
+    
+    struct H264SPS;
+    struct H264SliceHeader;
+    
+    class MEDIA_EXPORT H264POC {
+    public:
+        H264POC();
+        ~H264POC();
+        
+        // Compute the picture order count for a slice, storing the result into
+        // |*pic_order_cnt|.
+        bool ComputePicOrderCnt(
+                                const H264SPS* sps,
+                                const H264SliceHeader& slice_hdr,
+                                int32_t* pic_order_cnt);
+        
+        // Reset computation state. It's best (although not strictly required) to call
+        // this after a seek.
+        void Reset();
+        
+    private:
+        int32_t ref_pic_order_cnt_msb_;
+        int32_t ref_pic_order_cnt_lsb_;
+        int32_t prev_frame_num_;
+        int32_t prev_frame_num_offset_;
+        
+        DISALLOW_COPY_AND_ASSIGN(H264POC);
+    };
+    
+}  // namespace media
+
+#endif  // MEDIA_VIDEO_H264_POC_H_

bin_lib/windows/ZLMediaKit/include/ZLMediaKit/H264/macros.h

+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// This file contains macros and macro-like constructs (e.g., templates) that
+// are commonly used throughout Chromium source. (It may also contain things
+// that are closely related to things that are commonly used that belong in this
+// file.)
+
+#ifndef BASE_MACROS_H_
+#define BASE_MACROS_H_
+
+#include <stddef.h>  // For size_t.
+
+// Put this in the declarations for a class to be uncopyable.
+#define DISALLOW_COPY(TypeName) \
+TypeName(const TypeName&) = delete
+
+// Put this in the declarations for a class to be unassignable.
+#define DISALLOW_ASSIGN(TypeName) \
+void operator=(const TypeName&) = delete
+
+// A macro to disallow the copy constructor and operator= functions.
+// This should be used in the private: declarations for a class.
+#define DISALLOW_COPY_AND_ASSIGN(TypeName) \
+TypeName(const TypeName&) = delete;      \
+void operator=(const TypeName&) = delete
+
+// A macro to disallow all the implicit constructors, namely the
+// default constructor, copy constructor and operator= functions.
+//
+// This should be used in the private: declarations for a class
+// that wants to prevent anyone from instantiating it. This is
+// especially useful for classes containing only static methods.
+#define DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \
+TypeName() = delete;                           \
+DISALLOW_COPY_AND_ASSIGN(TypeName)
+
+// The arraysize(arr) macro returns the # of elements in an array arr.  The
+// expression is a compile-time constant, and therefore can be used in defining
+// new arrays, for example.  If you use arraysize on a pointer by mistake, you
+// will get a compile-time error.  For the technical details, refer to
+// http://blogs.msdn.com/b/the1/archive/2004/05/07/128242.aspx.
+
+// This template function declaration is used in defining arraysize.
+// Note that the function doesn't need an implementation, as we only
+// use its type.
+template <typename T, size_t N> char (&ArraySizeHelper(T (&array)[N]))[N];
+#define arraysize(array) (sizeof(ArraySizeHelper(array)))
+
+// Used to explicitly mark the return value of a function as unused. If you are
+// really sure you don't want to do anything with the return value of a function
+// that has been marked WARN_UNUSED_RESULT, wrap it with this. Example:
+//
+//   std::unique_ptr<MyType> my_var = ...;
+//   if (TakeOwnership(my_var.get()) == SUCCESS)
+//     ignore_result(my_var.release());
+//
+template<typename T>
+inline void ignore_result(const T&) {
+}
+
+// The following enum should be used only as a constructor argument to indicate
+// that the variable has static storage class, and that the constructor should
+// do nothing to its state.  It indicates to the reader that it is legal to
+// declare a static instance of the class, provided the constructor is given
+// the base::LINKER_INITIALIZED argument.  Normally, it is unsafe to declare a
+// static variable that has a constructor or a destructor because invocation
+// order is undefined.  However, IF the type can be initialized by filling with
+// zeroes (which the loader does for static variables), AND the destructor also
+// does nothing to the storage, AND there are no virtual methods, then a
+// constructor declared as
+//       explicit MyClass(base::LinkerInitialized x) {}
+// and invoked as
+//       static MyClass my_variable_name(base::LINKER_INITIALIZED);
+namespace base {
+    enum LinkerInitialized { LINKER_INITIALIZED };
+    
+    // Use these to declare and define a static local variable (static T;) so that
+    // it is leaked so that its destructors are not called at exit. If you need
+    // thread-safe initialization, use base/lazy_instance.h instead.
+#define CR_DEFINE_STATIC_LOCAL(type, name, arguments) \
+static type& name = *new type arguments
+    
+}  // base
+
+#define MEDIA_EXPORT
+
+#include <assert.h>
+#include "Util/logger.h"
+using namespace ZL::Util;
+
+#define DCHECK(x) if(!(x)) { ErrorL << "DCHECK " << #x <<endl; }
+#define DCHECK_GT(x,y) if(!((x) > (y))) { ErrorL << "DCHECK_GT:" << #x << #y << endl; }
+#define DCHECK_GE(x,y) if(!((x) >= (y))) { ErrorL << "DCHECK_GE:" << #x << #y << endl; }
+#define DCHECK_LT(x,y) if(!((x) < (y))) { ErrorL << "DCHECK_LT:" << #x << #y << endl; }
+#define NOTREACHED() ErrorL << "NOTREACHED" << endl;
+
+
+#endif  // BASE_MACROS_H_

bin_lib/windows/ZLMediaKit/include/ZLMediaKit/H264/ranges.h

+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef MEDIA_BASE_RANGES_H_
+#define MEDIA_BASE_RANGES_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <algorithm>
+#include <ostream>
+#include <vector>
+
+using namespace std;
+
+namespace media {
+    
+    // Ranges allows holding an ordered list of ranges of [start,end) intervals.
+    // The canonical example use-case is holding the list of ranges of buffered
+    // bytes or times in a <video> tag.
+    template <typename T>  // Endpoint type; typically a base::TimeDelta or an int64_t.
+    class Ranges {
+    public:
+        // Allow copy & assign.
+        
+        // Add (start,end) to this object, coallescing overlaps as appropriate.
+        // Returns the number of stored ranges, post coallescing.
+        size_t Add(T start, T end);
+        
+        // Return the number of disjoint ranges.
+        size_t size() const;
+        
+        // Return the "i"'th range's start & end (0-based).
+        T start(size_t i) const;
+        T end(size_t i) const;
+        
+        // Clear all ranges.
+        void clear();
+        
+        // Computes the intersection between this range and |other|.
+        Ranges<T> IntersectionWith(const Ranges<T>& other) const;
+        
+    private:
+        // Wrapper around DCHECK_LT allowing comparisons of operator<<'able T's.
+        void DCheckLT(const T& lhs, const T& rhs) const;
+        
+        // Disjoint, in increasing order of start.
+        std::vector<std::pair<T, T> > ranges_;
+    };
+    
+    //////////////////////////////////////////////////////////////////////
+    // EVERYTHING BELOW HERE IS IMPLEMENTATION DETAIL!!
+    //////////////////////////////////////////////////////////////////////
+    
+    template<class T>
+    size_t Ranges<T>::Add(T start, T end) {
+        if (start == end)  // Nothing to be done with empty ranges.
+            return ranges_.size();
+        
+        //DCheckLT(start, end);
+        size_t i;
+        // Walk along the array of ranges until |start| is no longer larger than the
+        // current interval's end.
+        for (i = 0; i < ranges_.size() && ranges_[i].second < start; ++i) {
+            // Empty body
+        }
+        
+        // Now we know |start| belongs in the i'th slot.
+        // If i is the end of the range, append new range and done.
+        if (i == ranges_.size()) {
+            ranges_.push_back(std::make_pair(start, end));
+            return ranges_.size();
+        }
+        
+        // If |end| is less than i->first, then [start,end) is a new (non-overlapping)
+        // i'th entry pushing everyone else back, and done.
+        if (end < ranges_[i].first) {
+            ranges_.insert(ranges_.begin() + i, std::make_pair(start, end));
+            return ranges_.size();
+        }
+        
+        // Easy cases done.  Getting here means there is overlap between [start,end)
+        // and the existing ranges.
+        
+        // Now: start <= i->second && i->first <= end
+        if (start < ranges_[i].first)
+            ranges_[i].first = start;
+        if (ranges_[i].second < end)
+            ranges_[i].second = end;
+        
+        // Now: [start,end) is contained in the i'th range, and we'd be done, except
+        // for the fact that the newly-extended i'th range might now overlap
+        // subsequent ranges.  Merge until discontinuities appear.  Note that there's
+        // no need to test/merge previous ranges, since needing that would mean the
+        // original loop went too far.
+        while ((i + 1) < ranges_.size() &&
+               ranges_[i + 1].first <= ranges_[i].second) {
+            ranges_[i].second = max(ranges_[i].second, ranges_[i + 1].second);
+            ranges_.erase(ranges_.begin() + i + 1);
+        }
+        
+        return ranges_.size();
+    }
+    
+
+    
+    template<class T>
+    size_t Ranges<T>::size() const {
+        return ranges_.size();
+    }
+    
+    template<class T>
+    T Ranges<T>::start(size_t i) const {
+        return ranges_[i].first;
+    }
+    
+    template<class T>
+    T Ranges<T>::end(size_t i) const {
+        return ranges_[i].second;
+    }
+    
+    template<class T>
+    void Ranges<T>::clear() {
+        ranges_.clear();
+    }
+    
+    template<class T>
+    Ranges<T> Ranges<T>::IntersectionWith(const Ranges<T>& other) const {
+        Ranges<T> result;
+        
+        size_t i = 0;
+        size_t j = 0;
+        
+        while (i < size() && j < other.size()) {
+            T max_start = max(start(i), other.start(j));
+            T min_end = min(end(i), other.end(j));
+            
+            // Add an intersection range to the result if the ranges overlap.
+            if (max_start < min_end)
+                result.Add(max_start, min_end);
+            
+            if (end(i) < other.end(j))
+                ++i;
+            else
+                ++j;
+        }
+        
+        return result;
+    }
+    
+}  // namespace media
+
+#endif  // MEDIA_BASE_RANGES_H_

bin_lib/windows/ZLMediaKit/include/ZLMediaKit/Http/HttpClient.h

+//
+//  HttpClient.h
+//  ZLMediaKit
+//
+//  Created by xzl on 2017/5/4.
+//
+
+#ifndef Http_HttpClient_h
+#define Http_HttpClient_h
+
+#include <string.h>
+#include <functional>
+#include <memory>
+#include "Rtsp/Rtsp.h"
+#include "Util/util.h"
+#include "Network/TcpClient.h"
+
+using namespace std;
+using namespace ZL::Util;
+using namespace ZL::Network;
+
+namespace ZL {
+namespace Http {
+
+class HttpArgs : public StrCaseMap
+{
+public:
+    HttpArgs(){}
+    virtual ~HttpArgs(){}
+    string make() const {
+        string ret;
+        for(auto &pr : *this){
+            ret.append(pr.first);
+            ret.append("=");
+            ret.append(pr.second);
+            ret.append("&");
+        }
+        if(ret.size()){
+            ret.pop_back();
+        }
+        return ret;
+    }
+};
+    
+class HttpClient : public TcpClient
+{
+public:
+    typedef StrCaseMap HttpHeader;
+    typedef std::shared_ptr<HttpClient> Ptr;
+    HttpClient();
+    virtual ~HttpClient();
+    virtual void sendRequest(const string &url);
+    void clear(){
+        _header.clear();
+        _body.clear();
+        _method.clear();
+        _path.clear();
+        _recvedResponse.clear();
+        _parser.Clear();
+    }
+    void setMethod(const string &method){
+        _method = method;
+    }
+    void setHeader(const HttpHeader &header){
+        _header = header;
+    }
+    void addHeader(const string &key,const string &val){
+        _header.emplace(key,val);
+    }
+    void setBody(const string &body){
+        _body = body;
+    }
+    const string &responseStatus(){
+        return _parser.Url();
+    }
+    const HttpHeader &responseHeader(){
+        return _parser.getValues();
+    }
+protected:
+    bool _isHttps;
+    
+    virtual void onResponseHeader(const string &status,const HttpHeader &headers){
+        DebugL << status;
+    };
+    virtual void onResponseBody(const char *buf,size_t size,size_t recvedSize,size_t totalSize){
+        DebugL << size << " " <<  recvedSize << " " << totalSize;
+    };
+    virtual void onResponseCompleted(){
+    	DebugL;
+    }
+    virtual void onRecvBytes(const char *data,int size);
+    virtual void onDisconnect(const SockException &ex){}
+private:
+    virtual void onConnect(const SockException &ex) override;
+    virtual void onRecv(const Socket::Buffer::Ptr &pBuf) override;
+    virtual void onErr(const SockException &ex) override;
+    
+    //send
+    HttpHeader _header;
+    string _body;
+    string _method;
+    string _path;
+    
+    //recv
+    string _recvedResponse;
+    size_t _recvedBodySize;
+    size_t _totalBodySize;
+    Parser _parser;
+    
+    string _lastHost;
+};
+
+
+
+
+
+
+
+
+} /* namespace Http */
+} /* namespace ZL */
+
+
+
+
+
+
+
+
+#endif /* Http_HttpClient_h */

bin_lib/windows/ZLMediaKit/include/ZLMediaKit/Http/HttpClientImp.h

+/*
+ * HttpClientImp.h
+ *
+ *  Created on: 2017年5月4日
+ *      Author: xzl
+ */
+
+#ifndef SRC_HTTP_HTTPCLIENTIMP_H_
+#define SRC_HTTP_HTTPCLIENTIMP_H_
+
+#include "HttpClient.h"
+#ifdef ENABLE_OPENSSL
+#include "Util/SSLBox.h"
+using namespace ZL::Util;
+#endif //ENABLE_OPENSSL
+
+namespace ZL {
+namespace Http {
+
+class HttpClientImp: public HttpClient {
+public:
+	typedef std::shared_ptr<HttpClientImp> Ptr;
+	HttpClientImp();
+	virtual ~HttpClientImp();
+	virtual void sendRequest(const string &url) override;
+
+#if defined(__GNUC__) && (__GNUC__ < 5)
+	void public_onRecvBytes(const char *data,int len){
+		HttpClient::onRecvBytes(data,len);
+	}
+	void public_send(const char *data, uint32_t len){
+		HttpClient::send(data,len);
+	}
+#endif //defined(__GNUC__) && (__GNUC__ < 5)
+private:
+#ifdef ENABLE_OPENSSL
+	virtual void onRecvBytes(const char *data,int size) override;
+	virtual int send(const string &str) override;
+	virtual int send(const char *str, int len) override;
+	std::shared_ptr<SSL_Box> _sslBox;
+#endif //ENABLE_OPENSSL
+};
+
+} /* namespace Http */
+} /* namespace ZL */
+
+#endif /* SRC_HTTP_HTTPCLIENTIMP_H_ */

bin_lib/windows/ZLMediaKit/include/ZLMediaKit/Http/HttpDownloader.h

+/*
+ * HttpDownloader.h
+ *
+ *  Created on: 2017年5月5日
+ *      Author: xzl
+ */
+
+#ifndef SRC_HTTP_HTTPDOWNLOADER_H_
+#define SRC_HTTP_HTTPDOWNLOADER_H_
+
+#include "HttpClientImp.h"
+
+namespace ZL {
+namespace Http {
+
+class HttpDownloader: public HttpClientImp {
+public:
+	typedef std::shared_ptr<HttpDownloader> Ptr;
+	typedef std::function<void(ErrCode code,const char *errMsg,const char *filePath)> onDownloadResult;
+	HttpDownloader();
+	virtual ~HttpDownloader();
+	//开始下载文件,默认断点续传方式下载
+	void startDownload(const string &url,const string &filePath = "",bool bAppend = false);
+	void startDownload(const string &url,const onDownloadResult &cb){
+		setOnResult(cb);
+		startDownload(url);
+	}
+	void setOnResult(const onDownloadResult &cb){
+		_onResult = cb;
+	}
+private:
+	void onResponseHeader(const string &status,const HttpHeader &headers) override;
+	void onResponseBody(const char *buf,size_t size,size_t recvedSize,size_t totalSize) override;
+	void onResponseCompleted() override;
+	void onDisconnect(const SockException &ex) override;
+	void closeFile();
+
+	FILE *_saveFile = nullptr;
+	string _filePath;
+	onDownloadResult _onResult;
+	bool _bDownloadSuccess = false;
+};
+
+} /* namespace Http */
+} /* namespace ZL */
+
+#endif /* SRC_HTTP_HTTPDOWNLOADER_H_ */

bin_lib/windows/ZLMediaKit/include/ZLMediaKit/Http/HttpRequester.h

+//
+//  HttpRequester_h
+//  ZLMediaKit
+//
+//  Created by xzl on 2017/5/5.
+//
+
+#ifndef Htt_HttpRequester_h
+#define Htt_HttpRequester_h
+
+#include "HttpClientImp.h"
+
+namespace ZL{
+namespace Http{
+    
+class HttpRequester : public HttpClientImp
+{
+public:
+    typedef std::shared_ptr<HttpRequester> Ptr;
+    typedef std::function<void(const SockException &ex,const string &status,const HttpHeader &header,const string &strRecvBody)> HttpRequesterResult;
+    HttpRequester();
+    virtual ~HttpRequester();
+    
+    void startRequester(const string &url,const HttpRequesterResult &onResult);
+private:
+    void onResponseHeader(const string &status,const HttpHeader &headers) override;
+    void onResponseBody(const char *buf,size_t size,size_t recvedSize,size_t totalSize)  override;
+    void onResponseCompleted() override;
+    void onDisconnect(const SockException &ex) override;
+    
+    string _strRecvBody;
+    HttpRequesterResult _onResult;
+    
+    
+};
+
+}//namespace Http
+}//namespace ZL
+
+#endif /* Htt_HttpRequester_h */

bin_lib/windows/ZLMediaKit/include/ZLMediaKit/Http/HttpSession.h

+/*
+ * HttpSession.h
+ *
+ *  Created on: 2016年9月22日
+ *      Author: xzl
+ */
+
+#ifndef SRC_HTTP_HTTPSESSION_H_
+#define SRC_HTTP_HTTPSESSION_H_
+
+#include <functional>
+#include "Common/config.h"
+#include "Rtsp/Rtsp.h"
+#include "Network/TcpLimitedSession.h"
+
+using namespace std;
+using namespace ZL::Network;
+
+namespace ZL {
+namespace Http {
+
+
+class HttpSession: public TcpLimitedSession<MAX_TCP_SESSION> {
+public:
+	typedef StrCaseMap KeyValue;
+	typedef std::function<void(const string &codeOut,
+							   const KeyValue &headerOut,
+							   const string &contentOut)>  HttpResponseInvoker;
+
+	HttpSession(const std::shared_ptr<ThreadPool> &pTh, const Socket::Ptr &pSock);
+	virtual ~HttpSession();
+
+	virtual void onRecv(const Socket::Buffer::Ptr &) override;
+	virtual void onError(const SockException &err) override;
+	virtual void onManager() override;
+protected:
+	void onRecv(const char *data,int size);
+private:
+	typedef enum
+	{
+		Http_success = 0,
+		Http_failed = 1,
+		Http_moreData = 2,
+	} HttpCode;
+	typedef HttpSession::HttpCode (HttpSession::*HttpCMDHandle)();
+	static unordered_map<string, HttpCMDHandle> g_mapCmdIndex;
+
+	Parser m_parser;
+	string m_strPath;
+	string m_strRcvBuf;
+	Ticker m_ticker;
+	uint32_t m_iReqCnt = 0;
+
+
+	inline HttpCode parserHttpReq(const string &);
+	inline HttpCode Handle_Req_GET();
+	inline HttpCode Handle_Req_POST();
+	inline bool makeMeun(const string &strFullPath, string &strRet);
+	inline void sendNotFound(bool bClose);
+	inline void sendResponse(const char *pcStatus,const KeyValue &header,const string &strContent);
+	inline static KeyValue makeHttpHeader(bool bClose=false,int64_t iContentSize=-1,const char *pcContentType="text/html");
+	void responseDelay(bool bClose,string &codeOut,KeyValue &headerOut, string &contentOut);
+};
+
+} /* namespace Http */
+} /* namespace ZL */
+
+#endif /* SRC_HTTP_HTTPSESSION_H_ */

bin_lib/windows/ZLMediaKit/include/ZLMediaKit/Http/HttpsSession.h

+/*
+ * HttpsSession.h
+ *
+ *  Created on: 2017年4月19日
+ *      Author: xzl
+ */
+
+#ifndef SRC_HTTP_HTTPSSESSION_H_
+#define SRC_HTTP_HTTPSSESSION_H_
+
+#include "HttpSession.h"
+#include "Util/SSLBox.h"
+#include "Util/TimeTicker.h"
+
+using namespace ZL::Util;
+
+namespace ZL {
+namespace Http {
+
+class HttpsSession: public HttpSession {
+public:
+	HttpsSession(const std::shared_ptr<ThreadPool> &pTh, const Socket::Ptr &pSock):
+		HttpSession(pTh,pSock){
+		m_sslBox.setOnEncData([&](const char *data, uint32_t len){
+#if defined(__GNUC__) && (__GNUC__ < 5)
+			public_send(data,len);
+#else//defined(__GNUC__) && (__GNUC__ < 5)
+			HttpSession::send(data,len);
+#endif//defined(__GNUC__) && (__GNUC__ < 5)
+		});
+		m_sslBox.setOnDecData([&](const char *data, uint32_t len){
+#if defined(__GNUC__) && (__GNUC__ < 5)
+			public_onRecv(data,len);
+#else//defined(__GNUC__) && (__GNUC__ < 5)
+			HttpSession::onRecv(data,len);
+#endif//defined(__GNUC__) && (__GNUC__ < 5)
+		});
+	}
+	virtual ~HttpsSession(){
+		//m_sslBox.shutdown();
+	}
+	void onRecv(const Socket::Buffer::Ptr &pBuf) override{
+		TimeTicker();
+		m_sslBox.onRecv(pBuf->data(), pBuf->size());
+	}
+#if defined(__GNUC__) && (__GNUC__ < 5)
+	int public_send(const char *data, uint32_t len){
+		return HttpSession::send(data,len);
+	}
+	void public_onRecv(const char *data, uint32_t len){
+		HttpSession::onRecv(data,len);
+	}
+#endif//defined(__GNUC__) && (__GNUC__ < 5)
+private:
+	virtual int send(const string &buf) override{
+		TimeTicker();
+		m_sslBox.onSend(buf.data(), buf.size());
+		return buf.size();
+	}
+	virtual int send(const char *buf, int size) override{
+		TimeTicker();
+		m_sslBox.onSend(buf, size);
+		return size;
+	}
+	SSL_Box m_sslBox;
+};
+
+} /* namespace Http */
+} /* namespace ZL */
+
+#endif /* SRC_HTTP_HTTPSSESSION_H_ */

bin_lib/windows/ZLMediaKit/include/ZLMediaKit/Http/strCoding.h

+/*
+ * strCoding.h
+ *
+ *  Created on: 2016年9月22日
+ *      Author: xzl
+ */
+
+#ifndef SRC_HTTP_STRCODING_H_
+#define SRC_HTTP_STRCODING_H_
+
+#include <iostream>
+#include <string>
+
+using namespace std;
+
+namespace ZL {
+namespace Http {
+
+class strCoding {
+public:
+	static string UrlUTF8Encode(const char * str); //urlutf8 编码
+	static string UrlUTF8Decode(const string &str); //urlutf8解码
+private:
+	strCoding(void);
+	virtual ~strCoding(void);
+	static inline char CharToInt(char ch);
+	static inline char StrToBin(const char *str);
+};
+
+} /* namespace Http */
+} /* namespace ZL */
+
+#endif /* SRC_HTTP_STRCODING_H_ */

bin_lib/windows/ZLMediaKit/include/ZLMediaKit/MediaFile/HLSMaker.h

+/*
+ * HLSMaker.h
+ *
+ *  Created on: 2013-6-24
+ *      Author: root
+ */
+
+#ifndef HLSMAKER_H_
+#define HLSMAKER_H_
+
+#include "TSMaker.h"
+#include "Common/config.h"
+#include "Util/TimeTicker.h"
+#include "Util/File.h"
+#include "Util/util.h"
+#include "Util/logger.h"
+
+using namespace ZL::Util;
+
+namespace ZL {
+namespace MediaFile {
+
+class HLSMaker {
+public:
+	HLSMaker(const string &strM3u8File,
+			const string &strHttpUrl,
+			uint32_t ui32BufSize = 64 * 1024,
+			uint32_t ui32Duration = 5,
+			uint32_t ui32Num = 3);
+
+	virtual ~HLSMaker();
+
+	//时间戳：参考频率90000
+	void inputH264(	void *pData,
+					uint32_t ui32Length,
+					uint32_t ui32TimeStamp,
+					int iType);
+
+	//时间戳：参考频率90000
+	void inputAAC(	void *pData,
+					uint32_t ui32Length,
+					uint32_t ui32TimeStamp);
+private:
+	TSMaker m_ts;
+	string m_strM3u8File;
+	string m_strHttpUrl;
+	string m_strFileName;
+	string m_strOutputPrefix;
+	string m_strTmpFileName;
+	uint32_t m_ui32SegmentDuration;
+	uint32_t m_ui32NumSegments;
+	uint64_t m_ui64TsCnt;
+	uint32_t m_ui32BufSize;
+	Ticker m_Timer;
+
+	int write_index_file(int iFirstSegment, unsigned int uiLastSegment, int iEnd);
+	void removets();
+};
+
+} /* namespace MediaFile */
+} /* namespace ZL */
+
+#endif /* HLSMAKER_H_ */

bin_lib/windows/ZLMediaKit/include/ZLMediaKit/MediaFile/MediaReader.h

+/*
+ * MediaReader.h
+ *
+ *  Created on: 2016年12月14日
+ *      Author: xzl
+ */
+
+#ifndef SRC_MEDIAFILE_MEDIAREADER_H_
+#define SRC_MEDIAFILE_MEDIAREADER_H_
+
+#include "Device/Device.h"
+#include "Rtsp/RtspMediaSource.h"
+#include "Rtmp/RtmpMediaSource.h"
+
+#ifdef ENABLE_MP4V2
+#include <mp4v2/mp4v2.h>
+#endif //ENABLE_MP4V2
+
+using namespace ZL::DEV;
+using namespace ZL::Rtsp;
+using namespace ZL::Rtmp;
+
+namespace ZL {
+namespace MediaFile {
+
+class MediaReader : public std::enable_shared_from_this<MediaReader>{
+public:
+	typedef std::shared_ptr<MediaReader> Ptr;
+	MediaReader(const string &strApp, const string &strId);
+	virtual ~MediaReader();
+	static RtspMediaSource::Ptr onMakeRtsp(const string &strApp, const string &strId);
+	static RtmpMediaSource::Ptr onMakeRtmp(const string &strApp, const string &strId);
+private:
+
+#ifdef ENABLE_MP4V2
+	MP4FileHandle m_hMP4File = MP4_INVALID_FILE_HANDLE;
+	MP4TrackId m_video_trId = MP4_INVALID_TRACK_ID;
+	uint32_t m_video_ms = 0;
+	uint32_t m_video_num_samples = 0;
+	uint32_t m_video_sample_max_size = 0;
+	uint32_t m_video_width = 0;
+	uint32_t m_video_height = 0;
+	uint32_t m_video_framerate = 0;
+	string m_strPps;
+	string m_strSps;
+	bool m_bSyncSample  = false;
+
+	MP4TrackId m_audio_trId = MP4_INVALID_TRACK_ID;
+	uint32_t m_audio_ms = 0;
+	uint32_t m_audio_num_samples = 0;
+	uint32_t m_audio_sample_max_size = 0;
+	uint32_t m_audio_sample_rate = 0;
+	uint32_t m_audio_num_channels = 0;
+	string m_strAacCfg;
+	AdtsFrame m_adts;
+
+	int m_iDuration = 0;
+	DevChannel::Ptr m_pChn;
+	MP4SampleId m_video_current = 0;
+	MP4SampleId m_audio_current = 0;
+	std::shared_ptr<uint8_t> m_pcVideoSample;
+
+	int m_iSeekTime = 0 ;
+	Ticker m_ticker;
+	Ticker m_alive;
+	recursive_mutex m_mtx;
+
+	void seek(int iSeekTime,bool bReStart = true);
+	inline void setSeekTime(int iSeekTime);
+	inline uint32_t getVideoCurrentTime();
+	void startReadMP4();
+	inline MP4SampleId getVideoSampleId(int iTimeInc = 0);
+	inline MP4SampleId getAudioSampleId(int iTimeInc = 0);
+	bool readSample(int iTimeInc = 0);
+	inline bool readVideoSample(int iTimeInc = 0);
+	inline bool readAudioSample(int iTimeInc = 0);
+	inline void writeH264(uint8_t *pucData,int iLen,uint32_t uiStamp);
+	inline void writeAAC(uint8_t *pucData,int iLen,uint32_t uiStamp);
+#endif //ENABLE_MP4V2
+};
+
+} /* namespace MediaFile */
+} /* namespace ZL */
+
+#endif /* SRC_MEDIAFILE_MEDIAREADER_H_ */

bin_lib/windows/ZLMediaKit/include/ZLMediaKit/MediaFile/MediaRecorder.h

+/*
+ * MediaRecorder.h
+ *
+ *  Created on: 2016年12月8日
+ *      Author: xzl
+ */
+
+#ifndef SRC_MEDIAFILE_MEDIARECORDER_H_
+#define SRC_MEDIAFILE_MEDIARECORDER_H_
+
+#include <memory>
+#include "Player/PlayerBase.h"
+
+#ifdef  ENABLE_MP4V2
+#include "Mp4Maker.h"
+#endif //ENABLE_MP4V2
+
+#ifdef  ENABLE_HLS
+#include "HLSMaker.h"
+#endif //ENABLE_HLS
+
+using namespace std;
+using namespace ZL::Player;
+
+namespace ZL {
+namespace MediaFile {
+
+
+class MediaRecorder {
+public:
+	typedef std::shared_ptr<MediaRecorder> Ptr;
+	MediaRecorder(const string &strApp,const string &strId,const std::shared_ptr<PlayerBase> &pPlayer);
+	virtual ~MediaRecorder();
+
+	void inputH264(	void *pData,
+					uint32_t ui32Length,
+					uint32_t ui32TimeStamp,
+					int iType);
+
+	void inputAAC(	void *pData,
+					uint32_t ui32Length,
+					uint32_t ui32TimeStamp);
+private:
+
+#ifdef  ENABLE_HLS
+	std::shared_ptr<HLSMaker> m_hlsMaker;
+#endif //ENABLE_HLS
+
+#ifdef  ENABLE_MP4V2
+	std::shared_ptr<Mp4Maker> m_mp4Maker;
+#endif //ENABLE_MP4V2
+
+};
+
+} /* namespace MediaFile */
+} /* namespace ZL */
+
+#endif /* SRC_MEDIAFILE_MEDIARECORDER_H_ */

bin_lib/windows/ZLMediaKit/include/ZLMediaKit/MediaFile/Mp4Maker.h

+/*
+ * Mp4Maker.h
+ *
+ *  Created on: 2013-9-18
+ *      Author: root
+ */
+
+#ifndef MP4MAKER_H_
+#define MP4MAKER_H_
+
+#ifdef ENABLE_MP4V2
+
+#include <mutex>
+#include <memory>
+#include <mp4v2/mp4v2.h>
+#include "Player/PlayerBase.h"
+#include "Util/util.h"
+#include "Util/logger.h"
+#include "Util/TimeTicker.h"
+#include "Util/TimeTicker.h"
+
+using namespace std;
+using namespace ZL::Util;
+using namespace ZL::Player;
+
+namespace ZL {
+namespace MediaFile {
+
+class Mp4Info
+{
+public:
+	time_t ui64StartedTime; //GMT标准时间，单位秒
+	time_t ui64TimeLen;//录像长度，单位秒
+	off_t ui64FileSize;//文件大小，单位BYTE
+	string strFilePath;//文件路径
+	string strFileName;//文件名称
+	string strFolder;//文件夹路径
+	string strUrl;//播放路径
+	string strAppName;//应用名称
+	string strStreamId;//流ID
+};
+class Mp4Maker {
+public:
+	typedef std::shared_ptr<Mp4Maker> Ptr;
+	Mp4Maker(const string &strPath,const string &strApp,const string &strStreamId, const PlayerBase::Ptr &pPlayer);
+	virtual ~Mp4Maker();
+	//时间戳：参考频率1000
+	void inputH264(void *pData, uint32_t ui32Length, uint32_t ui32TimeStamp, int iType);
+	//时间戳：参考频率1000
+	void inputAAC(void *pData, uint32_t ui32Length, uint32_t ui32TimeStamp);
+private:
+	MP4FileHandle m_hMp4 = MP4_INVALID_FILE_HANDLE;
+	MP4TrackId m_hVideo = MP4_INVALID_TRACK_ID;
+	MP4TrackId m_hAudio = MP4_INVALID_TRACK_ID;
+	PlayerBase::Ptr m_pPlayer;
+	string m_strPath;
+	string m_strFile;
+	string m_strFileTmp;
+	Ticker m_ticker;
+	SmoothTicker m_mediaTicker[2];
+
+	void createFile();
+	void closeFile();
+	void _inputH264(void *pData, uint32_t ui32Length, uint32_t ui64Duration, int iType);
+	void _inputAAC(void *pData, uint32_t ui32Length, uint32_t ui64Duration);
+
+	string m_strLastVideo;
+	string m_strLastAudio;
+
+	uint32_t m_ui32LastVideoTime = 0;
+	uint32_t m_ui32LastAudioTime = 0;
+	int m_iLastVideoType = 0;
+
+	Mp4Info m_info;
+};
+
+} /* namespace MediaFile */
+} /* namespace ZL */
+
+#endif ///ENABLE_MP4V2
+
+#endif /* MP4MAKER_H_ */

bin_lib/windows/ZLMediaKit/include/ZLMediaKit/MediaFile/crc32.h

+/*
+ * crc32.h
+ *
+ *  Created on: 2013-6-21
+ *      Author: root
+ */
+
+#ifndef CRC32_H_
+#define CRC32_H_
+
+unsigned int  calc_crc32 (unsigned char *data, unsigned int datalen);
+unsigned int Zwg_ntohl(unsigned int s);
+
+
+
+#endif /* CRC32_H_ */

bin_lib/windows/ZLMediaKit/include/ZLMediaKit/Player/MediaPlayer.h

+/*
+ * MediaPlayer.h
+ *
+ *  Created on: 2016年12月5日
+ *      Author: xzl
+ */
+
+#ifndef SRC_PLAYER_MEDIAPLAYER_H_
+#define SRC_PLAYER_MEDIAPLAYER_H_
+
+#include <memory>
+#include <string>
+#include "Player.h"
+#include "PlayerBase.h"
+#include "Rtsp/RtspPlayer.h"
+#include "Rtmp/RtmpPlayer.h"
+
+using namespace std;
+using namespace ZL::Rtsp;
+using namespace ZL::Rtmp;
+
+namespace ZL {
+namespace Player {
+
+class MediaPlayer : public PlayerImp<PlayerBase,PlayerBase> {
+public:
+	typedef std::shared_ptr<MediaPlayer> Ptr;
+
+	MediaPlayer();
+	virtual ~MediaPlayer();
+	void play(const char* strUrl) override;
+	void pause(bool bPause) override;
+	void teardown() override;
+private:
+	string m_strPrefix;
+
+};
+
+} /* namespace Player */
+} /* namespace ZL */
+
+#endif /* SRC_PLAYER_MEDIAPLAYER_H_ */

bin_lib/windows/ZLMediaKit/include/ZLMediaKit/Player/Player.h

+/*
+ * Player.h
+ *
+ *  Created on: 2016年12月2日
+ *      Author: xzl
+ */
+
+#ifndef SRC_PLAYER_PLAYER_H_
+#define SRC_PLAYER_PLAYER_H_
+
+#include <string>
+using namespace std;
+
+typedef struct {
+	uint16_t sequence;
+	uint32_t timeStamp;
+	unsigned char type;
+	string data;
+} H264Frame;
+
+//ADTS 头中相对有用的信息 采样率、声道数、帧长度
+typedef struct {
+	unsigned int syncword; //12 bslbf 同步字The bit string ‘1111 1111 1111’，说明一个ADTS帧的开始
+	unsigned int id;        //1 bslbf   MPEG 标示符, 设置为1
+	unsigned int layer;    //2 uimsbf Indicates which layer is used. Set to ‘00’
+	unsigned int protection_absent;  //1 bslbf  表示是否误码校验
+	unsigned int profile; //2 uimsbf  表示使用哪个级别的AAC，如01 Low Complexity(LC)--- AACLC
+	unsigned int sf_index;           //4 uimsbf  表示使用的采样率下标
+	unsigned int private_bit;        //1 bslbf
+	unsigned int channel_configuration;  //3 uimsbf  表示声道数
+	unsigned int original;               //1 bslbf
+	unsigned int home;                   //1 bslbf
+										 //下面的为改变的参数即每一帧都不同
+	unsigned int copyright_identification_bit;   //1 bslbf
+	unsigned int copyright_identification_start; //1 bslbf
+	unsigned int aac_frame_length; // 13 bslbf  一个ADTS帧的长度包括ADTS头和raw data block
+	unsigned int adts_buffer_fullness;           //11 bslbf     0x7FF 说明是码率可变的码流
+//no_raw_data_blocks_in_frame 表示ADTS帧中有number_of_raw_data_blocks_in_frame + 1个AAC原始帧.
+//所以说number_of_raw_data_blocks_in_frame == 0
+//表示说ADTS帧中有一个AAC数据块并不是说没有。(一个AAC原始帧包含一段时间内1024个采样及相关数据)
+	unsigned int no_raw_data_blocks_in_frame;    //2 uimsfb
+	unsigned char data[2 * 1024 + 7];
+	uint16_t sequence;
+	uint32_t timeStamp;
+} AdtsFrame;
+
+void	makeAdtsHeader(const string &strAudioCfg,AdtsFrame &adts);
+void 	writeAdtsHeader(const AdtsFrame &adts, uint8_t *pcAdts) ;
+string 	makeAdtsConfig(const uint8_t *pcAdts);
+void 	getAACInfo(const AdtsFrame &adts,int &iSampleRate,int &iChannel);
+bool 	getAVCInfo(const string &strSps,int &iVideoWidth, int &iVideoHeight, float  &iVideoFps);
+
+#endif /* SRC_PLAYER_PLAYER_H_ */

bin_lib/windows/ZLMediaKit/include/ZLMediaKit/Player/PlayerBase.h

+/*
+ * PlayerBase.h
+ *
+ *  Created on: 2016年12月1日
+ *      Author: xzl
+ */
+
+#ifndef SRC_PLAYER_PLAYERBASE_H_
+#define SRC_PLAYER_PLAYERBASE_H_
+
+#include <map>
+#include <memory>
+#include <string>
+#include <functional>
+#include "Player.h"
+#include "Network/Socket.h"
+#include "Util/mini.h"
+
+using namespace std;
+using namespace ZL::Util;
+using namespace ZL::Network;
+
+namespace ZL {
+namespace Player {
+
+class PlayerBase : public mINI{
+public:
+	typedef std::shared_ptr<PlayerBase> Ptr;
+	typedef enum {
+		RTP_TCP = 0,
+		RTP_UDP = 1,
+		RTP_MULTICAST = 2,
+	} eRtpType;
+    static Ptr createPlayer(const char* strUrl);
+    
+	PlayerBase(){};
+	virtual ~PlayerBase(){};
+	virtual void play(const char* strUrl) {};
+	virtual void pause(bool bPause) {};
+	virtual void teardown() {};
+
+	virtual void setOnShutdown( const function<void(const SockException &)> &cb) {};
+	virtual void setOnPlayResult( const function<void(const SockException &ex)> &cb) {};
+	virtual void setOnVideoCB( const function<void(const H264Frame &frame)> &cb) {};
+	virtual void setOnAudioCB( const function<void(const AdtsFrame &frame)> &cb) {};
+    
+	virtual int getVideoHeight() const { return 0; };
+	virtual int getVideoWidth() const { return 0; };
+	virtual float getVideoFps() const { return 0; };
+	virtual int getAudioSampleRate() const { return 0; };
+	virtual int getAudioSampleBit() const { return 0; };
+	virtual int getAudioChannel() const { return 0; };
+    virtual float getRtpLossRate(int iTrackId) const {return 0; };
+	virtual const string& getPps() const { static string null;return null; };
+	virtual const string& getSps() const { static string null;return null; };
+	virtual const string& getAudioCfg() const { static string null;return null; };
+	virtual bool containAudio() const { return false; };
+    virtual bool containVideo() const { return false; };
+    virtual bool isInited() const { return true; };
+    virtual float getDuration() const { return 0;};
+    virtual float getProgresss() const { return 0;};
+    virtual void seekTo(float fProgress) {};
+    
+
+protected:
+    virtual void onShutdown(const SockException &ex) {};
+    virtual void onPlayResult(const SockException &ex) {};
+};
+
+template<typename Parent,typename Parser>
+class PlayerImp : public Parent
+{
+public:
+	typedef std::shared_ptr<PlayerImp> Ptr;
+	PlayerImp(){};
+	virtual ~PlayerImp(){};
+	void setOnShutdown(const function<void(const SockException &)> &cb) override {
+		if (m_parser) {
+			m_parser->setOnShutdown(cb);
+		}
+		m_shutdownCB = cb;
+	}
+	void setOnPlayResult(const function<void(const SockException &ex)> &cb) override {
+		if (m_parser) {
+			m_parser->setOnPlayResult(cb);
+		}
+		m_playResultCB = cb;
+	}
+	void setOnVideoCB(const function<void(const H264Frame &frame)> &cb) override{
+		if (m_parser) {
+			m_parser->setOnVideoCB(cb);
+		}
+		m_onGetVideoCB = cb;
+	}
+	void setOnAudioCB(const function<void(const AdtsFrame &frame)> &cb) override{
+		if (m_parser) {
+			m_parser->setOnAudioCB(cb);
+		}
+		m_onGetAudioCB = cb;
+	}
+	int getVideoHeight() const override{
+		if (m_parser) {
+			return m_parser->getVideoHeight();
+		}
+		return PlayerBase::getVideoHeight();
+	}
+
+	int getVideoWidth() const override{
+		if (m_parser) {
+			return m_parser->getVideoWidth();
+		}
+		return PlayerBase::getVideoWidth();
+	}
+
+	float getVideoFps() const override{
+		if (m_parser) {
+			return m_parser->getVideoFps();
+		}
+		return PlayerBase::getVideoFps();
+	}
+
+	int getAudioSampleRate() const override{
+		if (m_parser) {
+			return m_parser->getAudioSampleRate();
+		}
+		return PlayerBase::getAudioSampleRate();
+	}
+
+	int getAudioSampleBit() const override{
+		if (m_parser) {
+			return m_parser->getAudioSampleBit();
+		}
+		return PlayerBase::getAudioSampleBit();
+	}
+
+	int getAudioChannel() const override{
+		if (m_parser) {
+			return m_parser->getAudioChannel();
+		}
+		return PlayerBase::getAudioChannel();
+	}
+
+	const string& getPps() const override{
+		if (m_parser) {
+			return m_parser->getPps();
+		}
+		return PlayerBase::getPps();
+	}
+
+	const string& getSps() const override{
+		if (m_parser) {
+			return m_parser->getSps();
+		}
+		return PlayerBase::getSps();
+	}
+
+	const string& getAudioCfg() const override{
+		if (m_parser) {
+			return m_parser->getAudioCfg();
+		}
+		return PlayerBase::getAudioCfg();
+	}
+	bool containAudio() const override{
+		if (m_parser) {
+			return m_parser->containAudio();
+		}
+		return PlayerBase::containAudio();
+	}
+    bool containVideo() const override{
+        if (m_parser) {
+            return m_parser->containVideo();
+        }
+        return PlayerBase::containVideo();
+    }
+    bool isInited() const override{
+        if (m_parser) {
+            return m_parser->isInited();
+        }
+        return PlayerBase::isInited();
+    }
+	float getDuration() const override {
+		if (m_parser) {
+			return m_parser->getDuration();
+		}
+		return PlayerBase::getDuration();
+	}
+    float getProgresss() const override{
+        if (m_parser) {
+            return m_parser->getProgresss();
+        }
+        return PlayerBase::getProgresss();
+    };
+    void seekTo(float fProgress) override{
+        if (m_parser) {
+            return m_parser->seekTo(fProgress);
+        }
+        return PlayerBase::seekTo(fProgress);
+    };
+protected:
+	void onShutdown(const SockException &ex) override {
+		if (m_shutdownCB) {
+			m_shutdownCB(ex);
+		}
+	}
+	void onPlayResult(const SockException &ex) override {
+		if (m_playResultCB) {
+			m_playResultCB(ex);
+			m_playResultCB = nullptr;
+		}
+	}
+	function<void(const SockException &ex)> m_shutdownCB;
+	function<void(const SockException &ex)> m_playResultCB;
+	std::shared_ptr<Parser> m_parser;
+	function<void(const H264Frame &frame)> m_onGetVideoCB;
+	function<void(const AdtsFrame &frame)> m_onGetAudioCB;
+
+};
+} /* namespace Player */
+} /* namespace ZL */
+
+#endif /* SRC_PLAYER_PLAYERBASE_H_ */

bin_lib/windows/ZLMediaKit/include/ZLMediaKit/RTP/RtpMaker.h

+/*
+ * RtpMaker.h
+ *
+ *  Created on: 2016年8月12日
+ *      Author: xzl
+ */
+
+#ifndef RTP_RTPMAKER_H_
+#define RTP_RTPMAKER_H_
+
+#include "Rtsp/RtspMediaSource.h"
+#include "Util/logger.h"
+#include "Util/RingBuffer.h"
+#include "Util/TimeTicker.h"
+#include "Util/ResourcePool.h"
+#include "Thread/ThreadPool.h"
+
+using namespace ZL::Util;
+using namespace ZL::Thread;
+
+namespace ZL {
+namespace Rtsp {
+
+class RtpMaker {
+public:
+	typedef function<void(const RtpPacket::Ptr &pPkt, bool bKeyPos)> onGetRTP;
+	RtpMaker(const onGetRTP &cb, uint32_t ui32Ssrc, int iMtuSize,int iSampleRate,
+			uint8_t ui8PlayloadType, uint8_t ui8Interleaved) {
+		callBack = cb;
+		m_ui32Ssrc = ui32Ssrc;
+		m_ui32SampleRate = iSampleRate;
+		m_iMtuSize = iMtuSize;
+		m_ui8PlayloadType = ui8PlayloadType;
+		m_ui8Interleaved = ui8Interleaved;
+	}
+	virtual ~RtpMaker() {
+	}
+
+	virtual void makeRtp(const char *pcData, int iDataLen, uint32_t uiStamp)=0;
+
+	int getInterleaved() const {
+		return m_ui8Interleaved;
+	}
+
+	int getPlayloadType() const {
+		return m_ui8PlayloadType;
+	}
+
+	int getSampleRate() const {
+		return m_ui32SampleRate;
+	}
+
+	uint32_t getSsrc() const {
+		return m_ui32Ssrc;
+	}
+
+	uint16_t getSeqence() const {
+		return m_ui16Sequence;
+	}
+	uint32_t getTimestamp() const {
+		return m_ui32TimeStamp;
+	}
+protected:
+	uint32_t m_ui32Ssrc;
+	uint32_t m_ui32SampleRate;
+	int m_iMtuSize;
+	uint8_t m_ui8PlayloadType;
+	uint8_t m_ui8Interleaved;
+	uint16_t m_ui16Sequence = 0;
+	uint32_t m_ui32TimeStamp = 0;
+	virtual void onMakeRtp(const RtpPacket::Ptr &pkt, bool bKeyPos = true) {
+		callBack(pkt, bKeyPos);
+	}
+	inline RtpPacket::Ptr obtainPkt() {
+		return m_pktPool.obtain();
+	}
+private:
+	RtspMediaSource::PoolType m_pktPool;
+	onGetRTP callBack;
+};
+
+} /* namespace RTP */
+} /* namespace ZL */
+
+#endif /* RTP_RTPMAKER_H_ */

bin_lib/windows/ZLMediaKit/include/ZLMediaKit/RTP/RtpMakerAAC.h

+/*
+ * RtpMakerAAC.h
+ *
+ *  Created on: 2016年8月12日
+ *      Author: xzl
+ */
+
+#ifndef RTP_RTPMAKERAAC_H_
+#define RTP_RTPMAKERAAC_H_
+
+#include <memory>
+#include "RtpMaker.h"
+#include "Rtsp/RtspMediaSource.h"
+#include "Util/logger.h"
+#include "Util/RingBuffer.h"
+#include "Util/ResourcePool.h"
+
+using namespace std;
+using namespace ZL::Util;
+
+namespace ZL {
+namespace Rtsp {
+
+class RtpMaker_AAC: public RtpMaker {
+public:
+	typedef std::shared_ptr<RtpMaker_AAC> Ptr;
+	RtpMaker_AAC(const onGetRTP &cb,
+			uint32_t ui32Ssrc, int iMtuSize , int iSampleRate, uint8_t ui8PlayloadType = 97,
+			uint8_t ui8Interleaved = 2) :
+			RtpMaker(cb, ui32Ssrc, iMtuSize,iSampleRate, ui8PlayloadType, ui8Interleaved) {
+	}
+	virtual ~RtpMaker_AAC() {
+	}
+	void makeRtp(const char *pcData, int iDataLen, uint32_t uiStamp) override;
+private:
+	inline void makeAACRtp(const void *pData, unsigned int uiLen, bool bMark, uint32_t uiStamp);
+	unsigned char m_aucSectionBuf[1600];
+};
+
+} /* namespace RTP */
+} /* namespace ZL */
+
+#endif /* RTP_RTPMAKERAAC_H_ */

bin_lib/windows/ZLMediaKit/include/ZLMediaKit/RTP/RtpMakerH264.h

+/*
+ * RtpMakerH264.h
+ *
+ *  Created on: 2016年8月12日
+ *      Author: xzl
+ */
+
+#ifndef RTP_RTPMAKERH264_H_
+#define RTP_RTPMAKERH264_H_
+
+#include <memory>
+#include "RtpMaker.h"
+#include "Rtsp/RtspMediaSource.h"
+#include "Util/logger.h"
+#include "Util/RingBuffer.h"
+
+using namespace std;
+using namespace ZL::Util;
+using namespace ZL::Rtsp;
+
+namespace ZL {
+namespace Rtsp {
+
+class RtpMaker_H264: public RtpMaker {
+public:
+	typedef std::shared_ptr<RtpMaker_H264> Ptr;
+	RtpMaker_H264(const onGetRTP &cb, uint32_t ui32Ssrc,int iMtuSize = 1400,int iSampleRate = 90000,
+			uint8_t ui8PlayloadType = 96, uint8_t ui8Interleaved = 0) :
+			RtpMaker(cb, ui32Ssrc, iMtuSize,iSampleRate, ui8PlayloadType, ui8Interleaved) {
+	}
+	virtual ~RtpMaker_H264() {
+	}
+
+	void makeRtp(const char *pcData, int iDataLen, uint32_t uiStamp) override;
+private:
+	inline void makeH264Rtp(const void *pData, unsigned int uiLen, bool bMark, uint32_t uiStamp);
+	unsigned char aucSectionBuf[1600];
+};
+
+} /* namespace RTP */
+} /* namespace ZL */
+
+#endif /* RTP_RTPMAKERH264_H_ */

bin_lib/windows/ZLMediaKit/include/ZLMediaKit/Rtmp/Rtmp.h

+#ifndef __rtmp_h
+#define __rtmp_h
+
+#include <memory>
+#include <string>
+#include "Util/util.h"
+#include "Util/logger.h"
+#include "Network/sockutil.h"
+
+using namespace std;
+using namespace ZL::Util;
+using namespace ZL::Network;
+
+#define PORT	1935
+#define DEFAULT_CHUNK_LEN	128
+
+#if !defined(_WIN32)
+#define PACKED	__attribute__((packed))
+#else
+#define PACKED
+#endif //!defined(_WIN32)
+
+
+#define HANDSHAKE_PLAINTEXT	0x03
+#define RANDOM_LEN		(1536 - 8)
+
+#define MSG_SET_CHUNK		1 	/*Set Chunk Size (1)*/
+#define MSG_ABORT			2	/*Abort Message (2)*/
+#define MSG_ACK				3 	/*Acknowledgement (3)*/
+#define MSG_USER_CONTROL	4	/*User Control Messages (4)*/
+#define MSG_WIN_SIZE		5	/*Window Acknowledgement Size (5)*/
+#define MSG_SET_PEER_BW		6	/*Set Peer Bandwidth (6)*/
+#define MSG_AUDIO			8	/*Audio Message (8)*/
+#define MSG_VIDEO			9	/*Video Message (9)*/
+#define MSG_DATA			18	/*Data Message (18, 15) AMF0*/
+#define MSG_DATA3			15	/*Data Message (18, 15) AMF3*/
+#define MSG_CMD				20	/*Command Message AMF0 */
+#define MSG_CMD3			17	/*Command Message AMF3 */
+#define MSG_OBJECT3			16	/*Shared Object Message (19, 16) AMF3*/
+#define MSG_OBJECT			19	/*Shared Object Message (19, 16) AMF0*/
+#define MSG_AGGREGATE		22	/*Aggregate Message (22)*/
+
+#define CONTROL_STREAM_BEGIN		0
+#define CONTROL_STREAM_EOF			1
+#define CONTROL_STREAM_DRY			2
+#define CONTROL_SETBUFFER			3
+#define CONTROL_STREAM_ISRECORDED	4
+#define CONTROL_PING_REQUEST		6
+#define CONTROL_PING_RESPONSE		7
+
+#define STREAM_CONTROL				0
+#define STREAM_MEDIA				1
+
+#define CHUNK_SERVER_REQUEST			2 /*服务器像客户端发出请求时的chunkID*/
+#define CHUNK_CLIENT_REQUEST_BEFORE		3 /*客户端在createStream前,向服务器发出请求的chunkID*/
+#define CHUNK_CLIENT_REQUEST_AFTER		4 /*客户端在createStream后,向服务器发出请求的chunkID*/
+#define CHUNK_AUDIO						6 /*音频chunkID*/
+#define CHUNK_VIDEO						7 /*视频chunkID*/
+
+#define FLV_KEY_FRAME				1
+#define FLV_INTER_FRAME				2
+
+
+#if defined(_WIN32)
+#pragma pack(push, 1)
+#endif // defined(_WIN32)
+
+class RtmpHandshake {
+public:
+    RtmpHandshake(uint32_t _time, uint8_t *_random = nullptr) {
+        _time = htonl(_time);
+        memcpy(timeStamp, &_time, 4);
+        if (!_random) {
+            random_generate((char *) random, sizeof(random));
+        } else {
+            memcpy(random, _random, sizeof(random));
+        }
+    }
+    uint8_t timeStamp[4];
+    uint8_t zero[4] = {0};
+    uint8_t random[RANDOM_LEN];
+    void random_generate(char* bytes, int size) {
+        static char cdata[] = { 0x73, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x2d, 0x72,
+            0x74, 0x6d, 0x70, 0x2d, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72,
+            0x2d, 0x77, 0x69, 0x6e, 0x6c, 0x69, 0x6e, 0x2d, 0x77, 0x69,
+            0x6e, 0x74, 0x65, 0x72, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72,
+            0x40, 0x31, 0x32, 0x36, 0x2e, 0x63, 0x6f, 0x6d };
+        for (int i = 0; i < size; i++) {
+            bytes[i] = cdata[rand() % (sizeof(cdata) - 1)];
+        }
+    }
+}PACKED;
+
+class RtmpHeader {
+public:
+    uint8_t flags;
+    uint8_t timeStamp[3];
+    uint8_t bodySize[3];
+    uint8_t typeId;
+    uint8_t streamId[4]; /* Note, this is little-endian while others are BE */
+}PACKED;
+
+#if defined(_WIN32)
+#pragma pack(pop)
+#endif // defined(_WIN32)
+
+class RtmpPacket {
+public:
+    typedef std::shared_ptr<RtmpPacket> Ptr;
+    uint8_t typeId;
+    uint32_t bodySize = 0;
+    uint32_t timeStamp = 0;
+    bool hasAbsStamp = false;
+    bool hasExtStamp = false;
+    uint32_t deltaStamp = 0;
+    uint32_t streamId;
+    uint32_t chunkId;
+    std::string strBuf;
+    bool isVideoKeyFrame() const {
+        return typeId == MSG_VIDEO && (uint8_t) strBuf[0] >> 4 == FLV_KEY_FRAME
+        && (uint8_t) strBuf[1] == 1;
+    }
+    bool isCfgFrame() const {
+        return (typeId == MSG_VIDEO || typeId == MSG_AUDIO)
+        && (uint8_t) strBuf[1] == 0;
+    }
+    int getMediaType() const {
+        switch (typeId) {
+            case MSG_VIDEO: {
+                return (uint8_t) strBuf[0] & 0x0F;
+            }
+                break;
+            case MSG_AUDIO: {
+                return (uint8_t) strBuf[0] >> 4;
+            }
+                break;
+            default:
+                break;
+        }
+        return 0;
+    }
+    int getAudioSampleRate() const {
+        if (typeId != MSG_AUDIO) {
+            return 0;
+        }
+        int flvSampleRate = ((uint8_t) strBuf[0] & 0x0C) >> 2;
+        const static int sampleRate[] = { 5512, 11025, 22050, 44100 };
+        return sampleRate[flvSampleRate];
+    }
+    int getAudioSampleBit() const {
+        if (typeId != MSG_AUDIO) {
+            return 0;
+        }
+        int flvSampleBit = ((uint8_t) strBuf[0] & 0x02) >> 1;
+        const static int sampleBit[] = { 8, 16 };
+        return sampleBit[flvSampleBit];
+    }
+    int getAudioChannel() const {
+        if (typeId != MSG_AUDIO) {
+            return 0;
+        }
+        int flvStereoOrMono = (uint8_t) strBuf[0] & 0x01;
+        const static int channel[] = { 1, 2 };
+        return channel[flvStereoOrMono];
+    }
+    string getH264SPS() const {
+        string ret;
+        if (getMediaType() != 7) {
+            return ret;
+        }
+        if (!isCfgFrame()) {
+            return ret;
+        }
+        if (strBuf.size() < 13) {
+            WarnL << "bad H264 cfg!";
+            return ret;
+        }
+        uint16_t sps_size ;
+        memcpy(&sps_size,strBuf.data() + 11,2);
+        sps_size = ntohs(sps_size);
+        if ((int) strBuf.size() < 13 + sps_size) {
+            WarnL << "bad H264 cfg!";
+            return ret;
+        }
+        ret.assign(strBuf.data() + 13, sps_size);
+        return ret;
+    }
+    string getH264PPS() const {
+        string ret;
+        if (getMediaType() != 7) {
+            return ret;
+        }
+        if (!isCfgFrame()) {
+            return ret;
+        }
+        if (strBuf.size() < 13) {
+            WarnL << "bad H264 cfg!";
+            return ret;
+        }
+        uint16_t sps_size ;
+        memcpy(&sps_size,strBuf.data() + 11,2);
+        sps_size = ntohs(sps_size);
+        
+        if ((int) strBuf.size() < 13 + sps_size + 1 + 2) {
+            WarnL << "bad H264 cfg!";
+            return ret;
+        }
+        uint16_t pps_size ;
+        memcpy(&pps_size,strBuf.data() + 13 + sps_size + 1,2);
+        pps_size = ntohs(pps_size);
+        
+        if ((int) strBuf.size() < 13 + sps_size + 1 + 2 + pps_size) {
+            WarnL << "bad H264 cfg!";
+            return ret;
+        }
+        ret.assign(strBuf.data() + 13 + sps_size + 1 + 2, pps_size);
+        return ret;
+    }
+    string getAacCfg() const {
+        string ret;
+        if (getMediaType() != 10) {
+            return ret;
+        }
+        if (!isCfgFrame()) {
+            return ret;
+        }
+        if (strBuf.size() < 4) {
+            WarnL << "bad aac cfg!";
+            return ret;
+        }
+        ret = strBuf.substr(2, 2);
+        return ret;
+    }
+};
+
+#endif

bin_lib/windows/ZLMediaKit/include/ZLMediaKit/Rtmp/RtmpMediaSource.h

+/*
+ * RtmpMediaSource.h
+ *
+ *  Created on: 2016年9月1日
+ *      Author: xzl
+ */
+
+#ifndef SRC_RTMP_RTMPMEDIASOURCE_H_
+#define SRC_RTMP_RTMPMEDIASOURCE_H_
+
+#include <mutex>
+#include <memory>
+#include <string>
+#include <functional>
+#include <unordered_map>
+#include "amf.h"
+#include "Rtmp.h"
+#include "Common/config.h"
+#include "Common/MediaSender.h"
+#include "Util/util.h"
+#include "Util/logger.h"
+#include "Util/RingBuffer.h"
+#include "Util/TimeTicker.h"
+#include "Util/ResourcePool.h"
+#include "Util/NoticeCenter.h"
+#include "Thread/ThreadPool.h"
+
+using namespace std;
+using namespace ZL::Util;
+using namespace ZL::Thread;
+
+namespace ZL {
+namespace Rtmp {
+
+
+class RtmpMediaSource: public enable_shared_from_this<RtmpMediaSource> {
+public:
+	typedef std::shared_ptr<RtmpMediaSource> Ptr;
+	typedef RingBuffer<RtmpPacket> RingType;
+	RtmpMediaSource(const string &strApp, const string &strId) :
+			m_strApp(strApp),
+			m_strId(strId),
+			m_pRing(new RingBuffer<RtmpPacket>()),
+			m_thPool( MediaSender::sendThread()) {
+	}
+	virtual ~RtmpMediaSource() {
+		unregist();
+	}
+	const RingType::Ptr &getRing() const {
+		//获取媒体源的rtp环形缓冲
+		return m_pRing;
+	}
+	virtual void regist() {
+		//注册该源，注册后rtmp服务器才能找到该源
+		lock_guard<recursive_mutex> lock(g_mtxMediaSrc);
+		if (!g_mapMediaSrc[m_strApp].erase(m_strId)) {
+			InfoL << "Rtmp src:" << m_strApp << " " << m_strId;
+		}
+		g_mapMediaSrc[m_strApp].emplace(m_strId, shared_from_this());
+		NoticeCenter::Instance().emitEvent(Config::Broadcast::kBroadcastRtmpSrcRegisted,m_strApp.data(),m_strId.data());
+	}
+	virtual void unregist() {
+		//反注册该源
+		lock_guard<recursive_mutex> lock(g_mtxMediaSrc);
+		auto it = g_mapMediaSrc.find(m_strApp);
+		if (it == g_mapMediaSrc.end()) {
+			return;
+		}
+		if (it->second.erase(m_strId)) {
+			if (it->second.size() == 0) {
+				g_mapMediaSrc.erase(it);
+			}
+			InfoL << "Rtmp src:" << m_strApp << " " << m_strId;
+		}
+	}
+	static set<string> getMediaSet() {
+		set<string> ret;
+		lock_guard<recursive_mutex> lock(g_mtxMediaSrc);
+		for (auto &pr0 : g_mapMediaSrc) {
+			for (auto &pr1 : pr0.second) {
+				if (pr1.second.lock()) {
+					ret.emplace(pr0.first + "/" + pr1.first);
+				}
+			}
+		}
+		return ret;
+	}
+	static Ptr find(const string &strApp, const string &strId, bool bMake = true) ;
+	const string& getApp() const {
+		//获取该源的id
+		return m_strApp;
+	}
+	const string& getId() const {
+		//获取该源的id
+		return m_strId;
+	}
+	const AMFValue &getMetaData() const {
+		return m_metadata;
+	}
+	template<typename FUN>
+	void getConfigFrame(const FUN &f) {
+		lock_guard<recursive_mutex> lock(m_mtxMap);
+		for (auto &pr : m_mapCfgFrame) {
+			f(pr.second);
+		}
+	}
+	bool ready() const {
+		lock_guard<recursive_mutex> lock(m_mtxMap);
+		return (m_mapCfgFrame.size() != 0);
+	}
+	virtual void onGetMetaData(const AMFValue &_metadata) {
+		m_metadata = _metadata;
+	}
+	virtual void onGetMedia(const RtmpPacket &_pkt) {
+		RtmpPacket & pkt = const_cast<RtmpPacket &>(_pkt);
+		if (pkt.isCfgFrame()) {
+			lock_guard<recursive_mutex> lock(m_mtxMap);
+			m_mapCfgFrame.emplace(pkt.typeId, pkt);
+		}
+		auto _ring = m_pRing;
+		m_thPool.async([_ring,pkt]() {
+			_ring->write(pkt,pkt.isVideoKeyFrame());
+		});
+	}
+	bool seekTo(uint32_t ui32Stamp) {
+		if (!m_onSeek) {
+			return false;
+		}
+		return m_onSeek(ui32Stamp);
+	}
+	virtual void setOnSeek(const function<bool(uint32_t)> &cb) {
+		m_onSeek = cb;
+	}
+	uint32_t getStamp() {
+		if (!m_onStamp) {
+			return 0;
+		}
+		return m_onStamp();
+	}
+	virtual void setOnStamp(const function<uint32_t()> &cb) {
+		m_onStamp = cb;
+	}
+protected:
+	function<bool(uint32_t)> m_onSeek;
+	function<uint32_t()> m_onStamp;
+private:
+	AMFValue m_metadata;
+	unordered_map<int, RtmpPacket> m_mapCfgFrame;
+	mutable recursive_mutex m_mtxMap;
+	string m_strApp; //媒体app
+	string m_strId; //媒体id
+	RingBuffer<RtmpPacket>::Ptr m_pRing; //rtp环形缓冲
+	ThreadPool &m_thPool;
+	static unordered_map<string, unordered_map<string,weak_ptr<RtmpMediaSource> > > g_mapMediaSrc; //静态的媒体源表
+	static recursive_mutex g_mtxMediaSrc; ///访问静态的媒体源表的互斥锁
+};
+
+} /* namespace Rtmp */
+} /* namespace ZL */
+
+#endif /* SRC_RTMP_RTMPMEDIASOURCE_H_ */

bin_lib/windows/ZLMediaKit/include/ZLMediaKit/Rtmp/RtmpParser.h

+/*
+ * RtmpParser.h
+ *
+ *  Created on: 2016年12月2日
+ *      Author: xzl
+ */
+
+#ifndef SRC_RTMP_RTMPPARSER_H_
+#define SRC_RTMP_RTMPPARSER_H_
+
+#include <functional>
+#include <unordered_map>
+#include "amf.h"
+#include "Rtmp.h"
+#include "Player/Player.h"
+#include "Util/TimeTicker.h"
+#include "Player/PlayerBase.h"
+
+using namespace std;
+using namespace ZL::Util;
+using namespace ZL::Player;
+
+namespace ZL {
+namespace Rtmp {
+
+class RtmpParser : public PlayerBase{
+public:
+	typedef std::shared_ptr<RtmpParser> Ptr;
+	RtmpParser(const AMFValue &val);
+	virtual ~RtmpParser();
+
+	bool inputRtmp(const RtmpPacket &pkt);
+
+	void setOnVideoCB(const function<void(const H264Frame &frame)> &cb) override{
+		lock_guard<recursive_mutex> lck(m_mtxCB);
+		onVideo = cb;
+	}
+	void setOnAudioCB(const function<void(const AdtsFrame &frame)> &cb) override{
+		lock_guard<recursive_mutex> lck(m_mtxCB);
+		onAudio = cb;
+	}
+
+	int getVideoHeight() const override{
+		return m_iVideoHeight;
+	}
+
+	int getVideoWidth() const override{
+		return m_iVideoWidth;
+	}
+
+	float getVideoFps() const override{
+		return m_fVideoFps;
+	}
+
+	int getAudioSampleRate() const override{
+		return m_iSampleRate;
+	}
+
+	int getAudioSampleBit() const override{
+		return m_iSampleBit;
+	}
+
+	int getAudioChannel() const override{
+		return m_iChannel;
+	}
+
+	const string& getPps() const override{
+		return m_strPPS;
+	}
+
+	const string& getSps() const override{
+		return m_strSPS;
+	}
+
+	const string& getAudioCfg() const override{
+		return m_strAudioCfg;
+	}
+	bool containAudio() const override{
+		return m_bHaveAudio;
+	}
+	bool containVideo () const override{
+		return m_bHaveVideo;
+	}
+	bool isInited() const override{
+		if (m_bHaveAudio && !m_strAudioCfg.size()) {
+			return false;
+		}
+		if (m_bHaveVideo && !m_strSPS.size()) {
+			return false;
+		}
+		return true;
+	}
+	float getDuration() const override{
+		return m_fDuration;
+	}
+private:
+	inline void onCheckMedia(const AMFValue &obj);
+
+	//返回值：true 代表是i帧第一个rtp包
+	inline bool inputVideo(const RtmpPacket &pkt);
+	inline bool inputAudio(const RtmpPacket &pkt);
+	inline void _onGetH264(const char *pcData, int iLen, uint32_t ui32TimeStamp);
+	inline void onGetH264(const char *pcData, int iLen, uint32_t ui32TimeStamp);
+	inline void onGetAAC(const char *pcData, int iLen, uint32_t ui32TimeStamp);
+	//video
+	H264Frame m_h264frame;
+	//aduio
+	AdtsFrame m_adts;
+
+	int m_iSampleRate = 44100;
+	int m_iSampleBit = 16;
+	int m_iChannel = 1;
+
+	string m_strSPS;
+	string m_strPPS;
+	string m_strAudioCfg;
+	int m_iVideoWidth = 0;
+	int m_iVideoHeight = 0;
+	float m_fVideoFps = 0;
+	bool m_bHaveAudio = false;
+	bool m_bHaveVideo = false;
+	float m_fDuration = 0;
+	function<void(const H264Frame &frame)> onVideo;
+	function<void(const AdtsFrame &frame)> onAudio;
+	recursive_mutex m_mtxCB;
+
+};
+
+} /* namespace Rtmp */
+} /* namespace ZL */
+
+#endif /* SRC_RTMP_RTMPPARSER_H_ */

bin_lib/windows/ZLMediaKit/include/ZLMediaKit/Rtmp/RtmpPlayer.h

+/*
+ * RtmpPlayer2.h
+ *
+ *  Created on: 2016年11月29日
+ *      Author: xzl
+ */
+
+#ifndef SRC_RTMP_RtmpPlayer2_H_
+#define SRC_RTMP_RtmpPlayer2_H_
+
+#include <memory>
+#include <string>
+#include <functional>
+#include "amf.h"
+#include "Rtmp.h"
+#include "RtmpProtocol.h"
+#include "Player/PlayerBase.h"
+#include "Util/util.h"
+#include "Util/logger.h"
+#include "Util/TimeTicker.h"
+#include "Network/Socket.h"
+#include "Network/TcpClient.h"
+
+using namespace std;
+using namespace ZL::Util;
+using namespace ZL::Player;
+using namespace ZL::Network;
+
+namespace ZL {
+namespace Rtmp {
+
+class RtmpPlayer:public PlayerBase, public TcpClient,  public RtmpProtocol{
+public:
+	typedef std::shared_ptr<RtmpPlayer> Ptr;
+	RtmpPlayer();
+	virtual ~RtmpPlayer();
+
+	void play(const char* strUrl) override;
+	void pause(bool bPause) override;
+	void teardown() override;
+protected:
+	virtual bool onCheckMeta(AMFValue &val) =0;
+	virtual void onMediaData(RtmpPacket &chunkData) =0;
+	float getProgressTime() const;
+	void seekToTime(float fTime);
+private:
+	void _onShutdown(const SockException &ex) {
+		WarnL << ex.getErrCode() << " " << ex.what();
+		m_pPlayTimer.reset();
+		m_pMediaTimer.reset();
+		m_pBeatTimer.reset();
+		onShutdown(ex);
+	}
+	void _onMediaData(RtmpPacket &chunkData) {
+		m_mediaTicker.resetTime();
+		onMediaData(chunkData);
+	}
+	void _onPlayResult(const SockException &ex) {
+		WarnL << ex.getErrCode() << " " << ex.what();
+		m_pPlayTimer.reset();
+		m_pMediaTimer.reset();
+		if (!ex) {
+			m_mediaTicker.resetTime();
+			weak_ptr<RtmpPlayer> weakSelf = dynamic_pointer_cast<RtmpPlayer>(shared_from_this());
+			m_pMediaTimer.reset( new Timer(5, [weakSelf]() {
+				auto strongSelf=weakSelf.lock();
+				if(!strongSelf) {
+					return false;
+				}
+				if(strongSelf->m_mediaTicker.elapsedTime()>10000) {
+					//recv media timeout!
+					strongSelf->_onShutdown(SockException(Err_timeout,"recv rtmp timeout"));
+					strongSelf->teardown();
+					return false;
+				}
+				return true;
+			}));
+		}
+		onPlayResult(ex);
+	}
+
+	//for Tcpclient
+	void onRecv(const Socket::Buffer::Ptr &pBuf) override;
+	void onConnect(const SockException &err) override;
+	void onErr(const SockException &ex) override;
+	//fro RtmpProtocol
+	void onRtmpChunk(RtmpPacket &chunkData) override;
+	void onStreamDry(uint32_t ui32StreamId) override;
+	void onSendRawData(const char *pcRawData, int iSize) override {
+		send(pcRawData, iSize);
+	}
+
+	template<typename FUN>
+	inline void addOnResultCB(const FUN &fun) {
+		lock_guard<recursive_mutex> lck(m_mtxOnResultCB);
+		m_mapOnResultCB.emplace(m_iReqID, fun);
+	}
+	template<typename FUN>
+	inline void addOnStatusCB(const FUN &fun) {
+		lock_guard<recursive_mutex> lck(m_mtxOnStatusCB);
+		m_dqOnStatusCB.emplace_back(fun);
+	}
+
+	void onCmd_result(AMFDecoder &dec);
+	void onCmd_onStatus(AMFDecoder &dec);
+	void onCmd_onMetaData(AMFDecoder &dec);
+
+	inline void send_connect();
+	inline void send_createStream();
+	inline void send_play();
+	inline void send_pause(bool bPause);
+
+	string m_strApp;
+	string m_strStream;
+	string m_strTcUrl;
+	bool m_bPaused = false;
+
+	unordered_map<int, function<void(AMFDecoder &dec)> > m_mapOnResultCB;
+	recursive_mutex m_mtxOnResultCB;
+	deque<function<void(AMFValue &dec)> > m_dqOnStatusCB;
+	recursive_mutex m_mtxOnStatusCB;
+
+	typedef void (RtmpPlayer::*rtmpCMDHandle)(AMFDecoder &dec);
+	static unordered_map<string, rtmpCMDHandle> g_mapCmd;
+
+	//超时功能实现
+	Ticker m_mediaTicker;
+	std::shared_ptr<Timer> m_pMediaTimer;
+	std::shared_ptr<Timer> m_pPlayTimer;
+	//心跳定时器
+	std::shared_ptr<Timer> m_pBeatTimer;
+
+	//播放进度控制
+	float m_fSeekTo = 0;
+	double m_adFistStamp[2] = { 0, 0 };
+	double m_adNowStamp[2] = { 0, 0 };
+	Ticker m_aNowStampTicker[2];
+};
+
+} /* namespace Rtmp */
+} /* namespace ZL */
+
+#endif /* SRC_RTMP_RtmpPlayer2_H_ */

bin_lib/windows/ZLMediaKit/include/ZLMediaKit/Rtmp/RtmpPlayerImp.h

+/*
+ * RtmpPlayerImp.h
+ *
+ *  Created on: 2016年12月1日
+ *      Author: xzl
+ */
+
+#ifndef SRC_RTMP_RTMPPLAYERIMP_H_
+#define SRC_RTMP_RTMPPLAYERIMP_H_
+
+#include <memory>
+#include <functional>
+#include "Common/config.h"
+#include "RtmpPlayer.h"
+#include "RtmpParser.h"
+#include "Poller/Timer.h"
+#include "Util/TimeTicker.h"
+
+using namespace std;
+using namespace ZL::Util;
+using namespace ZL::Player;
+
+namespace ZL {
+namespace Rtmp {
+class RtmpPlayerImp: public PlayerImp<RtmpPlayer,RtmpParser> {
+public:
+    typedef std::shared_ptr<RtmpPlayerImp> Ptr;
+    RtmpPlayerImp();
+    virtual ~RtmpPlayerImp();
+    float getProgresss() const override{
+        if(getDuration() > 0){
+            return getProgressTime() / getDuration();
+        }
+        return PlayerBase::getProgresss();
+    };
+    void seekTo(float fProgress) override{
+        fProgress = MAX(float(0),MIN(fProgress,float(1.0)));
+        seekToTime(fProgress * getDuration());
+    };
+private:
+    //派生类回调函数
+    bool onCheckMeta(AMFValue &val)  override {
+        try {
+            m_parser.reset(new RtmpParser(val));
+            m_parser->setOnVideoCB(m_onGetVideoCB);
+            m_parser->setOnAudioCB(m_onGetAudioCB);
+            return true;
+        } catch (std::exception &ex) {
+            WarnL << ex.what();
+            return false;
+        }
+    }
+    void onMediaData(RtmpPacket &chunkData) override {
+        m_parser->inputRtmp(chunkData);
+    }
+};
+                    
+                    
+} /* namespace Rtmp */
+} /* namespace ZL */
+                
+#endif /* SRC_RTMP_RTMPPLAYERIMP_H_ */

bin_lib/windows/ZLMediaKit/include/ZLMediaKit/Rtmp/RtmpProtocol.h

+/*
+ * RtmpProtocol.h
+ *
+ *  Created on: 2017年2月7日
+ *      Author: xzl
+ */
+
+#ifndef SRC_RTMP_RTMPPROTOCOL_H_
+#define SRC_RTMP_RTMPPROTOCOL_H_
+
+#include <memory>
+#include <string>
+#include <functional>
+#include "amf.h"
+#include "Rtmp.h"
+#include "Util/util.h"
+#include "Util/logger.h"
+#include "Util/TimeTicker.h"
+#include "Network/Socket.h"
+
+using namespace std;
+using namespace ZL::Util;
+using namespace ZL::Network;
+
+namespace ZL {
+namespace Rtmp {
+
+class RtmpProtocol {
+public:
+	RtmpProtocol();
+	virtual ~RtmpProtocol();
+	//作为客户端发送c0c1，等待s0s1s2并且回调
+	void startClientSession(const function<void()> &cb);
+	void onParseRtmp(const char *pcRawData,int iSize);
+	void reset();
+protected:
+	virtual void onSendRawData(const char *pcRawData,int iSize) = 0;
+	virtual void onRtmpChunk(RtmpPacket &chunkData) = 0;
+
+	virtual void onStreamBegin(uint32_t ui32StreamId){
+		m_ui32StreamId = ui32StreamId;
+	}
+	virtual void onStreamEof(uint32_t ui32StreamId){};
+	virtual void onStreamDry(uint32_t ui32StreamId){};
+protected:
+	void sendAcknowledgement(uint32_t ui32Size);
+	void sendAcknowledgementSize(uint32_t ui32Size);
+	void sendPeerBandwidth(uint32_t ui32Size);
+	void sendChunkSize(uint32_t ui32Size);
+	void sendPingRequest(uint32_t ui32TimeStamp = ::time(NULL));
+	void sendPingResponse(uint32_t ui32TimeStamp = ::time(NULL));
+	void sendSetBufferLength(uint32_t ui32StreamId, uint32_t ui32Length);
+	void sendUserControl(uint16_t ui16EventType, uint32_t ui32EventData);
+	void sendUserControl(uint16_t ui16EventType, const string &strEventData);
+
+	void sendInvoke(const string &strCmd, const AMFValue &val);
+	void sendRequest(int iCmd, const string &str);
+	void sendResponse(int iType, const string &str);
+	void sendRtmp(uint8_t ui8Type, uint32_t ui32StreamId, const std::string &strBuf, uint32_t ui32TimeStamp, int iChunkID);
+protected:
+	int m_iReqID = 0;
+	uint32_t m_ui32StreamId = STREAM_CONTROL;
+	int m_iNowStreamID = 0;
+	int m_iNowChunkID = 0;
+	bool m_bDataStarted = false;
+private:
+	void handle_S0S1S2(const function<void()> &cb);
+	void handle_C0C1();
+
+	void handle_C1_simple();
+#ifdef ENABLE_OPENSSL
+	void handle_C1_complex();
+	string get_C1_digest(const uint8_t *ptr,char **digestPos);
+	string get_C1_key(const uint8_t *ptr);
+	void check_C1_Digest(const string &digest,const string &data);
+	void send_complex_S0S1S2(int schemeType,const string &digest);
+#endif //ENABLE_OPENSSL
+
+	void handle_C2();
+	void handle_rtmp();
+	void handle_rtmpChunk(RtmpPacket &chunkData);
+
+	////////////ChunkSize////////////
+	size_t m_iChunkLenIn = DEFAULT_CHUNK_LEN;
+	size_t m_iChunkLenOut = DEFAULT_CHUNK_LEN;
+	////////////Acknowledgement////////////
+	uint32_t m_ui32ByteSent = 0;
+	uint32_t m_ui32LastSent = 0;
+	uint32_t m_ui32WinSize = 0;
+	///////////PeerBandwidth///////////
+	uint32_t m_ui32Bandwidth = 2500000;
+	uint8_t m_ui8LimitType = 2;
+	////////////Chunk////////////
+	unordered_map<int, RtmpPacket> m_mapChunkData;
+	//////////Rtmp parser//////////
+	string m_strRcvBuf;
+	function<void()> m_nextHandle;
+};
+
+} /* namespace Rtmp */
+} /* namespace ZL */
+
+#endif /* SRC_RTMP_RTMPPROTOCOL_H_ */

bin_lib/windows/ZLMediaKit/include/ZLMediaKit/Rtmp/RtmpPusher.h

+/*
+ * RtmpPusher.h
+ *
+ *  Created on: 2017年2月13日
+ *      Author: xzl
+ */
+
+#ifndef SRC_RTMP_RTMPPUSHER_H_
+#define SRC_RTMP_RTMPPUSHER_H_
+
+#include "RtmpProtocol.h"
+#include "RtmpMediaSource.h"
+#include "Network/TcpClient.h"
+
+namespace ZL {
+namespace Rtmp {
+
+class RtmpPusher: public RtmpProtocol , public TcpClient{
+public:
+	typedef std::shared_ptr<RtmpPusher> Ptr;
+	typedef std::function<void(const SockException &ex)> Event;
+	RtmpPusher(const char *strApp,const char *strStream);
+	virtual ~RtmpPusher();
+
+	void publish(const char* strUrl);
+	void teardown();
+
+	void setOnPublished(Event onPublished) {
+		m_onPublished = onPublished;
+	}
+
+	void setOnShutdown(Event onShutdown) {
+		m_onShutdown = onShutdown;
+	}
+
+protected:
+
+	//for Tcpclient
+	void onRecv(const Socket::Buffer::Ptr &pBuf) override;
+	void onConnect(const SockException &err) override;
+	void onErr(const SockException &ex) override;
+
+	//fro RtmpProtocol
+	void onRtmpChunk(RtmpPacket &chunkData) override;
+	void onSendRawData(const char *pcRawData, int iSize) override {
+		send(pcRawData, iSize);
+	}
+private:
+	void onShutdown(const SockException &ex) {
+		m_pPublishTimer.reset();
+		if(m_onShutdown){
+			m_onShutdown(ex);
+		}
+	}
+	void onPublishResult(const SockException &ex) {
+		m_pPublishTimer.reset();
+		if(m_onPublished){
+			m_onPublished(ex);
+		}
+	}
+
+	template<typename FUN>
+	inline void addOnResultCB(const FUN &fun) {
+		lock_guard<recursive_mutex> lck(m_mtxOnResultCB);
+		m_mapOnResultCB.emplace(m_iReqID, fun);
+	}
+	template<typename FUN>
+	inline void addOnStatusCB(const FUN &fun) {
+		lock_guard<recursive_mutex> lck(m_mtxOnStatusCB);
+		m_dqOnStatusCB.emplace_back(fun);
+	}
+
+	void onCmd_result(AMFDecoder &dec);
+	void onCmd_onStatus(AMFDecoder &dec);
+	void onCmd_onMetaData(AMFDecoder &dec);
+
+	inline void send_connect();
+	inline void send_createStream();
+	inline void send_publish();
+	inline void send_metaData();
+
+	string m_strApp;
+	string m_strStream;
+	string m_strTcUrl;
+
+	unordered_map<int, function<void(AMFDecoder &dec)> > m_mapOnResultCB;
+	recursive_mutex m_mtxOnResultCB;
+	deque<function<void(AMFValue &dec)> > m_dqOnStatusCB;
+	recursive_mutex m_mtxOnStatusCB;
+
+	typedef void (RtmpPusher::*rtmpCMDHandle)(AMFDecoder &dec);
+	static unordered_map<string, rtmpCMDHandle> g_mapCmd;
+
+	//超时功能实现
+	std::shared_ptr<Timer> m_pPublishTimer;
+    
+    //源
+    std::weak_ptr<RtmpMediaSource> m_pMediaSrc;
+    RtmpMediaSource::RingType::RingReader::Ptr m_pRtmpReader;
+    //事件监听
+    Event m_onShutdown;
+    Event m_onPublished;
+};
+
+} /* namespace Rtmp */
+} /* namespace ZL */
+
+#endif /* SRC_RTMP_RTMPPUSHER_H_ */

bin_lib/windows/ZLMediaKit/include/ZLMediaKit/Rtmp/RtmpSession.h

+/*
+ * RtmpSession.h
+ *
+ *  Created on: 2017年2月10日
+ *      Author: xzl
+ */
+
+#ifndef SRC_RTMP_RTMPSESSION_H_
+#define SRC_RTMP_RTMPSESSION_H_
+
+#include <unordered_map>
+#include "amf.h"
+#include "Rtmp.h"
+#include "utils.h"
+#include "Common/config.h"
+#include "RtmpProtocol.h"
+#include "RtmpToRtspMediaSource.h"
+#include "Util/util.h"
+#include "Util/TimeTicker.h"
+#include "Network/TcpLimitedSession.h"
+
+using namespace ZL::Util;
+using namespace ZL::Network;
+
+namespace ZL {
+namespace Rtmp {
+
+class RtmpSession: public TcpLimitedSession<MAX_TCP_SESSION> ,public  RtmpProtocol{
+public:
+	typedef std::shared_ptr<RtmpSession> Ptr;
+	RtmpSession(const std::shared_ptr<ThreadPool> &_th, const Socket::Ptr &_sock);
+	virtual ~RtmpSession();
+	void onRecv(const Socket::Buffer::Ptr &pBuf) override;
+	void onError(const SockException &err) override;
+	void onManager() override;
+private:
+	std::string m_strApp;
+	std::string m_strId;
+	double m_dNowReqID = 0;
+	Ticker m_ticker;//数据接收时间
+	typedef void (RtmpSession::*rtmpCMDHandle)(AMFDecoder &dec);
+	static unordered_map<string, rtmpCMDHandle> g_mapCmd;
+
+	RingBuffer<RtmpPacket>::RingReader::Ptr m_pRingReader;
+	std::shared_ptr<RtmpMediaSource> m_pPublisherSrc;
+	bool m_bPublisherSrcRegisted = false;
+    std::weak_ptr<RtmpMediaSource> m_pPlayerSrc;
+    uint32_t m_aui32FirstStamp[2] = {0};
+
+	void onProcessCmd(AMFDecoder &dec);
+	void onCmd_connect(AMFDecoder &dec);
+	void onCmd_createStream(AMFDecoder &dec);
+
+	void onCmd_publish(AMFDecoder &dec);
+	void onCmd_deleteStream(AMFDecoder &dec);
+
+	void onCmd_play(AMFDecoder &dec);
+	void onCmd_play2(AMFDecoder &dec);
+	void doPlay();
+	void onCmd_seek(AMFDecoder &dec);
+	void onCmd_pause(AMFDecoder &dec);
+	void setMetaData(AMFDecoder &dec);
+
+	void onSendMedia(const RtmpPacket &pkt);
+	void onSendRawData(const char *pcRawData,int iSize) override{
+		send(pcRawData, iSize);
+	}
+	void onRtmpChunk(RtmpPacket &chunkData) override;
+
+	template<typename first, typename second>
+	inline void sendReply(const char *str, const first &reply, const second &status) {
+		AMFEncoder invoke;
+		invoke << str << m_dNowReqID << reply << status;
+		sendResponse(MSG_CMD, invoke.data());
+	}
+};
+
+} /* namespace Rtmp */
+} /* namespace ZL */
+
+#endif /* SRC_RTMP_RTMPSESSION_H_ */

bin_lib/windows/ZLMediaKit/include/ZLMediaKit/Rtmp/RtmpToRtspMediaSource.h

+/*
+ * RtmpToRtspMediaSource.h
+ *
+ *  Created on: 2016年10月20日
+ *      Author: xzl
+ */
+
+#ifndef SRC_RTMP_RTMPTORTSPMEDIASOURCE_H_
+#define SRC_RTMP_RTMPTORTSPMEDIASOURCE_H_
+
+#include <mutex>
+#include <string>
+#include <memory>
+#include <functional>
+#include <unordered_map>
+#include "amf.h"
+#include "Rtmp.h"
+#include "RtmpParser.h"
+#include "RtmpMediaSource.h"
+#include "RTP/RtpMakerH264.h"
+#include "RTP/RtpMakerAAC.h"
+#include "Rtsp/RtpParser.h"
+#include "Rtsp/RtspMediaSource.h"
+#include "Util/util.h"
+#include "Util/logger.h"
+#include "MediaFile/MediaRecorder.h"
+
+using namespace std;
+using namespace ZL::Util;
+using namespace ZL::Rtsp;
+using namespace ZL::MediaFile;
+
+namespace ZL {
+namespace Rtmp {
+
+#ifdef ENABLE_RTMP2RTSP
+class RtmpToRtspMediaSource: public RtmpMediaSource {
+public:
+	typedef std::shared_ptr<RtmpToRtspMediaSource> Ptr;
+	RtmpToRtspMediaSource(const string &_app, const string &_id);
+	virtual ~RtmpToRtspMediaSource();
+	virtual void regist() override;
+	virtual void unregist() override;
+
+	virtual void onGetMetaData(const AMFValue &_metadata) override {
+		try {
+			m_pParser.reset(new RtmpParser(_metadata));
+			m_pRecorder.reset(new MediaRecorder(getApp(),getId(),m_pParser));
+			m_pParser->setOnAudioCB(std::bind(&RtmpToRtspMediaSource::onGetAdts, this, placeholders::_1));
+			m_pParser->setOnVideoCB(std::bind(&RtmpToRtspMediaSource::onGetH264, this, placeholders::_1));
+		} catch (exception &ex) {
+			WarnL << ex.what();
+		}
+		RtmpMediaSource::onGetMetaData(_metadata);
+	}
+
+	virtual void onGetMedia(const RtmpPacket &pkt) override {
+		if (m_pParser) {
+			if (!m_pRtspSrc && m_pParser->isInited()) {
+				makeSDP();
+			}
+			m_pParser->inputRtmp(pkt);
+		}
+		RtmpMediaSource::onGetMedia(pkt);
+	}
+	void setOnSeek(const function<bool(uint32_t)> &cb) override {
+		RtmpMediaSource::setOnSeek(cb);
+		if (m_pRtspSrc) {
+			m_pRtspSrc->setOnSeek(cb);
+		}
+	}
+	void setOnStamp(const function<uint32_t()> &cb)  override{
+		RtmpMediaSource::setOnStamp(cb);
+		if (m_pRtspSrc) {
+			m_pRtspSrc->setOnStamp(cb);
+		}
+	}
+private:
+	RtmpParser::Ptr m_pParser;
+	RtspMediaSource::Ptr m_pRtspSrc;
+	RtpMaker_AAC::Ptr m_pRtpMaker_aac;
+	RtpMaker_H264::Ptr m_pRtpMaker_h264;
+	MediaRecorder::Ptr m_pRecorder;
+
+	void onGetH264(const H264Frame &frame);
+	void onGetAdts(const AdtsFrame &frame);
+	void makeSDP();
+};
+#else
+	typedef RtmpMediaSource RtmpToRtspMediaSource;
+#endif //ENABLE_RTMP2RTSP
+
+} /* namespace Rtmp */
+} /* namespace ZL */
+
+#endif /* SRC_RTMP_RTMPTORTSPMEDIASOURCE_H_ */

bin_lib/windows/ZLMediaKit/include/ZLMediaKit/Rtmp/amf.h

+#ifndef __amf_h
+#define __amf_h
+
+#include <assert.h>
+#include <string>
+#include <vector>
+#include <unordered_map>
+#include <map>
+enum AMFType {
+	AMF_NUMBER,
+	AMF_INTEGER,
+	AMF_BOOLEAN,
+	AMF_STRING,
+	AMF_OBJECT,
+	AMF_NULL,
+	AMF_UNDEFINED,
+	AMF_ECMA_ARRAY,
+	AMF_STRICT_ARRAY,
+};
+
+class AMFValue;
+
+class AMFValue {
+public:
+
+	AMFValue(AMFType type = AMF_NULL);
+	AMFValue(const char *s);
+	AMFValue(const std::string &s);
+	AMFValue(double n);
+	AMFValue(int i);
+	AMFValue(bool b);
+	AMFValue(const AMFValue &from);
+	AMFValue(AMFValue &&from);
+	AMFValue &operator =(const AMFValue &from);
+	AMFValue &operator =(AMFValue &&from);
+	~AMFValue();
+
+	void clear() {
+		switch (m_type) {
+		case AMF_STRING:
+			m_value.string->clear();
+			break;
+		case AMF_OBJECT:
+		case AMF_ECMA_ARRAY:
+			m_value.object->clear();
+			break;
+		default:
+			break;
+		}
+	}
+
+	AMFType type() const {
+		return m_type;
+	}
+
+	const std::string &as_string() const {
+		if(m_type != AMF_STRING){
+			throw std::runtime_error("AMF not a string");
+		}
+		return *m_value.string;
+	}
+	double as_number() const {
+		switch (m_type) {
+		case AMF_NUMBER:
+			return m_value.number;
+		case AMF_INTEGER:
+			return m_value.integer;
+		case AMF_BOOLEAN:
+			return m_value.boolean;
+			break;
+		default:
+			throw std::runtime_error("AMF not a number");
+			break;
+		}
+	}
+	int as_integer() const {
+		switch (m_type) {
+		case AMF_NUMBER:
+			return m_value.number;
+		case AMF_INTEGER:
+			return m_value.integer;
+		case AMF_BOOLEAN:
+			return m_value.boolean;
+			break;
+		default:
+			throw std::runtime_error("AMF not a integer");
+			break;
+		}
+	}
+	bool as_boolean() const {
+		switch (m_type) {
+		case AMF_NUMBER:
+			return m_value.number;
+		case AMF_INTEGER:
+			return m_value.integer;
+		case AMF_BOOLEAN:
+			return m_value.boolean;
+			break;
+		default:
+			throw std::runtime_error("AMF not a boolean");
+			break;
+		}
+	}
+
+	const AMFValue &operator[](const char *str) const {
+		if (m_type != AMF_OBJECT && m_type != AMF_ECMA_ARRAY) {
+			throw std::runtime_error("AMF not a object");
+		}
+		auto i = m_value.object->find(str);
+		if (i == m_value.object->end()) {
+			static AMFValue val(AMF_NULL);
+			return val;
+		}
+		return i->second;
+	}
+	template<typename FUN>
+	void object_for_each(const FUN &fun) const {
+		if (m_type != AMF_OBJECT && m_type != AMF_ECMA_ARRAY) {
+			throw std::runtime_error("AMF not a object");
+		}
+		for (auto & pr : *(m_value.object)) {
+			fun(pr.first, pr.second);
+		}
+	}
+
+	operator bool() const{
+		return m_type != AMF_NULL;
+	}
+	void set(const std::string &s, const AMFValue &val) {
+		if (m_type != AMF_OBJECT && m_type != AMF_ECMA_ARRAY) {
+			throw std::runtime_error("AMF not a object");
+		}
+		m_value.object->emplace(s, val);
+	}
+	void add(const AMFValue &val) {
+		if (m_type != AMF_STRICT_ARRAY) {
+			throw std::runtime_error("AMF not a array");
+		}
+		assert(m_type == AMF_STRICT_ARRAY);
+		m_value.array->push_back(val);
+	}
+
+private:
+	typedef std::map<std::string, AMFValue> mapType;
+	typedef std::vector<AMFValue> arrayType;
+
+	AMFType m_type;
+	union {
+		std::string *string;
+		double number;
+		int integer;
+		bool boolean;
+		mapType *object;
+		arrayType *array;
+	} m_value;
+
+	friend class AMFEncoder;
+	const mapType &getMap() const {
+		if (m_type != AMF_OBJECT && m_type != AMF_ECMA_ARRAY) {
+			throw std::runtime_error("AMF not a object");
+		}
+		return *m_value.object;
+	}
+	const arrayType &getArr() const {
+		if (m_type != AMF_STRICT_ARRAY) {
+			throw std::runtime_error("AMF not a array");
+		}
+		return *m_value.array;
+	}
+	inline void destroy();
+	inline void init();
+};
+
+class AMFDecoder {
+public:
+	AMFDecoder(const std::string &_buf, size_t _pos, int _version = 0) :
+			buf(_buf), pos(_pos), version(_version) {
+	}
+
+	int getVersion() const {
+		return version;
+	}
+
+	template<typename TP>
+	TP load();
+
+
+
+private:
+	const std::string &buf;
+	size_t pos;
+	int version;
+
+	std::string load_key();
+	AMFValue load_object();
+	AMFValue load_ecma();
+	AMFValue load_arr();
+	uint8_t front();
+	uint8_t pop_front();
+};
+
+class AMFEncoder {
+public:
+	AMFEncoder & operator <<(const char *s);
+	AMFEncoder & operator <<(const std::string &s);
+	AMFEncoder & operator <<(std::nullptr_t);
+	AMFEncoder & operator <<(const int n);
+	AMFEncoder & operator <<(const double n);
+	AMFEncoder & operator <<(const bool b);
+	AMFEncoder & operator <<(const AMFValue &value);
+	const std::string data() const {
+		return buf;
+	}
+	void clear() {
+		buf.clear();
+	}
+private:
+	void write_key(const std::string &s);
+	AMFEncoder &write_undefined();
+	std::string buf;
+};
+
+
+#endif

bin_lib/windows/ZLMediaKit/include/ZLMediaKit/Rtmp/utils.h

+#ifndef __utils_h
+#define __utils_h
+
+#include <stdio.h>
+#include <stdint.h>
+
+
+uint32_t load_be32(const void *p);
+uint16_t load_be16(const void *p);
+uint32_t load_be24(const void *p);
+uint32_t load_le32(const void *p);
+void set_be24(void *p, uint32_t val);
+void set_le32(void *p, uint32_t val);
+void set_be32(void *p, uint32_t val);
+
+
+#endif

bin_lib/windows/ZLMediaKit/include/ZLMediaKit/Rtsp/RtpBroadCaster.h

+/*
+ * RtpBroadCaster.h
+ *
+ *  Created on: 2016年12月23日
+ *      Author: xzl
+ */
+
+#ifndef SRC_RTSP_RTPBROADCASTER_H_
+#define SRC_RTSP_RTPBROADCASTER_H_
+
+
+#include <mutex>
+#include <memory>
+#include <unordered_set>
+#include <unordered_map>
+#include "Common/config.h"
+#include "RtspMediaSource.h"
+#include "Util/mini.h"
+#include "Network/Socket.h"
+
+using namespace std;
+using namespace ZL::Util;
+using namespace ZL::Network;
+
+namespace ZL {
+namespace Rtsp {
+
+class MultiCastAddressMaker
+{
+public:
+	static MultiCastAddressMaker &Instance(){
+		static MultiCastAddressMaker instance;
+		return instance;
+	}
+	static bool isMultiCastAddress(uint32_t iAddr){
+		static uint32_t addrMin = mINI::Instance()[Config::MultiCast::kAddrMin].as<uint32_t>();
+		static uint32_t addrMax = mINI::Instance()[Config::MultiCast::kAddrMax].as<uint32_t>();
+		return iAddr >= addrMin && iAddr <= addrMax;
+	}
+	static string toString(uint32_t iAddr){
+		iAddr = htonl(iAddr);
+		return ::inet_ntoa((struct in_addr &)(iAddr));
+	}
+	virtual ~MultiCastAddressMaker(){}
+	std::shared_ptr<uint32_t> obtain(uint32_t iTry = 10);
+private:
+	MultiCastAddressMaker(){};
+	void release(uint32_t iAddr);
+	uint32_t m_iAddr = mINI::Instance()[Config::MultiCast::kAddrMin].as<uint32_t>();
+	recursive_mutex m_mtx;
+	unordered_set<uint32_t> m_setBadAddr;
+};
+class RtpBroadCaster {
+public:
+	typedef std::shared_ptr<RtpBroadCaster> Ptr;
+	typedef function<void()> onDetach;
+	virtual ~RtpBroadCaster();
+	static Ptr get(const string &strLocalIp,const string &strApp,const string &strStream);
+	void setDetachCB(void *listener,const onDetach &cb);
+	uint16_t getPort(int iTrackId);
+	string getIP();
+private:
+	static recursive_mutex g_mtx;
+	static unordered_map<string , weak_ptr<RtpBroadCaster> > g_mapBroadCaster;
+	static Ptr make(const string &strLocalIp,const string &strApp,const string &strStream);
+
+	std::shared_ptr<uint32_t> m_multiAddr;
+	recursive_mutex m_mtx;
+	unordered_map<void * , onDetach > m_mapDetach;
+	RtspMediaSource::RingType::RingReader::Ptr m_pReader;
+	Socket::Ptr m_apUdpSock[2];
+	struct sockaddr_in m_aPeerUdpAddr[2];
+
+	RtpBroadCaster(const string &strLocalIp,const string &strApp,const string &strStream);
+
+};
+
+} /* namespace Rtsp */
+} /* namespace ZL */
+
+#endif /* SRC_RTSP_RTPBROADCASTER_H_ */

bin_lib/windows/ZLMediaKit/include/ZLMediaKit/Rtsp/RtpParser.h

+/*
+ * RtpPraser.h
+ *
+ *  Created on: 2016年9月5日
+ *      Author: xzl
+ */
+
+#ifndef SRC_RTP_RTPPARSER_H_
+#define SRC_RTP_RTPPARSER_H_
+
+#include <unordered_map>
+#include "Rtsp/Rtsp.h"
+#include "Player/Player.h"
+#include "Player/PlayerBase.h"
+#include "Util/TimeTicker.h"
+
+using namespace std;
+using namespace ZL::Util;
+using namespace ZL::Player;
+
+namespace ZL {
+namespace Rtsp {
+
+class RtpParser : public PlayerBase{
+public:
+	typedef std::shared_ptr<RtpParser> Ptr;
+	RtpParser(const string &sdp);
+	virtual ~RtpParser();
+	//返回值：true 代表是i帧第一个rtp包
+	bool inputRtp(const RtpPacket &rtp);
+	void setOnVideoCB(const function<void(const H264Frame &frame)> &cb) override{
+		lock_guard<recursive_mutex> lck(m_mtxCB);
+		onVideo = cb;
+	}
+	void setOnAudioCB(const function<void(const AdtsFrame &frame)> &cb) override{
+		lock_guard<recursive_mutex> lck(m_mtxCB);
+		onAudio = cb;
+	}
+
+	int getVideoHeight() const override{
+		return m_iVideoHeight;
+	}
+
+	int getVideoWidth() const override{
+		return m_iVideoWidth;
+	}
+
+	float getVideoFps() const override{
+		return m_fVideoFps;
+	}
+
+	int getAudioSampleRate() const override{
+		return m_iSampleRate;
+	}
+
+	int getAudioSampleBit() const override{
+		return m_iSampleBit;
+	}
+
+	int getAudioChannel() const override{
+		return m_iChannel;
+	}
+
+	const string& getPps() const override{
+		return m_strPPS;
+	}
+
+	const string& getSps() const override{
+		return m_strSPS;
+	}
+
+	const string& getAudioCfg() const override{
+		return m_strAudioCfg;
+	}
+	bool containAudio() const override{
+		return m_bHaveAudio;
+	}
+	bool containVideo() const override{
+		return m_bHaveVideo;
+	}
+    bool isInited() const override{
+        if (m_bHaveAudio && !m_strAudioCfg.size()) {
+            return false;
+        }
+        if (m_bHaveVideo && !m_strSPS.size()) {
+            return false;
+        }
+        return true;
+    }
+	float getDuration() const override {
+		return m_fDuration;
+	}
+private:
+	std::unordered_map<uint8_t, RtspTrack> m_mapTracks;
+
+	inline void onGetAudioTrack(const RtspTrack &audio);
+	inline void onGetVideoTrack(const RtspTrack &video);
+
+	//返回值：true 代表是i帧第一个rtp包
+	inline bool inputVideo(const RtpPacket &rtp, const RtspTrack &track);
+	inline bool inputAudio(const RtpPacket &rtp, const RtspTrack &track);
+	inline void _onGetH264(H264Frame &frame);
+	inline void onGetH264(H264Frame &frame);
+	inline void onGetAdts(AdtsFrame &frame);
+	//video
+	H264Frame m_h264frame;
+	//aduio
+	AdtsFrame m_adts;
+
+	int m_iSampleRate = 44100;
+	int m_iSampleBit = 16;
+	int m_iChannel = 1;
+
+	string m_strSPS;
+	string m_strPPS;
+	string m_strAudioCfg;
+	int m_iVideoWidth = 0;
+	int m_iVideoHeight = 0;
+	float m_fVideoFps = 0;
+	bool m_bHaveAudio = false;
+	bool m_bHaveVideo= false;
+	float m_fDuration = 0;
+
+	function<void(const H264Frame &frame)> onVideo;
+	function<void(const AdtsFrame &frame)> onAudio;
+	recursive_mutex m_mtxCB;
+};
+
+} /* namespace Rtsp */
+} /* namespace ZL */
+
+#endif /* SRC_RTP_RTPPARSER_H_ */

bin_lib/windows/ZLMediaKit/include/ZLMediaKit/Rtsp/Rtsp.h

+#ifndef RTSP_RTSP_H_
+#define RTSP_RTSP_H_
+
+#include <string.h>
+#include <string>
+#include <memory>
+#include <unordered_map>
+#include "Common/config.h"
+#include "Util/util.h"
+
+using namespace std;
+using namespace ZL::Util;
+
+typedef enum {
+	TrackVideo = 0, TrackAudio
+} TrackType;
+
+class RtspTrack{
+public:
+	uint8_t PT;
+	uint8_t trackId;
+	uint8_t interleaved;
+	TrackType type = (TrackType) -1;
+	string trackSdp;
+	string trackStyle;
+	bool inited;
+	uint32_t ssrc = 0;
+	uint16_t seq;
+	uint32_t timeStamp;
+};
+
+class RtpPacket {
+public:
+    typedef std::shared_ptr<RtpPacket> Ptr;
+    uint8_t interleaved;
+    uint8_t PT;
+    bool mark;
+    uint32_t length;
+    uint32_t timeStamp;
+    uint16_t sequence;
+    uint32_t ssrc;
+    uint8_t payload[1560];
+    TrackType type;
+};
+
+class RtcpCounter {
+public:
+    uint32_t pktCnt = 0;
+    uint32_t octCount = 0;
+    uint32_t timeStamp = 0;
+};
+
+string FindField(const char* buf, const char* start, const char *end,int bufSize = 0 );
+int parserSDP(const string& sdp, RtspTrack Track[2]);
+
+
+struct StrCaseCompare
+{
+    bool operator()(const string& __x, const string& __y) const
+    {return strcasecmp(__x.data(), __y.data()) < 0 ;}
+};
+typedef map<string,string,StrCaseCompare> StrCaseMap;
+
+class Parser {
+public:
+	Parser() {
+	}
+	virtual ~Parser() {
+	}
+	void Parse(const char *buf) {
+		//解析
+		const char *start = buf;
+		string line;
+		string field;
+		string value;
+		Clear();
+		while (true) {
+			line = FindField(start, NULL, "\r\n");
+			if (line.size() == 0) {
+				break;
+			}
+			if (start == buf) {
+				m_strMethod = FindField(line.c_str(), NULL, " ");
+				m_strUrl = FindField(line.c_str(), " ", " ");
+				m_strTail = FindField(line.c_str(), (m_strUrl + " ").c_str(), NULL);
+			} else {
+				field = FindField(line.c_str(), NULL, ": ");
+				value = FindField(line.c_str(), ": ", NULL);
+				if (field.size() != 0) {
+					m_mapValues[field] = value;
+				}
+			}
+			start = start + line.size() + 2;
+			if (strncmp(start, "\r\n", 2) == 0) { //协议解析完毕
+				m_strContent = FindField(start, "\r\n", NULL);
+				break;
+			}
+		}
+	}
+	const string& Method() const {
+		//rtsp方法
+		return m_strMethod;
+	}
+	const string& Url() const {
+		//rtsp url
+		return m_strUrl;
+	}
+	const string& Tail() const {
+		//RTSP/1.0
+		return m_strTail;
+	}
+	const string& operator[](const char *name) const {
+		//rtsp field
+		auto it = m_mapValues.find(name);
+		if (it == m_mapValues.end()) {
+			return m_strNull;
+		}
+		return it->second;
+	}
+	const string& Content() const {
+		return m_strContent;
+	}
+	void Clear() {
+		m_strMethod.clear();
+		m_strUrl.clear();
+		m_strTail.clear();
+		m_strContent.clear();
+		m_mapValues.clear();
+	}
+
+	void setUrl(const string& url) {
+		this->m_strUrl = url;
+	}
+	void setContent(const string& content) {
+		this->m_strContent = content;
+	}
+
+	const StrCaseMap& getValues() const {
+		return m_mapValues;
+	}
+
+private:
+	string m_strMethod;
+	string m_strUrl;
+	string m_strTail;
+	string m_strContent;
+	string m_strNull;
+	StrCaseMap m_mapValues;
+
+};
+
+typedef struct {
+	unsigned forbidden_zero_bit :1;
+	unsigned nal_ref_idc :2;
+	unsigned type :5;
+} NALU;
+
+typedef struct {
+	unsigned S :1;
+	unsigned E :1;
+	unsigned R :1;
+	unsigned type :5;
+} FU;
+
+bool MakeNalu(char in, NALU &nal) ;
+bool MakeFU(char in, FU &fu) ;
+
+
+#endif //RTSP_RTSP_H_

bin_lib/windows/ZLMediaKit/include/ZLMediaKit/Rtsp/RtspMediaSource.h

+/*
+ * RtspMediaSource.h
+ *
+ *  Created on: 2016年8月10日
+ *      Author: xzl
+ */
+
+#ifndef SRC_RTSP_RTSPMEDIASOURCE_H_
+#define SRC_RTSP_RTSPMEDIASOURCE_H_
+
+#include <mutex>
+#include <string>
+#include <memory>
+#include <functional>
+#include <unordered_map>
+#include "Rtsp.h"
+#include "Common/config.h"
+#include "Common/MediaSender.h"
+#include "Util/logger.h"
+#include "Util/RingBuffer.h"
+#include "Util/TimeTicker.h"
+#include "Util/ResourcePool.h"
+#include "Util/NoticeCenter.h"
+#include "Thread/ThreadPool.h"
+
+using namespace std;
+using namespace ZL::Util;
+using namespace ZL::Thread;
+
+namespace ZL {
+namespace Rtsp {
+
+
+
+class RtspMediaSource: public enable_shared_from_this<RtspMediaSource> {
+public:
+	typedef ResourcePool<RtpPacket, 64> PoolType;
+	typedef std::shared_ptr<RtspMediaSource> Ptr;
+	typedef RingBuffer<RtpPacket::Ptr> RingType;
+	RtspMediaSource(const string &strApp, const string &strId) :
+			m_strApp(strApp),
+			m_strId(strId),
+			m_pRing(new RingBuffer<RtpPacket::Ptr>()),
+			m_thPool(MediaSender::sendThread()) {
+	}
+	virtual ~RtspMediaSource() {
+		unregist();
+	}
+
+	const RingType::Ptr &getRing() const {
+		//获取媒体源的rtp环形缓冲
+		return m_pRing;
+	}
+
+	const string& getSdp() const {
+		//获取该源的媒体描述信息
+		return m_strSdp;
+	}
+	virtual void regist() {
+		//注册该源，注册后rtsp服务器才能找到该源
+		lock_guard<recursive_mutex> lock(g_mtxMediaSrc);
+		if (!g_mapMediaSrc[m_strApp].erase(m_strId)) {
+			InfoL << "Rtsp src:" << m_strApp << " " << m_strId;
+		}
+		g_mapMediaSrc[m_strApp].emplace(m_strId, shared_from_this());
+		NoticeCenter::Instance().emitEvent(Config::Broadcast::kBroadcastRtspSrcRegisted,m_strApp.data(),m_strId.data());
+	}
+	virtual void unregist() {
+		//反注册该源
+		lock_guard<recursive_mutex> lock(g_mtxMediaSrc);
+		auto it = g_mapMediaSrc.find(m_strApp);
+		if (it == g_mapMediaSrc.end()) {
+			return;
+		}
+		if (it->second.erase(m_strId)) {
+			if(it->second.size() == 0){
+				g_mapMediaSrc.erase(it);
+			}
+			InfoL << "Rtsp src:" << m_strApp << " " << m_strId;
+		}
+	}
+	static set<string> getMediaSet() {
+		set<string> ret;
+		lock_guard<recursive_mutex> lock(g_mtxMediaSrc);
+		for (auto &pr0 : g_mapMediaSrc) {
+			for (auto &pr1 : pr0.second) {
+				if(pr1.second.lock()){
+					ret.emplace(pr0.first + "/" + pr1.first);
+				}
+			}
+		}
+		return ret;
+	}
+	static Ptr find(const string &_app, const string &_id,bool bMake = true) ;
+
+	const string& getApp() const {
+		//获取该源的id
+		return m_strApp;
+	}
+	const string& getId() const {
+		return m_strId;
+	}
+	virtual uint32_t getSsrc(int trackId) {
+		return m_mapTracks[trackId].ssrc;
+	}
+	virtual uint16_t getSeqence(int trackId) {
+		return m_mapTracks[trackId].seq;
+	}
+	virtual uint32_t getTimestamp(int trackId) {
+		return m_mapTracks[trackId].timeStamp;
+	}
+
+	virtual void onGetSDP(const string& sdp) {
+		//派生类设置该媒体源媒体描述信息
+		this->m_strSdp = sdp;
+	}
+	virtual void onGetRTP(const RtpPacket::Ptr &rtppt, bool keyPos) {
+		auto &trackRef = m_mapTracks[rtppt->interleaved / 2];
+		trackRef.seq = rtppt->sequence;
+		trackRef.timeStamp = rtppt->timeStamp;
+		trackRef.ssrc = rtppt->ssrc;
+		trackRef.type = rtppt->type;
+		auto _outRing = m_pRing;
+		m_thPool.async([_outRing,rtppt,keyPos]() {
+			_outRing->write(rtppt,keyPos);
+		});
+	}
+	bool seekTo(uint32_t ui32Stamp) {
+		if (!m_onSeek) {
+			return false;
+		}
+		return m_onSeek(ui32Stamp);
+	}
+	virtual void setOnSeek(const function<bool(uint32_t)> &cb){
+		m_onSeek = cb;
+	}
+	uint32_t getStamp() {
+		if (!m_onStamp) {
+			return 0;
+		}
+		return m_onStamp();
+	}
+	virtual void setOnStamp(const function<uint32_t()> &cb) {
+		m_onStamp = cb;
+	}
+protected:
+	function<bool(uint32_t)> m_onSeek;
+	function<uint32_t()> m_onStamp;
+	unordered_map<int, RtspTrack> m_mapTracks;
+private:
+	string m_strSdp; //媒体描述信息
+	string m_strApp; //媒体app
+	string m_strId; //媒体id
+	RingType::Ptr m_pRing; //rtp环形缓冲
+	ThreadPool &m_thPool;
+	static unordered_map<string, unordered_map<string, weak_ptr<RtspMediaSource> > > g_mapMediaSrc; //静态的媒体源表
+	static recursive_mutex g_mtxMediaSrc; ///访问静态的媒体源表的互斥锁
+};
+
+} /* namespace Rtsp */
+} /* namespace ZL */
+
+#endif /* SRC_RTSP_RTSPMEDIASOURCE_H_ */

bin_lib/windows/ZLMediaKit/include/ZLMediaKit/Rtsp/RtspPlayer.h

+/*
+ * RtspPlayer.h
+ *
+ *  Created on: 2016年8月17日
+ *      Author: xzl
+ */
+
+#ifndef SRC_RTSPPLAYER_RTSPPLAYER_H_TXT_
+#define SRC_RTSPPLAYER_RTSPPLAYER_H_TXT_
+
+#include <string>
+#include <memory>
+#include "Rtsp.h"
+#include "RtspSession.h"
+#include "RtspMediaSource.h"
+#include "Player/PlayerBase.h"
+#include "Util/util.h"
+#include "Util/logger.h"
+#include "Util/TimeTicker.h"
+#include "Poller/Timer.h"
+#include "Network/Socket.h"
+#include "Network/TcpClient.h"
+
+using namespace std;
+using namespace ZL::Rtsp;
+using namespace ZL::Player;
+using namespace ZL::Util;
+using namespace ZL::Poller;
+using namespace ZL::Network;
+
+namespace ZL {
+namespace Rtsp {
+
+//实现了rtsp播放器协议部分的功能
+class RtspPlayer: public PlayerBase,public TcpClient {
+public:
+	typedef std::shared_ptr<RtspPlayer> Ptr;
+	//设置rtp传输类型，可选项有0(tcp，默认)、1(udp)、2(组播)
+	//设置方法:player[RtspPlayer::kRtpType] = 0/1/2;
+	static const char kRtpType[];
+
+	RtspPlayer();
+	virtual ~RtspPlayer(void);
+	void play(const char* strUrl) override;
+	void pause(bool bPause) override;
+	void teardown() override;
+	float getRtpLossRate(int iTrackId) const override;
+protected:
+	//派生类回调函数
+	virtual bool onCheckSDP(const string &strSdp, const RtspTrack *pTrack, int iTrackCnt) = 0;
+	virtual void onRecvRTP(const RtpPacket::Ptr &pRtppt, const RtspTrack &track) = 0;
+    float getProgressTime() const;
+    void seekToTime(float fTime);
+private:
+	 void _onShutdown(const SockException &ex) {
+		WarnL << ex.getErrCode() << " " << ex.what();
+		m_pPlayTimer.reset();
+		m_pRtpTimer.reset();
+		m_pBeatTimer.reset();
+		onShutdown(ex);
+	}
+	void _onRecvRTP(const RtpPacket::Ptr &pRtppt, const RtspTrack &track) {
+		m_rtpTicker.resetTime();
+		onRecvRTP(pRtppt,track);
+	}
+	void _onPlayResult(const SockException &ex) {
+		WarnL << ex.getErrCode() << " " << ex.what();
+        m_pPlayTimer.reset();
+        m_pRtpTimer.reset();
+		if (!ex) {
+			m_rtpTicker.resetTime();
+			weak_ptr<RtspPlayer> weakSelf = dynamic_pointer_cast<RtspPlayer>(shared_from_this());
+			m_pRtpTimer.reset( new Timer(5, [weakSelf]() {
+				auto strongSelf=weakSelf.lock();
+				if(!strongSelf) {
+					return false;
+				}
+				if(strongSelf->m_rtpTicker.elapsedTime()>10000) {
+					//recv rtp timeout!
+					strongSelf->_onShutdown(SockException(Err_timeout,"recv rtp timeout"));
+					strongSelf->teardown();
+					return false;
+				}
+				return true;
+			}));
+		}
+		onPlayResult(ex);
+	}
+
+	void play(const char* strUrl, const char *strUser, const char *strPwd,  eRtpType eType);
+	void onConnect(const SockException &err) override;
+	void onRecv(const Socket::Buffer::Ptr &pBuf) override;
+	void onErr(const SockException &ex) override;
+
+	void HandleResSETUP(const Parser &parser, unsigned int uiTrackIndex);
+	void HandleResDESCRIBE(const Parser &parser);
+	void HandleResPAUSE(const Parser &parser, bool bPause);
+
+	//发数据给服务器
+	inline int write(const char *strMsg, ...);
+	inline int onProcess(const char* strBuf);
+	//生成rtp包结构体
+	inline void splitRtp(unsigned char *pucData, unsigned int uiLen);
+	//发送SETUP命令
+	inline void sendSetup(unsigned int uiTrackIndex);
+    inline void sendPause(bool bPause,float fTime);
+	//处理一个rtp包
+	inline bool HandleOneRtp(int iTrackidx, unsigned char *ucData, unsigned int uiLen);
+	bool sendOptions();
+	inline void _onRecvRTP(const RtpPacket::Ptr &pRtppt, int iTrackidx);
+	inline int getTrackIndex(int iTrackId) const{
+		for (unsigned int i = 0; i < m_uiTrackCnt; i++) {
+			if (m_aTrackInfo[i].trackId == iTrackId) {
+				return i;
+			}
+		}
+		return -1;
+	}
+
+	string m_strUrl;
+	unsigned int m_uiTrackCnt = 0;
+	RtspTrack m_aTrackInfo[2];
+
+	function<void(const Parser&)> m_onHandshake;
+	RtspMediaSource::PoolType m_pktPool;
+
+	uint8_t *m_pucRtpBuf = nullptr;
+	unsigned int m_uiRtpBufLen = 0;
+	Socket::Ptr m_apUdpSock[2];
+	//rtsp info
+	string m_strSession;
+	unsigned int m_uiCseq = 1;
+	uint32_t m_aui32SsrcErrorCnt[2] = { 0, 0 };
+	string m_strAuthorization;
+	string m_strContentBase;
+	eRtpType m_eType = RTP_TCP;
+	/* RTP包排序所用参数 */
+	uint16_t m_aui16LastSeq[2] = { 0 , 0 };
+	uint64_t m_aui64SeqOkCnt[2] = { 0 , 0};
+	bool m_abSortStarted[2] = { 0 , 0};
+	map<uint32_t , RtpPacket::Ptr> m_amapRtpSort[2];
+
+	/* 丢包率统计需要用到的参数 */
+	uint16_t m_aui16FirstSeq[2] = { 0 , 0};
+	uint16_t m_aui16NowSeq[2] = { 0 , 0 };
+	uint64_t m_aui64RtpRecv[2] = { 0 , 0};
+
+	//超时功能实现
+	Ticker m_rtpTicker;
+	std::shared_ptr<Timer> m_pPlayTimer;
+	std::shared_ptr<Timer> m_pRtpTimer;
+	//心跳定时器
+	std::shared_ptr<Timer> m_pBeatTimer;
+    
+    //播放进度控制
+    float m_fSeekTo = 0;
+    double m_adFistStamp[2] = {0,0};
+    double m_adNowStamp[2] = {0,0};
+    Ticker m_aNowStampTicker[2];
+};
+
+} /* namespace Rtsp */
+} /* namespace ZL */
+
+#endif /* SRC_RTSPPLAYER_RTSPPLAYER_H_TXT_ */

bin_lib/windows/ZLMediaKit/include/ZLMediaKit/Rtsp/RtspPlayerImp.h

+/*
+ * RtspParserTester.h
+ *
+ *  Created on: 2016年9月5日
+ *      Author: xzl
+ */
+
+#ifndef SRC_RTP_RTPPARSERTESTER_H_
+#define SRC_RTP_RTPPARSERTESTER_H_
+
+#include <memory>
+#include <algorithm>
+#include <functional>
+#include "Common/config.h"
+#include "RtpParser.h"
+#include "RtspPlayer.h"
+#include "Poller/Timer.h"
+#include "Util/TimeTicker.h"
+
+using namespace std;
+using namespace ZL::Util;
+using namespace ZL::Player;
+
+namespace ZL {
+namespace Rtsp {
+
+class RtspPlayerImp: public PlayerImp<RtspPlayer,RtpParser> {
+public:
+	typedef std::shared_ptr<RtspPlayerImp> Ptr;
+	RtspPlayerImp();
+	virtual ~RtspPlayerImp();
+    float getProgresss() const override{
+        if(getDuration() > 0){
+            return getProgressTime() / getDuration();
+        }
+        return PlayerBase::getProgresss();
+        
+    };
+    void seekTo(float fProgress) override{
+        fProgress = MAX(float(0),MIN(fProgress,float(1.0)));
+        seekToTime(fProgress * getDuration());
+    };
+private:
+	//派生类回调函数
+	bool onCheckSDP(const string &sdp, const RtspTrack *track, int trackCnt) override {
+		try {
+			m_parser.reset(new RtpParser(sdp));
+			m_parser->setOnVideoCB(m_onGetVideoCB);
+			m_parser->setOnAudioCB(m_onGetAudioCB);
+			return true;
+		} catch (std::exception &ex) {
+			WarnL << ex.what();
+			return false;
+		}
+	}
+	void onRecvRTP(const RtpPacket::Ptr &rtppt, const RtspTrack &track) override {
+		m_parser->inputRtp(*rtppt);
+	}
+    
+};
+
+} /* namespace Rtsp */
+} /* namespace ZL */
+
+#endif /* SRC_RTP_RTPPARSERTESTER_H_ */

bin_lib/windows/ZLMediaKit/include/ZLMediaKit/Rtsp/RtspSession.h

+/*
+ * RtspSession.h
+ *
+ *  Created on: 2016年8月12日
+ *      Author: xzl
+ */
+
+#ifndef SESSION_RTSPSESSION_H_
+#define SESSION_RTSPSESSION_H_
+
+#include <set>
+#include <vector>
+#include <unordered_map>
+#include "Common/config.h"
+#include "Rtsp.h"
+#include "RtpBroadCaster.h"
+#include "RtspMediaSource.h"
+#include "Player/PlayerBase.h"
+#include "Util/util.h"
+#include "Util/logger.h"
+#include "Network/TcpLimitedSession.h"
+
+using namespace std;
+using namespace ZL::Util;
+using namespace ZL::Rtsp;
+using namespace ZL::Player;
+using namespace ZL::Network;
+
+namespace ZL {
+namespace Rtsp {
+
+class RtspSession;
+class RtspSession: public TcpLimitedSession<MAX_TCP_SESSION> {
+public:
+	typedef std::shared_ptr<RtspSession> Ptr;
+	RtspSession(const std::shared_ptr<ThreadPool> &pTh, const Socket::Ptr &pSock);
+	virtual ~RtspSession();
+	void onRecv(const Socket::Buffer::Ptr &pBuf) override;
+	void onError(const SockException &err) override;
+	void onManager() override;
+private:
+	typedef bool (RtspSession::*rtspCMDHandle)();
+	int send(const string &strBuf) override {
+		return m_pSender->send(strBuf);
+	}
+	int send(const char *pcBuf, int iSize) override {
+		return m_pSender->send(pcBuf, iSize);
+	}
+	void shutdown() override;
+	bool handleReq_Options(); //处理options方法
+	bool handleReq_Describe(); //处理describe方法
+	bool handleReq_Setup(); //处理setup方法
+	bool handleReq_Play(); //处理play方法
+	bool handleReq_Pause(); //处理pause方法
+	bool handleReq_Teardown(); //处理teardown方法
+	bool handleReq_Get(); //处理Get方法
+	bool handleReq_Post(); //处理Post方法
+	bool handleReq_SET_PARAMETER(); //处理SET_PARAMETER方法
+
+	void inline send_StreamNotFound(); //rtsp资源未找到
+	void inline send_UnsupportedTransport(); //不支持的传输模式
+	void inline send_SessionNotFound(); //会话id错误
+	void inline send_NotAcceptable(); //rtsp同时播放数限制
+	inline bool findStream(); //根据rtsp url查找 MediaSource实例
+
+	inline void initSender(const std::shared_ptr<RtspSession> &pSession); //处理rtsp over http，quicktime使用的
+	inline void sendRtpPacket(const RtpPacket &pkt);
+	inline string printSSRC(uint32_t ui32Ssrc) {
+		char tmp[9] = { 0 };
+		ui32Ssrc = htonl(ui32Ssrc);
+		uint8_t *pSsrc = (uint8_t *) &ui32Ssrc;
+		for (int i = 0; i < 4; i++) {
+			sprintf(tmp + 2 * i, "%02X", pSsrc[i]);
+		}
+		return tmp;
+	}
+	inline int getTrackIndexByTrackId(int iTrackId) {
+		for (unsigned int i = 0; i < m_uiTrackCnt; i++) {
+			if (iTrackId == m_aTrackInfo[i].trackId) {
+				return i;
+			}
+		}
+		return -1;
+	}
+	inline void onRcvPeerUdpData(int iTrackIdx, const Socket::Buffer::Ptr &pBuf, const struct sockaddr &addr);
+	inline void tryGetPeerUdpPort();
+
+	char *m_pcBuf = nullptr;
+	Ticker m_ticker;
+	Parser m_parser; //rtsp解析类
+	string m_strUrl;
+	string m_strSdp;
+	string m_strSession;
+	bool m_bFirstPlay = true;
+	string m_strApp;
+	string m_strStream;
+	std::weak_ptr<RtspMediaSource> m_pMediaSrc;
+	static unordered_map<string, rtspCMDHandle> g_mapCmd;
+
+	//RTP缓冲
+	weak_ptr<RingBuffer<RtpPacket::Ptr> > m_pWeakRing;
+	RingBuffer<RtpPacket::Ptr>::RingReader::Ptr m_pRtpReader;
+
+	PlayerBase::eRtpType m_rtpType = PlayerBase::RTP_UDP;
+	bool m_bSetUped = false;
+	int m_iCseq = 0;
+	unsigned int m_uiTrackCnt = 0; //媒体track个数
+	RtspTrack m_aTrackInfo[2]; //媒体track信息,trackid idx 为数组下标
+
+#ifdef RTSP_SEND_RTCP
+	RtcpCounter m_aRtcpCnt[2]; //rtcp统计,trackid idx 为数组下标
+	Ticker m_aRtcpTicker[2]; //rtcp发送时间,trackid idx 为数组下标
+	inline void sendRTCP();
+#endif
+
+	//RTP over UDP
+	bool m_abGotPeerUdp[2] = { false, false }; //获取客户端udp端口计数
+	weak_ptr<Socket> m_apUdpSock[2]; //发送RTP的UDP端口,trackid idx 为数组下标
+	std::shared_ptr<struct sockaddr> m_apPeerUdpAddr[2]; //播放器接收RTP的地址,trackid idx 为数组下标
+	bool m_bListenPeerUdpPort = false;
+	RtpBroadCaster::Ptr m_pBrdcaster;
+
+	//RTSP over HTTP
+	function<void(void)> m_onDestory;
+	bool m_bBase64need = false; //是否需要base64解码
+	Socket::Ptr m_pSender; //回复rtsp时走的tcp通道，供quicktime用
+	//quicktime 请求rtsp会产生两次tcp连接，
+	//一次发送 get 一次发送post，需要通过sessioncookie关联起来
+	string m_strSessionCookie;
+	static recursive_mutex g_mtxGetter; //对quicktime上锁保护
+	static recursive_mutex g_mtxPostter; //对quicktime上锁保护
+	static unordered_map<string, weak_ptr<RtspSession> > g_mapGetter;
+	static unordered_map<void *, std::shared_ptr<RtspSession> > g_mapPostter;
+	static string g_serverName;
+
+};
+
+} /* namespace Session */
+} /* namespace ZL */
+
+#endif /* SESSION_RTSPSESSION_H_ */

bin_lib/windows/ZLMediaKit/include/ZLMediaKit/Rtsp/RtspToRtmpMediaSource.h

+/*
+ * RtspToRtmpMediaSource.h
+ *
+ *  Created on: 2016年9月7日
+ *      Author: xzl
+ */
+
+#ifndef SRC_RTSP_RTSPTORTMPMEDIASOURCE_H_
+#define SRC_RTSP_RTSPTORTMPMEDIASOURCE_H_
+
+#include "RtpParser.h"
+#include "RtspMediaSource.h"
+#include "Rtmp/amf.h"
+#include "Rtmp/RtmpMediaSource.h"
+#include "MediaFile/MediaRecorder.h"
+
+using namespace ZL::Rtmp;
+using namespace ZL::MediaFile;
+
+namespace ZL {
+namespace Rtsp {
+#ifdef ENABLE_RTSP2RTMP
+class RtspToRtmpMediaSource: public RtspMediaSource {
+public:
+	typedef std::shared_ptr<RtspToRtmpMediaSource> Ptr;
+	RtspToRtmpMediaSource(const string &_app,const string &_id,bool bEnableFile = true);
+	virtual ~RtspToRtmpMediaSource();
+
+	virtual void onGetSDP(const string& strSdp) override{
+		try {
+			m_pParser.reset(new RtpParser(strSdp));
+			if(m_bEnableFile){
+				m_pRecorder.reset(new MediaRecorder(getApp(),getId(),m_pParser));
+			}
+			m_pParser->setOnAudioCB( std::bind(&RtspToRtmpMediaSource::onGetAdts, this, placeholders::_1));
+			m_pParser->setOnVideoCB( std::bind(&RtspToRtmpMediaSource::onGetH264, this, placeholders::_1));
+			makeMetaData();
+		} catch (exception &ex) {
+			WarnL << ex.what();
+		}
+		RtspMediaSource::onGetSDP(strSdp);
+	}
+	virtual void onGetRTP(const RtpPacket::Ptr &pRtppkt, bool bKeyPos) override{
+		if (m_pParser) {
+			bKeyPos = m_pParser->inputRtp(*pRtppkt);
+		}
+		RtspMediaSource::onGetRTP(pRtppkt, bKeyPos);
+	}
+	virtual void regist() override ;
+	virtual void unregist() override;
+	int readerCount(){
+		return getRing()->readerCount() + (m_pRtmpSrc ? m_pRtmpSrc->getRing()->readerCount() : 0);
+	}
+	void setOnSeek(const function<bool(uint32_t)> &cb) override{
+		RtspMediaSource::setOnSeek(cb);
+		if(m_pRtmpSrc){
+			m_pRtmpSrc->setOnSeek(cb);
+		}
+	}
+	void setOnStamp(const function<uint32_t()> &cb) override{
+		RtspMediaSource::setOnStamp(cb);
+		if (m_pRtmpSrc) {
+			m_pRtmpSrc->setOnStamp(cb);
+		}
+	}
+	void updateTimeStamp(uint32_t uiStamp) {
+		for (auto &pr : m_mapTracks) {
+			switch (pr.second.type) {
+			case TrackAudio: {
+				pr.second.timeStamp = uiStamp * (m_pParser->getAudioSampleRate() / 1000.0);
+			}
+				break;
+			case TrackVideo: {
+				pr.second.timeStamp = uiStamp * 90;
+			}
+				break;
+			default:
+				break;
+			}
+		}
+	}
+private:
+	RtpParser::Ptr m_pParser;
+	RtmpMediaSource::Ptr m_pRtmpSrc;
+	RtmpPacket m_rtmpPkt;
+	uint8_t m_ui8AudioFlags = 0;
+	MediaRecorder::Ptr m_pRecorder;
+	bool m_bEnableFile = true;
+	void onGetH264(const H264Frame &frame);
+	void onGetAdts(const AdtsFrame &frame);
+	void makeVideoConfigPkt();
+	void makeAudioConfigPkt();
+	void makeMetaData();
+};
+
+#else
+typedef RtspMediaSource RtspToRtmpMediaSource;
+#endif //ENABLE_RTSP2RTMP
+} /* namespace Rtsp */
+} /* namespace ZL */
+
+#endif /* SRC_RTSP_RTSPTORTMPMEDIASOURCE_H_ */

bin_lib/windows/ZLMediaKit/include/ZLMediaKit/Rtsp/UDPServer.h

+/*
+ * UDPServer.h
+ *
+ *  Created on: 2016年8月12日
+ *      Author: xzl
+ */
+
+#ifndef RTSP_UDPSERVER_H_
+#define RTSP_UDPSERVER_H_
+
+#include <mutex>
+#include <stdint.h>
+#include <unordered_map>
+#include <unordered_set>
+#include "Util/util.h"
+#include "Util/logger.h"
+#include "Network/Socket.h"
+
+using namespace std;
+using namespace ZL::Util;
+using namespace ZL::Network;
+
+namespace ZL {
+namespace Rtsp {
+
+class UDPServer {
+public:
+	typedef function< bool(int, const Socket::Buffer::Ptr &, struct sockaddr *)> onRecvData;
+	UDPServer();
+	virtual ~UDPServer();
+	static UDPServer &Instance() {
+		static UDPServer *instance(new UDPServer());
+		return *instance;
+	}
+	static void Destory() {
+		delete &UDPServer::Instance();
+	}
+	Socket::Ptr getSock(const char *strLocalIp, int iTrackIndex);
+	void listenPeer(const char *strPeerIp, void *pSelf, const onRecvData &cb);
+	void stopListenPeer(const char *strPeerIp, void *pSelf);
+private:
+	void onRcvData(int iTrackId, const Socket::Buffer::Ptr &pBuf,struct sockaddr *pPeerAddr);
+	void onErr(const string &strKey,const SockException &err);
+	unordered_map<string, Socket::Ptr> m_mapUpdSock;
+	mutex m_mtxUpdSock;
+
+	unordered_map<string, unordered_map<void *, onRecvData> > m_mapDataHandler;
+	mutex m_mtxDataHandler;
+};
+
+} /* namespace Rtsp */
+} /* namespace ZL */
+
+#endif /* RTSP_UDPSERVER_H_ */

bin_lib/windows/ZLMediaKit/include/ZLMediaKit/Shell/CMD.h

+/*
+ * CMD.h
+ *
+ *  Created on: 2016年9月26日
+ *      Author: xzl
+ */
+
+#ifndef SRC_SHELL_CMD_H_
+#define SRC_SHELL_CMD_H_
+
+#if defined(_WIN32)
+#include "win32/getopt.h"
+#else
+#include <getopt.h>
+#endif //defined(_WIN32)
+
+#include <string>
+#include <vector>
+#include <iostream>
+#include <functional>
+#include <unordered_map>
+#include "Util/util.h"
+#include "Util/logger.h"
+
+using namespace std;
+using namespace ZL::Util;
+
+namespace ZL {
+namespace Shell {
+
+class OutStream {
+public:
+	virtual ~OutStream() {
+	}
+	virtual void response(const string &str) =0;
+	virtual string &operator[](const string &) =0;
+	virtual int erase(const string &) =0;
+};
+
+class Option {
+public:
+	typedef function<bool(OutStream *stream, const char *arg)> OptionHandler;
+	enum ArgType {
+		ArgNone = no_argument,
+		ArgRequired = required_argument,
+		ArgOptional = optional_argument
+	};
+	Option() {
+	}
+	Option(char _shortOpt, const char *_longOpt, enum ArgType _argType,
+			const char *_des, const OptionHandler &_cb) {
+		shortOpt = _shortOpt;
+		longOpt = _longOpt;
+		argType = _argType;
+		des = _des;
+		cb = _cb;
+	}
+	virtual ~Option() {
+	}
+	bool operator()(OutStream *stream, const char *arg){
+		return cb ? cb(stream,arg): true;
+	}
+private:
+	friend class OptionParser;
+	char shortOpt;
+	string longOpt;
+	enum ArgType argType;
+	string des;
+	OptionHandler cb;
+};
+
+class OptionParser {
+public:
+	typedef function< void(OutStream *stream, const unordered_multimap<char, string> &)> OptionCompleted;
+	OptionParser(const OptionCompleted &_cb) {
+		onCompleted = _cb;
+		helper = Option('h', "help", Option::ArgNone, "print this message", [this](OutStream *stream,const char *arg)->bool {
+			_StrPrinter printer;
+			for (auto &pr : options) {
+				printer<<"\t-"<<pr.first<<"\t--"<<pr.second.longOpt<<"\t"<<pr.second.des<<"\r\n";
+			}
+			auto sendStr=printer<<endl;
+			stream->response(sendStr);
+			return false;
+		});
+	}
+	virtual ~OptionParser() {
+	}
+	OptionParser &operator <<(const Option &option) {
+		options.emplace(option.shortOpt, option);
+		return *this;
+	}
+	void operator <<(ostream&(*f)(ostream&)) {
+		str_shortOpt.clear();
+		vec_longOpt.clear();
+		(*this) << helper;
+		struct option tmp;
+		for (auto &pr : options) {
+			//long opt
+			tmp.name = (char *)pr.second.longOpt.data();
+			tmp.has_arg = pr.second.argType;
+			tmp.flag = NULL;
+			tmp.val = pr.first;
+			vec_longOpt.emplace_back(tmp);
+			//short opt
+			str_shortOpt.push_back(pr.first);
+			switch (pr.second.argType) {
+			case Option::ArgRequired:
+				str_shortOpt.append(":");
+				break;
+			case Option::ArgOptional:
+				str_shortOpt.append("::");
+				break;
+			default:
+				break;
+			}
+		}
+		tmp.flag=0;
+		tmp.name=0;
+		tmp.has_arg=0;
+		tmp.val=0;
+		vec_longOpt.emplace_back(tmp);
+
+	}
+	bool operator ()(OutStream *stream, int argc, char *argv[]) {
+		lock_guard<mutex> lck(mtx_opt);
+		unordered_multimap<char, string> allArg;
+		int opt;
+		optind = 0;
+		while ((opt = getopt_long(argc, argv, &str_shortOpt[0], &vec_longOpt[0],NULL)) != -1) {
+			auto it = options.find(opt);
+			if (it == options.end()) {
+				string sendStr = StrPrinter << "\tUnrecognized option. Enter \"-h\" to get help.\r\n" << endl;
+				stream->response(sendStr);
+				return true;
+			}
+			allArg.emplace(it->first, optarg ? optarg : "");
+			if (!it->second(stream, optarg)) {
+				return true;
+			}
+			optarg = NULL;
+		}
+		if(!allArg.size() && options.size()){
+			helper(stream,"");
+			return true;
+		}
+		if (onCompleted) {
+			onCompleted(stream, allArg);
+		}
+		return true;
+	}
+private:
+	unordered_map<char, Option> options;
+	OptionCompleted onCompleted;
+	vector<struct option> vec_longOpt;
+	string str_shortOpt;
+	Option helper;
+	static mutex mtx_opt;
+};
+
+class CMD {
+public:
+	CMD();
+	virtual ~CMD();
+	virtual const char *description() const {
+		return "description";
+	}
+	bool operator ()(OutStream *stream, int argc, char *argv[]) const {
+		return (*parser)(stream, argc, argv);
+	}
+protected:
+	mutable std::shared_ptr<OptionParser> parser;
+};
+template<typename C>
+class CMDInstance {
+public:
+	static CMD &Instance() {
+		static C instance;
+		return (CMD &) instance;
+	}
+};
+class CMD_help: public CMD {
+public:
+	CMD_help();
+	virtual ~CMD_help() {
+	}
+	const char *description() const override {
+		return "打印帮助信息.";
+	}
+};
+
+class CMD_rtsp: public CMD {
+public:
+	CMD_rtsp();
+	virtual ~CMD_rtsp() {
+	}
+	const char *description() const override {
+		return "查看rtsp服务器相关信息.";
+	}
+};
+class CMD_rtmp: public CMD {
+public:
+	CMD_rtmp();
+	virtual ~CMD_rtmp() {
+	}
+	const char *description() const override {
+		return "查看rtmp服务器相关信息.";
+	}
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+} /* namespace Shell */
+} /* namespace ZL */
+
+#endif /* SRC_SHELL_CMD_H_ */