bool GstVideoCodec::start() {
hide();
if (0 == quid_->pmanage<MPtr(&PContainer::get<Selection<>::index_t>)>(codec_id_)) return true;
shmsink_sub_ = std::make_unique<GstShmdataSubscriber>(
shm_encoded_.get_raw(),
[this](const std::string& caps) {
this->quid_->graft_tree(
".shmdata.writer." + shm_encoded_path_,
ShmdataUtils::make_tree(caps, ShmdataUtils::get_category(caps), ShmdataStat()));
},
ShmdataStat::make_tree_updater(quid_, ".shmdata.writer." + shm_encoded_path_));
shmsrc_sub_ = std::make_unique<GstShmdataSubscriber>(
shmsrc_.get_raw(),
[this](const std::string& caps) {
this->quid_->graft_tree(
".shmdata.reader." + shmpath_to_encode_,
ShmdataUtils::make_tree(caps, ShmdataUtils::get_category(caps), ShmdataStat()));
},
ShmdataStat::make_tree_updater(quid_, ".shmdata.reader." + shmpath_to_encode_));
make_bin();
g_object_set(G_OBJECT(gst_pipeline_->get_pipeline()), "async-handling", TRUE, nullptr);
if (copy_buffers_) g_object_set(G_OBJECT(shmsrc_.get_raw()), "copy-buffers", TRUE, nullptr);
gst_pipeline_->play(true);
return true;
}
bool PulseSink::on_shmdata_connect(const std::string& shmpath) {
pmanage<MPtr(&PContainer::disable)>(devices_enum_id_, ShmdataConnector::disabledWhenConnectedMsg);
shmpath_ = shmpath;
g_object_set(G_OBJECT(shmsrc_.get_raw()), "socket-path", shmpath_.c_str(), nullptr);
if (!devices_.empty())
g_object_set(G_OBJECT(pulsesink_.get_raw()),
"device",
devices_.at(devices_enum_.get()).name_.c_str(),
nullptr);
shm_sub_ = std::make_unique<GstShmdataSubscriber>(
shmsrc_.get_raw(),
[this](const std::string& caps) {
this->graft_tree(
".shmdata.reader." + shmpath_,
ShmdataUtils::make_tree(caps, ShmdataUtils::get_category(caps), ShmdataStat()));
},
ShmdataStat::make_tree_updater(this, ".shmdata.reader." + shmpath_));
gst_bin_add_many(GST_BIN(gst_pipeline_->get_pipeline()),
shmsrc_.get_raw(),
audioconvert_.get_raw(),
pulsesink_.get_raw(),
nullptr);
gst_element_link_many(shmsrc_.get_raw(), audioconvert_.get_raw(), pulsesink_.get_raw(), nullptr);
gst_pipeline_->play(true);
return true;
}
void ShmdataFollower::on_server_connected(const std::string& data_type) {
if (data_type != data_type_) {
data_type_ = data_type;
quid_->graft_tree(
tree_path_ + shmpath_,
ShmdataUtils::make_tree(data_type_, ShmdataUtils::get_category(data_type_), ShmdataStat()));
}
if (osc_) osc_(data_type);
}
bool PulseSrc::start() {
g_object_set(G_OBJECT(pulsesrc_.get_raw()),
"device",
capture_devices_.at(devices_.get()).name_.c_str(),
nullptr);
shm_sub_ = std::make_unique<GstShmdataSubscriber>(
shmsink_.get_raw(),
[this](const std::string& caps) {
this->graft_tree(
".shmdata.writer." + shmpath_,
ShmdataUtils::make_tree(caps, ShmdataUtils::get_category(caps), ShmdataStat()));
},
ShmdataStat::make_tree_updater(this, ".shmdata.writer." + shmpath_));
gst_bin_add_many(
GST_BIN(gst_pipeline_->get_pipeline()), pulsesrc_.get_raw(), shmsink_.get_raw(), nullptr);
gst_element_link_many(pulsesrc_.get_raw(), shmsink_.get_raw(), nullptr);
gst_pipeline_->play(true);
return true;
}
bool GstDecodebin::on_shmdata_connect(const std::string& shmpath) {
// creating shmdata reader
g_object_set(
G_OBJECT(shmsrc_.get_raw()), "copy-buffers", TRUE, "socket-path", shmpath.c_str(), nullptr);
shmr_sub_ = std::make_unique<GstShmdataSubscriber>(
shmsrc_.get_raw(),
[this, shmpath](const std::string& caps) {
this->graft_tree(
".shmdata.reader." + shmpath,
ShmdataUtils::make_tree(caps, ShmdataUtils::get_category(caps), ShmdataStat()));
},
ShmdataStat::make_tree_updater(this, ".shmdata.writer." + shmpath));
// creating decodebin
std::unique_ptr<DecodebinToShmdata> decodebin = std::make_unique<DecodebinToShmdata>(
gst_pipeline_.get(),
[this](GstElement* el, const std::string& media_type, const std::string& media_label) {
configure_shmdatasink(el, media_type, media_label);
},
true /*decompress*/);
// adding to pipeline
gst_bin_add(GST_BIN(gst_pipeline_->get_pipeline()), shmsrc_.get_raw());
if (!decodebin->invoke_with_return<gboolean>([this](GstElement* el) {
return gst_bin_add(GST_BIN(gst_pipeline_->get_pipeline()), el);
})) {
g_warning("decodebin cannot be added to pipeline");
}
// get pads and link
GstPad* pad = gst_element_get_static_pad(shmsrc_.get_raw(), "src");
On_scope_exit { gst_object_unref(GST_OBJECT(pad)); };
GstPad* sinkpad = decodebin->invoke_with_return<GstPad*>(
[](GstElement* el) { return gst_element_get_static_pad(el, "sink"); });
On_scope_exit { gst_object_unref(GST_OBJECT(sinkpad)); };
if (!GstUtils::check_pad_link_return(gst_pad_link(pad, sinkpad))) return false;
// set media label if relevant
auto caps = gst_pad_get_allowed_caps(pad);
if (0 < gst_caps_get_size(caps)) {
On_scope_exit { gst_caps_unref(caps); };
auto structure = gst_caps_get_structure(caps, 0);
auto media_label = gst_structure_get_string(structure, "media-label");
if (nullptr != media_label)
decodebin->set_media_label(gst_structure_get_string(structure, "media-label"));
}
bool Timelapse::start_timelapse(const std::string& shmpath) {
{
auto timelapse = timelapse_.find(shmpath);
if (timelapse_.end() != timelapse) timelapse_.erase(timelapse);
}
auto img_path = img_dir_;
auto img_from_shmpath =
img_dir_.empty() ? shmpath : shmpath.substr(shmpath.find_last_of("/") + 1);
img_path += img_name_.empty() ? img_from_shmpath : img_name_;
if (num_files_ && std::string::npos == img_path.find('%'))
img_path += "_%d.jpg";
else if (img_name_.empty())
img_path += ".jpg";
timelapse_config_ = GstVideoTimelapseConfig(shmpath, img_path);
timelapse_config_.framerate_num_ = framerate_.numerator();
timelapse_config_.framerate_denom_ = framerate_.denominator();
timelapse_config_.width_ = width_;
timelapse_config_.height_ = height_;
timelapse_config_.jpg_quality_ = jpg_quality_;
timelapse_config_.max_files_ = max_files_;
auto new_timelapse = std::make_unique<GstVideoTimelapse>(
timelapse_config_,
[this, shmpath](const std::string& caps) {
graft_tree(".shmdata.reader." + shmpath,
ShmdataUtils::make_tree(caps, ShmdataUtils::get_category(caps), ShmdataStat()));
},
ShmdataStat::make_tree_updater(this, ".shmdata.reader." + shmpath),
nullptr,
[this, shmpath](std::string&& file_name) {
if (!notify_last_file_) return;
{
auto lock = pmanage<MPtr(&PContainer::get_lock)>(last_image_id_);
last_image_ = file_name;
}
pmanage<MPtr(&PContainer::notify)>(last_image_id_);
});
if (!new_timelapse.get()) return false;
timelapse_[shmpath] = std::move(new_timelapse);
return true;
}
void HTTPSDPDec::configure_shmdatasink(GstElement* element,
const std::string& media_type,
const std::string& media_label) {
auto count = counter_.get_count(media_label + media_type);
std::string media_name = media_type;
if (count != 0) media_name.append("-" + std::to_string(count));
std::string shmpath;
if (media_label.empty())
shmpath = make_file_name(media_name);
else
shmpath = make_file_name(media_label + "-" + media_name);
g_object_set(G_OBJECT(element), "socket-path", shmpath.c_str(), nullptr);
shm_subs_.emplace_back(std::make_unique<GstShmdataSubscriber>(
element,
[this, shmpath](const std::string& caps) {
this->graft_tree(
".shmdata.writer." + shmpath,
ShmdataUtils::make_tree(caps, ShmdataUtils::get_category(caps), ShmdataStat()));
},
ShmdataStat::make_tree_updater(this, ".shmdata.writer." + shmpath)));
}
