void App::startListen(QGst::PipelinePtr pipe, int port) { QGst::ElementPtr rtcpudpsink = QGst::ElementFactory::make("udpsrc"); rtcpudpsink->setProperty("host", "127.0.0.1"); // TODO settings rtcpudpsink->setProperty("port", port); // source // rtcpudpsink->setProperty("sync", false); // rtcpudpsink->setProperty("async", false); rtcpudpsink->setProperty("caps", QGst::Caps::fromString("application/x-rtp,media=(string)audio, clock-rate=(int)8000, encoding-name=(string)SPEEX,payload=(int)110")); pipe->add(rtcpudpsink); QGst::ElementPtr bin; try { bin = QGst::Bin::fromDescription( "rtpspeexdepay ! speexdec ! audioconvert" ); } catch (const QGlib::Error & error) { qCritical() << error; qFatal("One ore more required elements are missing. Aborting..."); } pipe->add(bin); rtcpudpsink->link(bin); volumeIn = QGst::ElementFactory::make("volume"); // TODO settings pipe->add(volumeIn); bin->link(volumeIn); QGst::ElementPtr audioSynk = QGst::ElementFactory::make("autoaudiosink"); pipe->add(audioSynk); volumeIn->link(audioSynk); }
void VideoSinkController::initFromStreamingThread(const QGst::PadPtr & srcPad, const QGst::PipelinePtr & pipeline) { m_bin = QGst::Bin::create(); m_tee = QGst::ElementFactory::make("tee"); QGst::ElementPtr fakesink = QGst::ElementFactory::make("fakesink"); fakesink->setProperty("sync", false); fakesink->setProperty("async", false); fakesink->setProperty("silent", true); fakesink->setProperty("enable-last-sample", false); m_bin->add(m_tee, fakesink); m_tee->getRequestPad("src_%u")->link(fakesink->getStaticPad("sink")); QGst::PadPtr binSinkPad = QGst::GhostPad::create(m_tee->getStaticPad("sink"), "sink"); m_bin->addPad(binSinkPad); pipeline->add(m_bin); m_bin->syncStateWithParent(); srcPad->link(binSinkPad); }
const QString GstRecorder::recordLocally() { QGst::BinPtr videoSrcBin = createVideoSrcBin(); //QGst::BinPtr audioSrcBin = createAudioSrcBin(); //QGst::ElementPtr mux = QGst::ElementFactory::make("mp4mux"); QGst::BinPtr mux = createVideoMuxBin(); QGst::ElementPtr sink = QGst::ElementFactory::make("filesink"); QString currentTime = QDateTime::currentDateTime().toString("yyyy_MM_dd_hh_mm_ss"); const QString filename = QDir::current().absoluteFilePath( currentTime + "-device-" + QString::number(deviceNumber) + ".mp4"); qDebug() << "GstRecorder: writing to:" << filename; sink->setProperty("location", filename); if (!videoSrcBin || !sink) { qDebug() << "Error. One or more elements could not be created."; return ""; } if (m_pipeline) { qDebug() << "Another Recording was not started. Already one in progress"; return ""; } m_pipeline = QGst::Pipeline::create(); //m_pipeline->add(videoSrcBin, audioSrcBin, mux, sink); m_pipeline->add(videoSrcBin, mux, sink); //QGst::PadPtr videoPad = mux->getRequestPad("video_%u"); //QGst::PadPtr audioPad = mux->getRequestPad("audio_%u"); //videoSrcBin->getStaticPad("src")->link(videoPad); //audioSrcBin->getStaticPad("src")->link(audioPad); videoSrcBin->link(mux); mux->link(sink); m_pipeline->bus()->addSignalWatch(); QGlib::connect(m_pipeline->bus(), "message", this, &GstRecorder::onBusMessage); m_pipeline->setState(QGst::StatePlaying); return filename; }
void GstRecorder::createRtpSink(quint16 port, QString address) { QGst::BinPtr videoSrcBin = createVideoSrcBin(); QGst::ElementPtr rtpbin = QGst::ElementFactory::make("rtpbin"); QGst::ElementPtr h264pay = QGst::ElementFactory::make("rtph264pay"); if (!videoSrcBin || !rtpbin) { qDebug() << "Error. One or more elements could not be created."; return; } m_pipeline = QGst::Pipeline::create(); m_pipeline->add(videoSrcBin, h264pay); videoSrcBin->link(h264pay); m_pipeline->add(rtpbin); // send_rtp_sink_0 is needed as a parameter for rtpbin for the configuration h264pay->link(rtpbin, "send_rtp_sink_0"); QGst::ElementPtr RtpUdpSink = QGst::ElementFactory::make("udpsink"); RtpUdpSink->setProperty("port", (int)port); RtpUdpSink->setProperty("host", address); if (!RtpUdpSink) { qFatal("Failed to create udpsink. Aborting..."); } m_pipeline->add(RtpUdpSink); rtpbin->link("send_rtp_src_0", RtpUdpSink); QGst::ElementPtr RtcpUdpSink = QGst::ElementFactory::make("udpsink"); RtcpUdpSink->setProperty("port", port + 1); RtcpUdpSink->setProperty("host", address); RtcpUdpSink->setProperty("sync", false); // needed for real-time RtcpUdpSink->setProperty("async", false); m_pipeline->add(RtcpUdpSink); rtpbin->link("send_rtcp_src_0", RtcpUdpSink); QGst::ElementPtr RtcpUdpSrc = QGst::ElementFactory::make("udpsrc"); RtcpUdpSrc->setProperty("port", port + 2); m_pipeline->add(RtcpUdpSrc); RtcpUdpSrc->link(rtpbin, "recv_rtcp_sink_0"); // watch the bus m_pipeline->bus()->addSignalWatch(); QGlib::connect(m_pipeline->bus(), "message", this, &GstRecorder::onBusMessage); qDebug() << "Streaming to RTP"; m_pipeline->setState(QGst::StatePlaying); }
QGst::BinPtr GstExporter::createFileSrcBin(const QString path, const int i) { qDebug() << "creating filesrc bin, path: " << path << " i: " << i; QGst::BinPtr videoBin; QDir current = QDir::current(); current.cd("recordings"); const QString fullPath = current.absoluteFilePath(path); try { char* srcname = nameWithIndex("file", i); QGst::ElementPtr src = QGst::ElementFactory::make("filesrc", srcname); src->setProperty("location", fullPath); char* demuxName = nameWithIndex("demux", i); QGst::ElementPtr demuxer = QGst::ElementFactory::make("qtdemux", demuxName); QGst::BinPtr decoder = createDecoder(i); QGst::ElementPtr scale = QGst::ElementFactory::make("videoscale"); QGst::ElementPtr capsfilter = createCapsFilter(elementWidthPx, elementHeightPx); char* binname = nameWithIndex("filebin", i); videoBin = QGst::Bin::create(binname); videoBin->add(src, demuxer, decoder, capsfilter, scale); src->link(demuxer); videoBin->linkMany(decoder, scale, capsfilter); qDebug() << "filesrc bin: Added and linked all elements"; QGst::PadPtr filterPadSrc = capsfilter->getStaticPad("src"); videoBin->addPad(QGst::GhostPad::create(filterPadSrc, "src")); qDebug() << "filesrc bin: Added Ghostpad to the bin"; QGlib::connect(demuxer, "pad-added", this, &GstExporter::callbackNewPad, QGlib::PassSender); } catch (const QGlib::Error& error) { qCritical() << "Failed to create a filesource:" << error; return QGst::BinPtr(); } return videoBin; }
QGst::BinPtr GstExporter::createVideoMixer() { qDebug() << "createVideoMixer start"; QGst::BinPtr videoMixerBin = QGst::Bin::create(); try { QGst::ElementPtr videoMixer = QGst::ElementFactory::make("videomixer", "mix"); videoMixer->setProperty("background", (int) 1); //black background videoMixerBin->add(videoMixer); int count = 0; // go through every element in the grid for (int i = 0; i < rec_->grid.height; ++i) { for (int j = 0; j < rec_->grid.width; ++j) { VideoFile* current = &rec_->grid.grid[i][j]; if (current->id != 0) { qDebug() << "Working on video[" << i << "][" << j << "] with id: " << current->id; QGst::PadPtr pad = videoMixer->getRequestPad("sink_%u"); pad->setProperty("ypos", i * elementHeightPx); pad->setProperty("xpos", j * elementWidthPx); qDebug() << "Pad created with xpos: " << pad->property("xpos") << ", ypos: " << pad->property("ypos"); QGst::BinPtr filesrc = createFileSrcBin(current->filepath, count); videoMixerBin->add(filesrc); QGst::PadPtr sourcepad = filesrc->getStaticPad("src"); sourcepad->link(pad); ++count; } } } QGst::PadPtr mixSrcPad = videoMixer->getStaticPad("src"); videoMixerBin->addPad(QGst::GhostPad::create(mixSrcPad, "src")); } catch (const QGlib::Error& error) { qDebug() << "Failed to create a videomixer:" << error; return QGst::BinPtr(); } return videoMixerBin; }
QGst::ElementPtr GstExporter::createCapsFilter(const quint16 width, const quint16 height) { qDebug() << "creating capsfilter with width: " << width << ", height: " << height; QGst::ElementPtr capsfilter; try { capsfilter = QGst::ElementFactory::make("capsfilter"); const QGst::CapsPtr caps = QGst::Caps::createSimple("video/x-raw"); caps->setValue("width", (int)width); caps->setValue("height", (int)height); capsfilter->setProperty("caps", caps); } catch (const QGlib::Error& error) { qCritical() << "Failed to create capsfilter: " << error; return QGst::ElementPtr(); } return capsfilter; }
QGst::BinPtr GstRecorder::createVideoSrcBin() { QGst::BinPtr videoBin; try { videoBin = QGst::Bin::create(); QGst::ElementPtr src = QGst::ElementFactory::make("v4l2src"); src->setProperty("device", devicepath); qDebug() << "GstRecorder: v4l2src with device: " << devicepath; QGst::ElementPtr encoder; QGst::ElementPtr capsfilter = createCapsFilter(videoWitdhPx, videoHeightPx, framerate); //QGst::ElementPtr parse = QGst::ElementFactory::make("h264parse"); //QGst::ElementPtr queue = QGst::ElementFactory::make("queue"); if (usesOmx) { encoder = QGst::ElementFactory::make("omxh264enc"); } else { encoder = QGst::ElementFactory::make("x264enc"); qDebug() << "GstRecoder: created x264enc"; } videoBin->add(src, capsfilter, encoder); videoBin->linkMany(src, capsfilter, encoder); qDebug() << "GstRecorder: createVideoSrcBin: added and linked the elements"; QGst::PadPtr encoderSrcPad = encoder->getStaticPad("src"); videoBin->addPad(QGst::GhostPad::create(encoderSrcPad, "src")); } catch (const QGlib::Error &error) { qDebug() << "Failed to create video source bin:" << error; return QGst::BinPtr(); } return videoBin; }
QString GstExporter::exportVideo() { qDebug() << "Starting Videoexport..."; QGst::BinPtr mixer = createVideoMixer(); QGst::BinPtr encoder = createEncoder(); QGst::ElementPtr scale = QGst::ElementFactory::make("videoscale"); QGst::ElementPtr sink = QGst::ElementFactory::make("filesink"); QGst::ElementPtr capsfilter = createCapsFilter(exportWidthPx, exportHeightPx); QString recordingTime = rec_->datetime.toString("yyyy_MM_dd_hh_mm_ss"); qDebug() << "Loaded recodring, recording time: " << rec_->datetime; QDir current = QDir::current(); current.mkdir("exports"); current.cd("exports"); QString filename = current.absoluteFilePath("export-" + recordingTime + ".mp4"); sink->setProperty("location", filename); m_pipeline = QGst::Pipeline::create(); m_pipeline->add(mixer, capsfilter, encoder, scale, sink); m_pipeline->linkMany(mixer, capsfilter, scale, encoder, sink); qDebug() << "GstExporter: pipeline: Added and linked all elements"; m_pipeline->bus()->addSignalWatch(); QGlib::connect(m_pipeline->bus(), "message", this, &GstExporter::onBusMessage); qDebug() << "exportVideo(): Starting pipeline"; m_pipeline->setState(QGst::StatePlaying); timer = new QTimer(this); connect(timer, &QTimer::timeout, this, &GstExporter::progressPercent); timer->start(1000); return current.relativeFilePath(filename); }
void QtGStreamerCaptureBackend::startCapture(const QString &filePath) { // clear pipeline if still existing if (m_pipeline) { qCWarning(LIBSOUND_LOG) << "removing forgotten pipeline"; //send an end-of-stream event to flush metadata and cause an EosMessage to be delivered m_pipeline->sendEvent(QGst::EosEvent::create()); } QGst::BinPtr audioSrcBin = createAudioSrcBin(); QGst::ElementPtr mux = QGst::ElementFactory::make("oggmux"); QGst::ElementPtr sink = QGst::ElementFactory::make("filesink"); if (!audioSrcBin || !mux || !sink) { qCritical() << "One or more elements could not be created. " << "Verify that you have all the necessary element plugins installed."; return; } // set output path sink->setProperty("location", filePath); m_pipeline = QGst::Pipeline::create(); m_pipeline->add(audioSrcBin, mux, sink); //link elements QGst::PadPtr audioPad = mux->getRequestPad("audio_%u"); audioSrcBin->getStaticPad("src")->link(audioPad); mux->link(sink); //connect the bus m_pipeline->bus()->addSignalWatch(); QGlib::connect(m_pipeline->bus(), "message", this, &QtGStreamerCaptureBackend::onBusMessage); m_pipeline->setState(QGst::StatePlaying); }