/* GStreamer * Copyright (C) 2019 Pexip (http://pexip.com/) * @author: Havard Graff * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Library General Public License for more details. * * You should have received a copy of the GNU Library General Public * License along with this library; if not, write to the * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "rtptwcc.h" #include #include #include #include "gstrtputils.h" GST_DEBUG_CATEGORY_EXTERN (rtp_session_debug); #define GST_CAT_DEFAULT rtp_session_debug #define TWCC_EXTMAP_STR "http://www.ietf.org/id/draft-holmer-rmcat-transport-wide-cc-extensions-01" #define REF_TIME_UNIT (64 * GST_MSECOND) #define DELTA_UNIT (250 * GST_USECOND) #define MAX_TS_DELTA (0xff * DELTA_UNIT) #define STATUS_VECTOR_MAX_CAPACITY 14 #define STATUS_VECTOR_TWO_BIT_MAX_CAPACITY 7 typedef enum { RTP_TWCC_CHUNK_TYPE_RUN_LENGTH = 0, RTP_TWCC_CHUNK_TYPE_STATUS_VECTOR = 1, } RTPTWCCChunkType; typedef struct { guint8 base_seqnum[2]; guint8 packet_count[2]; guint8 base_time[3]; guint8 fb_pkt_count[1]; } RTPTWCCHeader; typedef struct { GstClockTime ts; guint16 seqnum; gint64 delta; RTPTWCCPacketStatus status; guint16 missing_run; guint equal_run; } RecvPacket; typedef struct { GstClockTime ts; GstClockTime socket_ts; GstClockTime remote_ts; guint16 seqnum; guint8 pt; guint size; gboolean lost; } SentPacket; struct _RTPTWCCManager { GObject object; guint8 send_ext_id; guint8 recv_ext_id; guint16 send_seqnum; guint mtu; guint max_packets_per_rtcp; GArray *recv_packets; guint64 fb_pkt_count; gint32 last_seqnum; GArray *sent_packets; GArray *parsed_packets; GQueue *rtcp_buffers; guint64 recv_sender_ssrc; guint64 recv_media_ssrc; guint16 expected_recv_seqnum; guint16 packet_count_no_marker; gboolean first_fci_parse; guint16 expected_parsed_seqnum; guint8 expected_parsed_fb_pkt_count; GstClockTime next_feedback_send_time; GstClockTime feedback_interval; guint64 remote_ts_base; gint64 base_time_prev; }; G_DEFINE_TYPE (RTPTWCCManager, rtp_twcc_manager, G_TYPE_OBJECT); static void rtp_twcc_manager_init (RTPTWCCManager * twcc) { twcc->recv_packets = g_array_new (FALSE, FALSE, sizeof (RecvPacket)); twcc->sent_packets = g_array_new (FALSE, FALSE, sizeof (SentPacket)); twcc->parsed_packets = g_array_new (FALSE, FALSE, sizeof (RecvPacket)); twcc->rtcp_buffers = g_queue_new (); twcc->last_seqnum = -1; twcc->recv_media_ssrc = -1; twcc->recv_sender_ssrc = -1; twcc->first_fci_parse = TRUE; twcc->feedback_interval = GST_CLOCK_TIME_NONE; twcc->next_feedback_send_time = GST_CLOCK_TIME_NONE; twcc->remote_ts_base = -1; } static void rtp_twcc_manager_finalize (GObject * object) { RTPTWCCManager *twcc = RTP_TWCC_MANAGER_CAST (object); g_array_unref (twcc->recv_packets); g_array_unref (twcc->sent_packets); g_array_unref (twcc->parsed_packets); g_queue_free_full (twcc->rtcp_buffers, (GDestroyNotify) gst_buffer_unref); G_OBJECT_CLASS (rtp_twcc_manager_parent_class)->finalize (object); } static void rtp_twcc_manager_class_init (RTPTWCCManagerClass * klass) { GObjectClass *gobject_class = (GObjectClass *) klass; gobject_class->finalize = rtp_twcc_manager_finalize; } RTPTWCCManager * rtp_twcc_manager_new (guint mtu) { RTPTWCCManager *twcc = g_object_new (RTP_TYPE_TWCC_MANAGER, NULL); rtp_twcc_manager_set_mtu (twcc, mtu); return twcc; } static void recv_packet_init (RecvPacket * packet, guint16 seqnum, RTPPacketInfo * pinfo) { memset (packet, 0, sizeof (RecvPacket)); packet->seqnum = seqnum; if (GST_CLOCK_TIME_IS_VALID (pinfo->arrival_time)) packet->ts = pinfo->arrival_time; else packet->ts = pinfo->current_time; } void rtp_twcc_manager_parse_recv_ext_id (RTPTWCCManager * twcc, const GstStructure * s) { guint8 recv_ext_id = gst_rtp_get_extmap_id_for_attribute (s, TWCC_EXTMAP_STR); if (recv_ext_id > 0) { twcc->recv_ext_id = recv_ext_id; GST_INFO ("TWCC enabled for recv using extension id: %u", twcc->recv_ext_id); } } void rtp_twcc_manager_parse_send_ext_id (RTPTWCCManager * twcc, const GstStructure * s) { guint8 send_ext_id = gst_rtp_get_extmap_id_for_attribute (s, TWCC_EXTMAP_STR); if (send_ext_id > 0) { twcc->send_ext_id = send_ext_id; GST_INFO ("TWCC enabled for send using extension id: %u", twcc->send_ext_id); } } void rtp_twcc_manager_set_mtu (RTPTWCCManager * twcc, guint mtu) { twcc->mtu = mtu; /* the absolute worst case is that 7 packets uses header (4 * 4 * 4) 32 bytes) and packet_chunk 2 bytes + recv_deltas (2 * 7) 14 bytes */ twcc->max_packets_per_rtcp = ((twcc->mtu - 32) * 7) / (2 + 14); } void rtp_twcc_manager_set_feedback_interval (RTPTWCCManager * twcc, GstClockTime feedback_interval) { twcc->feedback_interval = feedback_interval; } GstClockTime rtp_twcc_manager_get_feedback_interval (RTPTWCCManager * twcc) { return twcc->feedback_interval; } static gboolean _get_twcc_seqnum_data (RTPPacketInfo * pinfo, guint8 ext_id, gpointer * data) { gboolean ret = FALSE; guint size; if (pinfo->header_ext && gst_rtp_buffer_get_extension_onebyte_header_from_bytes (pinfo->header_ext, pinfo->header_ext_bit_pattern, ext_id, 0, data, &size)) { if (size == 2) ret = TRUE; } return ret; } static void sent_packet_init (SentPacket * packet, guint16 seqnum, RTPPacketInfo * pinfo, GstRTPBuffer * rtp) { packet->seqnum = seqnum; packet->ts = pinfo->current_time; packet->size = gst_rtp_buffer_get_payload_len (rtp); packet->pt = gst_rtp_buffer_get_payload_type (rtp); packet->remote_ts = GST_CLOCK_TIME_NONE; packet->socket_ts = GST_CLOCK_TIME_NONE; packet->lost = FALSE; } static void _set_twcc_seqnum_data (RTPTWCCManager * twcc, RTPPacketInfo * pinfo, GstBuffer * buf, guint8 ext_id) { SentPacket packet; GstRTPBuffer rtp = GST_RTP_BUFFER_INIT; gpointer data; if (gst_rtp_buffer_map (buf, GST_MAP_READWRITE, &rtp)) { if (gst_rtp_buffer_get_extension_onebyte_header (&rtp, ext_id, 0, &data, NULL)) { guint16 seqnum = twcc->send_seqnum++; GST_WRITE_UINT16_BE (data, seqnum); sent_packet_init (&packet, seqnum, pinfo, &rtp); g_array_append_val (twcc->sent_packets, packet); GST_LOG ("Send: twcc-seqnum: %u, pt: %u, marker: %d, len: %u, ts: %" GST_TIME_FORMAT, seqnum, packet.pt, pinfo->marker, packet.size, GST_TIME_ARGS (pinfo->current_time)); } gst_rtp_buffer_unmap (&rtp); } } static void rtp_twcc_manager_set_send_twcc_seqnum (RTPTWCCManager * twcc, RTPPacketInfo * pinfo) { if (GST_IS_BUFFER_LIST (pinfo->data)) { GstBufferList *list; guint i = 0; pinfo->data = gst_buffer_list_make_writable (pinfo->data); list = GST_BUFFER_LIST (pinfo->data); for (i = 0; i < gst_buffer_list_length (list); i++) { GstBuffer *buffer = gst_buffer_list_get_writable (list, i); _set_twcc_seqnum_data (twcc, pinfo, buffer, twcc->send_ext_id); } } else { pinfo->data = gst_buffer_make_writable (pinfo->data); _set_twcc_seqnum_data (twcc, pinfo, pinfo->data, twcc->send_ext_id); } } static gint32 rtp_twcc_manager_get_recv_twcc_seqnum (RTPTWCCManager * twcc, RTPPacketInfo * pinfo) { gint32 val = -1; gpointer data; if (twcc->recv_ext_id == 0) { GST_DEBUG ("Received TWCC packet, but no extension registered; ignoring"); return val; } if (_get_twcc_seqnum_data (pinfo, twcc->recv_ext_id, &data)) { val = GST_READ_UINT16_BE (data); } return val; } static gint _twcc_seqnum_sort (gconstpointer a, gconstpointer b) { gint32 seqa = ((RecvPacket *) a)->seqnum; gint32 seqb = ((RecvPacket *) b)->seqnum; gint res = seqa - seqb; if (res < -65000) res = 1; if (res > 65000) res = -1; return res; } static void rtp_twcc_write_recv_deltas (guint8 * fci_data, GArray * twcc_packets) { guint i; for (i = 0; i < twcc_packets->len; i++) { RecvPacket *pkt = &g_array_index (twcc_packets, RecvPacket, i); if (pkt->status == RTP_TWCC_PACKET_STATUS_SMALL_DELTA) { GST_WRITE_UINT8 (fci_data, pkt->delta); fci_data += 1; } else if (pkt->status == RTP_TWCC_PACKET_STATUS_LARGE_NEGATIVE_DELTA) { GST_WRITE_UINT16_BE (fci_data, pkt->delta); fci_data += 2; } } } static void rtp_twcc_write_run_length_chunk (GArray * packet_chunks, RTPTWCCPacketStatus status, guint run_length) { guint written = 0; while (written < run_length) { GstBitWriter writer; guint16 data = 0; guint len = MIN (run_length - written, 8191); GST_LOG ("Writing a run-length of %u with status %u", len, status); gst_bit_writer_init_with_data (&writer, (guint8 *) & data, 2, FALSE); gst_bit_writer_put_bits_uint8 (&writer, RTP_TWCC_CHUNK_TYPE_RUN_LENGTH, 1); gst_bit_writer_put_bits_uint8 (&writer, status, 2); gst_bit_writer_put_bits_uint16 (&writer, len, 13); g_array_append_val (packet_chunks, data); written += len; } } typedef struct { GArray *packet_chunks; GstBitWriter writer; guint16 data; guint symbol_size; } ChunkBitWriter; static void chunk_bit_writer_reset (ChunkBitWriter * writer) { writer->data = 0; gst_bit_writer_init_with_data (&writer->writer, (guint8 *) & writer->data, 2, FALSE); gst_bit_writer_put_bits_uint8 (&writer->writer, RTP_TWCC_CHUNK_TYPE_STATUS_VECTOR, 1); /* 1 for 2-bit symbol-size, 0 for 1-bit */ gst_bit_writer_put_bits_uint8 (&writer->writer, writer->symbol_size - 1, 1); } static void chunk_bit_writer_configure (ChunkBitWriter * writer, guint symbol_size) { writer->symbol_size = symbol_size; chunk_bit_writer_reset (writer); } static gboolean chunk_bit_writer_is_empty (ChunkBitWriter * writer) { return writer->writer.bit_size == 2; } static gboolean chunk_bit_writer_is_full (ChunkBitWriter * writer) { return writer->writer.bit_size == 16; } static guint chunk_bit_writer_get_available_slots (ChunkBitWriter * writer) { return (16 - writer->writer.bit_size) / writer->symbol_size; } static guint chunk_bit_writer_get_total_slots (ChunkBitWriter * writer) { return STATUS_VECTOR_MAX_CAPACITY / writer->symbol_size; } static void chunk_bit_writer_flush (ChunkBitWriter * writer) { /* don't append a chunk if no bits have been written */ if (!chunk_bit_writer_is_empty (writer)) { g_array_append_val (writer->packet_chunks, writer->data); chunk_bit_writer_reset (writer); } } static void chunk_bit_writer_init (ChunkBitWriter * writer, GArray * packet_chunks, guint symbol_size) { writer->packet_chunks = packet_chunks; chunk_bit_writer_configure (writer, symbol_size); } static void chunk_bit_writer_write (ChunkBitWriter * writer, RTPTWCCPacketStatus status) { gst_bit_writer_put_bits_uint8 (&writer->writer, status, writer->symbol_size); if (chunk_bit_writer_is_full (writer)) { chunk_bit_writer_flush (writer); } } static void rtp_twcc_write_status_vector_chunk (ChunkBitWriter * writer, RecvPacket * pkt) { if (pkt->missing_run > 0) { guint available = chunk_bit_writer_get_available_slots (writer); guint total = chunk_bit_writer_get_total_slots (writer); guint i; if (pkt->missing_run > (available + total)) { /* here it is better to finish up the current status-chunk and then go for run-length */ for (i = 0; i < available; i++) { chunk_bit_writer_write (writer, RTP_TWCC_PACKET_STATUS_NOT_RECV); } rtp_twcc_write_run_length_chunk (writer->packet_chunks, RTP_TWCC_PACKET_STATUS_NOT_RECV, pkt->missing_run - available); } else { for (i = 0; i < pkt->missing_run; i++) { chunk_bit_writer_write (writer, RTP_TWCC_PACKET_STATUS_NOT_RECV); } } } chunk_bit_writer_write (writer, pkt->status); } typedef struct { RecvPacket *equal; } RunLengthHelper; static void run_lenght_helper_update (RunLengthHelper * rlh, RecvPacket * pkt) { /* for missing packets we reset */ if (pkt->missing_run > 0) { rlh->equal = NULL; } /* all status equal run */ if (rlh->equal == NULL) { rlh->equal = pkt; rlh->equal->equal_run = 0; } if (rlh->equal->status == pkt->status) { rlh->equal->equal_run++; } else { rlh->equal = pkt; rlh->equal->equal_run = 1; } } static guint _get_max_packets_capacity (guint symbol_size) { if (symbol_size == 2) return STATUS_VECTOR_TWO_BIT_MAX_CAPACITY; return STATUS_VECTOR_MAX_CAPACITY; } static gboolean _pkt_fits_run_length_chunk (RecvPacket * pkt, guint packets_per_chunks, guint remaining_packets) { if (pkt->missing_run == 0) { /* we have more or the same equal packets than the ones we can write in to a status chunk */ if (pkt->equal_run >= packets_per_chunks) return TRUE; /* we have more than one equal and not enough space for the remainings */ if (pkt->equal_run > 1 && remaining_packets > STATUS_VECTOR_MAX_CAPACITY) return TRUE; /* we have all equal packets for the remaining to write */ if (pkt->equal_run == remaining_packets) return TRUE; } return FALSE; } static void rtp_twcc_write_chunks (GArray * packet_chunks, GArray * twcc_packets, guint symbol_size) { ChunkBitWriter writer; guint i; guint packets_per_chunks = _get_max_packets_capacity (symbol_size); chunk_bit_writer_init (&writer, packet_chunks, symbol_size); for (i = 0; i < twcc_packets->len; i++) { RecvPacket *pkt = &g_array_index (twcc_packets, RecvPacket, i); guint remaining_packets = twcc_packets->len - i; GST_LOG ("About to write pkt: #%u missing_run: %u equal_run: %u status: %u, remaining_packets: %u", pkt->seqnum, pkt->missing_run, pkt->equal_run, pkt->status, remaining_packets); /* we can only start a run-length chunk if the status-chunk is completed */ if (chunk_bit_writer_is_empty (&writer)) { /* first write in any preceeding gaps, we use run-length if it would take up more than one chunk (14/7) */ if (pkt->missing_run > packets_per_chunks) { rtp_twcc_write_run_length_chunk (packet_chunks, RTP_TWCC_PACKET_STATUS_NOT_RECV, pkt->missing_run); } /* we have a run of the same status, write a run-length chunk and skip to the next point */ if (_pkt_fits_run_length_chunk (pkt, packets_per_chunks, remaining_packets)) { rtp_twcc_write_run_length_chunk (packet_chunks, pkt->status, pkt->equal_run); i += pkt->equal_run - 1; continue; } } GST_LOG ("i=%u: Writing a %u-bit vector of status: %u", i, symbol_size, pkt->status); rtp_twcc_write_status_vector_chunk (&writer, pkt); } chunk_bit_writer_flush (&writer); } static void rtp_twcc_manager_add_fci (RTPTWCCManager * twcc, GstRTCPPacket * packet) { RecvPacket *first, *last, *prev; guint16 packet_count; GstClockTime base_time; GstClockTime ts_rounded; guint i; GArray *packet_chunks = g_array_new (FALSE, FALSE, 2); RTPTWCCHeader header; guint header_size = sizeof (RTPTWCCHeader); guint packet_chunks_size; guint recv_deltas_size = 0; guint16 fci_length; guint16 fci_chunks; guint8 *fci_data; guint8 *fci_data_ptr; RunLengthHelper rlh = { NULL }; guint symbol_size = 1; GstClockTimeDiff delta_ts; gint64 delta_ts_rounded; guint8 fb_pkt_count; g_array_sort (twcc->recv_packets, _twcc_seqnum_sort); /* Quick scan to remove duplicates */ prev = &g_array_index (twcc->recv_packets, RecvPacket, 0); for (i = 1; i < twcc->recv_packets->len;) { RecvPacket *cur = &g_array_index (twcc->recv_packets, RecvPacket, i); if (prev->seqnum == cur->seqnum) { GST_DEBUG ("Removing duplicate packet #%u", cur->seqnum); g_array_remove_index (twcc->recv_packets, i); } else { prev = cur; i += 1; } } /* get first and last packet */ first = &g_array_index (twcc->recv_packets, RecvPacket, 0); last = &g_array_index (twcc->recv_packets, RecvPacket, twcc->recv_packets->len - 1); packet_count = last->seqnum - first->seqnum + 1; base_time = first->ts / REF_TIME_UNIT; fb_pkt_count = (guint8) (twcc->fb_pkt_count % G_MAXUINT8); GST_WRITE_UINT16_BE (header.base_seqnum, first->seqnum); GST_WRITE_UINT16_BE (header.packet_count, packet_count); GST_WRITE_UINT24_BE (header.base_time, base_time); GST_WRITE_UINT8 (header.fb_pkt_count, fb_pkt_count); base_time *= REF_TIME_UNIT; ts_rounded = base_time; GST_DEBUG ("Created TWCC feedback: base_seqnum: #%u, packet_count: %u, " "base_time %" GST_TIME_FORMAT " fb_pkt_count: %u", first->seqnum, packet_count, GST_TIME_ARGS (base_time), fb_pkt_count); twcc->fb_pkt_count++; twcc->expected_recv_seqnum = first->seqnum + packet_count; /* calculate all deltas and check for gaps etc */ prev = first; for (i = 0; i < twcc->recv_packets->len; i++) { RecvPacket *pkt = &g_array_index (twcc->recv_packets, RecvPacket, i); if (i != 0) { pkt->missing_run = pkt->seqnum - prev->seqnum - 1; } delta_ts = GST_CLOCK_DIFF (ts_rounded, pkt->ts); pkt->delta = delta_ts / DELTA_UNIT; delta_ts_rounded = pkt->delta * DELTA_UNIT; ts_rounded += delta_ts_rounded; if (delta_ts_rounded < 0 || delta_ts_rounded > MAX_TS_DELTA) { pkt->status = RTP_TWCC_PACKET_STATUS_LARGE_NEGATIVE_DELTA; recv_deltas_size += 2; symbol_size = 2; } else { pkt->status = RTP_TWCC_PACKET_STATUS_SMALL_DELTA; recv_deltas_size += 1; } run_lenght_helper_update (&rlh, pkt); GST_LOG ("pkt: #%u, ts: %" GST_TIME_FORMAT " ts_rounded: %" GST_TIME_FORMAT " delta_ts: %" GST_STIME_FORMAT " delta_ts_rounded: %" GST_STIME_FORMAT " missing_run: %u, status: %u", pkt->seqnum, GST_TIME_ARGS (pkt->ts), GST_TIME_ARGS (ts_rounded), GST_STIME_ARGS (delta_ts), GST_STIME_ARGS (delta_ts_rounded), pkt->missing_run, pkt->status); prev = pkt; } rtp_twcc_write_chunks (packet_chunks, twcc->recv_packets, symbol_size); packet_chunks_size = packet_chunks->len * 2; fci_length = header_size + packet_chunks_size + recv_deltas_size; fci_chunks = (fci_length - 1) / sizeof (guint32) + 1; if (!gst_rtcp_packet_fb_set_fci_length (packet, fci_chunks)) { GST_ERROR ("Could not fit: %u packets", packet_count); g_assert_not_reached (); } fci_data = gst_rtcp_packet_fb_get_fci (packet); fci_data_ptr = fci_data; memcpy (fci_data_ptr, &header, header_size); fci_data_ptr += header_size; memcpy (fci_data_ptr, packet_chunks->data, packet_chunks_size); fci_data_ptr += packet_chunks_size; rtp_twcc_write_recv_deltas (fci_data_ptr, twcc->recv_packets); GST_MEMDUMP ("twcc-header:", (guint8 *) & header, header_size); GST_MEMDUMP ("packet-chunks:", (guint8 *) packet_chunks->data, packet_chunks_size); GST_MEMDUMP ("full fci:", fci_data, fci_length); g_array_unref (packet_chunks); g_array_set_size (twcc->recv_packets, 0); } static void rtp_twcc_manager_create_feedback (RTPTWCCManager * twcc) { GstBuffer *buf; GstRTCPBuffer rtcp = GST_RTCP_BUFFER_INIT; GstRTCPPacket packet; buf = gst_rtcp_buffer_new (twcc->mtu); gst_rtcp_buffer_map (buf, GST_MAP_READWRITE, &rtcp); gst_rtcp_buffer_add_packet (&rtcp, GST_RTCP_TYPE_RTPFB, &packet); gst_rtcp_packet_fb_set_type (&packet, GST_RTCP_RTPFB_TYPE_TWCC); if (twcc->recv_sender_ssrc != 1) gst_rtcp_packet_fb_set_sender_ssrc (&packet, twcc->recv_sender_ssrc); gst_rtcp_packet_fb_set_media_ssrc (&packet, twcc->recv_media_ssrc); rtp_twcc_manager_add_fci (twcc, &packet); gst_rtcp_buffer_unmap (&rtcp); g_queue_push_tail (twcc->rtcp_buffers, buf); } /* we have calculated a (very pessimistic) max-packets per RTCP feedback, so this is to make sure we don't exceed that */ static gboolean _exceeds_max_packets (RTPTWCCManager * twcc, guint16 seqnum) { if (twcc->recv_packets->len + 1 > twcc->max_packets_per_rtcp) return TRUE; return FALSE; } /* in this case we could have lost the packet with the marker bit, so with a large (30) amount of packets, lost packets and still no marker, we send a feedback anyway */ static gboolean _many_packets_some_lost (RTPTWCCManager * twcc, guint16 seqnum) { RecvPacket *first; guint16 packet_count; guint received_packets = twcc->recv_packets->len; guint lost_packets; if (received_packets == 0) return FALSE; first = &g_array_index (twcc->recv_packets, RecvPacket, 0); packet_count = seqnum - first->seqnum + 1; /* If there are a high number of duplicates, we can't use the following * metrics */ if (received_packets > packet_count) return FALSE; /* check if we lost half of the threshold */ lost_packets = packet_count - received_packets; if (received_packets >= 30 && lost_packets >= 60) return TRUE; /* we have lost the marker bit for some and lost some */ if (twcc->packet_count_no_marker >= 10 && lost_packets >= 60) return TRUE; return FALSE; } gboolean rtp_twcc_manager_recv_packet (RTPTWCCManager * twcc, RTPPacketInfo * pinfo) { gboolean send_feedback = FALSE; RecvPacket packet; gint32 seqnum; gint diff; seqnum = rtp_twcc_manager_get_recv_twcc_seqnum (twcc, pinfo); if (seqnum == -1) return FALSE; /* if this packet would exceed the capacity of our MTU, we create a feedback with the current packets, and start over with this one */ if (_exceeds_max_packets (twcc, seqnum)) { GST_INFO ("twcc-seqnum: %u would overflow max packets: %u, create feedback" " with current packets", seqnum, twcc->max_packets_per_rtcp); rtp_twcc_manager_create_feedback (twcc); send_feedback = TRUE; } /* we can have multiple ssrcs here, so just pick the first one */ if (twcc->recv_media_ssrc == -1) twcc->recv_media_ssrc = pinfo->ssrc; /* check if we are reordered, and treat it as lost if we already sent a feedback msg with a higher seqnum. If the diff is huge, treat it as a restart of a stream */ diff = gst_rtp_buffer_compare_seqnum (twcc->expected_recv_seqnum, seqnum); if (twcc->fb_pkt_count > 0 && diff < 0) { GST_INFO ("Received out of order packet (%u after %u), treating as lost", seqnum, twcc->expected_recv_seqnum); return FALSE; } /* store the packet for Transport-wide RTCP feedback message */ recv_packet_init (&packet, seqnum, pinfo); g_array_append_val (twcc->recv_packets, packet); twcc->last_seqnum = seqnum; GST_LOG ("Receive: twcc-seqnum: %u, pt: %u, marker: %d, ts: %" GST_TIME_FORMAT, seqnum, pinfo->pt, pinfo->marker, GST_TIME_ARGS (pinfo->arrival_time)); if (!pinfo->marker) twcc->packet_count_no_marker++; /* are we sending on an interval, or based on marker bit */ if (GST_CLOCK_TIME_IS_VALID (twcc->feedback_interval)) { if (!GST_CLOCK_TIME_IS_VALID (twcc->next_feedback_send_time)) twcc->next_feedback_send_time = pinfo->running_time + twcc->feedback_interval; if (pinfo->running_time >= twcc->next_feedback_send_time) { GST_LOG ("Generating feedback : Exceeded feedback interval %" GST_TIME_FORMAT, GST_TIME_ARGS (twcc->feedback_interval)); rtp_twcc_manager_create_feedback (twcc); send_feedback = TRUE; while (pinfo->running_time >= twcc->next_feedback_send_time) twcc->next_feedback_send_time += twcc->feedback_interval; } } else if (pinfo->marker || _many_packets_some_lost (twcc, seqnum)) { GST_LOG ("Generating feedback because of %s", pinfo->marker ? "marker packet" : "many packets some lost"); rtp_twcc_manager_create_feedback (twcc); send_feedback = TRUE; twcc->packet_count_no_marker = 0; } return send_feedback; } static void _change_rtcp_fb_sender_ssrc (GstBuffer * buf, guint32 sender_ssrc) { GstRTCPBuffer rtcp = GST_RTCP_BUFFER_INIT; GstRTCPPacket packet; gst_rtcp_buffer_map (buf, GST_MAP_READWRITE, &rtcp); gst_rtcp_buffer_get_first_packet (&rtcp, &packet); gst_rtcp_packet_fb_set_sender_ssrc (&packet, sender_ssrc); gst_rtcp_buffer_unmap (&rtcp); } GstBuffer * rtp_twcc_manager_get_feedback (RTPTWCCManager * twcc, guint sender_ssrc) { GstBuffer *buf; buf = g_queue_pop_head (twcc->rtcp_buffers); if (buf && twcc->recv_sender_ssrc != sender_ssrc) { _change_rtcp_fb_sender_ssrc (buf, sender_ssrc); twcc->recv_sender_ssrc = sender_ssrc; } return buf; } void rtp_twcc_manager_send_packet (RTPTWCCManager * twcc, RTPPacketInfo * pinfo) { if (twcc->send_ext_id == 0) return; rtp_twcc_manager_set_send_twcc_seqnum (twcc, pinfo); } static void _add_twcc_packet (GArray * twcc_packets, guint16 seqnum, guint status) { RTPTWCCPacket packet; memset (&packet, 0, sizeof (RTPTWCCPacket)); packet.local_ts = GST_CLOCK_TIME_NONE; packet.remote_ts = GST_CLOCK_TIME_NONE; packet.local_delta = GST_CLOCK_STIME_NONE; packet.remote_delta = GST_CLOCK_STIME_NONE; packet.delta_delta = GST_CLOCK_STIME_NONE; packet.seqnum = seqnum; packet.status = status; g_array_append_val (twcc_packets, packet); } static guint _parse_run_length_chunk (GstBitReader * reader, GArray * twcc_packets, guint16 seqnum_offset, guint remaining_packets) { guint16 run_length; guint8 status_code; guint i; gst_bit_reader_get_bits_uint8 (reader, &status_code, 2); gst_bit_reader_get_bits_uint16 (reader, &run_length, 13); run_length = MIN (remaining_packets, run_length); for (i = 0; i < run_length; i++) { _add_twcc_packet (twcc_packets, seqnum_offset + i, status_code); } return run_length; } static guint _parse_status_vector_chunk (GstBitReader * reader, GArray * twcc_packets, guint16 seqnum_offset, guint remaining_packets) { guint8 symbol_size; guint num_bits; guint i; gst_bit_reader_get_bits_uint8 (reader, &symbol_size, 1); symbol_size += 1; num_bits = MIN (remaining_packets, 14 / symbol_size); for (i = 0; i < num_bits; i++) { guint8 status_code; if (gst_bit_reader_get_bits_uint8 (reader, &status_code, symbol_size)) _add_twcc_packet (twcc_packets, seqnum_offset + i, status_code); } return num_bits; } /* Remove all locally stored packets that has been reported back to us */ static void _prune_sent_packets (RTPTWCCManager * twcc, GArray * twcc_packets) { SentPacket *first; RTPTWCCPacket *last; guint16 last_idx; if (twcc_packets->len == 0 || twcc->sent_packets->len == 0) return; first = &g_array_index (twcc->sent_packets, SentPacket, 0); last = &g_array_index (twcc_packets, RTPTWCCPacket, twcc_packets->len - 1); last_idx = last->seqnum - first->seqnum; if (last_idx < twcc->sent_packets->len) g_array_remove_range (twcc->sent_packets, 0, last_idx); } static void _check_for_lost_packets (RTPTWCCManager * twcc, GArray * twcc_packets, guint16 base_seqnum, guint16 packet_count, guint8 fb_pkt_count) { guint packets_lost; gint8 fb_pkt_count_diff; guint i; /* first packet */ if (twcc->first_fci_parse) { twcc->first_fci_parse = FALSE; goto done; } fb_pkt_count_diff = (gint8) (fb_pkt_count - twcc->expected_parsed_fb_pkt_count); /* we have gone backwards, don't reset the expectations, but process the packet nonetheless */ if (fb_pkt_count_diff < 0) { GST_DEBUG ("feedback packet count going backwards (%u < %u)", fb_pkt_count, twcc->expected_parsed_fb_pkt_count); return; } /* we have jumped forwards, reset expectations, but don't trigger lost packets in case the missing fb-packet(s) arrive later */ if (fb_pkt_count_diff > 0) { GST_DEBUG ("feedback packet count jumped ahead (%u > %u)", fb_pkt_count, twcc->expected_parsed_fb_pkt_count); goto done; } if (base_seqnum < twcc->expected_parsed_seqnum) { GST_DEBUG ("twcc seqnum is older than expected (%u < %u)", base_seqnum, twcc->expected_parsed_seqnum); return; } packets_lost = base_seqnum - twcc->expected_parsed_seqnum; for (i = 0; i < packets_lost; i++) { _add_twcc_packet (twcc_packets, twcc->expected_parsed_seqnum + i, RTP_TWCC_PACKET_STATUS_NOT_RECV); } done: twcc->expected_parsed_seqnum = base_seqnum + packet_count; twcc->expected_parsed_fb_pkt_count = fb_pkt_count + 1; return; } GArray * rtp_twcc_manager_parse_fci (RTPTWCCManager * twcc, guint8 * fci_data, guint fci_length) { GArray *twcc_packets; guint16 base_seqnum; guint16 packet_count; GstClockTime base_time; gint64 base_time_ext; GstClockTime ts_rounded; guint8 fb_pkt_count; guint packets_parsed = 0; guint fci_parsed; guint i; SentPacket *first_sent_pkt = NULL; if (fci_length < 10) { GST_WARNING ("Malformed TWCC RTCP feedback packet"); return NULL; } base_seqnum = GST_READ_UINT16_BE (&fci_data[0]); packet_count = GST_READ_UINT16_BE (&fci_data[2]); base_time = GST_READ_UINT24_BE (&fci_data[4]); /* Sign-extend the base_time from a 24-bit integer into a 64-bit signed integer * so that we can calculate diffs with regular 64-bit operations. */ base_time_ext = (base_time & 0x800000) ? base_time | 0xFFFFFFFFFF800000 : base_time; fb_pkt_count = fci_data[7]; GST_DEBUG ("Parsed TWCC feedback: base_seqnum: #%u, packet_count: %u, " "base_time %" GST_TIME_FORMAT " fb_pkt_count: %u", base_seqnum, packet_count, GST_TIME_ARGS (base_time * REF_TIME_UNIT), fb_pkt_count); twcc_packets = g_array_sized_new (FALSE, FALSE, sizeof (RTPTWCCPacket), packet_count); _check_for_lost_packets (twcc, twcc_packets, base_seqnum, packet_count, fb_pkt_count); fci_parsed = 8; while (packets_parsed < packet_count && (fci_parsed + 1) < fci_length) { GstBitReader reader = GST_BIT_READER_INIT (&fci_data[fci_parsed], 2); guint8 chunk_type; guint seqnum_offset = base_seqnum + packets_parsed; guint remaining_packets = packet_count - packets_parsed; gst_bit_reader_get_bits_uint8 (&reader, &chunk_type, 1); if (chunk_type == RTP_TWCC_CHUNK_TYPE_RUN_LENGTH) { packets_parsed += _parse_run_length_chunk (&reader, twcc_packets, seqnum_offset, remaining_packets); } else { packets_parsed += _parse_status_vector_chunk (&reader, twcc_packets, seqnum_offset, remaining_packets); } fci_parsed += 2; } if (twcc->sent_packets->len > 0) first_sent_pkt = &g_array_index (twcc->sent_packets, SentPacket, 0); if (twcc->remote_ts_base == -1) { /* Add an initial offset of 1 << 24 so that we don't risk going below 0 if * a future extended timestamp is earlier than the first. */ twcc->remote_ts_base = (G_GINT64_CONSTANT (1) << 24) + base_time_ext; } else { /* Calculate our internal accumulated reference timestamp by continously * adding the diff between the current and the previous sign-extended * reference time. */ twcc->remote_ts_base += base_time_ext - twcc->base_time_prev; } twcc->base_time_prev = base_time_ext; /* Our internal accumulated reference time is in units of 64ms, propagate as * GstClockTime in ns. */ ts_rounded = twcc->remote_ts_base * REF_TIME_UNIT; for (i = 0; i < twcc_packets->len; i++) { RTPTWCCPacket *pkt = &g_array_index (twcc_packets, RTPTWCCPacket, i); gint16 delta = 0; GstClockTimeDiff delta_ts; if (pkt->status == RTP_TWCC_PACKET_STATUS_SMALL_DELTA) { delta = fci_data[fci_parsed]; fci_parsed += 1; } else if (pkt->status == RTP_TWCC_PACKET_STATUS_LARGE_NEGATIVE_DELTA) { delta = GST_READ_UINT16_BE (&fci_data[fci_parsed]); fci_parsed += 2; } if (fci_parsed > fci_length) { GST_WARNING ("Malformed TWCC RTCP feedback packet"); g_array_set_size (twcc_packets, 0); break; } if (pkt->status != RTP_TWCC_PACKET_STATUS_NOT_RECV) { delta_ts = delta * DELTA_UNIT; ts_rounded += delta_ts; pkt->remote_ts = ts_rounded; GST_LOG ("pkt: #%u, remote_ts: %" GST_TIME_FORMAT " delta_ts: %" GST_STIME_FORMAT " status: %u", pkt->seqnum, GST_TIME_ARGS (pkt->remote_ts), GST_STIME_ARGS (delta_ts), pkt->status); } if (first_sent_pkt) { SentPacket *found = NULL; guint16 sent_idx = pkt->seqnum - first_sent_pkt->seqnum; if (sent_idx < twcc->sent_packets->len) found = &g_array_index (twcc->sent_packets, SentPacket, sent_idx); if (found && found->seqnum == pkt->seqnum) { if (GST_CLOCK_TIME_IS_VALID (found->socket_ts)) { pkt->local_ts = found->socket_ts; } else { pkt->local_ts = found->ts; } pkt->size = found->size; pkt->pt = found->pt; GST_LOG ("matching pkt: #%u with local_ts: %" GST_TIME_FORMAT " size: %u", pkt->seqnum, GST_TIME_ARGS (pkt->local_ts), pkt->size); } } } _prune_sent_packets (twcc, twcc_packets); return twcc_packets; }