Init FastoCloud on Github

src/stream/stypes.cpp

@@ -0,0 +1,274 @@
+/*  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