void SyntroPythonClient::clientSendE2EData(int servicePort, QByteArray data)
{
if (clientIsServiceActive(servicePort)) {
SYNTRO_EHEAD *multiCast = clientBuildMessage(servicePort, data.size());
memcpy(multiCast + 1, data.data(), data.size());
clientSendMessage(servicePort, multiCast, data.size(), SYNTROLINK_MEDPRI);
}
}
bool CFSClient::appClientProcessThreadMessage(SyntroThreadMsg *msg)
{
if (msg->message == SYNTRO_CFS_MESSAGE) {
clientSendMessage(m_CFSPort, (SYNTRO_EHEAD *)msg->ptrParam, msg->intParam, SYNTROCFS_E2E_PRIORITY);
return true;
}
return false;
}
void CamClient::sendNullFrameMJPPCM(qint64 now, bool highRate)
{
if (highRate) {
if (clientIsServiceActive(m_avmuxPortHighRate) && clientClearToSend(m_avmuxPortHighRate)) {
SYNTRO_EHEAD *multiCast = clientBuildMessage(m_avmuxPortHighRate, sizeof(SYNTRO_RECORD_AVMUX));
SYNTRO_RECORD_AVMUX *videoHead = (SYNTRO_RECORD_AVMUX *)(multiCast + 1);
SyntroUtils::avmuxHeaderInit(videoHead, &m_avParams, SYNTRO_RECORDHEADER_PARAM_NOOP, m_recordIndex++, 0, 0, 0);
int length = sizeof(SYNTRO_RECORD_AVMUX);
clientSendMessage(m_avmuxPortHighRate, multiCast, length, SYNTROLINK_LOWPRI);
m_lastFrameTime = now;
}
} else {
if (m_generateLowRate && clientIsServiceActive(m_avmuxPortLowRate) && clientClearToSend(m_avmuxPortLowRate)) {
SYNTRO_EHEAD *multiCast = clientBuildMessage(m_avmuxPortLowRate, sizeof(SYNTRO_RECORD_AVMUX));
SYNTRO_RECORD_AVMUX *videoHead = (SYNTRO_RECORD_AVMUX *)(multiCast + 1);
SyntroUtils::avmuxHeaderInit(videoHead, &m_avParams, SYNTRO_RECORDHEADER_PARAM_NOOP, m_recordIndex++, 0, 0, 0);
int length = sizeof(SYNTRO_RECORD_AVMUX);
clientSendMessage(m_avmuxPortLowRate, multiCast, length, SYNTROLINK_LOWPRI);
m_lastLowRateFrameTime = now;
}
}
}
//断开连接按钮
void client::on_disconnectpushButton_clicked()
{
ui->clientMessagelineEdit->setText (tr("clientStop"));
clientSendMessage ();
ui->clientMessagelineEdit->setText (tr(""));
ui->cStatuslabel->setText (tr("连接断开"));
tcp->abort();
delete tcp;
tcp=NULL;
ui->connectpushButton->setEnabled (true);
ui->disconnectpushButton->setEnabled (false);
ui->clientSendpushButton->setEnabled (false);
}
void CamClient::sendHeartbeatFrameMJPPCM(qint64 now, const QByteArray& jpeg)
{
QByteArray lowRateJpeg;
if (clientIsServiceActive(m_avmuxPortHighRate) && clientClearToSend(m_avmuxPortHighRate) &&
SyntroUtils::syntroTimerExpired(now, m_lastFullFrameTime, m_highRateMaxInterval)) {
SYNTRO_EHEAD *multiCast = clientBuildMessage(m_avmuxPortHighRate, sizeof(SYNTRO_RECORD_AVMUX) + jpeg.size());
SYNTRO_RECORD_AVMUX *videoHead = (SYNTRO_RECORD_AVMUX *)(multiCast + 1);
SyntroUtils::avmuxHeaderInit(videoHead, &m_avParams, SYNTRO_RECORDHEADER_PARAM_REFRESH, m_recordIndex++, 0, jpeg.size(), 0);
memcpy((unsigned char *)(videoHead + 1), jpeg.data(), jpeg.size());
int length = sizeof(SYNTRO_RECORD_AVMUX) + jpeg.size();
clientSendMessage(m_avmuxPortHighRate, multiCast, length, SYNTROLINK_LOWPRI);
m_lastFrameTime = m_lastFullFrameTime = now;
}
if (m_generateLowRate && clientIsServiceActive(m_avmuxPortLowRate) && clientClearToSend(m_avmuxPortLowRate) &&
SyntroUtils::syntroTimerExpired(now, m_lastLowRateFullFrameTime, m_lowRateMaxInterval)) {
lowRateJpeg = jpeg;
if (m_lowRateHalfRes)
halfRes(lowRateJpeg);
SYNTRO_EHEAD *multiCast = clientBuildMessage(m_avmuxPortLowRate, sizeof(SYNTRO_RECORD_AVMUX) + lowRateJpeg.size());
SYNTRO_RECORD_AVMUX *videoHead = (SYNTRO_RECORD_AVMUX *)(multiCast + 1);
SyntroUtils::avmuxHeaderInit(videoHead, &m_avParams, SYNTRO_RECORDHEADER_PARAM_REFRESH, m_recordIndex++, 0, lowRateJpeg.size(), 0);
memcpy((unsigned char *)(videoHead + 1), lowRateJpeg.data(), lowRateJpeg.size());
int length = sizeof(SYNTRO_RECORD_AVMUX) + lowRateJpeg.size();
clientSendMessage(m_avmuxPortLowRate, multiCast, length, SYNTROLINK_LOWPRI);
m_lastLowRateFrameTime = m_lastLowRateFullFrameTime = now;
}
if (SyntroUtils::syntroTimerExpired(now, m_lastFrameTime, m_highRateNullInterval))
sendNullFrameMJPPCM(now, true);
if (SyntroUtils::syntroTimerExpired(now, m_lastLowRateFrameTime, m_lowRateNullInterval))
sendNullFrameMJPPCM(now, false);
}
void CamClient::sendCaps()
{
if (!clientIsServiceActive(m_avmuxPort) || !clientClearToSend(m_avmuxPort))
return;
gchar *videoCaps = m_encoder->getVideoCaps();
gchar *audioCaps = m_encoder->getAudioCaps();
int videoLength = 0;
int audioLength = 0;
int totalLength = 0;
if (videoCaps != NULL)
videoLength = strlen(videoCaps) + 1;
if (audioCaps != NULL)
audioLength = strlen(audioCaps) + 1;
totalLength = videoLength + audioLength;
if (totalLength == 0)
return;
SYNTRO_EHEAD *multiCast = clientBuildMessage(m_avmuxPort, sizeof(SYNTRO_RECORD_AVMUX) + totalLength);
SYNTRO_RECORD_AVMUX *avmux = (SYNTRO_RECORD_AVMUX *)(multiCast + 1);
SyntroUtils::avmuxHeaderInit(avmux, &m_avParams, SYNTRO_RECORDHEADER_PARAM_NORMAL, m_recordIndex++, 0, videoLength, audioLength);
avmux->videoSubtype = SYNTRO_RECORD_TYPE_VIDEO_RTPCAPS;
avmux->audioSubtype = SYNTRO_RECORD_TYPE_AUDIO_RTPCAPS;
unsigned char *ptr = (unsigned char *)(avmux + 1);
if (videoLength > 0) {
memcpy(ptr, videoCaps, videoLength);
ptr += videoLength;
}
if (audioLength > 0) {
memcpy(ptr, audioCaps, audioLength);
ptr += audioLength;
}
clientSendMessage(m_avmuxPort, multiCast, sizeof(SYNTRO_RECORD_AVMUX) + totalLength, SYNTROLINK_MEDPRI);
}
void DisplayClient::ledWrite(quint32 mask, quint32 values)
{
if (!clientIsConnected())
return;
if (!clientIsServiceActive(m_controlPort))
return;
int length = 2 * sizeof(quint32);
SYNTRO_EHEAD *head = clientBuildMessage(m_controlPort, length);
quint32 *p = (quint32 *)(head + 1);
p[0] = mask;
p[1] = values;
clientSendMessage(m_controlPort, head, length, SYNTROLINK_MEDPRI);
}
void SyntroPythonClient::clientSendJpegAVData(int servicePort, QByteArray video, QByteArray audio)
{
if (clientIsServiceActive(servicePort) && clientClearToSend(servicePort)) {
SYNTRO_EHEAD *multiCast = clientBuildMessage(servicePort, sizeof(SYNTRO_RECORD_AVMUX)
+ video.size() + audio.size());
SYNTRO_RECORD_AVMUX *avHead = (SYNTRO_RECORD_AVMUX *)(multiCast + 1);
SyntroUtils::avmuxHeaderInit(avHead, &m_avParams, SYNTRO_RECORDHEADER_PARAM_NORMAL, m_recordIndex++, 0, video.size(), audio.size());
SyntroUtils::convertInt64ToUC8(QDateTime::currentMSecsSinceEpoch(), avHead->recordHeader.timestamp);
unsigned char *ptr = (unsigned char *)(avHead + 1);
if (video.size() > 0) {
memcpy(ptr, video.data(), video.size());
ptr += video.size();
}
if (audio.size() > 0) {
memcpy(ptr, audio.data(), audio.size());
}
int length = sizeof(SYNTRO_RECORD_AVMUX) + video.size() + audio.size();
clientSendMessage(servicePort, multiCast, length, SYNTROLINK_MEDPRI);
}
}
void CamClient::processAVQueue()
{
QByteArray data;
int videoLength, audioLength;
SYNTRO_UC4 lengthData;
QByteArray videoArray;
QByteArray audioArray;
int totalLength;
unsigned char *ptr;
qint64 videoTimestamp;
qint64 audioTimestamp;
int videoParam;
int audioParam;
if (m_avmuxPort == -1)
return;
if (!clientIsServiceActive(m_avmuxPort)) { // just discard encoder queue
while (m_encoder->getCompressedVideo(data, videoTimestamp, videoParam))
;
while (m_encoder->getCompressedAudio(data, audioTimestamp, audioParam))
;
return;
}
if (!m_encoder->pipelinesActive())
return;
if (SyntroUtils::syntroTimerExpired(QDateTime::currentMSecsSinceEpoch(), m_lastCapsSend, CAMCLIENT_CAPS_INTERVAL)) {
sendCaps();
m_lastCapsSend = QDateTime::currentMSecsSinceEpoch();
}
if (clientClearToSend(m_avmuxPort)) {
while (m_encoder->getCompressedVideo(data, videoTimestamp, videoParam)) {
SyntroUtils::convertIntToUC4(data.length(), lengthData);
videoArray.append((const char *)lengthData, 4);
videoArray.append(data);
}
videoLength = videoArray.length();
while (m_encoder->getCompressedAudio(data, audioTimestamp, audioParam)) {
SyntroUtils::convertIntToUC4(data.length(), lengthData);
audioArray.append((const char *)lengthData, 4);
audioArray.append(data);
}
audioLength = audioArray.length();
totalLength = videoLength + audioLength;
if (totalLength > 0) {
SYNTRO_EHEAD *multiCast = clientBuildMessage(m_avmuxPort, sizeof(SYNTRO_RECORD_AVMUX) + totalLength);
SYNTRO_RECORD_AVMUX *avmux = (SYNTRO_RECORD_AVMUX *)(multiCast + 1);
SyntroUtils::avmuxHeaderInit(avmux, &m_avParams, SYNTRO_RECORDHEADER_PARAM_NORMAL, m_recordIndex++, 0, videoLength, audioLength);
if ((audioLength > 0) && (videoLength == 0)) {
SyntroUtils::convertInt64ToUC8(audioTimestamp, avmux->recordHeader.timestamp);
SyntroUtils::convertIntToUC2(audioParam, avmux->recordHeader.param);
} else {
SyntroUtils::convertInt64ToUC8(videoTimestamp, avmux->recordHeader.timestamp);
SyntroUtils::convertIntToUC2(videoParam, avmux->recordHeader.param);
}
ptr = (unsigned char *)(avmux + 1);
if (videoLength > 0) {
memcpy(ptr, videoArray.constData(), videoLength);
ptr += videoLength;
}
if (audioLength > 0) {
memcpy(ptr, audioArray.constData(), audioLength);
ptr += audioLength;
}
clientSendMessage(m_avmuxPort, multiCast, sizeof(SYNTRO_RECORD_AVMUX) + totalLength, SYNTROLINK_MEDPRI);
m_videoByteCountLock.lock();
m_videoByteCount += videoLength;
m_videoByteCountLock.unlock();
m_audioByteCountLock.lock();
m_audioByteCount += audioLength;
m_audioByteCountLock.unlock();
}
}
}
bool CamClient::sendAVMJPPCM(qint64 now, int param, bool checkMotion)
{
qint64 videoTimestamp;
qint64 audioTimestamp;
QByteArray highRateJpeg;
QByteArray lowRateJpeg;
QByteArray audioFrame;
bool audioValid;
// see if anything to send
dequeueVideoFrame(highRateJpeg, videoTimestamp);
lowRateJpeg = highRateJpeg;
audioValid = dequeueAudioFrame(audioFrame, audioTimestamp);
if (clientIsServiceActive(m_avmuxPortHighRate)) {
if (!SyntroUtils::syntroTimerExpired(now, m_lastFullFrameTime, m_highRateMinInterval)) {
highRateJpeg.clear();
if (SyntroUtils::syntroTimerExpired(now, m_lastFrameTime, m_highRateNullInterval)) {
sendNullFrameMJPPCM(now, true); // in case very long time
}
}
}
if (m_generateLowRate && clientIsServiceActive(m_avmuxPortLowRate)) {
if (!SyntroUtils::syntroTimerExpired(now, m_lastLowRateFullFrameTime, m_lowRateMinInterval)) {
lowRateJpeg.clear(); // too soon
if (SyntroUtils::syntroTimerExpired(now, m_lastLowRateFrameTime, m_lowRateNullInterval)) {
sendNullFrameMJPPCM(now, false); // in case very long time
}
}
}
if ((highRateJpeg.size() > 0) || audioValid) {
if (clientIsServiceActive(m_avmuxPortHighRate) && clientClearToSend(m_avmuxPortHighRate) ) {
SYNTRO_EHEAD *multiCast = clientBuildMessage(m_avmuxPortHighRate, sizeof(SYNTRO_RECORD_AVMUX) + highRateJpeg.size() + audioFrame.size());
SYNTRO_RECORD_AVMUX *avHead = (SYNTRO_RECORD_AVMUX *)(multiCast + 1);
SyntroUtils::avmuxHeaderInit(avHead, &m_avParams, param, m_recordIndex++, 0, highRateJpeg.size(), audioFrame.size());
if (audioValid)
SyntroUtils::convertInt64ToUC8(audioTimestamp, avHead->recordHeader.timestamp);
if (highRateJpeg.size() > 0)
SyntroUtils::convertInt64ToUC8(videoTimestamp, avHead->recordHeader.timestamp);
unsigned char *ptr = (unsigned char *)(avHead + 1);
if (highRateJpeg.size() > 0) {
memcpy(ptr, highRateJpeg.data(), highRateJpeg.size());
m_lastFullFrameTime = m_lastFrameTime = now;
ptr += highRateJpeg.size();
}
if (audioFrame.size() > 0)
memcpy(ptr, audioFrame.data(), audioFrame.size());
int length = sizeof(SYNTRO_RECORD_AVMUX) + highRateJpeg.size() + audioFrame.size();
clientSendMessage(m_avmuxPortHighRate, multiCast, length, SYNTROLINK_MEDPRI);
}
}
if ((lowRateJpeg.size() > 0) || audioValid) {
if (m_generateLowRate && clientIsServiceActive(m_avmuxPortLowRate) && clientClearToSend(m_avmuxPortLowRate)) {
if ((lowRateJpeg.size() > 0) && m_lowRateHalfRes)
halfRes(lowRateJpeg);
SYNTRO_EHEAD *multiCast = clientBuildMessage(m_avmuxPortLowRate, sizeof(SYNTRO_RECORD_AVMUX) + lowRateJpeg.size() + audioFrame.size());
SYNTRO_RECORD_AVMUX *avHead = (SYNTRO_RECORD_AVMUX *)(multiCast + 1);
SyntroUtils::avmuxHeaderInit(avHead, &m_avParams, param, m_recordIndex++, 0, lowRateJpeg.size(), audioFrame.size());
if (audioValid)
SyntroUtils::convertInt64ToUC8(audioTimestamp, avHead->recordHeader.timestamp);
if (lowRateJpeg.size() > 0)
SyntroUtils::convertInt64ToUC8(videoTimestamp, avHead->recordHeader.timestamp);
unsigned char *ptr = (unsigned char *)(avHead + 1);
if (lowRateJpeg.size() > 0) {
memcpy(ptr, lowRateJpeg.data(), lowRateJpeg.size());
m_lastLowRateFullFrameTime = m_lastLowRateFrameTime = now;
ptr += lowRateJpeg.size();
}
if (audioFrame.size() > 0)
memcpy(ptr, audioFrame.data(), audioFrame.size());
int length = sizeof(SYNTRO_RECORD_AVMUX) + lowRateJpeg.size() + audioFrame.size();
clientSendMessage(m_avmuxPortLowRate, multiCast, length, SYNTROLINK_MEDPRI);
}
}
if ((highRateJpeg.size() > 0) && checkMotion) {
if ((now - m_lastDeltaTime) > m_deltaInterval)
checkForMotion(now, highRateJpeg);
return m_imageChanged; // image may have changed
}
return false; // change not processed
}
void CamClient::sendPrerollMJPPCM(bool highRate)
{
PREROLL *videoPreroll = NULL;
PREROLL *audioPreroll = NULL;
int videoSize = 0;
int audioSize = 0;
if (highRate) {
if (!m_videoPrerollQueue.empty()) {
videoPreroll = m_videoPrerollQueue.dequeue();
videoSize = videoPreroll->data.size();
m_lastFrameTime = QDateTime::currentMSecsSinceEpoch();
}
if (!m_audioPrerollQueue.empty()) {
audioPreroll = m_audioPrerollQueue.dequeue();
audioSize = audioPreroll->data.size();
}
if ((videoPreroll != NULL) || (audioPreroll != NULL)) {
SYNTRO_EHEAD *multiCast = clientBuildMessage(m_avmuxPortHighRate, sizeof(SYNTRO_RECORD_AVMUX) + videoSize + audioSize);
SYNTRO_RECORD_AVMUX *avHead = (SYNTRO_RECORD_AVMUX *)(multiCast + 1);
SyntroUtils::avmuxHeaderInit(avHead, &m_avParams, SYNTRO_RECORDHEADER_PARAM_PREROLL, m_recordIndex++, 0, videoSize, audioSize);
if (audioPreroll != NULL)
SyntroUtils::convertInt64ToUC8(audioPreroll->timestamp, avHead->recordHeader.timestamp);
if (videoPreroll != NULL)
SyntroUtils::convertInt64ToUC8(videoPreroll->timestamp, avHead->recordHeader.timestamp);
unsigned char *ptr = (unsigned char *)(avHead + 1);
if (videoSize > 0) {
memcpy(ptr, videoPreroll->data.data(), videoSize);
ptr += videoSize;
}
if (audioSize > 0)
memcpy(ptr, audioPreroll->data.data(), audioSize);
int length = sizeof(SYNTRO_RECORD_AVMUX) + videoSize + audioSize;
clientSendMessage(m_avmuxPortHighRate, multiCast, length, SYNTROLINK_MEDPRI);
}
} else {
if (!m_videoLowRatePrerollQueue.empty()) {
videoPreroll = m_videoLowRatePrerollQueue.dequeue();
if (m_lowRateHalfRes)
halfRes(videoPreroll->data);
videoSize = videoPreroll->data.size();
m_lastLowRateFrameTime = SyntroClock();
}
if (!m_audioLowRatePrerollQueue.empty()) {
audioPreroll = m_audioLowRatePrerollQueue.dequeue();
audioSize = audioPreroll->data.size();
}
if ((videoPreroll != NULL) || (audioPreroll == NULL)) {
SYNTRO_EHEAD *multiCast = clientBuildMessage(m_avmuxPortLowRate, sizeof(SYNTRO_RECORD_AVMUX) + videoSize + audioSize);
SYNTRO_RECORD_AVMUX *avHead = (SYNTRO_RECORD_AVMUX *)(multiCast + 1);
SyntroUtils::avmuxHeaderInit(avHead, &m_avParams, SYNTRO_RECORDHEADER_PARAM_PREROLL, m_recordIndex++, 0, videoSize, audioSize);
if (audioPreroll != NULL)
SyntroUtils::convertInt64ToUC8(audioPreroll->timestamp, avHead->recordHeader.timestamp);
if (videoPreroll != NULL)
SyntroUtils::convertInt64ToUC8(videoPreroll->timestamp, avHead->recordHeader.timestamp);
unsigned char *ptr = (unsigned char *)(avHead + 1);
if (videoSize > 0) {
memcpy(ptr, videoPreroll->data.data(), videoSize);
ptr += videoSize;
}
if (audioSize > 0)
memcpy(ptr, audioPreroll->data.data(), audioSize);
int length = sizeof(SYNTRO_RECORD_AVMUX) + videoSize + audioSize;
clientSendMessage(m_avmuxPortLowRate, multiCast, length, SYNTROLINK_MEDPRI);
}
}
if (videoPreroll != NULL)
delete videoPreroll;
if (audioPreroll != NULL)
delete audioPreroll;
}
errorCode RTPImageConnector::run()
{
uint64_t finish = 0;
while(finish == 0)
{
ImageBufferContainer* message;
while(message = clientGetMessage())
{
if (message->type == GROUP_OBSERVED)
{
int nr;
for (nr = 0; nr < streams.size(); nr++)
if (!streams[nr].is_used)
break;
if (nr < streams.size())
{
//gst-launch-1.0 appsrc ! videoconf ! x264enc ! rtph264pay config-interval=10 pt=96 ! udpsink host=127.0.0.1 port=5000
GST_LOAD_ELEMENT_OR_DIE(streams[nr],appsrc)
g_object_set (G_OBJECT (streams[nr].appsrc), "caps",
gst_caps_new_simple ("video/x-raw",
"format", G_TYPE_STRING, "RGBx",
"bpp", G_TYPE_INT, 32,
"depth", G_TYPE_INT, 32,
"width", G_TYPE_INT, message->group->getFramebufferWidth(),
"height", G_TYPE_INT, message->group->getFramebufferHeight(),
"framerate", GST_TYPE_FRACTION, 0, 1,
NULL), NULL);
g_object_set (G_OBJECT (streams[nr].appsrc),
"do-timestamp", 1,
"min-percent", 0,
"emit-signals", 0,
"format", GST_FORMAT_TIME, NULL);
GST_LOAD_ELEMENT_OR_DIE(streams[nr],videoconvert)
if (raw)
{
GST_LOAD_ELEMENT_OR_DIE(streams[nr],capsfilter)
g_object_set (G_OBJECT (streams[nr].capsfilter), "caps",
gst_caps_new_simple ("video/x-raw",
"format", G_TYPE_STRING, "I420",
NULL), NULL);
GST_LOAD_ELEMENT_OR_DIE(streams[nr],jpegenc)
GST_LOAD_ELEMENT_OR_DIE(streams[nr],rtpjpegpay)
g_object_set(G_OBJECT(streams[nr].rtpjpegpay),
"pt", 96, NULL);
}
else
{
GST_LOAD_ELEMENT_OR_DIE(streams[nr],x264enc)
size_t bitrate_heuristic = (size_t) (
(uint64_t)3000 *
(uint64_t)message->group->getFramebufferWidth() *
(uint64_t)message->group->getFramebufferHeight() /
(uint64_t)800 /
(uint64_t)600 );
g_object_set (G_OBJECT (streams[nr].x264enc),
"tune", zerolatency ? 0x00000004 : 0x00000000,
"psy-tune", 2,
"speed-preset", 1,
"bitrate", bitrate_heuristic,
"threads", 2,
"byte-stream", 1, NULL);
GST_LOAD_ELEMENT_OR_DIE(streams[nr],rtph264pay)
g_object_set(G_OBJECT(streams[nr].rtph264pay),
"config-interval", 10,
"pt", 96, NULL);
}
GST_LOAD_ELEMENT_OR_DIE(streams[nr],udpsink)
g_object_set(G_OBJECT(streams[nr].udpsink),
"host", message->target.c_str(),
"port", nr+minport, NULL);
streams[nr].pipeline = gst_pipeline_new( NULL );
streams[nr].bin = gst_bin_new( NULL );
gboolean success = 0;
if (raw)
{
gst_bin_add_many(GST_BIN(streams[nr].bin), streams[nr].appsrc, streams[nr].videoconvert, streams[nr].capsfilter, streams[nr].jpegenc, streams[nr].rtpjpegpay, streams[nr].udpsink, NULL);
gst_bin_add(GST_BIN(streams[nr].pipeline), streams[nr].bin);
success = gst_element_link_many(streams[nr].appsrc, streams[nr].videoconvert, streams[nr].capsfilter, streams[nr].jpegenc, streams[nr].rtpjpegpay, streams[nr].udpsink, NULL);
}
else
{
gst_bin_add_many(GST_BIN(streams[nr].bin), streams[nr].appsrc, streams[nr].videoconvert, streams[nr].x264enc, streams[nr].rtph264pay, streams[nr].udpsink, NULL);
gst_bin_add(GST_BIN(streams[nr].pipeline), streams[nr].bin);
success = gst_element_link_many(streams[nr].appsrc, streams[nr].videoconvert, streams[nr].x264enc, streams[nr].rtph264pay, streams[nr].udpsink, NULL);
}
if ( !success )
{
fprintf(stderr,"RTPImageConnector: Could not link elements for rtp stream.\n");
}
else
{
streams[nr].is_used = true;
streams[nr].group = message->group;
streams[nr].ref = message->reference;
streams[nr].url = message->target;
char* register_message = (char*)malloc(128);
if (raw)
sprintf(register_message,"v=0\nm=video %i RTP/AVP 96\nc=IN IP4 %s\na=rtpmap:96 JPEG/90000\n",nr+minport,url.c_str());
else
sprintf(register_message,"v=0\nm=video %i RTP/AVP 96\nc=IN IP4 %s\na=rtpmap:96 H264/90000\n",nr+minport,url.c_str());
clientSendMessage(new ImageBufferContainer(REGISTER_STREAM,(uint8_t*)register_message,message->group,1,message->target,message->reference));
if (raw)
printf("RTIPImageConnector: Openend JPEG Stream at port %i\n",minport+nr);
else
printf("RTIPImageConnector: Openend H264 Stream at port %i\n",minport+nr);
if (gst_element_set_state(GST_ELEMENT(streams[nr].pipeline), GST_STATE_PLAYING) == GST_STATE_CHANGE_FAILURE)
printf("RTIPImageConnector: Could not play stream!\n");
}
}
else
fprintf(stderr,"RTPImageConnector: No free port!\n");
}
