void MediaStream::onTransportData(std::shared_ptr<DataPacket> incoming_packet, Transport *transport) {
if ((audio_sink_ == nullptr && video_sink_ == nullptr && fb_sink_ == nullptr)) {
return;
}
std::shared_ptr<DataPacket> packet = std::make_shared<DataPacket>(*incoming_packet);
if (transport->mediaType == AUDIO_TYPE) {
packet->type = AUDIO_PACKET;
} else if (transport->mediaType == VIDEO_TYPE) {
packet->type = VIDEO_PACKET;
}
auto stream_ptr = shared_from_this();
worker_->task([stream_ptr, packet]{
if (!stream_ptr->pipeline_initialized_) {
ELOG_DEBUG("%s message: Pipeline not initialized yet.", stream_ptr->toLog());
return;
}
char* buf = packet->data;
RtpHeader *head = reinterpret_cast<RtpHeader*> (buf);
RtcpHeader *chead = reinterpret_cast<RtcpHeader*> (buf);
if (!chead->isRtcp()) {
uint32_t recvSSRC = head->getSSRC();
if (stream_ptr->isVideoSourceSSRC(recvSSRC)) {
packet->type = VIDEO_PACKET;
} else if (stream_ptr->isAudioSourceSSRC(recvSSRC)) {
packet->type = AUDIO_PACKET;
}
}
stream_ptr->pipeline_->read(std::move(packet));
});
}
void WebRtcConnection::writeSsrc(char* buf, int len, unsigned int ssrc) {
ELOG_DEBUG("LEN %d", len);
RtpHeader *head = reinterpret_cast<RtpHeader*> (buf);
RtcpHeader *chead = reinterpret_cast<RtcpHeader*> (buf);
//if it is RTCP we check it it is a compound packet
if (chead->isRtcp()) {
char* movingBuf = buf;
int rtcpLength = 0;
int totalLength = 0;
do{
movingBuf+=rtcpLength;
RtcpHeader *chead= reinterpret_cast<RtcpHeader*>(movingBuf);
rtcpLength= (ntohs(chead->length)+1)*4;
totalLength+= rtcpLength;
ELOG_DEBUG("Is RTCP, prev SSRC %u, new %u, len %d ", chead->getSSRC(), ssrc, rtcpLength);
chead->ssrc=htonl(ssrc);
if (chead->packettype == RTCP_PS_Feedback_PT){
FirHeader *thefir = reinterpret_cast<FirHeader*>(movingBuf);
if (thefir->fmt == 4){ // It is a FIR Packet, we generate it
this->sendPLI();
}
}
} while(totalLength<len);
} else {
head->setSSRC(ssrc);
}
}
void RRGenerationHandler::handleSR(std::shared_ptr<dataPacket> packet) {
RtcpHeader *chead = reinterpret_cast<RtcpHeader*>(packet->data);
auto rr_packet_pair = rr_info_map_.find(chead->getSSRC());
if (rr_packet_pair == rr_info_map_.end()) {
ELOG_DEBUG("%s message: handleRtpPacket ssrc not found, ssrc: %u", connection_->toLog(), chead->getSSRC());
return;
}
std::shared_ptr<RRPackets> selected_packet_info = rr_packet_pair->second;
selected_packet_info->last_sr_mid_ntp = chead->get32MiddleNtp();
selected_packet_info->last_sr_ts = packet->received_time_ms;
uint32_t expected = selected_packet_info->extended_seq - selected_packet_info->base_seq + 1;
selected_packet_info->lost = expected - selected_packet_info->packets_received;
uint8_t fraction = 0;
uint32_t expected_interval = expected - selected_packet_info->expected_prior;
selected_packet_info->expected_prior = expected;
uint32_t received_interval = selected_packet_info->packets_received - selected_packet_info->received_prior;
selected_packet_info->received_prior = selected_packet_info->packets_received;
uint32_t lost_interval = expected_interval - received_interval;
if (expected_interval != 0 && lost_interval > 0) {
fraction = (lost_interval << 8) / expected_interval;
}
selected_packet_info->frac_lost = fraction;
if (!use_timing_) {
sendRR(selected_packet_info);
}
}
void SdesTransport::onNiceData(unsigned int component_id, char* data, int len, NiceConnection* nice) {
//boost::mutex::scoped_lock lock(readMutex_);
int length = len;
SrtpChannel *srtp = srtp_;
if (this->getTransportState() == TRANSPORT_READY) {
memcpy(unprotectBuf_, data, len);
if (component_id == 2) {
srtp = srtcp_;
}
RtcpHeader *chead = reinterpret_cast<RtcpHeader*> (unprotectBuf_);
if (chead->isRtcp()){
if(srtp->unprotectRtcp(unprotectBuf_, &length)<0)
return;
} else {
if(srtp->unprotectRtp(unprotectBuf_, &length)<0)
return;
}
if (length <= 0)
return;
getTransportListener()->onTransportData(unprotectBuf_, length, this);
}
}
void RRGenerationHandler::read(Context *ctx, std::shared_ptr<dataPacket> packet) {
RtcpHeader *chead = reinterpret_cast<RtcpHeader*>(packet->data);
if (!chead->isRtcp() && enabled_) {
handleRtpPacket(packet);
} else if (chead->packettype == RTCP_Sender_PT && enabled_) {
handleSR(packet);
}
ctx->fireRead(packet);
}
void WebRtcConnection::writeSsrc(char* buf, int len, unsigned int ssrc) {
RtpHeader *head = reinterpret_cast<RtpHeader*> (buf);
RtcpHeader *chead = reinterpret_cast<RtcpHeader*> (buf);
//if it is RTCP we check it it is a compound packet
if (chead->isRtcp()) {
processRtcpHeaders(buf,len,ssrc);
} else {
head->ssrc=htonl(ssrc);
}
}
void SenderBandwidthEstimationHandler::write(Context *ctx, std::shared_ptr<dataPacket> packet) {
RtcpHeader *chead = reinterpret_cast<RtcpHeader*>(packet->data);
if (!chead->isRtcp() && packet->type == VIDEO_PACKET) {
period_packets_sent_++;
} else if (chead->getPacketType() == RTCP_Sender_PT &&
chead->getSSRC() == connection_->getVideoSinkSSRC()) {
analyzeSr(chead);
}
ctx->fireWrite(packet);
}
void RtcpRrGenerator::handleSr(std::shared_ptr<dataPacket> packet) {
RtcpHeader* chead = reinterpret_cast<RtcpHeader*>(packet->data);
if (ssrc_ != chead->getSSRC()) {
ELOG_DEBUG("message: handleRtpPacket ssrc not found, ssrc: %u", chead->getSSRC());
return;
}
rr_info_.last_sr_mid_ntp = chead->get32MiddleNtp();
rr_info_.last_sr_ts = packet->received_time_ms;
}
void MediaStream::read(std::shared_ptr<DataPacket> packet) {
char* buf = packet->data;
int len = packet->length;
// PROCESS RTCP
RtpHeader *head = reinterpret_cast<RtpHeader*> (buf);
RtcpHeader *chead = reinterpret_cast<RtcpHeader*> (buf);
uint32_t recvSSRC = 0;
if (!chead->isRtcp()) {
recvSSRC = head->getSSRC();
} else if (chead->packettype == RTCP_Sender_PT) { // Sender Report
recvSSRC = chead->getSSRC();
}
// DELIVER FEEDBACK (RR, FEEDBACK PACKETS)
if (chead->isFeedback()) {
if (fb_sink_ != nullptr && should_send_feedback_) {
fb_sink_->deliverFeedback(std::move(packet));
}
} else {
// RTP or RTCP Sender Report
if (bundle_) {
// Check incoming SSRC
// Deliver data
if (isVideoSourceSSRC(recvSSRC)) {
parseIncomingPayloadType(buf, len, VIDEO_PACKET);
video_sink_->deliverVideoData(std::move(packet));
} else if (isAudioSourceSSRC(recvSSRC)) {
parseIncomingPayloadType(buf, len, AUDIO_PACKET);
audio_sink_->deliverAudioData(std::move(packet));
} else {
ELOG_DEBUG("%s read video unknownSSRC: %u, localVideoSSRC: %u, localAudioSSRC: %u",
toLog(), recvSSRC, this->getVideoSourceSSRC(), this->getAudioSourceSSRC());
}
} else {
if (packet->type == AUDIO_PACKET && audio_sink_ != nullptr) {
parseIncomingPayloadType(buf, len, AUDIO_PACKET);
// Firefox does not send SSRC in SDP
if (getAudioSourceSSRC() == 0) {
ELOG_DEBUG("%s discoveredAudioSourceSSRC:%u", toLog(), recvSSRC);
this->setAudioSourceSSRC(recvSSRC);
}
audio_sink_->deliverAudioData(std::move(packet));
} else if (packet->type == VIDEO_PACKET && video_sink_ != nullptr) {
parseIncomingPayloadType(buf, len, VIDEO_PACKET);
// Firefox does not send SSRC in SDP
if (getVideoSourceSSRC() == 0) {
ELOG_DEBUG("%s discoveredVideoSourceSSRC:%u", toLog(), recvSSRC);
this->setVideoSourceSSRC(recvSSRC);
}
// change ssrc for RTP packets, don't touch here if RTCP
video_sink_->deliverVideoData(std::move(packet));
}
} // if not bundle
} // if not Feedback
}
void RtcpProcessorHandler::write(Context *ctx, std::shared_ptr<dataPacket> packet) {
RtcpHeader *chead = reinterpret_cast<RtcpHeader*>(packet->data);
if (chead->isFeedback()) {
int length = processor_->analyzeFeedback(packet->data, packet->length);
if (length) {
ctx->fireWrite(packet);
}
return;
}
ctx->fireWrite(packet);
}
void SRPacketHandler::write(Context *ctx, std::shared_ptr<dataPacket> packet) {
if (initialized_ && enabled_) {
RtcpHeader *chead = reinterpret_cast<RtcpHeader*>(packet->data);
if (!chead->isRtcp() && enabled_) {
handleRtpPacket(packet);
} else if (chead->packettype == RTCP_Sender_PT && enabled_) {
handleSR(packet);
}
}
ctx->fireWrite(packet);
}
void DtlsTransport::onNiceData(packetPtr packet) {
int len = packet->length;
char *data = packet->data;
unsigned int component_id = packet->comp;
int length = len;
SrtpChannel *srtp = srtp_.get();
if (DtlsTransport::isDtlsPacket(data, len)) {
ELOG_DEBUG("%s message: Received DTLS message, transportName: %s, componentId: %u",
toLog(), transport_name.c_str(), component_id);
if (component_id == 1) {
if (rtp_resender_.get() != NULL) {
rtp_resender_->cancel();
}
dtlsRtp->read(reinterpret_cast<unsigned char*>(data), len);
} else {
if (rtcp_resender_.get() != NULL) {
rtcp_resender_->cancel();
}
dtlsRtcp->read(reinterpret_cast<unsigned char*>(data), len);
}
return;
} else if (this->getTransportState() == TRANSPORT_READY) {
unprotect_packet_->length = len;
unprotect_packet_->received_time_ms = packet->received_time_ms;
memcpy(unprotect_packet_->data, data, len);
if (dtlsRtcp != NULL && component_id == 2) {
srtp = srtcp_.get();
}
if (srtp != NULL) {
RtcpHeader *chead = reinterpret_cast<RtcpHeader*>(unprotect_packet_->data);
if (chead->isRtcp()) {
if (srtp->unprotectRtcp(unprotect_packet_->data, &unprotect_packet_->length) < 0) {
return;
}
} else {
if (srtp->unprotectRtp(unprotect_packet_->data, &unprotect_packet_->length) < 0) {
return;
}
}
} else {
return;
}
if (length <= 0) {
return;
}
getTransportListener()->onTransportData(unprotect_packet_, this);
}
}
void RtcpProcessorHandler::read(Context *ctx, std::shared_ptr<dataPacket> packet) {
RtcpHeader *chead = reinterpret_cast<RtcpHeader*> (packet->data);
if (chead->isRtcp()) {
if (chead->packettype == RTCP_Sender_PT) { // Sender Report
processor_->analyzeSr(chead);
}
} else {
if (stats_->getNode()["total"].hasChild("bitrateCalculated")) {
processor_->setPublisherBW(stats_->getNode()["total"]["bitrateCalculated"].value());
}
}
processor_->checkRtcpFb();
ctx->fireRead(packet);
}
void PacketCodecParser::read(Context *ctx, std::shared_ptr<DataPacket> packet) {
RtcpHeader *chead = reinterpret_cast<RtcpHeader*>(packet->data);
if (!chead->isRtcp() && enabled_) {
RtpHeader *rtp_header = reinterpret_cast<RtpHeader*>(packet->data);
RtpMap *codec =
stream_->getRemoteSdpInfo()->getCodecByExternalPayloadType(
rtp_header->getPayloadType());
if (codec) {
packet->codec = codec->encoding_name;
packet->clock_rate = codec->clock_rate;
ELOG_DEBUG("Reading codec: %s, clock: %u", packet->codec.c_str(), packet->clock_rate);
}
}
ctx->fireRead(std::move(packet));
}
int WebRtcConnection::deliverFeedback_(char* buf, int len){
// Check where to send the feedback
RtcpHeader *chead = reinterpret_cast<RtcpHeader*> (buf);
// ELOG_DEBUG("received Feedback type %u ssrc %u, sourcessrc %u", chead->packettype, chead->getSSRC(), chead->getSourceSSRC());
if (chead->getSourceSSRC() == this->getAudioSourceSSRC()) {
writeSsrc(buf,len,this->getAudioSinkSSRC());
} else {
writeSsrc(buf,len,this->getVideoSinkSSRC());
}
if (videoTransport_ != NULL) {
this->queueData(0, buf, len, videoTransport_);
}
return len;
}
int MediaStream::deliverFeedback_(std::shared_ptr<DataPacket> fb_packet) {
RtcpHeader *chead = reinterpret_cast<RtcpHeader*>(fb_packet->data);
uint32_t recvSSRC = chead->getSourceSSRC();
if (isVideoSourceSSRC(recvSSRC)) {
fb_packet->type = VIDEO_PACKET;
sendPacketAsync(fb_packet);
} else if (isAudioSourceSSRC(recvSSRC)) {
fb_packet->type = AUDIO_PACKET;
sendPacketAsync(fb_packet);
} else {
ELOG_DEBUG("%s deliverFeedback unknownSSRC: %u, localVideoSSRC: %u, localAudioSSRC: %u",
toLog(), recvSSRC, this->getVideoSourceSSRC(), this->getAudioSourceSSRC());
}
return fb_packet->length;
}
void MediaStream::changeDeliverPayloadType(DataPacket *dp, packetType type) {
RtpHeader* h = reinterpret_cast<RtpHeader*>(dp->data);
RtcpHeader *chead = reinterpret_cast<RtcpHeader*>(dp->data);
if (!chead->isRtcp()) {
int internalPT = h->getPayloadType();
int externalPT = internalPT;
if (type == AUDIO_PACKET) {
externalPT = remote_sdp_->getAudioExternalPT(internalPT);
} else if (type == VIDEO_PACKET) {
externalPT = remote_sdp_->getVideoExternalPT(externalPT);
}
if (internalPT != externalPT) {
h->setPayloadType(externalPT);
}
}
}
void ExternalOutput::queueData(char* buffer, int length, packetType type){
if (!recording_) {
return;
}
RtcpHeader *head = reinterpret_cast<RtcpHeader*>(buffer);
if (head->isRtcp()){
return;
}
if (firstDataReceived_ == -1) {
timeval time;
gettimeofday(&time, NULL);
firstDataReceived_ = (time.tv_sec * 1000) + (time.tv_usec / 1000);
if (this->getAudioSinkSSRC() == 0){
ELOG_DEBUG("No audio detected");
context_->oformat->audio_codec = AV_CODEC_ID_PCM_MULAW;
}
}
timeval time;
gettimeofday(&time, NULL);
unsigned long long millis = (time.tv_sec * 1000) + (time.tv_usec / 1000);
if (millis -lastFullIntraFrameRequest_ >FIR_INTERVAL_MS){
this->sendFirPacket();
lastFullIntraFrameRequest_ = millis;
}
if (type == VIDEO_PACKET){
if(this->videoOffsetMsec_ == -1) {
videoOffsetMsec_ = ((time.tv_sec * 1000) + (time.tv_usec / 1000)) - firstDataReceived_;
ELOG_DEBUG("File %s, video offset msec: %llu", context_->filename, videoOffsetMsec_);
}
videoQueue_.pushPacket(buffer, length);
}else{
if(this->audioOffsetMsec_ == -1) {
audioOffsetMsec_ = ((time.tv_sec * 1000) + (time.tv_usec / 1000)) - firstDataReceived_;
ELOG_DEBUG("File %s, audio offset msec: %llu", context_->filename, audioOffsetMsec_);
}
audioQueue_.pushPacket(buffer, length);
}
if( audioQueue_.hasData() || videoQueue_.hasData()) {
// One or both of our queues has enough data to write stuff out. Notify our writer.
cond_.notify_one();
}
}
void RtcpFeedbackGenerationHandler::read(Context *ctx, std::shared_ptr<DataPacket> packet) {
// Pass packets to RR and NACK Generator
RtcpHeader *chead = reinterpret_cast<RtcpHeader*>(packet->data);
if (!initialized_) {
ctx->fireRead(std::move(packet));
return;
}
if (chead->getPacketType() == RTCP_Sender_PT) {
uint32_t ssrc = chead->getSSRC();
auto generator_it = generators_map_.find(ssrc);
if (generator_it != generators_map_.end()) {
generator_it->second->rr_generator->handleSr(packet);
} else {
ELOG_DEBUG("message: no RrGenerator found, ssrc: %u", ssrc);
}
ctx->fireRead(std::move(packet));
return;
}
bool should_send_rr = false;
bool should_send_nack = false;
if (!chead->isRtcp()) {
RtpHeader *head = reinterpret_cast<RtpHeader*>(packet->data);
uint32_t ssrc = head->getSSRC();
auto generator_it = generators_map_.find(ssrc);
if (generator_it != generators_map_.end()) {
should_send_rr = generator_it->second->rr_generator->handleRtpPacket(packet);
if (nacks_enabled_) {
should_send_nack = generator_it->second->nack_generator->handleRtpPacket(packet);
}
} else {
ELOG_DEBUG("message: no Generator found, ssrc: %u", ssrc);
}
if (should_send_rr || should_send_nack) {
ELOG_DEBUG("message: Should send Rtcp, ssrc %u", ssrc);
std::shared_ptr<DataPacket> rtcp_packet = generator_it->second->rr_generator->generateReceiverReport();
if (nacks_enabled_ && generator_it->second->nack_generator != nullptr) {
generator_it->second->nack_generator->addNackPacketToRr(rtcp_packet);
}
ctx->fireWrite(std::move(rtcp_packet));
}
}
ctx->fireRead(std::move(packet));
}
void DtlsTransport::onNiceData(unsigned int component_id, char* data, int len, NiceConnection* nice)
{
int length = len;
SrtpChannel* srtp = srtp_.get();
if (DtlsTransport::isDtlsPacket(data, len)) {
ELOG_DEBUG("%s - Received DTLS message from %u", transport_name.c_str(), component_id);
if (component_id == 1) {
if (rtpResender_.get() != NULL) {
rtpResender_->cancel();
}
dtlsRtp_->read(reinterpret_cast<unsigned char*>(data), len);
} else {
if (rtcpResender_.get() != NULL) {
rtcpResender_->cancel();
}
dtlsRtcp_->read(reinterpret_cast<unsigned char*>(data), len);
}
return;
} else if (this->getTransportState() == TRANSPORT_READY) {
memcpy(unprotectBuf_, data, len);
if (dtlsRtcp_ != NULL && component_id == 2) {
srtp = srtcp_.get();
}
if (srtp != NULL) {
RtcpHeader* chead = reinterpret_cast<RtcpHeader*>(unprotectBuf_);
if (chead->isRtcp()) {
if (srtp->unprotectRtcp(unprotectBuf_, &length) < 0) {
return;
}
} else {
if (srtp->unprotectRtp(unprotectBuf_, &length) < 0) {
return;
}
}
} else {
return;
}
if (length <= 0) {
return;
}
getTransportListener()->onTransportData(unprotectBuf_, length, this);
}
}
// parses incoming payload type, replaces occurence in buf
void MediaStream::parseIncomingPayloadType(char *buf, int len, packetType type) {
RtcpHeader* chead = reinterpret_cast<RtcpHeader*>(buf);
RtpHeader* h = reinterpret_cast<RtpHeader*>(buf);
if (!chead->isRtcp()) {
int externalPT = h->getPayloadType();
int internalPT = externalPT;
if (type == AUDIO_PACKET) {
internalPT = remote_sdp_->getAudioInternalPT(externalPT);
} else if (type == VIDEO_PACKET) {
internalPT = remote_sdp_->getVideoInternalPT(externalPT);
}
if (externalPT != internalPT) {
h->setPayloadType(internalPT);
} else {
// ELOG_WARN("onTransportData did not find mapping for %i", externalPT);
}
}
}
void RtpPaddingGeneratorHandler::write(Context *ctx, std::shared_ptr<DataPacket> packet) {
RtcpHeader *chead = reinterpret_cast<RtcpHeader*>(packet->data);
bool is_higher_sequence_number = false;
if (packet->type == VIDEO_PACKET && !chead->isRtcp()) {
stream_->getWorker()->unschedule(scheduled_task_);
is_higher_sequence_number = isHigherSequenceNumber(packet);
if (!first_packet_received_) {
started_at_ = clock_->now();
}
first_packet_received_ = true;
}
ctx->fireWrite(packet);
if (is_higher_sequence_number) {
onVideoPacket(std::move(packet));
}
}
int RtcpForwarder::addREMB(char* buf, int len, uint32_t bitrate){
buf+=len;
RtcpHeader theREMB;
theREMB.setPacketType(RTCP_PS_Feedback_PT);
theREMB.setBlockCount(RTCP_AFB);
memcpy(&theREMB.report.rembPacket.uniqueid, "REMB", 4);
theREMB.setSSRC(rtcpSink_->getVideoSinkSSRC());
theREMB.setSourceSSRC(rtcpSource_->getVideoSourceSSRC());
theREMB.setLength(5);
theREMB.setREMBBitRate(bitrate);
theREMB.setREMBNumSSRC(1);
theREMB.setREMBFeedSSRC(rtcpSource_->getVideoSourceSSRC());
int rembLength = (theREMB.getLength()+1)*4;
memcpy(buf, (uint8_t*)&theREMB, rembLength);
return (len+rembLength);
}
// parses incoming payload type, replaces occurence in buf
void WebRtcConnection::parseIncomingPayloadType(char *buf, int len, packetType type) {
RtcpHeader* chead = reinterpret_cast<RtcpHeader*>(buf);
RtpHeader* h = reinterpret_cast<RtpHeader*>(buf);
if (!chead->isRtcp()) {
int externalPT = h->getPayloadType();
int internalPT = externalPT;
if (type == AUDIO_PACKET) {
internalPT = remoteSdp_.getAudioInternalPT(externalPT);
} else if (type == VIDEO_PACKET) {
internalPT = remoteSdp_.getVideoInternalPT(externalPT);
}
if (externalPT != internalPT) {
h->setPayloadType(internalPT);
// ELOG_ERROR("onTransportData mapping %i to %i", externalPT, internalPT);
} else {
// ELOG_ERROR("onTransportData did not find mapping for %i", externalPT);
}
}
}
int RtcpForwarder::addNACK(char* buf, int len, uint16_t seqNum, uint16_t blp, uint32_t sourceSsrc, uint32_t sinkSsrc){
buf+=len;
ELOG_DEBUG("Setting PID %u, BLP %u", seqNum , blp);
RtcpHeader theNACK;
theNACK.setPacketType(RTCP_RTP_Feedback_PT);
theNACK.setBlockCount(1);
theNACK.setNackPid(seqNum);
theNACK.setNackBlp(blp);
theNACK.setSSRC(sinkSsrc);
theNACK.setSourceSSRC(sourceSsrc);
theNACK.setLength(3);
int nackLength = (theNACK.getLength()+1)*4;
memcpy(buf, (uint8_t*)&theNACK, nackLength);
return (len+nackLength);
}
void DtlsTransport::write(char* data, int len) {
boost::mutex::scoped_lock lock(writeMutex_);
if (nice_==NULL)
return;
int length = len;
SrtpChannel *srtp = srtp_.get();
if (this->getTransportState() == TRANSPORT_READY) {
memcpy(protectBuf_, data, len);
int comp = 1;
RtcpHeader *chead = reinterpret_cast<RtcpHeader*> (protectBuf_);
if (chead->isRtcp()) {
if (!rtcp_mux_) {
comp = 2;
}
if (dtlsRtcp != NULL) {
srtp = srtcp_.get();
}
if (srtp && nice_->checkIceState() == NICE_READY) {
if(srtp->protectRtcp(protectBuf_, &length)<0) {
return;
}
}
}
else{
comp = 1;
if (srtp && nice_->checkIceState() == NICE_READY) {
if(srtp->protectRtp(protectBuf_, &length)<0) {
return;
}
}
}
if (length <= 10) {
return;
}
if (nice_->checkIceState() == NICE_READY) {
this->writeOnNice(comp, protectBuf_, length);
}
}
}
int OneToManyProcessor::deliverVideoData_(char* buf, int len) {
if (subscribers.empty() || len <= 0)
return 0;
RtcpHeader* head = reinterpret_cast<RtcpHeader*>(buf);
if(head->isFeedback()){
ELOG_WARN("Receiving Feedback in wrong path: %d", head->packettype);
if (feedbackSink_!=NULL){
head->ssrc = htonl(publisher->getVideoSourceSSRC());
feedbackSink_->deliverFeedback(buf,len);
}
return 0;
}
std::map<std::string, sink_ptr>::iterator it;
for (it = subscribers.begin(); it != subscribers.end(); ++it) {
if((*it).second != NULL) {
(*it).second->deliverVideoData(buf, len);
}
}
sentPackets_++;
return 0;
}
int MediaStream::sendPLI() {
RtcpHeader thePLI;
thePLI.setPacketType(RTCP_PS_Feedback_PT);
thePLI.setBlockCount(1);
thePLI.setSSRC(this->getVideoSinkSSRC());
thePLI.setSourceSSRC(this->getVideoSourceSSRC());
thePLI.setLength(2);
char *buf = reinterpret_cast<char*>(&thePLI);
int len = (thePLI.getLength() + 1) * 4;
sendPacketAsync(std::make_shared<DataPacket>(0, buf, len, VIDEO_PACKET));
return len;
}
int OneToManyProcessor::deliverVideoData_(std::shared_ptr<dataPacket> video_packet) {
if (video_packet->length <= 0)
return 0;
RtcpHeader* head = reinterpret_cast<RtcpHeader*>(video_packet->data);
if (head->isFeedback()) {
ELOG_WARN("Receiving Feedback in wrong path: %d", head->packettype);
if (feedbackSink_ != nullptr) {
head->ssrc = htonl(publisher->getVideoSourceSSRC());
feedbackSink_->deliverFeedback(video_packet);
}
return 0;
}
boost::unique_lock<boost::mutex> lock(monitor_mutex_);
if (subscribers.empty())
return 0;
std::map<std::string, std::shared_ptr<MediaSink>>::iterator it;
for (it = subscribers.begin(); it != subscribers.end(); ++it) {
if ((*it).second != nullptr) {
(*it).second->deliverVideoData(video_packet);
}
}
return 0;
}
void RtpPaddingRemovalHandler::read(Context *ctx, std::shared_ptr<DataPacket> packet) {
RtcpHeader *chead = reinterpret_cast<RtcpHeader*>(packet->data);
RtpHeader *rtp_header = reinterpret_cast<RtpHeader*>(packet->data);
if (!chead->isRtcp() && enabled_ && packet->type == VIDEO_PACKET) {
uint32_t ssrc = rtp_header->getSSRC();
std::shared_ptr<SequenceNumberTranslator> translator = getTranslatorForSsrc(ssrc, true);
if (!removePaddingBytes(packet, translator)) {
return;
}
uint16_t sequence_number = rtp_header->getSeqNumber();
SequenceNumber sequence_number_info = translator->get(sequence_number, false);
if (sequence_number_info.type != SequenceNumberType::Valid) {
ELOG_DEBUG("Invalid translation %u, ssrc: %u", sequence_number, ssrc);
return;
}
ELOG_DEBUG("Changing seq_number from %u to %u, ssrc %u", sequence_number, sequence_number_info.output,
ssrc);
rtp_header->setSeqNumber(sequence_number_info.output);
}
ctx->fireRead(std::move(packet));
}
