466f6b4fc4
The HTTP Streamer can be enabled via the _streamer_enabled_ daemon parameter. When the Streamer is active the daemon starts capturing the configured _Sinks_ up to the maximum number of channels configured by the _streamer_channels_ parameters. The captured PCM samples are split into _streamer_files_num_ files of _streamer_file_duration_ duration (in seconds) for each sink, compressed using AAC LC codec and served via HTTP. The HTTP streamer requires the libfaac-dev package to compile. Please note that since the HTTP Streamer uses the RAVENNA ALSA device for capturing it's not possible to use such device for other audio captures.
634 lines
23 KiB
C++
634 lines
23 KiB
C++
//
|
|
// json.cpp
|
|
//
|
|
// Copyright (c) 2019 2020 Andrea Bondavalli. All rights reserved.
|
|
//
|
|
// This program 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
|
|
// any later version.
|
|
//
|
|
// This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
|
|
//
|
|
|
|
#include <boost/foreach.hpp>
|
|
#include <boost/property_tree/json_parser.hpp>
|
|
#include <boost/property_tree/ptree.hpp>
|
|
#include <iostream>
|
|
#include <regex>
|
|
#include <string>
|
|
#include <chrono>
|
|
|
|
#include "log.hpp"
|
|
#include "utils.hpp"
|
|
#include "json.hpp"
|
|
|
|
using namespace std::chrono;
|
|
using second_t = duration<double, std::ratio<1> >;
|
|
|
|
static inline std::string remove_undesired_chars(const std::string& s) {
|
|
std::regex html_regex("[^ A-Za-z0-9:~.,_/=%()\\r\\n\\t\?#-]?");
|
|
return std::regex_replace(s, html_regex, "");
|
|
}
|
|
|
|
static std::string escape_json(const std::string& js) {
|
|
std::string s(remove_undesired_chars(js));
|
|
std::ostringstream ss;
|
|
for (auto c = s.cbegin(); c != s.cend(); c++) {
|
|
switch (*c) {
|
|
case '"':
|
|
ss << "\\\"";
|
|
break;
|
|
case '\\':
|
|
ss << "\\\\";
|
|
break;
|
|
case '\b':
|
|
ss << "\\b";
|
|
break;
|
|
case '\f':
|
|
ss << "\\f";
|
|
break;
|
|
case '\n':
|
|
ss << "\\n";
|
|
break;
|
|
case '\r':
|
|
ss << "\\r";
|
|
break;
|
|
case '\t':
|
|
ss << "\\t";
|
|
break;
|
|
default:
|
|
if ('\x00' <= *c && *c <= '\x1f') {
|
|
ss << "\\u" << std::hex << std::setw(4) << std::setfill('0')
|
|
<< (int)*c;
|
|
} else {
|
|
ss << *c;
|
|
}
|
|
}
|
|
}
|
|
return ss.str();
|
|
}
|
|
|
|
std::string config_to_json(const Config& config) {
|
|
std::stringstream ss;
|
|
ss << "{"
|
|
<< "\n \"http_port\": " << config.get_http_port()
|
|
<< ",\n \"rtsp_port\": " << config.get_rtsp_port()
|
|
<< ",\n \"http_base_dir\": \"" << config.get_http_base_dir() << "\""
|
|
<< ",\n \"log_severity\": " << config.get_log_severity()
|
|
<< ",\n \"playout_delay\": " << config.get_playout_delay()
|
|
<< ",\n \"tic_frame_size_at_1fs\": " << config.get_tic_frame_size_at_1fs()
|
|
<< ",\n \"max_tic_frame_size\": " << config.get_max_tic_frame_size()
|
|
<< ",\n \"sample_rate\": " << config.get_sample_rate()
|
|
<< ",\n \"rtp_mcast_base\": \""
|
|
<< escape_json(config.get_rtp_mcast_base()) << "\""
|
|
<< ",\n \"rtp_port\": " << config.get_rtp_port()
|
|
<< ",\n \"ptp_domain\": " << unsigned(config.get_ptp_domain())
|
|
<< ",\n \"ptp_dscp\": " << unsigned(config.get_ptp_dscp())
|
|
<< ",\n \"sap_mcast_addr\": \""
|
|
<< escape_json(config.get_sap_mcast_addr()) << "\""
|
|
<< ",\n \"sap_interval\": " << config.get_sap_interval()
|
|
<< ",\n \"syslog_proto\": \"" << escape_json(config.get_syslog_proto())
|
|
<< "\""
|
|
<< ",\n \"syslog_server\": \"" << escape_json(config.get_syslog_server())
|
|
<< "\""
|
|
<< ",\n \"status_file\": \"" << escape_json(config.get_status_file())
|
|
<< "\""
|
|
<< ",\n \"interface_name\": \""
|
|
<< escape_json(config.get_interface_name()) << "\""
|
|
<< ",\n \"mdns_enabled\": " << std::boolalpha << config.get_mdns_enabled()
|
|
<< ",\n \"custom_node_id\": \""
|
|
<< escape_json(config.get_custom_node_id()) << "\""
|
|
<< ",\n \"node_id\": \"" << escape_json(config.get_node_id()) << "\""
|
|
<< ",\n \"ptp_status_script\": \""
|
|
<< escape_json(config.get_ptp_status_script()) << "\""
|
|
<< ",\n \"mac_addr\": \"" << escape_json(config.get_mac_addr_str())
|
|
<< "\""
|
|
<< ",\n \"ip_addr\": \"" << escape_json(config.get_ip_addr_str()) << "\""
|
|
<< ",\n \"streamer_channels\": "
|
|
<< unsigned(config.get_streamer_channels())
|
|
<< ",\n \"streamer_files_num\": "
|
|
<< unsigned(config.get_streamer_files_num())
|
|
<< ",\n \"streamer_file_duration\": "
|
|
<< unsigned(config.get_streamer_file_duration())
|
|
<< ",\n \"streamer_player_buffer_files_num\": "
|
|
<< unsigned(config.get_streamer_player_buffer_files_num())
|
|
<< ",\n \"streamer_enabled\": " << std::boolalpha
|
|
<< config.get_streamer_enabled()
|
|
<< ",\n \"auto_sinks_update\": " << std::boolalpha
|
|
<< config.get_auto_sinks_update() << "\n}\n";
|
|
return ss.str();
|
|
}
|
|
|
|
std::string source_to_json(const StreamSource& source) {
|
|
std::stringstream ss;
|
|
ss << "\n {"
|
|
<< "\n \"id\": " << unsigned(source.id)
|
|
<< ",\n \"enabled\": " << std::boolalpha << source.enabled
|
|
<< ",\n \"name\": \"" << escape_json(source.name) << "\""
|
|
<< ",\n \"io\": \"" << escape_json(source.io) << "\""
|
|
<< ",\n \"max_samples_per_packet\": " << source.max_samples_per_packet
|
|
<< ",\n \"codec\": \"" << escape_json(source.codec) << "\""
|
|
<< ",\n \"address\": \"" << escape_json(source.address) << "\""
|
|
<< ",\n \"ttl\": " << unsigned(source.ttl)
|
|
<< ",\n \"payload_type\": " << unsigned(source.payload_type)
|
|
<< ",\n \"dscp\": " << +unsigned(source.dscp)
|
|
<< ",\n \"refclk_ptp_traceable\": " << std::boolalpha
|
|
<< source.refclk_ptp_traceable << ",\n \"map\": [ ";
|
|
int i = 0;
|
|
for (int value : source.map) {
|
|
if (i++ > 0)
|
|
ss << ", ";
|
|
ss << value;
|
|
}
|
|
ss << " ]\n }";
|
|
return ss.str();
|
|
}
|
|
|
|
std::string sink_to_json(const StreamSink& sink) {
|
|
std::stringstream ss;
|
|
ss << "\n {"
|
|
<< "\n \"id\": " << unsigned(sink.id) << ",\n \"name\": \""
|
|
<< escape_json(sink.name) << "\""
|
|
<< ",\n \"io\": \"" << escape_json(sink.io) << "\""
|
|
<< ",\n \"use_sdp\": " << std::boolalpha << sink.use_sdp
|
|
<< ",\n \"source\": \"" << escape_json(sink.source) << "\""
|
|
<< ",\n \"sdp\": \"" << escape_json(sink.sdp) << "\""
|
|
<< ",\n \"delay\": " << sink.delay
|
|
<< ",\n \"ignore_refclk_gmid\": " << std::boolalpha
|
|
<< sink.ignore_refclk_gmid << ",\n \"map\": [ ";
|
|
int i = 0;
|
|
for (int value : sink.map) {
|
|
if (i++ > 0)
|
|
ss << ", ";
|
|
ss << value;
|
|
}
|
|
ss << " ]\n }";
|
|
return ss.str();
|
|
}
|
|
|
|
std::string sink_status_to_json(const SinkStreamStatus& status) {
|
|
std::stringstream ss;
|
|
ss << "{";
|
|
ss << "\n \"sink_flags\":\n {" << std::boolalpha
|
|
<< " \n \"rtp_seq_id_error\": " << status.is_rtp_seq_id_error
|
|
<< ", \n \"rtp_ssrc_error\": " << status.is_rtp_ssrc_error
|
|
<< ", \n \"rtp_payload_type_error\": "
|
|
<< status.is_rtp_payload_type_error
|
|
<< ", \n \"rtp_sac_error\": " << status.is_rtp_sac_error
|
|
<< ", \n \"receiving_rtp_packet\": " << status.is_receiving_rtp_packet
|
|
<< ", \n \"some_muted\": " << status.is_some_muted
|
|
<< ", \n \"all_muted\": " << status.is_all_muted
|
|
<< ", \n \"muted\": " << status.is_muted << "\n },"
|
|
<< "\n \"sink_min_time\": " << status.min_time << "\n}\n";
|
|
return ss.str();
|
|
}
|
|
|
|
std::string ptp_config_to_json(const PTPConfig& ptp_config) {
|
|
std::stringstream ss;
|
|
ss << "{"
|
|
<< " \"domain\": " << unsigned(ptp_config.domain)
|
|
<< ", \"dscp\": " << unsigned(ptp_config.dscp) << " }\n";
|
|
return ss.str();
|
|
}
|
|
|
|
std::string ptp_status_to_json(const PTPStatus& status) {
|
|
std::stringstream ss;
|
|
ss << "{"
|
|
<< " \"status\": \"" << escape_json(status.status) << "\""
|
|
<< ", \"gmid\": \"" << escape_json(status.gmid) << "\""
|
|
<< ", \"jitter\": " << status.jitter << " }\n";
|
|
return ss.str();
|
|
}
|
|
|
|
std::string sources_to_json(const std::list<StreamSource>& sources) {
|
|
int count = 0;
|
|
std::stringstream ss;
|
|
ss << "{\n \"sources\": [";
|
|
for (auto const& source : sources) {
|
|
if (count++) {
|
|
ss << ", ";
|
|
}
|
|
ss << source_to_json(source);
|
|
}
|
|
ss << " ]\n}\n";
|
|
return ss.str();
|
|
}
|
|
|
|
std::string sinks_to_json(const std::list<StreamSink>& sinks) {
|
|
int count = 0;
|
|
std::stringstream ss;
|
|
ss << "{\n \"sinks\": [";
|
|
for (auto const& sink : sinks) {
|
|
if (count++) {
|
|
ss << ", ";
|
|
}
|
|
ss << sink_to_json(sink);
|
|
}
|
|
ss << " ]\n}\n";
|
|
return ss.str();
|
|
}
|
|
|
|
std::string streams_to_json(const std::list<StreamSource>& sources,
|
|
const std::list<StreamSink>& sinks) {
|
|
int count = 0;
|
|
std::stringstream ss;
|
|
ss << "{\n \"sources\": [";
|
|
for (auto const& source : sources) {
|
|
if (count++) {
|
|
ss << ", ";
|
|
}
|
|
ss << source_to_json(source);
|
|
}
|
|
count = 0;
|
|
ss << " ],\n \"sinks\": [";
|
|
for (auto const& sink : sinks) {
|
|
if (count++) {
|
|
ss << ", ";
|
|
}
|
|
ss << sink_to_json(sink);
|
|
}
|
|
ss << " ]\n}\n";
|
|
return ss.str();
|
|
}
|
|
|
|
std::string remote_source_to_json(const RemoteSource& source) {
|
|
std::stringstream ss;
|
|
ss << "\n {"
|
|
<< "\n \"source\": \"" << escape_json(source.source) << "\""
|
|
<< ",\n \"id\": \"" << escape_json(source.id) << "\""
|
|
<< ",\n \"name\": \"" << escape_json(source.name) << "\""
|
|
<< ",\n \"domain\": \"" << escape_json(source.domain) << "\""
|
|
<< ",\n \"address\": \"" << escape_json(source.address) << "\""
|
|
<< ",\n \"sdp\": \"" << escape_json(source.sdp) << "\""
|
|
<< ",\n \"last_seen\": "
|
|
<< unsigned(duration_cast<second_t>(steady_clock::now() -
|
|
source.last_seen_timepoint)
|
|
.count())
|
|
<< ",\n \"announce_period\": " << unsigned(source.announce_period)
|
|
<< " \n }";
|
|
return ss.str();
|
|
}
|
|
|
|
std::string remote_sources_to_json(const std::list<RemoteSource>& sources) {
|
|
int count = 0;
|
|
std::stringstream ss;
|
|
ss << "{\n \"remote_sources\": [";
|
|
for (auto const& source : sources) {
|
|
if (count++) {
|
|
ss << ", ";
|
|
}
|
|
ss << remote_source_to_json(source);
|
|
}
|
|
ss << " ]\n}\n";
|
|
return ss.str();
|
|
}
|
|
|
|
std::string streamer_info_to_json(const StreamerInfo& info) {
|
|
std::stringstream ss;
|
|
ss << "{"
|
|
<< "\n \"status\": " << unsigned(info.status)
|
|
<< ",\n \"file_duration\": " << unsigned(info.file_duration)
|
|
<< ",\n \"files_num\": " << unsigned(info.files_num)
|
|
<< ",\n \"player_buffer_files_num\": " << unsigned(info.player_buffer_files_num)
|
|
<< ",\n \"start_file_id\": " << unsigned(info.start_file_id)
|
|
<< ",\n \"current_file_id\": " << unsigned(info.current_file_id)
|
|
<< ",\n \"channels\": " << unsigned(info.channels)
|
|
<< ",\n \"format\": \"" << info.format << "\""
|
|
<< ",\n \"rate\": " << unsigned(info.rate) << "\n}\n";
|
|
return ss.str();
|
|
}
|
|
|
|
Config json_to_config_(std::istream& js, Config& config) {
|
|
try {
|
|
boost::property_tree::ptree pt;
|
|
boost::property_tree::read_json(js, pt);
|
|
|
|
for (auto const& [key, val] : pt) {
|
|
if (key == "http_port") {
|
|
config.set_http_port(val.get_value<int>());
|
|
} else if (key == "rtsp_port") {
|
|
config.set_rtsp_port(val.get_value<int>());
|
|
} else if (key == "http_base_dir") {
|
|
config.set_http_base_dir(
|
|
remove_undesired_chars(val.get_value<std::string>()));
|
|
} else if (key == "streamer_channels") {
|
|
config.set_streamer_channels(val.get_value<uint8_t>());
|
|
} else if (key == "streamer_files_num") {
|
|
config.set_streamer_files_num(val.get_value<uint8_t>());
|
|
} else if (key == "streamer_file_duration") {
|
|
config.set_streamer_file_duration(val.get_value<uint16_t>());
|
|
} else if (key == "streamer_player_buffer_files_num") {
|
|
config.set_streamer_player_buffer_files_num(val.get_value<uint8_t>());
|
|
} else if (key == "streamer_enabled") {
|
|
config.set_streamer_enabled(val.get_value<bool>());
|
|
} else if (key == "log_severity") {
|
|
config.set_log_severity(val.get_value<int>());
|
|
} else if (key == "interface_name") {
|
|
config.set_interface_name(
|
|
remove_undesired_chars(val.get_value<std::string>()));
|
|
} else if (key == "playout_delay") {
|
|
config.set_playout_delay(val.get_value<uint32_t>());
|
|
} else if (key == "tic_frame_size_at_1fs") {
|
|
config.set_tic_frame_size_at_1fs(val.get_value<uint32_t>());
|
|
} else if (key == "max_tic_frame_size") {
|
|
config.set_max_tic_frame_size(val.get_value<uint32_t>());
|
|
} else if (key == "sample_rate") {
|
|
config.set_sample_rate(val.get_value<uint32_t>());
|
|
} else if (key == "rtp_mcast_base") {
|
|
config.set_rtp_mcast_base(
|
|
remove_undesired_chars(val.get_value<std::string>()));
|
|
} else if (key == "rtp_port") {
|
|
config.set_rtp_port(val.get_value<uint16_t>());
|
|
} else if (key == "ptp_domain") {
|
|
config.set_ptp_domain(val.get_value<uint8_t>());
|
|
} else if (key == "ptp_dscp") {
|
|
config.set_ptp_dscp(val.get_value<uint8_t>());
|
|
} else if (key == "sap_mcast_addr") {
|
|
config.set_sap_mcast_addr(
|
|
remove_undesired_chars(val.get_value<std::string>()));
|
|
} else if (key == "sap_interval") {
|
|
config.set_sap_interval(val.get_value<uint16_t>());
|
|
} else if (key == "mdns_enabled") {
|
|
config.set_mdns_enabled(val.get_value<bool>());
|
|
} else if (key == "status_file") {
|
|
config.set_status_file(
|
|
remove_undesired_chars(val.get_value<std::string>()));
|
|
} else if (key == "syslog_proto") {
|
|
config.set_syslog_proto(
|
|
remove_undesired_chars(val.get_value<std::string>()));
|
|
} else if (key == "syslog_server") {
|
|
config.set_syslog_server(
|
|
remove_undesired_chars(val.get_value<std::string>()));
|
|
} else if (key == "ptp_status_script") {
|
|
config.set_ptp_status_script(
|
|
remove_undesired_chars(val.get_value<std::string>()));
|
|
} else if (key == "custom_node_id") {
|
|
config.set_custom_node_id(
|
|
remove_undesired_chars(val.get_value<std::string>()));
|
|
} else if (key == "auto_sinks_update") {
|
|
config.set_auto_sinks_update(val.get_value<bool>());
|
|
} else if (key == "mac_addr" || key == "ip_addr" || key == "node_id") {
|
|
/* ignored */
|
|
} else {
|
|
std::cerr << "Warning: unkown configuration option " << key
|
|
<< std::endl;
|
|
}
|
|
}
|
|
} catch (boost::property_tree::json_parser::json_parser_error& je) {
|
|
throw std::runtime_error("error parsing JSON at line " +
|
|
std::to_string(je.line()) + " :" + je.message());
|
|
} catch (std::invalid_argument& e) {
|
|
throw std::runtime_error(
|
|
"error parsing JSON: cannot perform number conversion");
|
|
} catch (std::out_of_range& e) {
|
|
throw std::runtime_error(
|
|
"error parsing JSON: number conversion out of range");
|
|
} catch (std::exception& e) {
|
|
throw std::runtime_error("error parsing JSON: " + std::string(e.what()));
|
|
}
|
|
return config;
|
|
}
|
|
|
|
Config json_to_config(std::istream& js, const Config& curConfig) {
|
|
Config config(curConfig);
|
|
return json_to_config_(js, config);
|
|
}
|
|
|
|
Config json_to_config(std::istream& js) {
|
|
Config config;
|
|
return json_to_config_(js, config);
|
|
}
|
|
|
|
Config json_to_config(const std::string& json, const Config& curConfig) {
|
|
std::stringstream ss(json);
|
|
return json_to_config(ss, curConfig);
|
|
}
|
|
|
|
Config json_to_config(const std::string& json) {
|
|
std::stringstream ss(json);
|
|
return json_to_config(ss);
|
|
}
|
|
|
|
StreamSource json_to_source(const std::string& id, const std::string& json) {
|
|
/* JSON request
|
|
"enabled": true,
|
|
"name": "ALSA (on ubuntu)_1",
|
|
"io": "Audio Device",
|
|
"map": [ 0, 1, 2, 3, 4, 5, 6, 7 ],
|
|
"max_samples_per_packet": 48,
|
|
"codec": "L24",
|
|
"address": "",
|
|
"ttl": 15,
|
|
"payload_type": 98,
|
|
"dscp": 34,
|
|
"refclk_ptp_traceable": false
|
|
*/
|
|
StreamSource source;
|
|
try {
|
|
boost::property_tree::ptree pt;
|
|
std::stringstream ss(json);
|
|
boost::property_tree::read_json(ss, pt);
|
|
|
|
source.id = std::stoi(id);
|
|
source.enabled = pt.get<bool>("enabled");
|
|
source.name = remove_undesired_chars(pt.get<std::string>("name"));
|
|
source.io = remove_undesired_chars(pt.get<std::string>("io"));
|
|
/* source map determite the association with
|
|
ALSA output channels used to playing */
|
|
BOOST_FOREACH (boost::property_tree::ptree::value_type& v,
|
|
pt.get_child("map")) {
|
|
source.map.emplace_back(std::stoi(v.second.data()));
|
|
}
|
|
source.max_samples_per_packet = pt.get<uint32_t>("max_samples_per_packet");
|
|
source.codec = remove_undesired_chars(pt.get<std::string>("codec"));
|
|
source.address = remove_undesired_chars(pt.get<std::string>("address"));
|
|
source.ttl = pt.get<uint8_t>("ttl");
|
|
source.payload_type = pt.get<uint8_t>("payload_type");
|
|
source.dscp = pt.get<uint8_t>("dscp");
|
|
source.refclk_ptp_traceable = pt.get<bool>("refclk_ptp_traceable");
|
|
} catch (boost::property_tree::json_parser::json_parser_error& je) {
|
|
throw std::runtime_error("error parsing JSON at line " +
|
|
std::to_string(je.line()) + " :" + je.message());
|
|
} catch (std::invalid_argument& e) {
|
|
throw std::runtime_error(
|
|
"error parsing JSON: cannot perform number conversion");
|
|
} catch (std::out_of_range& e) {
|
|
throw std::runtime_error(
|
|
"error parsing JSON: number conversion out of range");
|
|
} catch (std::exception& e) {
|
|
throw std::runtime_error("error parsing JSON: " + std::string(e.what()));
|
|
}
|
|
return source;
|
|
}
|
|
|
|
StreamSink json_to_sink(const std::string& id, const std::string& json) {
|
|
/* JSON request
|
|
"name": "ALSA (on ubuntu)_1",
|
|
"io": "Audio Device",
|
|
"use_sdp": true,
|
|
"source": "...",
|
|
"sdp": "...",
|
|
"delay": 384,
|
|
"ignore_refclk_gmid": false,
|
|
"map": [ 0, 1, 2, 3, 4, 5, 6, 7 ]
|
|
*/
|
|
StreamSink sink;
|
|
try {
|
|
boost::property_tree::ptree pt;
|
|
std::stringstream ss(json);
|
|
boost::property_tree::read_json(ss, pt);
|
|
|
|
sink.id = std::stoi(id);
|
|
sink.name = remove_undesired_chars(pt.get<std::string>("name"));
|
|
sink.io = remove_undesired_chars(pt.get<std::string>("io"));
|
|
sink.source = remove_undesired_chars(pt.get<std::string>("source"));
|
|
sink.use_sdp = pt.get<bool>("use_sdp");
|
|
sink.sdp = remove_undesired_chars(pt.get<std::string>("sdp"));
|
|
sink.delay = pt.get<uint32_t>("delay");
|
|
sink.ignore_refclk_gmid = pt.get<bool>("ignore_refclk_gmid");
|
|
/* source map determite the association with
|
|
ALSA input channels used to recording */
|
|
BOOST_FOREACH (boost::property_tree::ptree::value_type& v,
|
|
pt.get_child("map")) {
|
|
sink.map.emplace_back(std::stoi(v.second.data()));
|
|
}
|
|
} catch (boost::property_tree::json_parser::json_parser_error& je) {
|
|
throw std::runtime_error("error parsing JSON at line " +
|
|
std::to_string(je.line()) + " :" + je.message());
|
|
} catch (std::invalid_argument& e) {
|
|
throw std::runtime_error(
|
|
"error parsing JSON: cannot perform number conversion");
|
|
} catch (std::out_of_range& e) {
|
|
throw std::runtime_error(
|
|
"error parsing JSON: number conversion out of range");
|
|
} catch (std::exception& e) {
|
|
throw std::runtime_error("error parsing JSON: " + std::string(e.what()));
|
|
}
|
|
return sink;
|
|
}
|
|
|
|
PTPConfig json_to_ptp_config(const std::string& json) {
|
|
PTPConfig ptpConfig;
|
|
try {
|
|
boost::property_tree::ptree pt;
|
|
std::stringstream ss(json);
|
|
boost::property_tree::read_json(ss, pt);
|
|
|
|
ptpConfig.domain = pt.get<int>("domain");
|
|
ptpConfig.dscp = pt.get<int>("dscp");
|
|
} catch (boost::property_tree::json_parser::json_parser_error& je) {
|
|
throw std::runtime_error("error parsing JSON at line " +
|
|
std::to_string(je.line()) + " :" + je.message());
|
|
}
|
|
return ptpConfig;
|
|
}
|
|
|
|
void json_to_sources(const std::string& json,
|
|
std::list<StreamSource>& sources) {
|
|
std::stringstream ss(json);
|
|
return json_to_sources(ss, sources);
|
|
}
|
|
|
|
static void parse_json_sources(boost::property_tree::ptree& pt,
|
|
std::list<StreamSource>& sources) {
|
|
BOOST_FOREACH (auto const& v, pt.get_child("sources")) {
|
|
StreamSource source;
|
|
source.id = v.second.get<uint8_t>("id");
|
|
source.enabled = v.second.get<bool>("enabled");
|
|
source.name = v.second.get<std::string>("name");
|
|
source.io = v.second.get<std::string>("io");
|
|
source.max_samples_per_packet =
|
|
v.second.get<uint32_t>("max_samples_per_packet");
|
|
source.codec = v.second.get<std::string>("codec");
|
|
source.address = v.second.get<std::string>("address");
|
|
source.ttl = v.second.get<uint8_t>("ttl");
|
|
source.payload_type = v.second.get<uint8_t>("payload_type");
|
|
source.dscp = v.second.get<uint8_t>("dscp");
|
|
source.refclk_ptp_traceable = v.second.get<bool>("refclk_ptp_traceable");
|
|
/* source map determite the association with
|
|
ALSA output channels used to playing */
|
|
BOOST_FOREACH (const boost::property_tree::ptree::value_type& vm,
|
|
v.second.get_child("map")) {
|
|
source.map.emplace_back(std::stoi(vm.second.data()));
|
|
}
|
|
sources.emplace_back(std::move(source));
|
|
}
|
|
}
|
|
|
|
void json_to_sources(std::istream& js, std::list<StreamSource>& sources) {
|
|
try {
|
|
boost::property_tree::ptree pt;
|
|
boost::property_tree::read_json(js, pt);
|
|
parse_json_sources(pt, sources);
|
|
} catch (boost::property_tree::json_parser::json_parser_error& je) {
|
|
throw std::runtime_error("error parsing JSON at line " +
|
|
std::to_string(je.line()) + " :" + je.message());
|
|
}
|
|
}
|
|
|
|
void json_to_sinks(const std::string& json, std::list<StreamSink>& sinks) {
|
|
std::stringstream ss(json);
|
|
return json_to_sinks(ss, sinks);
|
|
}
|
|
|
|
static void parse_json_sinks(boost::property_tree::ptree& pt,
|
|
std::list<StreamSink>& sinks) {
|
|
BOOST_FOREACH (auto const& v, pt.get_child("sinks")) {
|
|
StreamSink sink;
|
|
sink.id = v.second.get<uint8_t>("id");
|
|
sink.name = v.second.get<std::string>("name");
|
|
sink.io = v.second.get<std::string>("io");
|
|
sink.source = v.second.get<std::string>("source");
|
|
sink.use_sdp = v.second.get<bool>("use_sdp");
|
|
sink.sdp = v.second.get<std::string>("sdp");
|
|
sink.delay = v.second.get<uint32_t>("delay");
|
|
sink.ignore_refclk_gmid = v.second.get<bool>("ignore_refclk_gmid");
|
|
/* source map determite the association with
|
|
ALSA input channels used to recording */
|
|
BOOST_FOREACH (const boost::property_tree::ptree::value_type& vm,
|
|
v.second.get_child("map")) {
|
|
sink.map.emplace_back(std::stoi(vm.second.data()));
|
|
}
|
|
sinks.emplace_back(std::move(sink));
|
|
}
|
|
}
|
|
|
|
void json_to_sinks(std::istream& js, std::list<StreamSink>& sinks) {
|
|
try {
|
|
boost::property_tree::ptree pt;
|
|
boost::property_tree::read_json(js, pt);
|
|
parse_json_sinks(pt, sinks);
|
|
} catch (boost::property_tree::json_parser::json_parser_error& je) {
|
|
throw std::runtime_error("error parsing JSON at line " +
|
|
std::to_string(je.line()) + " :" + je.message());
|
|
}
|
|
}
|
|
|
|
void json_to_streams(const std::string& json,
|
|
std::list<StreamSource>& sources,
|
|
std::list<StreamSink>& sinks) {
|
|
std::stringstream ss(json);
|
|
json_to_streams(ss, sources, sinks);
|
|
}
|
|
|
|
void json_to_streams(std::istream& js,
|
|
std::list<StreamSource>& sources,
|
|
std::list<StreamSink>& sinks) {
|
|
try {
|
|
boost::property_tree::ptree pt;
|
|
boost::property_tree::read_json(js, pt);
|
|
parse_json_sources(pt, sources);
|
|
parse_json_sinks(pt, sinks);
|
|
} catch (boost::property_tree::json_parser::json_parser_error& je) {
|
|
throw std::runtime_error("error parsing JSON at line " +
|
|
std::to_string(je.line()) + " :" + je.message());
|
|
}
|
|
}
|