gst/rtp/gstrtpulpfecdec.c

   1 /* GStreamer plugin for forward error correction
   2  * Copyright (C) 2017 Pexip
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  17  *
  18  * Author: Mikhail Fludkov <misha@pexip.com>
  19  */
  20
  21 /**
  22  * SECTION:element-rtpulpfecdec
  23  * @short_description: Generic RTP Forward Error Correction (FEC) decoder
  24  * @title: rtpulpfecdec
  25  *
  26  * Generic Forward Error Correction (FEC) decoder for Uneven Level
  27  * Protection (ULP) as described in RFC 5109.
  28  *
  29  * This element will work in combination with an upstream #GstRtpStorage
  30  * element and attempt to recover packets declared lost through custom
  31  * 'GstRTPPacketLost' events, usually emitted by #GstRtpJitterBuffer.
  32  *
  33  * As such, this element cannot be usefully used from the command line,
  34  * because a reference to the upstream storage object needs to be
  35  * provided to it through its #GstRtpUlpFecDec:storage property, example
  36  * programs are available at
  37  * <https://github.com/sdroege/gstreamer-rs/blob/master/examples/src/bin/rtpfecserver.rs>
  38  * and
  39  * <https://github.com/sdroege/gstreamer-rs/blob/master/examples/src/bin/rtpfecclient.rs>.
  40  *
  41  * Additionally, the payload types of the protection packets *must* be
  42  * provided to this element via its #GstRtpUlpFecDec:pt property.
  43  *
  44  * When using #GstRtpBin, this element should be inserted through the
  45  * #GstRtpBin::request-fec-decoder signal.
  46  *
  47  * See also: #GstRtpUlpFecEnc, #GstRtpBin, #GstRtpStorage
  48  * Since: 1.14
  49  */
  50
  51 #include <gst/rtp/gstrtpbuffer.h>
  52 #include <gst/rtp/gstrtp-enumtypes.h>
  53
  54 #include "rtpulpfeccommon.h"
  55 #include "gstrtpulpfecdec.h"
  56
  57 static GstStaticPadTemplate sinktemplate = GST_STATIC_PAD_TEMPLATE ("sink",
  58     GST_PAD_SINK,
  59     GST_PAD_ALWAYS,
  60     GST_STATIC_CAPS ("application/x-rtp")
  61     );
  62
  63 static GstStaticPadTemplate srctemplate = GST_STATIC_PAD_TEMPLATE ("src",
  64     GST_PAD_SRC,
  65     GST_PAD_ALWAYS,
  66     GST_STATIC_CAPS ("application/x-rtp")
  67     );
  68
  69 enum
  70 {
  71   PROP_0,
  72   PROP_PT,
  73   PROP_STORAGE,
  74   PROP_RECOVERED,
  75   PROP_UNRECOVERED,
  76   N_PROPERTIES
  77 };
  78
  79 #define DEFAULT_FEC_PT 0
  80
  81 static GParamSpec *klass_properties[N_PROPERTIES] = { NULL, };
  82
  83 GST_DEBUG_CATEGORY (gst_rtp_ulpfec_dec_debug);
  84 #define GST_CAT_DEFAULT (gst_rtp_ulpfec_dec_debug)
  85
  86 G_DEFINE_TYPE (GstRtpUlpFecDec, gst_rtp_ulpfec_dec, GST_TYPE_ELEMENT);
  87
  88 #define RTP_FEC_MAP_INFO_NTH(dec, data) (&g_array_index (\
  89     ((GstRtpUlpFecDec *)dec)->info_arr, \
  90     RtpUlpFecMapInfo, \
  91     GPOINTER_TO_UINT(data)))
  92
  93 static gint
  94 _compare_fec_map_info (gconstpointer a, gconstpointer b, gpointer userdata)
  95 {
  96   guint16 aseq =
  97       gst_rtp_buffer_get_seq (&RTP_FEC_MAP_INFO_NTH (userdata, a)->rtp);
  98   guint16 bseq =
  99       gst_rtp_buffer_get_seq (&RTP_FEC_MAP_INFO_NTH (userdata, b)->rtp);
 100   return gst_rtp_buffer_compare_seqnum (bseq, aseq);
 101 }
 102
 103 static void
 104 gst_rtp_ulpfec_dec_start (GstRtpUlpFecDec * self, GstBufferList * buflist,
 105     guint8 fec_pt, guint16 lost_seq)
 106 {
 107   guint fec_packets = 0;
 108   gsize i;
 109
 110   g_assert (NULL == self->info_media);
 111   g_assert (0 == self->info_fec->len);
 112   g_assert (0 == self->info_arr->len);
 113
 114   g_array_set_size (self->info_arr, gst_buffer_list_length (buflist));
 115
 116   for (i = 0;
 117       i < gst_buffer_list_length (buflist) && !self->lost_packet_from_storage;
 118       ++i) {
 119     GstBuffer *buffer = gst_buffer_list_get (buflist, i);
 120     RtpUlpFecMapInfo *info = RTP_FEC_MAP_INFO_NTH (self, i);
 121
 122     if (!rtp_ulpfec_map_info_map (gst_buffer_ref (buffer), info))
 123       g_assert_not_reached ();
 124
 125     if (fec_pt == gst_rtp_buffer_get_payload_type (&info->rtp)) {
 126       GST_DEBUG_RTP_PACKET (self, "rtp header (fec)", &info->rtp);
 127
 128       ++fec_packets;
 129       if (rtp_ulpfec_buffer_is_valid (&info->rtp)) {
 130         GST_DEBUG_FEC_PACKET (self, &info->rtp);
 131         g_ptr_array_add (self->info_fec, GUINT_TO_POINTER (i));
 132       }
 133     } else {
 134       GST_LOG_RTP_PACKET (self, "rtp header (incoming)", &info->rtp);
 135
 136       if (lost_seq == gst_rtp_buffer_get_seq (&info->rtp)) {
 137         GST_DEBUG_OBJECT (self, "Received lost packet from the storage");
 138         g_list_free (self->info_media);
 139         self->info_media = NULL;
 140         self->lost_packet_from_storage = TRUE;
 141       }
 142       self->info_media =
 143           g_list_insert_sorted_with_data (self->info_media,
 144           GUINT_TO_POINTER (i), _compare_fec_map_info, self);
 145     }
 146   }
 147   if (!self->lost_packet_from_storage) {
 148     self->fec_packets_received += fec_packets;
 149     self->fec_packets_rejected += fec_packets - self->info_fec->len;
 150   }
 151 }
 152
 153 static void
 154 gst_rtp_ulpfec_dec_stop (GstRtpUlpFecDec * self)
 155 {
 156   g_array_set_size (self->info_arr, 0);
 157   g_ptr_array_set_size (self->info_fec, 0);
 158   g_list_free (self->info_media);
 159   self->info_media = NULL;
 160   self->lost_packet_from_storage = FALSE;
 161   self->lost_packet_returned = FALSE;
 162 }
 163
 164 static guint64
 165 gst_rtp_ulpfec_dec_get_media_buffers_mask (GstRtpUlpFecDec * self,
 166     guint16 fec_seq_base)
 167 {
 168   guint64 mask = 0;
 169   GList *it;
 170
 171   for (it = self->info_media; it; it = it->next) {
 172     RtpUlpFecMapInfo *info = RTP_FEC_MAP_INFO_NTH (self, it->data);
 173     mask |=
 174         rtp_ulpfec_packet_mask_from_seqnum (gst_rtp_buffer_get_seq (&info->rtp),
 175         fec_seq_base, TRUE);
 176   }
 177   return mask;
 178 }
 179
 180 static gboolean
 181 gst_rtp_ulpfec_dec_is_recovered_pt_valid (GstRtpUlpFecDec * self, gint media_pt,
 182     guint8 recovered_pt)
 183 {
 184   GList *it;
 185   if (media_pt == recovered_pt)
 186     return TRUE;
 187
 188   for (it = self->info_media; it; it = it->next) {
 189     RtpUlpFecMapInfo *info = RTP_FEC_MAP_INFO_NTH (self, it->data);
 190     if (gst_rtp_buffer_get_payload_type (&info->rtp) == recovered_pt)
 191       return TRUE;
 192   }
 193   return FALSE;
 194 }
 195
 196 static GstBuffer *
 197 gst_rtp_ulpfec_dec_recover_from_fec (GstRtpUlpFecDec * self,
 198     RtpUlpFecMapInfo * info_fec, guint32 ssrc, gint media_pt, guint16 seq,
 199     guint8 * dst_pt)
 200 {
 201   guint64 fec_mask = rtp_ulpfec_buffer_get_mask (&info_fec->rtp);
 202   gboolean fec_mask_long = rtp_ulpfec_buffer_get_fechdr (&info_fec->rtp)->L;
 203   guint16 fec_seq_base = rtp_ulpfec_buffer_get_seq_base (&info_fec->rtp);
 204   GstBuffer *ret;
 205   GList *it;
 206
 207   g_array_set_size (self->scratch_buf, 0);
 208   rtp_buffer_to_ulpfec_bitstring (&info_fec->rtp, self->scratch_buf, TRUE,
 209       fec_mask_long);
 210
 211   for (it = self->info_media; it; it = it->next) {
 212     RtpUlpFecMapInfo *info = RTP_FEC_MAP_INFO_NTH (self, it->data);
 213     guint64 packet_mask =
 214         rtp_ulpfec_packet_mask_from_seqnum (gst_rtp_buffer_get_seq (&info->rtp),
 215         fec_seq_base, TRUE);
 216
 217     if (fec_mask & packet_mask) {
 218       fec_mask ^= packet_mask;
 219       rtp_buffer_to_ulpfec_bitstring (&info->rtp, self->scratch_buf, FALSE,
 220           fec_mask_long);
 221     }
 222   }
 223
 224   ret =
 225       rtp_ulpfec_bitstring_to_media_rtp_buffer (self->scratch_buf,
 226       fec_mask_long, ssrc, seq);
 227   if (ret) {
 228     /* We are about to put recovered packet back in self->info_media to be able
 229      * to reuse it later for recovery of other packets
 230      **/
 231     gint i = self->info_arr->len;
 232     RtpUlpFecMapInfo *info;
 233     guint8 recovered_pt;
 234
 235     g_array_set_size (self->info_arr, self->info_arr->len + 1);
 236     info = RTP_FEC_MAP_INFO_NTH (self, i);
 237
 238     if (!rtp_ulpfec_map_info_map (gst_buffer_ref (ret), info)) {
 239       GST_WARNING_OBJECT (self, "Invalid recovered packet");
 240       goto recovered_packet_invalid;
 241     }
 242
 243     recovered_pt = gst_rtp_buffer_get_payload_type (&info->rtp);
 244     if (!gst_rtp_ulpfec_dec_is_recovered_pt_valid (self, media_pt,
 245             recovered_pt)) {
 246       GST_WARNING_OBJECT (self,
 247           "Recovered packet has unexpected payload type (%u)", recovered_pt);
 248       goto recovered_packet_invalid;
 249     }
 250
 251     GST_DEBUG_RTP_PACKET (self, "rtp header (recovered)", &info->rtp);
 252     self->info_media =
 253         g_list_insert_sorted_with_data (self->info_media, GUINT_TO_POINTER (i),
 254         _compare_fec_map_info, self);
 255     *dst_pt = recovered_pt;
 256   }
 257   return ret;
 258
 259 recovered_packet_invalid:
 260   g_array_set_size (self->info_arr, self->info_arr->len - 1);
 261   gst_buffer_unref (ret);
 262   return NULL;
 263 }
 264
 265 static GstBuffer *
 266 gst_rtp_ulpfec_dec_recover_from_storage (GstRtpUlpFecDec * self,
 267     guint8 * dst_pt, guint16 * dst_seq)
 268 {
 269   RtpUlpFecMapInfo *info;
 270
 271   if (self->lost_packet_returned)
 272     return NULL;
 273
 274   g_assert (g_list_length (self->info_media) == 1);
 275
 276   info = RTP_FEC_MAP_INFO_NTH (self, self->info_media->data);
 277   *dst_seq = gst_rtp_buffer_get_seq (&info->rtp);
 278   *dst_pt = gst_rtp_buffer_get_payload_type (&info->rtp);
 279   self->lost_packet_returned = TRUE;
 280   GST_DEBUG_RTP_PACKET (self, "rtp header (recovered)", &info->rtp);
 281   return gst_buffer_ref (info->rtp.buffer);
 282 }
 283
 284 /* __has_builtin only works with clang, so test compiler version for gcc */
 285 /* Intel compiler and MSVC probably have their own things as well */
 286 /* TODO: make sure we use builtin for clang as well */
 287 #if defined(__GNUC__) && __GNUC__ >= 4
 288 #define rtp_ulpfec_ctz64 __builtin_ctzll
 289 #else
 290 static inline gint
 291 rtp_ulpfec_ctz64_inline (guint64 mask)
 292 {
 293   gint nth_bit = 0;
 294
 295   do {
 296     if ((mask & 1))
 297       return nth_bit;
 298     mask = mask >> 1;
 299   } while (++nth_bit < 64);
 300
 301   return -1;                    /* should not be reached, since mask must not be 0 */
 302 }
 303
 304 #define rtp_ulpfec_ctz64 rtp_ulpfec_ctz64_inline
 305 #endif
 306
 307 static GstBuffer *
 308 gst_rtp_ulpfec_dec_recover (GstRtpUlpFecDec * self, guint32 ssrc, gint media_pt,
 309     guint8 * dst_pt, guint16 * dst_seq)
 310 {
 311   guint64 media_mask = 0;
 312   gint media_mask_seq_base = -1;
 313   gsize i;
 314
 315   if (self->lost_packet_from_storage)
 316     return gst_rtp_ulpfec_dec_recover_from_storage (self, dst_pt, dst_seq);
 317
 318   /* Looking for a FEC packet which can be used for recovery */
 319   for (i = 0; i < self->info_fec->len; ++i) {
 320     RtpUlpFecMapInfo *info = RTP_FEC_MAP_INFO_NTH (self,
 321         g_ptr_array_index (self->info_fec, i));
 322     guint16 seq_base = rtp_ulpfec_buffer_get_seq_base (&info->rtp);
 323     guint64 fec_mask = rtp_ulpfec_buffer_get_mask (&info->rtp);
 324     guint64 missing_packets_mask;
 325
 326     if (media_mask_seq_base != (gint) seq_base) {
 327       media_mask_seq_base = seq_base;
 328       media_mask = gst_rtp_ulpfec_dec_get_media_buffers_mask (self, seq_base);
 329     }
 330
 331     /* media_mask has 1s if packet exist.
 332      * fec_mask is the mask of protected packets
 333      * The statement below excludes existing packets from the protected. So
 334      * we are left with 1s only for missing packets which can be recovered
 335      * by this FEC packet. */
 336     missing_packets_mask = fec_mask & (~media_mask);
 337
 338     /* Do we have any 1s? Checking if current FEC packet can be used for recovery */
 339     if (0 != missing_packets_mask) {
 340       guint trailing_zeros = rtp_ulpfec_ctz64 (missing_packets_mask);
 341
 342       /* Is it the only 1 in the mask? Checking if we lacking single packet in
 343        * that case FEC packet can be used for recovery */
 344       if (missing_packets_mask == (G_GUINT64_CONSTANT (1) << trailing_zeros)) {
 345         GstBuffer *ret;
 346
 347         *dst_seq =
 348             seq_base + (RTP_ULPFEC_SEQ_BASE_OFFSET_MAX (TRUE) - trailing_zeros);
 349         ret =
 350             gst_rtp_ulpfec_dec_recover_from_fec (self, info, ssrc, media_pt,
 351             *dst_seq, dst_pt);
 352         if (ret)
 353           return ret;
 354       }
 355     }
 356   }
 357   return NULL;
 358 }
 359
 360 static GstFlowReturn
 361 gst_rtp_ulpfec_dec_chain (GstPad * pad, GstObject * parent, GstBuffer * buf)
 362 {
 363   GstRtpUlpFecDec *self = GST_RTP_ULPFEC_DEC (parent);
 364
 365   if (G_LIKELY (GST_FLOW_OK == self->chain_return_val)) {
 366     GstRTPBuffer rtp = GST_RTP_BUFFER_INIT;
 367     buf = gst_buffer_make_writable (buf);
 368
 369     if (G_UNLIKELY (self->unset_discont_flag)) {
 370       self->unset_discont_flag = FALSE;
 371       GST_BUFFER_FLAG_UNSET (buf, GST_BUFFER_FLAG_DISCONT);
 372     }
 373
 374     gst_rtp_buffer_map (buf, GST_MAP_WRITE, &rtp);
 375     gst_rtp_buffer_set_seq (&rtp, self->next_seqnum++);
 376     gst_rtp_buffer_unmap (&rtp);
 377
 378     return gst_pad_push (self->srcpad, buf);
 379   }
 380
 381   gst_buffer_unref (buf);
 382   return self->chain_return_val;
 383 }
 384
 385 static gboolean
 386 gst_rtp_ulpfec_dec_handle_packet_loss (GstRtpUlpFecDec * self, guint16 seqnum,
 387     GstClockTime timestamp, GstClockTime duration)
 388 {
 389   gint caps_pt = self->have_caps_pt ? self->caps_pt : -1;
 390   gboolean ret = TRUE;
 391   GstBufferList *buflist =
 392       rtp_storage_get_packets_for_recovery (self->storage, self->fec_pt,
 393       self->caps_ssrc, seqnum);
 394
 395   if (buflist) {
 396     GstBuffer *recovered_buffer = NULL;
 397     guint16 recovered_seq = 0;
 398     guint8 recovered_pt = 0;
 399
 400     gst_rtp_ulpfec_dec_start (self, buflist, self->fec_pt, seqnum);
 401
 402     while (NULL != (recovered_buffer =
 403             gst_rtp_ulpfec_dec_recover (self, self->caps_ssrc, caps_pt,
 404                 &recovered_pt, &recovered_seq))) {
 405       if (seqnum == recovered_seq) {
 406         GstBuffer *sent_buffer;
 407         GstRTPBuffer rtp = GST_RTP_BUFFER_INIT;
 408
 409         recovered_buffer = gst_buffer_make_writable (recovered_buffer);
 410         GST_BUFFER_PTS (recovered_buffer) = timestamp;
 411         /* GST_BUFFER_DURATION (recovered_buffer) = duration;
 412          * JB does not set the duration, so we will not too */
 413
 414         if (!self->lost_packet_from_storage)
 415           rtp_storage_put_recovered_packet (self->storage,
 416               recovered_buffer, recovered_pt, self->caps_ssrc, recovered_seq);
 417
 418         GST_DEBUG_OBJECT (self,
 419             "Pushing recovered packet ssrc=0x%08x seq=%u %" GST_PTR_FORMAT,
 420             self->caps_ssrc, seqnum, recovered_buffer);
 421
 422         sent_buffer = gst_buffer_copy_deep (recovered_buffer);
 423
 424         if (self->lost_packet_from_storage)
 425           gst_buffer_unref (recovered_buffer);
 426
 427         gst_rtp_buffer_map (sent_buffer, GST_MAP_WRITE, &rtp);
 428         gst_rtp_buffer_set_seq (&rtp, self->next_seqnum++);
 429         gst_rtp_buffer_unmap (&rtp);
 430
 431         ret = FALSE;
 432         self->unset_discont_flag = TRUE;
 433         self->chain_return_val = gst_pad_push (self->srcpad, sent_buffer);
 434         break;
 435       }
 436
 437       rtp_storage_put_recovered_packet (self->storage,
 438           recovered_buffer, recovered_pt, self->caps_ssrc, recovered_seq);
 439     }
 440
 441     gst_rtp_ulpfec_dec_stop (self);
 442     gst_buffer_list_unref (buflist);
 443   }
 444
 445   GST_DEBUG_OBJECT (self, "Packet lost ssrc=0x%08x seq=%u", self->caps_ssrc,
 446       seqnum);
 447
 448   return ret;
 449 }
 450
 451 static gboolean
 452 gst_rtp_ulpfec_dec_handle_sink_event (GstPad * pad, GstObject * parent,
 453     GstEvent * event)
 454 {
 455   GstRtpUlpFecDec *self = GST_RTP_ULPFEC_DEC (parent);
 456   gboolean forward = TRUE;
 457
 458   GST_LOG_OBJECT (self, "Received event %" GST_PTR_FORMAT, event);
 459
 460   if (GST_FLOW_OK == self->chain_return_val &&
 461       GST_EVENT_CUSTOM_DOWNSTREAM == GST_EVENT_TYPE (event) &&
 462       gst_event_has_name (event, "GstRTPPacketLost")) {
 463     guint seqnum;
 464     GstClockTime timestamp, duration;
 465     GstStructure *s;
 466
 467     event = gst_event_make_writable (event);
 468     s = gst_event_writable_structure (event);
 469
 470     g_assert (self->have_caps_ssrc);
 471     g_assert (self->storage);
 472
 473     if (!gst_structure_get (s,
 474             "seqnum", G_TYPE_UINT, &seqnum,
 475             "timestamp", G_TYPE_UINT64, &timestamp,
 476             "duration", G_TYPE_UINT64, &duration, NULL))
 477       g_assert_not_reached ();
 478
 479     forward =
 480         gst_rtp_ulpfec_dec_handle_packet_loss (self, seqnum, timestamp,
 481         duration);
 482
 483     if (forward) {
 484       gst_structure_remove_field (s, "seqnum");
 485       gst_structure_set (s, "might-have-been-fec", G_TYPE_BOOLEAN, TRUE, NULL);
 486       ++self->packets_unrecovered;
 487     } else {
 488       ++self->packets_recovered;
 489     }
 490
 491     GST_DEBUG_OBJECT (self, "Unrecovered / Recovered: %lu / %lu",
 492         (gulong) self->packets_unrecovered, (gulong) self->packets_recovered);
 493   } else if (GST_EVENT_CAPS == GST_EVENT_TYPE (event)) {
 494     GstCaps *caps;
 495     gboolean have_caps_pt = FALSE;
 496     gboolean have_caps_ssrc = FALSE;
 497     guint caps_ssrc = 0;
 498     gint caps_pt = 0;
 499
 500     gst_event_parse_caps (event, &caps);
 501     have_caps_ssrc =
 502         gst_structure_get_uint (gst_caps_get_structure (caps, 0), "ssrc",
 503         &caps_ssrc);
 504     have_caps_pt =
 505         gst_structure_get_int (gst_caps_get_structure (caps, 0), "payload",
 506         &caps_pt);
 507
 508     if (self->have_caps_ssrc != have_caps_ssrc || self->caps_ssrc != caps_ssrc)
 509       GST_DEBUG_OBJECT (self, "SSRC changed %u, 0x%08x -> %u, 0x%08x",
 510           self->have_caps_ssrc, self->caps_ssrc, have_caps_ssrc, caps_ssrc);
 511     if (self->have_caps_pt != have_caps_pt || self->caps_pt != caps_pt)
 512       GST_DEBUG_OBJECT (self, "PT changed %u, %u -> %u, %u",
 513           self->have_caps_pt, self->caps_pt, have_caps_pt, caps_pt);
 514
 515     self->have_caps_ssrc = have_caps_ssrc;
 516     self->have_caps_pt = have_caps_pt;
 517     self->caps_ssrc = caps_ssrc;
 518     self->caps_pt = caps_pt;
 519   }
 520
 521   if (forward)
 522     return gst_pad_push_event (self->srcpad, event);
 523   gst_event_unref (event);
 524   return TRUE;
 525 }
 526
 527 static void
 528 gst_rtp_ulpfec_dec_init (GstRtpUlpFecDec * self)
 529 {
 530   self->srcpad = gst_pad_new_from_static_template (&srctemplate, "src");
 531   self->sinkpad = gst_pad_new_from_static_template (&sinktemplate, "sink");
 532   GST_PAD_SET_PROXY_CAPS (self->sinkpad);
 533   GST_PAD_SET_PROXY_ALLOCATION (self->sinkpad);
 534   gst_pad_set_chain_function (self->sinkpad,
 535       GST_DEBUG_FUNCPTR (gst_rtp_ulpfec_dec_chain));
 536   gst_pad_set_event_function (self->sinkpad,
 537       GST_DEBUG_FUNCPTR (gst_rtp_ulpfec_dec_handle_sink_event));
 538
 539   gst_element_add_pad (GST_ELEMENT (self), self->srcpad);
 540   gst_element_add_pad (GST_ELEMENT (self), self->sinkpad);
 541
 542   self->fec_pt = DEFAULT_FEC_PT;
 543
 544   self->next_seqnum = g_random_int_range (0, G_MAXINT16);
 545
 546   self->chain_return_val = GST_FLOW_OK;
 547   self->have_caps_ssrc = FALSE;
 548   self->caps_ssrc = 0;
 549   self->info_fec = g_ptr_array_new ();
 550   self->info_arr = g_array_new (FALSE, TRUE, sizeof (RtpUlpFecMapInfo));
 551   g_array_set_clear_func (self->info_arr,
 552       (GDestroyNotify) rtp_ulpfec_map_info_unmap);
 553   self->scratch_buf = g_array_new (FALSE, TRUE, sizeof (guint8));
 554 }
 555
 556 static void
 557 gst_rtp_ulpfec_dec_dispose (GObject * obj)
 558 {
 559   GstRtpUlpFecDec *self = GST_RTP_ULPFEC_DEC (obj);
 560
 561   GST_INFO_OBJECT (self,
 562       " ssrc=0x%08x pt=%u"
 563       " packets_recovered=%" G_GSIZE_FORMAT
 564       " packets_unrecovered=%" G_GSIZE_FORMAT,
 565       self->caps_ssrc, self->caps_pt,
 566       self->packets_recovered, self->packets_unrecovered);
 567
 568   if (self->storage)
 569     g_object_unref (self->storage);
 570
 571   g_assert (NULL == self->info_media);
 572   g_assert (0 == self->info_fec->len);
 573   g_assert (0 == self->info_arr->len);
 574
 575   if (self->fec_packets_received) {
 576     GST_INFO_OBJECT (self,
 577         " fec_packets_received=%" G_GSIZE_FORMAT
 578         " fec_packets_rejected=%" G_GSIZE_FORMAT
 579         " packets_rejected=%" G_GSIZE_FORMAT,
 580         self->fec_packets_received,
 581         self->fec_packets_rejected, self->packets_rejected);
 582   }
 583
 584   g_ptr_array_free (self->info_fec, TRUE);
 585   g_array_free (self->info_arr, TRUE);
 586   g_array_free (self->scratch_buf, TRUE);
 587
 588   G_OBJECT_CLASS (gst_rtp_ulpfec_dec_parent_class)->dispose (obj);
 589 }
 590
 591 static void
 592 gst_rtp_ulpfec_dec_set_property (GObject * object, guint prop_id,
 593     const GValue * value, GParamSpec * pspec)
 594 {
 595   GstRtpUlpFecDec *self = GST_RTP_ULPFEC_DEC (object);
 596
 597   switch (prop_id) {
 598     case PROP_PT:
 599       self->fec_pt = g_value_get_uint (value);
 600       break;
 601     case PROP_STORAGE:
 602       if (self->storage)
 603         g_object_unref (self->storage);
 604       self->storage = g_value_get_object (value);
 605       if (self->storage)
 606         g_object_ref (self->storage);
 607       break;
 608     default:
 609       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 610       break;
 611   }
 612 }
 613
 614 static void
 615 gst_rtp_ulpfec_dec_get_property (GObject * object, guint prop_id,
 616     GValue * value, GParamSpec * pspec)
 617 {
 618   GstRtpUlpFecDec *self = GST_RTP_ULPFEC_DEC (object);
 619
 620   switch (prop_id) {
 621     case PROP_PT:
 622       g_value_set_uint (value, self->fec_pt);
 623       break;
 624     case PROP_STORAGE:
 625       g_value_set_object (value, self->storage);
 626       break;
 627     case PROP_RECOVERED:
 628       g_value_set_uint (value, (guint) self->packets_recovered);
 629       break;
 630     case PROP_UNRECOVERED:
 631       g_value_set_uint (value, (guint) self->packets_unrecovered);
 632       break;
 633     default:
 634       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 635       break;
 636   }
 637 }
 638
 639 static void
 640 gst_rtp_ulpfec_dec_class_init (GstRtpUlpFecDecClass * klass)
 641 {
 642   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 643   GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
 644
 645   GST_DEBUG_CATEGORY_INIT (gst_rtp_ulpfec_dec_debug,
 646       "rtpulpfecdec", 0, "RTP FEC Decoder");
 647
 648   gst_element_class_add_pad_template (element_class,
 649       gst_static_pad_template_get (&srctemplate));
 650   gst_element_class_add_pad_template (element_class,
 651       gst_static_pad_template_get (&sinktemplate));
 652
 653   gst_element_class_set_static_metadata (element_class,
 654       "RTP FEC Decoder",
 655       "Codec/Depayloader/Network/RTP",
 656       "Decodes RTP FEC (RFC5109)", "Mikhail Fludkov <misha@pexip.com>");
 657
 658   gobject_class->set_property =
 659       GST_DEBUG_FUNCPTR (gst_rtp_ulpfec_dec_set_property);
 660   gobject_class->get_property =
 661       GST_DEBUG_FUNCPTR (gst_rtp_ulpfec_dec_get_property);
 662   gobject_class->dispose = GST_DEBUG_FUNCPTR (gst_rtp_ulpfec_dec_dispose);
 663
 664   klass_properties[PROP_PT] = g_param_spec_uint ("pt", "pt",
 665       "FEC packets payload type", 0, 127,
 666       DEFAULT_FEC_PT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
 667   klass_properties[PROP_STORAGE] =
 668       g_param_spec_object ("storage", "RTP storage", "RTP storage",
 669       G_TYPE_OBJECT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
 670   klass_properties[PROP_RECOVERED] =
 671       g_param_spec_uint ("recovered", "recovered",
 672       "The number of recovered packets", 0, G_MAXUINT, 0,
 673       G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
 674   klass_properties[PROP_UNRECOVERED] =
 675       g_param_spec_uint ("unrecovered", "unrecovered",
 676       "The number of unrecovered packets", 0, G_MAXUINT, 0,
 677       G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
 678
 679   g_object_class_install_properties (gobject_class, N_PROPERTIES,
 680       klass_properties);
 681
 682   g_assert (rtp_ulpfec_ctz64 (G_GUINT64_CONSTANT (0x1)) == 0);
 683   g_assert (rtp_ulpfec_ctz64 (G_GUINT64_CONSTANT (0x8000000000000000)) == 63);
 684 }