/**
 * gst_rtsp_range_to_string:
 * @range: a #GstRTSPTimeRange
 *
 * Convert @range into a string representation.
 *
 * Returns: The string representation of @range. g_free() after usage.
 */
gchar *
gst_rtsp_range_to_string (const GstRTSPTimeRange * range)
{
  GString *string;

  g_return_val_if_fail (range != NULL, NULL);

  switch (range->unit) {
    case GST_RTSP_RANGE_NPT:
      string = g_string_new ("npt=");
      break;
    case GST_RTSP_RANGE_SMPTE:
    case GST_RTSP_RANGE_SMPTE_30_DROP:
      string = g_string_new ("smpte=");
      break;
    case GST_RTSP_RANGE_SMPTE_25:
      string = g_string_new ("smpte-25=");
      break;
    case GST_RTSP_RANGE_CLOCK:
      string = g_string_new ("clock=");
      break;
    default:
      goto not_implemented;
  }

  if (!range_to_string (range, string))
    goto format_failed;

  return g_string_free (string, FALSE);

  /* ERRORS */
not_implemented:
  {
    g_warning ("time range unit not yet implemented");
    return NULL;
  }
format_failed:
  {
    g_string_free (string, TRUE);
    return NULL;
  }
}
Exemplo n.º 2
0
static std::string serialize_values(const option_values_t &option_values)
{
	std::vector<std::string> values;

	std::visit(visitor{
			[&](const std::monostate &arg)
			{
				values.push_back("true");
			},
		        [&](const std::unordered_map<std::string,
			    std::string> &arg)
			{
				values.reserve(arg.size());

				for (const auto &v:arg)
					values.push_back(v.first);
			},
		        [&](const std::unordered_map<std::string,
			    std::u32string> &arg)
			{
				values.reserve(arg.size());

				for (const auto &v:arg)
					values.push_back(v.first);
			},
		        [&](const std::unordered_map<int, std::string> &arg)
			{
				values.reserve(arg.size());

				for (const auto &v:arg)
					values.push_back(std::to_string
							 (v.first));
			},
		        [&](const std::unordered_map<int, std::u32string> &arg)
			{
				values.reserve(arg.size());

				for (const auto &v:arg)
					values.push_back(std::to_string
							 (v.first));
			},
		        [&](const std::unordered_set<int> &arg)
			{
				values.reserve(arg.size());

				for (const auto &v:arg)
					values.push_back(std::to_string(v));
			},
		        [&](const std::unordered_set<bool> &arg)
			{
				values.reserve(arg.size());

				for (const auto &v:arg)
					values.push_back(v? "true":"false");
			},
		        [&](const std::vector<resolution> &arg)
			{
				values.reserve(arg.size());

				for (const auto &r:arg)
				{
					values.push_back(std::to_string
							 (r.xres) + "x" +
							 std::to_string
							 (r.yres) +
							 (r.units ==
							  resolution::per_inch
							  ? "dpi":"dpcm"));
				}
			},
		        [&](const std::vector<std::tuple<int, int>> &arg)
			{
				values.push_back(range_to_string(arg));
			},
			[&](const std::vector<const_collection> &arg)
			{
				values.reserve(arg.size());
				for (const auto &r:arg)
				{
					values.push_back
						(std::string{"{"} +
						 serialize_collection(r) +
						 std::string{"}"});
				}
			}

		}, option_values);

	return join(values, ",");
}
Exemplo n.º 3
0
 static inline std::string to_string(Container const& container, std::string const& sep_each = " ",
                                     std::string const& pre_each = "") {
   return range_to_string(container, sep_each, pre_each);
 }