external/srs
1
0
Fork 0
mirror of https://github.com/ossrs/srs.git synced 2025-03-09 15:49:59 +00:00
Code Issues Releases Wiki Activity

remove flashP2P hss dvr, for it's a can-not-run feature. 0.9.178

Browse source
This commit is contained in:
winlin 2014-07-30 10:00:23 +08:00
parent 83d1e7288c
commit 79c641e8d6
11 changed files with 3 additions and 598 deletions
Download patch file Download diff file Expand all files Collapse all files

13
trunk/src/app/srs_app_config.cpp
View file

@ -1333,7 +1333,7 @@ int SrsConfig::check_config()
for (int j = 0; j < (int)conf0->directives.size(); j++) {
string m = conf0->at(j)->name.c_str();
if (m != "enabled" && m != "on_connect" && m != "on_close" && m != "on_publish"
&& m != "on_unpublish" && m != "on_play" && m != "on_stop" && m != "on_dvr_hss_reap_flv"
&& m != "on_unpublish" && m != "on_play" && m != "on_stop"
) {
ret = ERROR_SYSTEM_CONFIG_INVALID;
srs_error("unsupported vhost http_hooks directive %s, ret=%d", m.c_str(), ret);
@ -2096,17 +2096,6 @@ SrsConfDirective* SrsConfig::get_vhost_on_stop(string vhost)
return conf->get("on_stop");
}
SrsConfDirective* SrsConfig::get_vhost_on_dvr_hss_reap_flv(string vhost)
{
SrsConfDirective* conf = get_vhost_http_hooks(vhost);
if (!conf) {
return NULL;
}
return conf->get("on_dvr_hss_reap_flv");
}
bool SrsConfig::get_bw_check_enabled(string vhost)
{
SrsConfDirective* conf = get_vhost(vhost);

7
trunk/src/app/srs_app_config.hpp
View file

@ -51,8 +51,6 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#define SRS_CONF_DEFAULT_DVR_PATH "./objs/nginx/html"
#define SRS_CONF_DEFAULT_DVR_PLAN_SESSION "session"
#define SRS_CONF_DEFAULT_DVR_PLAN_SEGMENT "segment"
// chnvideo hss
#define SRS_CONF_DEFAULT_DVR_PLAN_HSS "hss"
#define SRS_CONF_DEFAULT_DVR_PLAN SRS_CONF_DEFAULT_DVR_PLAN_SESSION
#define SRS_CONF_DEFAULT_DVR_DURATION 30
#define SRS_CONF_DEFAULT_TIME_JITTER "full"
@ -566,11 +564,6 @@ public:
* @return the on_stop callback directive, the args is the url to callback.
*/
virtual SrsConfDirective* get_vhost_on_stop(std::string vhost);
/**
* get the on_dvr_hss_reap_flv callbacks of vhost.
* @return the on_dvr_hss_reap_flv callback directive, the args is the url to callback.
*/
virtual SrsConfDirective* get_vhost_on_dvr_hss_reap_flv(std::string vhost);
// bwct(bandwidth check tool) section
public:
/**

233
trunk/src/app/srs_app_dvr.cpp
View file

@ -318,12 +318,6 @@ int SrsDvrPlan::flv_close()
return ret;
}
#ifdef SRS_AUTO_HTTP_CALLBACK
if ((ret = on_dvr_hss_reap_flv()) != ERROR_SUCCESS) {
return ret;
}
#endif
return ret;
}
@ -366,29 +360,6 @@ int SrsDvrPlan::write_flv_header()
return ret;
}
int SrsDvrPlan::on_dvr_hss_reap_flv()
{
int ret = ERROR_SUCCESS;
#ifdef SRS_AUTO_HTTP_CALLBACK
if (!_srs_config->get_vhost_http_hooks_enabled(_req->vhost)) {
// HTTP: on_dvr_hss_reap_flv
SrsConfDirective* on_dvr_hss_reap_flv = _srs_config->get_vhost_on_dvr_hss_reap_flv(_req->vhost);
if (!on_dvr_hss_reap_flv) {
srs_info("ignore the empty http callback: on_dvr_hss_reap_flv");
return ret;
}
for (int i = 0; i < (int)on_dvr_hss_reap_flv->args.size(); i++) {
std::string url = on_dvr_hss_reap_flv->args.at(i);
SrsHttpHooks::on_dvr_hss_reap_flv(url, _req, segment);
}
}
#endif
return ret;
}
SrsDvrPlan* SrsDvrPlan::create_plan(string vhost)
{
std::string plan = _srs_config->get_dvr_plan(vhost);
@ -396,8 +367,6 @@ SrsDvrPlan* SrsDvrPlan::create_plan(string vhost)
return new SrsDvrSegmentPlan();
} else if (plan == SRS_CONF_DEFAULT_DVR_PLAN_SESSION) {
return new SrsDvrSessionPlan();
} else if (plan == SRS_CONF_DEFAULT_DVR_PLAN_HSS) {
return new SrsDvrHssPlan();
} else {
return new SrsDvrSessionPlan();
}
@ -502,208 +471,6 @@ int SrsDvrSegmentPlan::update_duration(SrsSharedPtrMessage* msg)
return ret;
}
SrsDvrHssPlan::SrsDvrHssPlan()
{
segment_duration = -1;
expect_reap_time = 0;
}
SrsDvrHssPlan::~SrsDvrHssPlan()
{
}
int SrsDvrHssPlan::initialize(SrsSource* source, SrsRequest* req)
{
int ret = ERROR_SUCCESS;
if ((ret = SrsDvrPlan::initialize(source, req)) != ERROR_SUCCESS) {
return ret;
}
// TODO: FIXME: support reload
segment_duration = _srs_config->get_dvr_duration(req->vhost);
// to ms
segment_duration *= 1000;
return ret;
}
int SrsDvrHssPlan::on_publish()
{
int ret = ERROR_SUCCESS;
// if already opened, continue to dvr.
// the segment plan maybe keep running longer than the encoder.
// for example, segment running, encoder restart,
// the segment plan will just continue going and donot open new segment.
if (fs->is_open()) {
dvr_enabled = true;
return ret;
}
if ((ret = SrsDvrPlan::on_publish()) != ERROR_SUCCESS) {
return ret;
}
// expect reap flv time
expect_reap_time = segment->stream_starttime + segment_duration;
return ret;
}
void SrsDvrHssPlan::on_unpublish()
{
// support multiple publish.
if (!dvr_enabled) {
return;
}
dvr_enabled = false;
}
int SrsDvrHssPlan::on_meta_data(SrsOnMetaDataPacket* metadata)
{
int ret = ERROR_SUCCESS;
SrsRequest* req = _req;
// new flv file
std::stringstream path;
path << _srs_config->get_dvr_path(req->vhost)
<< "/" << req->app << "/"
<< req->stream << ".header.flv";
SrsFileWriter fs;
if ((ret = fs.open(path.str().c_str())) != ERROR_SUCCESS) {
return ret;
}
SrsFlvEncoder enc;
if ((ret = enc.initialize(&fs)) != ERROR_SUCCESS) {
return ret;
}
if ((ret = enc.write_header()) != ERROR_SUCCESS) {
return ret;
}
int size = 0;
char* payload = NULL;
if ((ret = metadata->encode(size, payload)) != ERROR_SUCCESS) {
return ret;
}
SrsAutoFree(char, payload);
if ((ret = enc.write_metadata(payload, size)) != ERROR_SUCCESS) {
return ret;
}
#ifdef SRS_AUTO_HTTP_CALLBACK
if ((ret = on_dvr_hss_reap_flv_header(path.str())) != ERROR_SUCCESS) {
return ret;
}
#endif
return ret;
}
int SrsDvrHssPlan::write_flv_header()
{
int ret = ERROR_SUCCESS;
return ret;
}
int SrsDvrHssPlan::on_dvr_request_sh()
{
int ret = ERROR_SUCCESS;
return ret;
}
int SrsDvrHssPlan::on_video_keyframe()
{
int ret = ERROR_SUCCESS;
segment->sequence_header_offset = fs->tellg();
if ((ret = SrsDvrPlan::on_dvr_request_sh()) != ERROR_SUCCESS) {
return ret;
}
return ret;
}
int64_t SrsDvrHssPlan::filter_timestamp(int64_t timestamp)
{
//return timestamp;
srs_assert(segment);
srs_verbose("filter timestamp from %"PRId64" to %"PRId64, timestamp, segment->stream_starttime + timestamp);
return segment->stream_starttime + timestamp;
}
int SrsDvrHssPlan::on_dvr_hss_reap_flv_header(string path)
{
int ret = ERROR_SUCCESS;
#ifdef SRS_AUTO_HTTP_CALLBACK
if (!_srs_config->get_vhost_http_hooks_enabled(_req->vhost)) {
// HTTP: on_dvr_hss_reap_flv_header
SrsConfDirective* on_dvr_hss_reap_flv = _srs_config->get_vhost_on_dvr_hss_reap_flv(_req->vhost);
if (!on_dvr_hss_reap_flv) {
srs_info("ignore the empty http callback: on_dvr_hss_reap_flv");
return ret;
}
for (int i = 0; i < (int)on_dvr_hss_reap_flv->args.size(); i++) {
std::string url = on_dvr_hss_reap_flv->args.at(i);
SrsHttpHooks::on_dvr_hss_reap_flv_header(url, _req, path);
}
}
#endif
return ret;
}
int SrsDvrHssPlan::update_duration(SrsSharedPtrMessage* msg)
{
int ret = ERROR_SUCCESS;
if ((ret = SrsDvrPlan::update_duration(msg)) != ERROR_SUCCESS) {
return ret;
}
srs_assert(segment);
// if not initialized, ignore reap.
if (expect_reap_time <= 0
|| segment->stream_starttime <= 0
|| segment->stream_duration <= 0
) {
return ret;
}
// reap if exceed atc expect time.
if (segment->stream_starttime + segment->stream_duration > expect_reap_time) {
srs_verbose("hss reap start=%"PRId64", duration=%"PRId64", expect=%"PRId64
", segment(start=%"PRId64", duration=%"PRId64", file=%s",
segment->stream_starttime, segment->stream_duration, expect_reap_time,
segment->stream_starttime + segment->starttime,
segment->duration, segment->path.c_str());
// update expect reap time
expect_reap_time += segment_duration;
if ((ret = flv_close()) != ERROR_SUCCESS) {
segment->reset();
return ret;
}
on_unpublish();
if ((ret = open_new_segment()) != ERROR_SUCCESS) {
return ret;
}
}
return ret;
}
SrsDvr::SrsDvr(SrsSource* source)
{
_source = source;

32
trunk/src/app/srs_app_dvr.hpp
View file

@ -137,11 +137,6 @@ protected:
virtual int on_dvr_request_sh();
virtual int on_video_keyframe();
virtual int64_t filter_timestamp(int64_t timestamp);
private:
/**
* when srs reap the flv(close the segment), notice the api.
*/
virtual int on_dvr_hss_reap_flv();
public:
static SrsDvrPlan* create_plan(std::string vhost);
};
@ -177,33 +172,6 @@ private:
virtual int update_duration(SrsSharedPtrMessage* msg);
};
/**
* hss plan: use atc time to reap flv segment
*/
class SrsDvrHssPlan : public SrsDvrPlan
{
private:
// in config, in ms
int segment_duration;
int64_t expect_reap_time;
public:
SrsDvrHssPlan();
virtual ~SrsDvrHssPlan();
public:
virtual int initialize(SrsSource* source, SrsRequest* req);
virtual int on_publish();
virtual void on_unpublish();
virtual int on_meta_data(SrsOnMetaDataPacket* metadata);
protected:
virtual int write_flv_header();
virtual int on_dvr_request_sh();
virtual int on_video_keyframe();
virtual int64_t filter_timestamp(int64_t timestamp);
private:
virtual int on_dvr_hss_reap_flv_header(std::string path);
virtual int update_duration(SrsSharedPtrMessage* msg);
};
/**
* dvr(digital video recorder) to record RTMP stream to flv file.
* TODO: FIXME: add utest for it.

110
trunk/src/app/srs_app_http_hooks.cpp
View file

@ -326,114 +326,4 @@ void SrsHttpHooks::on_stop(string url, int client_id, string ip, SrsRequest* req
return;
}
#ifdef SRS_AUTO_DVR
void SrsHttpHooks::on_dvr_hss_reap_flv_header(std::string url, SrsRequest* req, std::string header_file)
{
int ret = ERROR_SUCCESS;
srs_verbose("flv header reap, file=%s", header_file.c_str());
SrsHttpUri uri;
if ((ret = uri.initialize(url)) != ERROR_SUCCESS) {
srs_warn("http uri parse on_dvr_hss_reap_flv_header url failed, ignored. "
"url=%s, ret=%d", url.c_str(), ret);
return;
}
std::stringstream ss;
ss << __SRS_JOBJECT_START
<< __SRS_JFIELD_STR("action", "on_dvr_hss_reap_flv_header") << __SRS_JFIELD_CONT
<< __SRS_JFIELD_STR("vhost", req->vhost) << __SRS_JFIELD_CONT
<< __SRS_JFIELD_STR("app", req->app) << __SRS_JFIELD_CONT
<< __SRS_JFIELD_STR("stream", req->stream) << __SRS_JFIELD_CONT
<< __SRS_JFIELD_NAME("segment") << __SRS_JOBJECT_START
<< __SRS_JFIELD_STR("cwd", _srs_config->cwd()) << __SRS_JFIELD_CONT
<< __SRS_JFIELD_STR("path", header_file)
<< __SRS_JOBJECT_END
<< __SRS_JOBJECT_END;
std::string data = ss.str();
std::string res;
SrsHttpClient http;
if ((ret = http.post(&uri, data, res)) != ERROR_SUCCESS) {
srs_warn("http post on_dvr_hss_reap_flv_header uri failed, ignored. "
"url=%s, request=%s, response=%s, ret=%d",
url.c_str(), data.c_str(), res.c_str(), ret);
return;
}
if (res.empty() || res != SRS_HTTP_RESPONSE_OK) {
ret = ERROR_HTTP_DATA_INVLIAD;
srs_warn("http hook on_dvr_hss_reap_flv_header validate failed, ignored. "
"res=%s, ret=%d", res.c_str(), ret);
return;
}
srs_info("http hook on_dvr_hss_reap_flv_header success. "
"url=%s, request=%s, response=%s, ret=%d",
url.c_str(), data.c_str(), res.c_str(), ret);
return;
}
void SrsHttpHooks::on_dvr_hss_reap_flv(string url, SrsRequest* req, SrsFlvSegment* segment)
{
int ret = ERROR_SUCCESS;
srs_assert(segment);
srs_verbose("flv segment %s, atc_start=%"PRId64", "
"has_key=%d, starttime=%"PRId64", duration=%d",
segment->path.c_str(), segment->stream_starttime,
segment->has_keyframe, segment->starttime, (int)segment->duration);
SrsHttpUri uri;
if ((ret = uri.initialize(url)) != ERROR_SUCCESS) {
srs_warn("http uri parse on_dvr_hss_reap_flv url failed, ignored. "
"url=%s, ret=%d", url.c_str(), ret);
return;
}
std::stringstream ss;
ss << __SRS_JOBJECT_START
<< __SRS_JFIELD_STR("action", "on_dvr_hss_reap_flv") << __SRS_JFIELD_CONT
<< __SRS_JFIELD_STR("vhost", req->vhost) << __SRS_JFIELD_CONT
<< __SRS_JFIELD_STR("app", req->app) << __SRS_JFIELD_CONT
<< __SRS_JFIELD_STR("stream", req->stream) << __SRS_JFIELD_CONT
<< __SRS_JFIELD_NAME("segment") << __SRS_JOBJECT_START
<< __SRS_JFIELD_STR("cwd", _srs_config->cwd()) << __SRS_JFIELD_CONT
<< __SRS_JFIELD_STR("path", segment->path) << __SRS_JFIELD_CONT
<< __SRS_JFIELD_ORG("duration", segment->duration) << __SRS_JFIELD_CONT
<< __SRS_JFIELD_ORG("offset", segment->sequence_header_offset) << __SRS_JFIELD_CONT
<< __SRS_JFIELD_ORG("has_keyframe", (segment->has_keyframe? "true":"false")) << __SRS_JFIELD_CONT
<< __SRS_JFIELD_ORG("pts", segment->stream_starttime + segment->starttime)
<< __SRS_JOBJECT_END
<< __SRS_JOBJECT_END;
std::string data = ss.str();
std::string res;
SrsHttpClient http;
if ((ret = http.post(&uri, data, res)) != ERROR_SUCCESS) {
srs_warn("http post on_dvr_hss_reap_flv uri failed, ignored. "
"url=%s, request=%s, response=%s, ret=%d",
url.c_str(), data.c_str(), res.c_str(), ret);
return;
}
if (res.empty() || res != SRS_HTTP_RESPONSE_OK) {
ret = ERROR_HTTP_DATA_INVLIAD;
srs_warn("http hook on_dvr_hss_reap_flv validate failed, ignored. "
"res=%s, ret=%d", res.c_str(), ret);
return;
}
srs_info("http hook on_dvr_hss_reap_flv success. "
"url=%s, request=%s, response=%s, ret=%d",
url.c_str(), data.c_str(), res.c_str(), ret);
return;
}
#endif
#endif

17
trunk/src/app/srs_app_http_hooks.hpp
View file

@ -98,23 +98,6 @@ public:
* ignore if empty.
*/
static void on_stop(std::string url, int client_id, std::string ip, SrsRequest* req);
#ifdef SRS_AUTO_DVR
public:
/**
* on_dvr_hss_reap_flv_header hook, when dvr write flv file header.
* @param url the api server url, to process the event.
* ignore if empty.
* @param header_file the flv header file.
*/
static void on_dvr_hss_reap_flv_header(std::string url, SrsRequest* req, std::string header_file);
/**
* on_dvr_hss_reap_flv hook, when dvr close flv file.
* @param url the api server url, to process the event.
* ignore if empty.
* @param segment the current flv segment.
*/
static void on_dvr_hss_reap_flv(std::string url, SrsRequest* req, SrsFlvSegment* segment);
#endif
};
#endif