mirror of
https://github.com/fastogt/fastocloud.git
synced 2025-03-09 23:18:50 +00:00
274 lines
6.5 KiB
C++
274 lines
6.5 KiB
C++
/* Copyright (C) 2014-2022 FastoGT. All right reserved.
|
|
This file is part of fastocloud.
|
|
fastocloud is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
fastocloud 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 General Public License for more details.
|
|
You should have received a copy of the GNU General Public License
|
|
along with fastocloud. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "stream/stypes.h"
|
|
|
|
#include <regex>
|
|
|
|
#include <common/convert2string.h>
|
|
#include <common/sprintf.h>
|
|
|
|
#define APPLICATION_HLS "application/x-hls"
|
|
#define APPLICATION_ICY "application/x-icy"
|
|
#define APPLICATION_TELETEXT "application/x-teletext"
|
|
#define APPLICATION_GZIP "application/x-gzip"
|
|
#define APPLICATION_XRTP "application/x-rtp"
|
|
|
|
#define IMAGE_PNG "image/png"
|
|
#define IMAGE_JPEG "image/jpeg"
|
|
#define SUBPICTURE_DVB "subpicture/x-dvb"
|
|
|
|
#define DEMUXER_FLV "video/x-flv"
|
|
#define DEMUXER_MPEGTS "video/mpegts"
|
|
#define DEMUXER_QUICKTIME "video/quicktime"
|
|
|
|
#define VIDEO_MPEG "video/mpeg"
|
|
#define VIDEO_H264 "video/x-h264"
|
|
#define VIDEO_H265 "video/x-h265"
|
|
#define VIDEO_VP8 "video/x-vp8"
|
|
#define VIDEO_VP9 "video/x-vp9"
|
|
|
|
#define AUDIO_MPEG "audio/mpeg"
|
|
#define AUDIO_AC3 "audio/x-ac3"
|
|
#define AUDIO_RAW "audio/x-mulaw"
|
|
#define AUDIO_OPUS "audio/x-opus"
|
|
|
|
#define RAW_VIDEO "video/x-raw"
|
|
#define RAW_AUDIO "audio/x-raw"
|
|
|
|
#define TEST_SRC_URL "unknown://test"
|
|
#define DISPLAY_SRC_URL "unknown://display"
|
|
|
|
namespace fastocloud {
|
|
namespace stream {
|
|
|
|
bool IsScreenUrl(const common::uri::GURL& url) {
|
|
return url == common::uri::GURL(SCREEN_URL);
|
|
}
|
|
|
|
bool IsDecklinkUrl(const common::uri::GURL& url) {
|
|
return url == common::uri::GURL(DECKLINK_URL);
|
|
}
|
|
|
|
bool IsDeviceOutUrl(const common::uri::GURL& url, SinkDeviceType* type) {
|
|
if (IsScreenUrl(url)) {
|
|
if (type) {
|
|
*type = SCREEN_OUTPUT;
|
|
}
|
|
return true;
|
|
} else if (IsDecklinkUrl(url)) {
|
|
if (type) {
|
|
*type = DECKLINK_OUTPUT;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool IsRecordingUrl(const common::uri::GURL& url) {
|
|
return url == common::uri::GURL(RECORDING_URL);
|
|
}
|
|
|
|
bool IsFakeUrl(const common::uri::GURL& url) {
|
|
return url == common::uri::GURL(FAKE_URL);
|
|
}
|
|
|
|
bool IsTestSrcUrl(const common::uri::GURL& url) {
|
|
return url == common::uri::GURL(TEST_SRC_URL);
|
|
}
|
|
|
|
bool IsDisplaySrcUrl(const common::uri::GURL& url) {
|
|
return url == common::uri::GURL(DISPLAY_SRC_URL);
|
|
}
|
|
|
|
bool GetElementId(const std::string& name, element_id_t* elem_id) {
|
|
if (!elem_id) {
|
|
return false;
|
|
}
|
|
|
|
static const std::regex digit_end("^([^_]+_)+([0-9]+)$");
|
|
std::smatch match_results;
|
|
if (!std::regex_match(name, match_results, digit_end)) {
|
|
return false;
|
|
}
|
|
|
|
element_id_t lid;
|
|
if (common::ConvertFromString(match_results.str(2), &lid)) {
|
|
*elem_id = lid;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool GetPadId(const std::string& name, int* pad_id) {
|
|
if (!pad_id) {
|
|
return false;
|
|
}
|
|
|
|
static const std::regex digit_end("^([^_]+_)+([0-9]+)$");
|
|
std::smatch match_results;
|
|
if (!std::regex_match(name, match_results, digit_end)) {
|
|
return false;
|
|
}
|
|
|
|
int lpad_id;
|
|
if (common::ConvertFromString(match_results.str(2), &lpad_id)) {
|
|
*pad_id = lpad_id;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool IsOtherFromType(const std::string& type, SupportedOtherType* oc) {
|
|
if (type.empty() || !oc) {
|
|
return false;
|
|
}
|
|
|
|
if (type == APPLICATION_HLS) {
|
|
*oc = APPLICATION_HLS_TYPE;
|
|
return true;
|
|
} else if (type == APPLICATION_ICY) {
|
|
*oc = APPLICATION_ICY_TYPE;
|
|
return true;
|
|
} else if (type == APPLICATION_TELETEXT) {
|
|
*oc = APPLICATION_TELETEXT_TYPE;
|
|
return true;
|
|
} else if (type == APPLICATION_GZIP) {
|
|
*oc = APPLICATION_GZIP_TYPE;
|
|
return true;
|
|
} else if (type == APPLICATION_XRTP) {
|
|
*oc = APPLICATION_XRTP_TYPE;
|
|
return true;
|
|
} else if (type == IMAGE_PNG) {
|
|
*oc = IMAGE_PNG_TYPE;
|
|
return true;
|
|
} else if (type == IMAGE_JPEG) {
|
|
*oc = IMAGE_JPEG_TYPE;
|
|
return true;
|
|
} else if (type == SUBPICTURE_DVB) {
|
|
*oc = SUBPICTURE_DVB_TYPE;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool IsDemuxerFromType(const std::string& type, SupportedDemuxer* dc) {
|
|
if (type.empty() || !dc) {
|
|
return false;
|
|
}
|
|
|
|
if (type == DEMUXER_MPEGTS) {
|
|
*dc = VIDEO_MPEGTS_DEMUXER;
|
|
return true;
|
|
} else if (type == DEMUXER_FLV) {
|
|
*dc = VIDEO_FLV_DEMUXER;
|
|
return true;
|
|
} else if (type == DEMUXER_QUICKTIME) {
|
|
*dc = VIDEO_QUICKTIME_DEMUXER;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool IsVideoCodecFromType(const std::string& type, SupportedVideoCodec* vc) {
|
|
if (type.empty() || !vc) {
|
|
return false;
|
|
}
|
|
|
|
if (type == VIDEO_MPEG) {
|
|
*vc = VIDEO_MPEG_CODEC;
|
|
return true;
|
|
} else if (type == VIDEO_H264) {
|
|
*vc = VIDEO_H264_CODEC;
|
|
return true;
|
|
} else if (type == VIDEO_H265) {
|
|
*vc = VIDEO_H265_CODEC;
|
|
return true;
|
|
} else if (type == VIDEO_VP8) {
|
|
*vc = VIDEO_VP8_CODEC;
|
|
return true;
|
|
} else if (type == VIDEO_VP9) {
|
|
*vc = VIDEO_VP9_CODEC;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool IsAudioCodecFromType(const std::string& type, SupportedAudioCodec* ac) {
|
|
if (type.empty() || !ac) {
|
|
return false;
|
|
}
|
|
|
|
if (type == AUDIO_MPEG) {
|
|
*ac = AUDIO_MPEG_CODEC;
|
|
return true;
|
|
} else if (type == AUDIO_AC3) {
|
|
*ac = AUDIO_AC3_CODEC;
|
|
return true;
|
|
} else if (type == AUDIO_OPUS) {
|
|
*ac = AUDIO_OPUS_CODEC;
|
|
return true;
|
|
} else if (type == AUDIO_RAW) {
|
|
*ac = AUDIO_RAW_CODEC;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool IsRawStreamFromType(const std::string& type, SupportedRawStream* rc) {
|
|
if (type.empty() || !rc) {
|
|
return false;
|
|
}
|
|
|
|
if (type == RAW_VIDEO) {
|
|
*rc = VIDEO_RAW_STREAM;
|
|
return true;
|
|
} else if (type == RAW_AUDIO) {
|
|
*rc = AUDIO_RAW_STREAM;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
std::string GenHttpTsTemplate(common::time64_t msec) {
|
|
return common::MemSPrintf("%llu_%s", msec, TS_TEMPLATE);
|
|
}
|
|
|
|
std::string GenVodHttpTsTemplate() {
|
|
return TS_TEMPLATE;
|
|
}
|
|
|
|
bool GetIndexFromHttpTsTemplate(const std::string& file_name, uint64_t* index) {
|
|
if (!index) {
|
|
return false;
|
|
}
|
|
|
|
std::smatch match;
|
|
static const std::regex chunk_index("^[0-9]+_([0-9]+)" CHUNK_EXT "$");
|
|
if (std::regex_match(file_name, match, chunk_index)) {
|
|
uint64_t t;
|
|
if (common::ConvertFromString(match.str(1), &t)) {
|
|
*index = t;
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
} // namespace stream
|
|
} // namespace fastocloud
|