void ExternalOutput::writeAudioData(char* buf, int len){
RtpHeader* head = reinterpret_cast<RtpHeader*>(buf);
uint16_t currentAudioSequenceNumber = head->getSeqNumber();
if (currentAudioSequenceNumber != lastAudioSequenceNumber_ + 1) {
// Something screwy. We should always see sequence numbers incrementing monotonically.
ELOG_DEBUG("Unexpected audio sequence number; current %d, previous %d", currentAudioSequenceNumber, lastAudioSequenceNumber_);
}
lastAudioSequenceNumber_ = currentAudioSequenceNumber;
if (firstAudioTimestamp_ == -1) {
firstAudioTimestamp_ = head->getTimestamp();
}
timeval time;
gettimeofday(&time, NULL);
// Figure out our audio codec.
if(context_->oformat->audio_codec == AV_CODEC_ID_NONE) {
//We dont need any other payload at this time
if(head->getPayloadType() == PCMU_8000_PT){
context_->oformat->audio_codec = AV_CODEC_ID_PCM_MULAW;
} else if (head->getPayloadType() == OPUS_48000_PT) {
context_->oformat->audio_codec = AV_CODEC_ID_OPUS;
}
}
initContext();
if (audio_stream_ == NULL) {
// not yet.
return;
}
long long currentTimestamp = head->getTimestamp();
if (currentTimestamp - firstAudioTimestamp_ < 0) {
// we wrapped. add 2^32 to correct this. We only handle a single wrap around since that's 13 hours of recording, minimum.
currentTimestamp += 0xFFFFFFFF;
}
long long timestampToWrite = (currentTimestamp - firstAudioTimestamp_) / (audio_stream_->codec->time_base.den / audio_stream_->time_base.den);
// Adjust for our start time offset
timestampToWrite += audioOffsetMsec_ / (1000 / audio_stream_->time_base.den); // in practice, our timebase den is 1000, so this operation is a no-op.
/* ELOG_DEBUG("Writing audio frame %d with timestamp %u, normalized timestamp %u, audio offset msec %u, length %d, input timebase: %d/%d, target timebase: %d/%d", */
/* head->getSeqNumber(), head->getTimestamp(), timestampToWrite, audioOffsetMsec_, ret, */
/* audio_stream_->codec->time_base.num, audio_stream_->codec->time_base.den, // timebase we requested */
/* audio_stream_->time_base.num, audio_stream_->time_base.den); // actual timebase */
AVPacket avpkt;
av_init_packet(&avpkt);
avpkt.data = (uint8_t*) buf + head->getHeaderLength();
avpkt.size = len - head->getHeaderLength();
avpkt.pts = timestampToWrite;
avpkt.stream_index = 1;
av_write_frame(context_, &avpkt);
av_free_packet(&avpkt);
}
void ExternalOutput::writeAudioData(char* buf, int len){
RtpHeader* head = reinterpret_cast<RtpHeader*>(buf);
if (firstAudioTimestamp_ == -1) {
firstAudioTimestamp_ = head->getTimestamp();
}
timeval time;
gettimeofday(&time, NULL);
// Figure out our audio codec.
if(context_->oformat->audio_codec == AV_CODEC_ID_NONE) {
//We dont need any other payload at this time
if(head->getPayloadType() == PCMU_8000_PT){
context_->oformat->audio_codec = AV_CODEC_ID_PCM_MULAW;
} else if (head->getPayloadType() == OPUS_48000_PT) {
context_->oformat->audio_codec = AV_CODEC_ID_OPUS;
}
}
initContext();
if (audio_stream_ == NULL) {
// not yet.
return;
}
int ret = inputProcessor_->unpackageAudio(reinterpret_cast<unsigned char*>(buf), len, unpackagedAudioBuffer_);
if (ret <= 0)
return;
long long currentTimestamp = head->getTimestamp();
if (currentTimestamp - firstAudioTimestamp_ < 0) {
// we wrapped. add 2^32 to correct this. We only handle a single wrap around since that's 13 hours of recording, minimum.
currentTimestamp += 0xFFFFFFFF;
}
long long timestampToWrite = (currentTimestamp - firstAudioTimestamp_) / (audio_stream_->codec->time_base.den / audio_stream_->time_base.den);
// Adjust for our start time offset
timestampToWrite += audioOffsetMsec_ / (1000 / audio_stream_->time_base.den); // in practice, our timebase den is 1000, so this operation is a no-op.
/* ELOG_DEBUG("Writing audio frame %d with timestamp %u, normalized timestamp %u, audio offset msec %u, length %d, input timebase: %d/%d, target timebase: %d/%d", */
/* head->getSeqNumber(), head->getTimestamp(), timestampToWrite, audioOffsetMsec_, ret, */
/* audio_stream_->codec->time_base.num, audio_stream_->codec->time_base.den, // timebase we requested */
/* audio_stream_->time_base.num, audio_stream_->time_base.den); // actual timebase */
AVPacket avpkt;
av_init_packet(&avpkt);
avpkt.data = unpackagedAudioBuffer_;
avpkt.size = ret;
avpkt.pts = timestampToWrite;
avpkt.stream_index = 1;
av_write_frame(context_, &avpkt);
av_free_packet(&avpkt);
}
void ExternalOutput::writeAudioData(char* buf, int len) {
RtpHeader* head = reinterpret_cast<RtpHeader*>(buf);
uint16_t currentAudioSequenceNumber = head->getSeqNumber();
if (first_audio_timestamp_ != -1 && currentAudioSequenceNumber != lastAudioSequenceNumber_ + 1) {
// Something screwy. We should always see sequence numbers incrementing monotonically.
ELOG_DEBUG("Unexpected audio sequence number; current %d, previous %d",
currentAudioSequenceNumber, lastAudioSequenceNumber_);
}
lastAudioSequenceNumber_ = currentAudioSequenceNumber;
if (first_audio_timestamp_ == -1) {
first_audio_timestamp_ = head->getTimestamp();
}
// Figure out our audio codec.
if (context_->oformat->audio_codec == AV_CODEC_ID_NONE) {
// We dont need any other payload at this time
if (head->getPayloadType() == PCMU_8000_PT) {
context_->oformat->audio_codec = AV_CODEC_ID_PCM_MULAW;
} else if (head->getPayloadType() == OPUS_48000_PT) {
context_->oformat->audio_codec = AV_CODEC_ID_OPUS;
}
}
initContext();
if (audio_stream_ == NULL) {
// not yet.
return;
}
long long currentTimestamp = head->getTimestamp(); // NOLINT
if (currentTimestamp - first_audio_timestamp_ < 0) {
// we wrapped. add 2^32 to correct this. We only handle a single wrap around
// since that's 13 hours of recording, minimum.
currentTimestamp += 0xFFFFFFFF;
}
long long timestampToWrite = (currentTimestamp - first_audio_timestamp_) / // NOLINT
(audio_stream_->codec->sample_rate / audio_stream_->time_base.den);
// generally 48000 / 1000 for the denominator portion, at least for opus
// Adjust for our start time offset
// in practice, our timebase den is 1000, so this operation is a no-op.
timestampToWrite += audio_offset_ms_ / (1000 / audio_stream_->time_base.den);
AVPacket avpkt;
av_init_packet(&avpkt);
avpkt.data = reinterpret_cast<uint8_t*>(buf) + head->getHeaderLength();
avpkt.size = len - head->getHeaderLength();
avpkt.pts = timestampToWrite;
avpkt.stream_index = 1;
av_interleaved_write_frame(context_, &avpkt); // takes ownership of the packet
}
bool RtcpRrGenerator::isRetransmitOfOldPacket(std::shared_ptr<dataPacket> packet) {
RtpHeader *head = reinterpret_cast<RtpHeader*>(packet->data);
if (!RtpUtils::sequenceNumberLessThan(head->getSeqNumber(), rr_info_.max_seq) || rr_info_.jitter.jitter == 0) {
return false;
}
int64_t time_diff_ms = static_cast<uint32_t>(packet->received_time_ms) - rr_info_.last_recv_ts;
int64_t timestamp_diff = static_cast<int32_t>(head->getTimestamp() - rr_info_.last_rtp_ts);
uint16_t clock_rate = type_ == VIDEO_PACKET ? getVideoClockRate(head->getPayloadType()) :
getAudioClockRate(head->getPayloadType());
int64_t rtp_time_stamp_diff_ms = timestamp_diff / clock_rate;
int64_t max_delay_ms = ((2 * rr_info_.jitter.jitter) / clock_rate);
return time_diff_ms > rtp_time_stamp_diff_ms + max_delay_ms;
}
bool RtcpRrGenerator::handleRtpPacket(std::shared_ptr<dataPacket> packet) {
RtpHeader *head = reinterpret_cast<RtpHeader*>(packet->data);
if (ssrc_ != head->getSSRC()) {
ELOG_DEBUG("message: handleRtpPacket ssrc not found, ssrc: %u", head->getSSRC());
return false;
}
uint16_t seq_num = head->getSeqNumber();
rr_info_.packets_received++;
if (rr_info_.base_seq == -1) {
rr_info_.base_seq = head->getSeqNumber();
}
if (rr_info_.max_seq == -1) {
rr_info_.max_seq = seq_num;
} else if (!RtpUtils::sequenceNumberLessThan(seq_num, rr_info_.max_seq)) {
if (seq_num < rr_info_.max_seq) {
rr_info_.cycle++;
}
rr_info_.max_seq = seq_num;
}
rr_info_.extended_seq = (rr_info_.cycle << 16) | rr_info_.max_seq;
uint16_t clock_rate = type_ == VIDEO_PACKET ? getVideoClockRate(head->getPayloadType()) :
getAudioClockRate(head->getPayloadType());
if (head->getTimestamp() != rr_info_.last_rtp_ts &&
!isRetransmitOfOldPacket(packet)) {
int transit_time = static_cast<int>((packet->received_time_ms * clock_rate) - head->getTimestamp());
int delta = abs(transit_time - rr_info_.jitter.transit_time);
if (rr_info_.jitter.transit_time != 0 && delta < MAX_DELAY) {
rr_info_.jitter.jitter +=
(1. / 16.) * (static_cast<double>(delta) - rr_info_.jitter.jitter);
}
rr_info_.jitter.transit_time = transit_time;
}
rr_info_.last_rtp_ts = head->getTimestamp();
rr_info_.last_recv_ts = static_cast<uint32_t>(packet->received_time_ms);
uint64_t now = ClockUtils::timePointToMs(clock_->now());
if (rr_info_.next_packet_ms == 0) { // Schedule the first packet
uint16_t selected_interval = selectInterval();
rr_info_.next_packet_ms = now + selected_interval;
return false;
}
if (now >= rr_info_.next_packet_ms) {
ELOG_DEBUG("message: should send packet, ssrc: %u", ssrc_);
return true;
}
return false;
}
void ExternalOutput::writeVideoData(char* buf, int len) {
RtpHeader* head = reinterpret_cast<RtpHeader*>(buf);
uint16_t current_video_sequence_number = head->getSeqNumber();
if (current_video_sequence_number != last_video_sequence_number_ + 1) {
// Something screwy. We should always see sequence numbers incrementing monotonically.
ELOG_DEBUG("Unexpected video sequence number; current %d, previous %d",
current_video_sequence_number, last_video_sequence_number_);
// Restart the depacketizer so it looks for the start of a frame
if (depacketizer_!= nullptr) {
depacketizer_->reset();
}
}
last_video_sequence_number_ = current_video_sequence_number;
if (first_video_timestamp_ == -1) {
first_video_timestamp_ = head->getTimestamp();
}
auto map_iterator = video_maps_.find(head->getPayloadType());
if (map_iterator != video_maps_.end()) {
updateVideoCodec(map_iterator->second);
if (map_iterator->second.encoding_name == "VP8" || map_iterator->second.encoding_name == "H264") {
maybeWriteVideoPacket(buf, len);
}
}
}
int InputProcessor::unpackageVideo(unsigned char* inBuff, int inBuffLen, unsigned char* outBuff, int* gotFrame) {
if (videoUnpackager == 0) {
ELOG_DEBUG("Unpackager not correctly initialized");
return -1;
}
int inBuffOffset = 0;
*gotFrame = 0;
RtpHeader* head = reinterpret_cast<RtpHeader*>(inBuff);
if (head->getPayloadType() != 100) {
return -1;
}
int l = inBuffLen - head->getHeaderLength();
inBuffOffset+=head->getHeaderLength();
erizo::RTPPayloadVP8* parsed = pars.parseVP8((unsigned char*) &inBuff[inBuffOffset], l);
memcpy(outBuff, parsed->data, parsed->dataLength);
if (head->getMarker()) {
*gotFrame = 1;
}
int ret = parsed->dataLength;
delete parsed;
return ret;
}
int main(int argc, const char * argv[]) {
// data setup
uint32_t first = 0xFFFF | 0x1FFFFFFF;
uint32_t timestamp = 0x0128;
uint32_t ssrc = 0x01 | 0x02 | 0x04 | 0x08 | 0x256;
int somedata[4];
// The htonl() function converts the unsigned integer hostlong from host byte order to network byte order.
// on the other side:
// The ntohl() function converts the unsigned integer netlong from network byte order to host byte order.
somedata[0] = htonl(first);
somedata[1] = htonl(timestamp);
somedata[2] = htonl(ssrc);
somedata[2] = htonl(ssrc);
somedata[3] = htonl(ssrc);
RtpHeader* head = reinterpret_cast<RtpHeader*>(somedata);
printf("version: %" PRIu8 "\n", head->getVersion());
printf("padding: %" PRIu8 "\n", head->hasPadding());
printf("extension: %" PRIu8 "\n", head->getExtension());
printf("marker: %" PRIu8 "\n", head->getMarker());
printf("payload type: %" PRIu8 "\n", head->getPayloadType());
printf("sequence number: %" PRIu16 "\n", head->getSeqNumber());
printf("timestamp %" PRIu32 "\n", head->getTimestamp());
printf("ssrc %" PRIu32 "\n", head->getSSRC());
printf("header length: %u\n", head->getHeaderLength());
return 0;
}
void RRGenerationHandler::handleRtpPacket(std::shared_ptr<dataPacket> packet) {
RtpHeader *head = reinterpret_cast<RtpHeader*>(packet->data);
auto rr_packet_pair = rr_info_map_.find(head->getSSRC());
if (rr_packet_pair == rr_info_map_.end()) {
ELOG_DEBUG("%s message: handleRtpPacket ssrc not found, ssrc: %u", connection_->toLog(), head->getSSRC());
return;
}
std::shared_ptr<RRPackets> selected_packet_info = rr_packet_pair->second;
uint16_t seq_num = head->getSeqNumber();
selected_packet_info->packets_received++;
if (selected_packet_info->base_seq == -1) {
selected_packet_info->ssrc = head->getSSRC();
selected_packet_info->base_seq = head->getSeqNumber();
}
if (selected_packet_info->max_seq == -1) {
selected_packet_info->max_seq = seq_num;
} else if (!rtpSequenceLessThan(seq_num, selected_packet_info->max_seq)) {
if (seq_num < selected_packet_info->max_seq) {
selected_packet_info->cycle++;
}
selected_packet_info->max_seq = seq_num;
}
selected_packet_info->extended_seq = (selected_packet_info->cycle << 16) | selected_packet_info->max_seq;
uint16_t clock_rate = selected_packet_info->type == VIDEO_PACKET ? getVideoClockRate(head->getPayloadType()) :
getAudioClockRate(head->getPayloadType());
if (head->getTimestamp() != selected_packet_info->last_rtp_ts &&
!isRetransmitOfOldPacket(packet, selected_packet_info)) {
int transit_time = static_cast<int>((packet->received_time_ms * clock_rate) - head->getTimestamp());
int delta = abs(transit_time - selected_packet_info->jitter.transit_time);
if (selected_packet_info->jitter.transit_time != 0 && delta < MAX_DELAY) {
selected_packet_info->jitter.jitter +=
(1. / 16.) * (static_cast<double>(delta) - selected_packet_info->jitter.jitter);
}
selected_packet_info->jitter.transit_time = transit_time;
}
selected_packet_info->last_rtp_ts = head->getTimestamp();
selected_packet_info->last_recv_ts = static_cast<uint32_t>(packet->received_time_ms);
uint64_t now = ClockUtils::timePointToMs(clock::now());
if (selected_packet_info->next_packet_ms == 0) { // Schedule the first packet
uint16_t selected_interval = selectInterval(selected_packet_info);
selected_packet_info->next_packet_ms = now + selected_interval;
return;
}
if (now >= selected_packet_info->next_packet_ms) {
sendRR(selected_packet_info);
}
}
void ExternalOutput::writeAudioData(char* buf, int len) {
RtpHeader* head = reinterpret_cast<RtpHeader*>(buf);
uint16_t current_audio_sequence_number = head->getSeqNumber();
if (first_audio_timestamp_ != -1 && current_audio_sequence_number != last_audio_sequence_number_ + 1) {
// Something screwy. We should always see sequence numbers incrementing monotonically.
ELOG_DEBUG("Unexpected audio sequence number; current %d, previous %d",
current_audio_sequence_number, last_audio_sequence_number_);
}
last_audio_sequence_number_ = current_audio_sequence_number;
if (first_audio_timestamp_ == -1) {
first_audio_timestamp_ = head->getTimestamp();
}
auto map_iterator = audio_maps_.find(head->getPayloadType());
if (map_iterator != audio_maps_.end()) {
updateAudioCodec(map_iterator->second);
}
initContext();
if (audio_stream_ == nullptr) {
// not yet.
return;
}
long long current_timestamp = head->getTimestamp(); // NOLINT
if (current_timestamp - first_audio_timestamp_ < 0) {
// we wrapped. add 2^32 to correct this. We only handle a single wrap around
// since that's 13 hours of recording, minimum.
current_timestamp += 0xFFFFFFFF;
}
long long timestamp_to_write = (current_timestamp - first_audio_timestamp_) / // NOLINT
(audio_stream_->codec->sample_rate / audio_stream_->time_base.den);
// generally 48000 / 1000 for the denominator portion, at least for opus
// Adjust for our start time offset
// in practice, our timebase den is 1000, so this operation is a no-op.
timestamp_to_write += audio_offset_ms_ / (1000 / audio_stream_->time_base.den);
AVPacket av_packet;
av_init_packet(&av_packet);
av_packet.data = reinterpret_cast<uint8_t*>(buf) + head->getHeaderLength();
av_packet.size = len - head->getHeaderLength();
av_packet.pts = timestamp_to_write;
av_packet.stream_index = 1;
av_interleaved_write_frame(context_, &av_packet); // takes ownership of the packet
}
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);
}
}
}
int OneToManyTranscoder::deliverVideoData_(char* buf, int len) {
memcpy(sendVideoBuffer_, buf, len);
RtpHeader* theHead = reinterpret_cast<RtpHeader*>(buf);
// ELOG_DEBUG("extension %d pt %u", theHead->getExtension(),
// theHead->getPayloadType());
if (theHead->getPayloadType() == 100) {
ip_->deliverVideoData(sendVideoBuffer_, len);
} else {
this->receiveRtpData((unsigned char*) buf, len);
}
sentPackets_++;
return 0;
}
// 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);
}
}
}
// 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 WebRtcConnection::deliverVideoData_(char* buf, int len) {
writeSsrc(buf, len, this->getVideoSinkSSRC());
if (videoTransport_ != NULL) {
if (videoEnabled_ == true) {
RtpHeader* h = reinterpret_cast<RtpHeader*>(buf);
if (h->getPayloadType() == RED_90000_PT && !remoteSdp_.supportPayloadType(RED_90000_PT)) {
// This is a RED/FEC payload, but our remote endpoint doesn't support that (most likely because it's firefox :/ )
// Let's go ahead and run this through our fec receiver to convert it to raw VP8
webrtc::RTPHeader hackyHeader;
hackyHeader.headerLength = h->getHeaderLength();
hackyHeader.sequenceNumber = h->getSeqNumber();
// FEC copies memory, manages its own memory, including memory passed in callbacks (in the callback, be sure to memcpy out of webrtc's buffers
if (fec_receiver_.AddReceivedRedPacket(hackyHeader, (const uint8_t*) buf, len, ULP_90000_PT) == 0) {
fec_receiver_.ProcessReceivedFec();
}
} else {
this->queueData(0, buf, len, videoTransport_);
}
}
}
return len;
}
void ExternalOutput::writeVideoData(char* buf, int len){
RtpHeader* head = reinterpret_cast<RtpHeader*>(buf);
if (head->getPayloadType() == RED_90000_PT) {
int totalLength = head->getHeaderLength();
int rtpHeaderLength = totalLength;
RedHeader *redhead = reinterpret_cast<RedHeader*>(buf + totalLength);
if (redhead->payloadtype == VP8_90000_PT) {
while (redhead->follow) {
totalLength += redhead->getLength() + 4; // RED header
redhead = reinterpret_cast<RedHeader*>(buf + totalLength);
}
// Parse RED packet to VP8 packet.
// Copy RTP header
memcpy(deliverMediaBuffer_, buf, rtpHeaderLength);
// Copy payload data
memcpy(deliverMediaBuffer_ + totalLength, buf + totalLength + 1, len - totalLength - 1);
// Copy payload type
RtpHeader *mediahead = reinterpret_cast<RtpHeader*>(deliverMediaBuffer_);
mediahead->setPayloadType(redhead->payloadtype);
buf = reinterpret_cast<char*>(deliverMediaBuffer_);
len = len - 1 - totalLength + rtpHeaderLength;
}
}
if (firstVideoTimestamp_ == -1) {
firstVideoTimestamp_ = head->getTimestamp();
}
int gotUnpackagedFrame = false;
int ret = inputProcessor_->unpackageVideo(reinterpret_cast<unsigned char*>(buf), len, unpackagedBufferpart_, &gotUnpackagedFrame);
if (ret < 0){
ELOG_ERROR("Error Unpackaging Video");
return;
}
initContext();
if (video_stream_ == NULL) {
// could not init our context yet.
return;
}
unpackagedSize_ += ret;
unpackagedBufferpart_ += ret;
if (gotUnpackagedFrame) {
unpackagedBufferpart_ -= unpackagedSize_;
long long currentTimestamp = head->getTimestamp();
if (currentTimestamp - firstVideoTimestamp_ < 0) {
// we wrapped. add 2^32 to correct this. We only handle a single wrap around since that's ~13 hours of recording, minimum.
currentTimestamp += 0xFFFFFFFF;
}
long long timestampToWrite = (currentTimestamp - firstVideoTimestamp_) / (90000 / video_stream_->time_base.den); // All of our video offerings are using a 90khz clock.
// Adjust for our start time offset
timestampToWrite += videoOffsetMsec_ / (1000 / video_stream_->time_base.den); // in practice, our timebase den is 1000, so this operation is a no-op.
/* ELOG_DEBUG("Writing video frame %d with timestamp %u, normalized timestamp %u, video offset msec %u, length %d, input timebase: %d/%d, target timebase: %d/%d", */
/* head->getSeqNumber(), head->getTimestamp(), timestampToWrite, videoOffsetMsec_, unpackagedSize_, */
/* video_stream_->codec->time_base.num, video_stream_->codec->time_base.den, // timebase we requested */
/* video_stream_->time_base.num, video_stream_->time_base.den); // actual timebase */
AVPacket avpkt;
av_init_packet(&avpkt);
avpkt.data = unpackagedBufferpart_;
avpkt.size = unpackagedSize_;
avpkt.pts = timestampToWrite;
avpkt.stream_index = 0;
av_write_frame(context_, &avpkt);
av_free_packet(&avpkt);
unpackagedSize_ = 0;
unpackagedBufferpart_ = unpackagedBuffer_;
}
}
void ExternalOutput::queueData(char* buffer, int length, packetType type) {
if (!recording_) {
return;
}
RtcpHeader *head = reinterpret_cast<RtcpHeader*>(buffer);
if (head->isRtcp()) {
return;
}
if (first_data_received_ == time_point()) {
first_data_received_ = clock::now();
if (getAudioSinkSSRC() == 0) {
ELOG_DEBUG("No audio detected");
audio_map_ = RtpMap{0, "PCMU", 8000, AUDIO_TYPE, 1};
audio_codec_ = AV_CODEC_ID_PCM_MULAW;
}
}
if (need_to_send_fir_ && video_source_ssrc_) {
sendFirPacket();
need_to_send_fir_ = false;
}
if (type == VIDEO_PACKET) {
RtpHeader* h = reinterpret_cast<RtpHeader*>(buffer);
uint8_t payloadtype = h->getPayloadType();
if (video_offset_ms_ == -1) {
video_offset_ms_ = ClockUtils::durationToMs(clock::now() - first_data_received_);
ELOG_DEBUG("File %s, video offset msec: %llu", context_->filename, video_offset_ms_);
video_queue_.setTimebase(video_maps_[payloadtype].clock_rate);
}
// If this is a red header, let's push it to our fec_receiver_, which will spit out frames in one
// of our other callbacks.
// Otherwise, just stick it straight into the video queue.
if (payloadtype == RED_90000_PT) {
// The only things AddReceivedRedPacket uses are headerLength and sequenceNumber.
// Unfortunately the amount of crap
// we would have to pull in from the WebRtc project to fully construct
// a webrtc::RTPHeader object is obscene. So
// let's just do this hacky fix.
webrtc::RTPHeader hacky_header;
hacky_header.headerLength = h->getHeaderLength();
hacky_header.sequenceNumber = h->getSeqNumber();
// AddReceivedRedPacket returns 0 if there's data to process
if (0 == fec_receiver_->AddReceivedRedPacket(hacky_header, (const uint8_t*)buffer,
length, ULP_90000_PT)) {
fec_receiver_->ProcessReceivedFec();
}
} else {
video_queue_.pushPacket(buffer, length);
}
} else {
if (audio_offset_ms_ == -1) {
audio_offset_ms_ = ClockUtils::durationToMs(clock::now() - first_data_received_);
ELOG_DEBUG("File %s, audio offset msec: %llu", context_->filename, audio_offset_ms_);
// Let's also take a moment to set our audio queue timebase.
RtpHeader* h = reinterpret_cast<RtpHeader*>(buffer);
if (h->getPayloadType() == PCMU_8000_PT) {
audio_queue_.setTimebase(8000);
} else if (h->getPayloadType() == OPUS_48000_PT) {
audio_queue_.setTimebase(48000);
}
}
audio_queue_.pushPacket(buffer, length);
}
if (audio_queue_.hasData() || video_queue_.hasData()) {
// One or both of our queues has enough data to write stuff out. Notify our writer.
cond_.notify_one();
}
}
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_);
}
// If this is a red header, let's push it to our fec_receiver_, which will spit out frames in one of our other callbacks.
// Otherwise, just stick it straight into the video queue.
RtpHeader* h = reinterpret_cast<RtpHeader*>(buffer);
if (h->getPayloadType() == RED_90000_PT) {
// The only things AddReceivedRedPacket uses are headerLength and sequenceNumber. Unfortunately the amount of crap
// we would have to pull in from the WebRtc project to fully construct a webrtc::RTPHeader object is obscene. So
// let's just do this hacky fix.
webrtc::RTPHeader hackyHeader;
hackyHeader.headerLength = h->getHeaderLength();
hackyHeader.sequenceNumber = h->getSeqNumber();
fec_receiver_.AddReceivedRedPacket(hackyHeader, (const uint8_t*)buffer, length, ULP_90000_PT);
fec_receiver_.ProcessReceivedFec();
} else {
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();
}
}
