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
 109   g_assert (NULL == self->info_media);
 110   g_assert (0 == self->info_fec->len);
 111   g_assert (0 == self->info_arr->len);
 112
 113   g_array_set_size (self->info_arr, gst_buffer_list_length (buflist));
 114
 115   for (gsize i = 0;
 116       i < gst_buffer_list_length (buflist) && !self->lost_packet_from_storage;
 117       ++i) {
 118     GstBuffer *buffer = gst_buffer_list_get (buflist, i);
 119     RtpUlpFecMapInfo *info = RTP_FEC_MAP_INFO_NTH (self, i);
 120
 121     if (!rtp_ulpfec_map_info_map (gst_buffer_ref (buffer), info))
 122       g_assert_not_reached ();
 123
 124     if (fec_pt == gst_rtp_buffer_get_payload_type (&info->rtp)) {
 125       GST_DEBUG_RTP_PACKET (self, "rtp header (fec)", &info->rtp);
 126
 127       ++fec_packets;
 128       if (rtp_ulpfec_buffer_is_valid (&info->rtp)) {
 129         GST_DEBUG_FEC_PACKET (self, &info->rtp);
 130         g_ptr_array_add (self->info_fec, GUINT_TO_POINTER (i));
 131       }
 132     } else {
 133       GST_LOG_RTP_PACKET (self, "rtp header (incoming)", &info->rtp);
 134
 135       if (lost_seq == gst_rtp_buffer_get_seq (&info->rtp)) {
 136         GST_DEBUG_OBJECT (self, "Received lost packet from from the storage");
 137         g_list_free (self->info_media);
 138         self->info_media = NULL;
 139         self->lost_packet_from_storage = TRUE;
 140       }
 141       self->info_media =
 142           g_list_insert_sorted_with_data (self->info_media,
 143           GUINT_TO_POINTER (i), _compare_fec_map_info, self);
 144     }
 145   }
 146   if (!self->lost_packet_from_storage) {
 147     self->fec_packets_received += fec_packets;
 148     self->fec_packets_rejected += fec_packets - self->info_fec->len;
 149   }
 150 }
 151
 152 static void
 153 gst_rtp_ulpfec_dec_stop (GstRtpUlpFecDec * self)
 154 {
 155   g_array_set_size (self->info_arr, 0);
 156   g_ptr_array_set_size (self->info_fec, 0);
 157   g_list_free (self->info_media);
 158   self->info_media = NULL;
 159   self->lost_packet_from_storage = FALSE;
 160   self->lost_packet_returned = FALSE;
 161 }
 162
 163 static guint64
 164 gst_rtp_ulpfec_dec_get_media_buffers_mask (GstRtpUlpFecDec * self,
 165     guint16 fec_seq_base)
 166 {
 167   guint64 mask = 0;
 168   for (GList * it = self->info_media; it; it = it->next) {
 169     RtpUlpFecMapInfo *info = RTP_FEC_MAP_INFO_NTH (self, it->data);
 170     mask |=
 171         rtp_ulpfec_packet_mask_from_seqnum (gst_rtp_buffer_get_seq (&info->rtp),
 172         fec_seq_base, TRUE);
 173   }
 174   return mask;
 175 }
 176
 177 static gboolean
 178 gst_rtp_ulpfec_dec_is_recovered_pt_valid (GstRtpUlpFecDec * self, gint media_pt,
 179     guint8 recovered_pt)
 180 {
 181   if (media_pt == recovered_pt)
 182     return TRUE;
 183
 184   for (GList * it = self->info_media; it; it = it->next) {
 185     RtpUlpFecMapInfo *info = RTP_FEC_MAP_INFO_NTH (self, it->data);
 186     if (gst_rtp_buffer_get_payload_type (&info->rtp) == recovered_pt)
 187       return TRUE;
 188   }
 189   return FALSE;
 190 }
 191
 192 static GstBuffer *
 193 gst_rtp_ulpfec_dec_recover_from_fec (GstRtpUlpFecDec * self,
 194     RtpUlpFecMapInfo * info_fec, guint32 ssrc, gint media_pt, guint16 seq,
 195     guint8 * dst_pt)
 196 {
 197   guint64 fec_mask = rtp_ulpfec_buffer_get_mask (&info_fec->rtp);
 198   gboolean fec_mask_long = rtp_ulpfec_buffer_get_fechdr (&info_fec->rtp)->L;
 199   guint16 fec_seq_base = rtp_ulpfec_buffer_get_seq_base (&info_fec->rtp);
 200   GstBuffer *ret;
 201
 202   g_array_set_size (self->scratch_buf, 0);
 203   rtp_buffer_to_ulpfec_bitstring (&info_fec->rtp, self->scratch_buf, TRUE,
 204       fec_mask_long);
 205
 206   for (GList * it = self->info_media; it; it = it->next) {
 207     RtpUlpFecMapInfo *info = RTP_FEC_MAP_INFO_NTH (self, it->data);
 208     guint64 packet_mask =
 209         rtp_ulpfec_packet_mask_from_seqnum (gst_rtp_buffer_get_seq (&info->rtp),
 210         fec_seq_base, TRUE);
 211
 212     if (fec_mask & packet_mask) {
 213       fec_mask ^= packet_mask;
 214       rtp_buffer_to_ulpfec_bitstring (&info->rtp, self->scratch_buf, FALSE,
 215           fec_mask_long);
 216     }
 217   }
 218
 219   ret =
 220       rtp_ulpfec_bitstring_to_media_rtp_buffer (self->scratch_buf,
 221       fec_mask_long, ssrc, seq);
 222   if (ret) {
 223     /* We are about to put recovered packet back in self->info_media to be able
 224      * to reuse it later for recovery of other packets
 225      **/
 226     gint i = self->info_arr->len;
 227     RtpUlpFecMapInfo *info;
 228     guint8 recovered_pt;
 229
 230     g_array_set_size (self->info_arr, self->info_arr->len + 1);
 231     info = RTP_FEC_MAP_INFO_NTH (self, i);
 232
 233     if (!rtp_ulpfec_map_info_map (gst_buffer_ref (ret), info)) {
 234       GST_WARNING_OBJECT (self, "Invalid recovered packet");
 235       goto recovered_packet_invalid;
 236     }
 237
 238     recovered_pt = gst_rtp_buffer_get_payload_type (&info->rtp);
 239     if (!gst_rtp_ulpfec_dec_is_recovered_pt_valid (self, media_pt,
 240             recovered_pt)) {
 241       GST_WARNING_OBJECT (self,
 242           "Recovered packet has unexpected payload type (%u)", recovered_pt);
 243       goto recovered_packet_invalid;
 244     }
 245
 246     GST_DEBUG_RTP_PACKET (self, "rtp header (recovered)", &info->rtp);
 247     self->info_media =
 248         g_list_insert_sorted_with_data (self->info_media, GUINT_TO_POINTER (i),
 249         _compare_fec_map_info, self);
 250     *dst_pt = recovered_pt;
 251   }
 252   return ret;
 253
 254 recovered_packet_invalid:
 255   g_array_set_size (self->info_arr, self->info_arr->len - 1);
 256   gst_buffer_unref (ret);
 257   return NULL;
 258 }
 259
 260 static GstBuffer *
 261 gst_rtp_ulpfec_dec_recover_from_storage (GstRtpUlpFecDec * self,
 262     guint8 * dst_pt, guint16 * dst_seq)
 263 {
 264   RtpUlpFecMapInfo *info;
 265
 266   if (self->lost_packet_returned)
 267     return NULL;
 268
 269   g_assert (g_list_length (self->info_media) == 1);
 270
 271   info = RTP_FEC_MAP_INFO_NTH (self, self->info_media->data);
 272   *dst_seq = gst_rtp_buffer_get_seq (&info->rtp);
 273   *dst_pt = gst_rtp_buffer_get_payload_type (&info->rtp);
 274   self->lost_packet_returned = TRUE;
 275   GST_DEBUG_RTP_PACKET (self, "rtp header (recovered)", &info->rtp);
 276   return gst_buffer_ref (info->rtp.buffer);
 277 }
 278
 279 /* __has_builtin only works with clang, so test compiler version for gcc */
 280 /* Intel compiler and MSVC probably have their own things as well */
 281 /* TODO: make sure we use builtin for clang as well */
 282 #if defined(__GNUC__) && __GNUC__ >= 4
 283 #define rtp_ulpfec_ctz64 __builtin_ctzll
 284 #else
 285 static inline gint
 286 rtp_ulpfec_ctz64_inline (guint64 mask)
 287 {
 288   gint nth_bit = 0;
 289
 290   do {
 291     if ((mask & 1))
 292       return nth_bit;
 293     mask = mask >> 1;
 294   } while (++nth_bit < 64);
 295
 296   return -1;                    /* should not be reached, since mask must not be 0 */
 297 }
 298
 299 #define rtp_ulpfec_ctz64 rtp_ulpfec_ctz64_inline
 300 #endif
 301
 302 static GstBuffer *
 303 gst_rtp_ulpfec_dec_recover (GstRtpUlpFecDec * self, guint32 ssrc, gint media_pt,
 304     guint8 * dst_pt, guint16 * dst_seq)
 305 {
 306   guint64 media_mask = 0;
 307   gint media_mask_seq_base = -1;
 308
 309   if (self->lost_packet_from_storage)
 310     return gst_rtp_ulpfec_dec_recover_from_storage (self, dst_pt, dst_seq);
 311
 312   /* Looking for a FEC packet which can be used for recovery */
 313   for (gsize i = 0; i < self->info_fec->len; ++i) {
 314     RtpUlpFecMapInfo *info = RTP_FEC_MAP_INFO_NTH (self,
 315         g_ptr_array_index (self->info_fec, i));
 316     guint16 seq_base = rtp_ulpfec_buffer_get_seq_base (&info->rtp);
 317     guint64 fec_mask = rtp_ulpfec_buffer_get_mask (&info->rtp);
 318     guint64 missing_packets_mask;
 319
 320     if (media_mask_seq_base != (gint) seq_base) {
 321       media_mask_seq_base = seq_base;
 322       media_mask = gst_rtp_ulpfec_dec_get_media_buffers_mask (self, seq_base);
 323     }
 324
 325     /* media_mask has 1s if packet exist.
 326      * fec_mask is the mask of protected packets
 327      * The statement below excludes existing packets from the protected. So
 328      * we are left with 1s only for missing packets which can be recovered
 329      * by this FEC packet. */
 330     missing_packets_mask = fec_mask & (~media_mask);
 331
 332     /* Do we have any 1s? Checking if current FEC packet can be used for recovery */
 333     if (0 != missing_packets_mask) {
 334       guint trailing_zeros = rtp_ulpfec_ctz64 (missing_packets_mask);
 335
 336       /* Is it the only 1 in the mask? Checking if we lacking single packet in
 337        * that case FEC packet can be used for recovery */
 338       if (missing_packets_mask == (G_GUINT64_CONSTANT (1) << trailing_zeros)) {
 339         GstBuffer *ret;
 340
 341         *dst_seq =
 342             seq_base + (RTP_ULPFEC_SEQ_BASE_OFFSET_MAX (TRUE) - trailing_zeros);
 343         ret =
 344             gst_rtp_ulpfec_dec_recover_from_fec (self, info, ssrc, media_pt,
 345             *dst_seq, dst_pt);
 346         if (ret)
 347           return ret;
 348       }
 349     }
 350   }
 351   return NULL;
 352 }
 353
 354 static GstFlowReturn
 355 gst_rtp_ulpfec_dec_chain (GstPad * pad, GstObject * parent, GstBuffer * buf)
 356 {
 357   GstRtpUlpFecDec *self = GST_RTP_ULPFEC_DEC (parent);
 358
 359   if (G_LIKELY (GST_FLOW_OK == self->chain_return_val)) {
 360     if (G_UNLIKELY (self->unset_discont_flag)) {
 361       self->unset_discont_flag = FALSE;
 362       buf = gst_buffer_make_writable (buf);
 363       GST_BUFFER_FLAG_UNSET (buf, GST_BUFFER_FLAG_DISCONT);
 364     }
 365     return gst_pad_push (self->srcpad, buf);
 366   }
 367
 368   gst_buffer_unref (buf);
 369   return self->chain_return_val;
 370 }
 371
 372 static gboolean
 373 gst_rtp_ulpfec_dec_handle_packet_loss (GstRtpUlpFecDec * self, guint16 seqnum,
 374     GstClockTime timestamp, GstClockTime duration)
 375 {
 376   gint caps_pt = self->have_caps_pt ? self->caps_pt : -1;
 377   gboolean ret = TRUE;
 378   GstBufferList *buflist =
 379       rtp_storage_get_packets_for_recovery (self->storage, self->fec_pt,
 380       self->caps_ssrc, seqnum);
 381
 382   if (buflist) {
 383     GstBuffer *recovered_buffer = NULL;
 384     guint16 recovered_seq = 0;
 385     guint8 recovered_pt = 0;
 386
 387     gst_rtp_ulpfec_dec_start (self, buflist, self->fec_pt, seqnum);
 388
 389     while (NULL != (recovered_buffer =
 390             gst_rtp_ulpfec_dec_recover (self, self->caps_ssrc, caps_pt,
 391                 &recovered_pt, &recovered_seq))) {
 392       if (seqnum == recovered_seq) {
 393         recovered_buffer = gst_buffer_make_writable (recovered_buffer);
 394         GST_BUFFER_PTS (recovered_buffer) = timestamp;
 395         /* GST_BUFFER_DURATION (recovered_buffer) = duration;
 396          * JB does not set the duration, so we will not too */
 397
 398         if (!self->lost_packet_from_storage)
 399           rtp_storage_put_recovered_packet (self->storage,
 400               gst_buffer_ref (recovered_buffer), recovered_pt, self->caps_ssrc,
 401               recovered_seq);
 402
 403         GST_DEBUG_OBJECT (self,
 404             "Pushing recovered packet ssrc=0x%08x seq=%u %" GST_PTR_FORMAT,
 405             self->caps_ssrc, seqnum, recovered_buffer);
 406
 407         ret = FALSE;
 408         self->unset_discont_flag = TRUE;
 409         self->chain_return_val = gst_pad_push (self->srcpad, recovered_buffer);
 410         break;
 411       }
 412
 413       rtp_storage_put_recovered_packet (self->storage,
 414           recovered_buffer, recovered_pt, self->caps_ssrc, recovered_seq);
 415     }
 416
 417     gst_rtp_ulpfec_dec_stop (self);
 418     gst_buffer_list_unref (buflist);
 419   }
 420
 421   GST_DEBUG_OBJECT (self, "Packet lost ssrc=0x%08x seq=%u", self->caps_ssrc,
 422       seqnum);
 423
 424   return ret;
 425 }
 426
 427 static gboolean
 428 gst_rtp_ulpfec_dec_handle_sink_event (GstPad * pad, GstObject * parent,
 429     GstEvent * event)
 430 {
 431   GstRtpUlpFecDec *self = GST_RTP_ULPFEC_DEC (parent);
 432   gboolean forward = TRUE;
 433
 434   GST_LOG_OBJECT (self, "Received event %" GST_PTR_FORMAT, event);
 435
 436   if (GST_FLOW_OK == self->chain_return_val &&
 437       GST_EVENT_CUSTOM_DOWNSTREAM == GST_EVENT_TYPE (event) &&
 438       gst_event_has_name (event, "GstRTPPacketLost")) {
 439     guint seqnum;
 440     GstClockTime timestamp, duration;
 441
 442     g_assert (self->have_caps_ssrc);
 443     g_assert (self->storage);
 444
 445     if (!gst_structure_get (gst_event_get_structure (event),
 446             "seqnum", G_TYPE_UINT, &seqnum,
 447             "timestamp", G_TYPE_UINT64, &timestamp,
 448             "duration", G_TYPE_UINT64, &duration, NULL))
 449       g_assert_not_reached ();
 450
 451     forward =
 452         gst_rtp_ulpfec_dec_handle_packet_loss (self, seqnum, timestamp,
 453         duration);
 454     if (forward)
 455       ++self->packets_unrecovered;
 456     else
 457       ++self->packets_recovered;
 458     GST_DEBUG_OBJECT (self, "Unrecovered / Recovered: %lu / %lu",
 459         (gulong) self->packets_unrecovered, (gulong) self->packets_recovered);
 460   } else if (GST_EVENT_CAPS == GST_EVENT_TYPE (event)) {
 461     GstCaps *caps;
 462     gboolean have_caps_pt = FALSE;
 463     gboolean have_caps_ssrc = FALSE;
 464     guint caps_ssrc = 0;
 465     gint caps_pt = 0;
 466
 467     gst_event_parse_caps (event, &caps);
 468     have_caps_ssrc =
 469         gst_structure_get_uint (gst_caps_get_structure (caps, 0), "ssrc",
 470         &caps_ssrc);
 471     have_caps_pt =
 472         gst_structure_get_int (gst_caps_get_structure (caps, 0), "payload",
 473         &caps_pt);
 474
 475     if (self->have_caps_ssrc != have_caps_ssrc || self->caps_ssrc != caps_ssrc)
 476       GST_DEBUG_OBJECT (self, "SSRC changed %u, 0x%08x -> %u, 0x%08x",
 477           self->have_caps_ssrc, self->caps_ssrc, have_caps_ssrc, caps_ssrc);
 478     if (self->have_caps_pt != have_caps_pt || self->caps_pt != caps_pt)
 479       GST_DEBUG_OBJECT (self, "PT changed %u, %u -> %u, %u",
 480           self->have_caps_pt, self->caps_pt, have_caps_pt, caps_pt);
 481
 482     self->have_caps_ssrc = have_caps_ssrc;
 483     self->have_caps_pt = have_caps_pt;
 484     self->caps_ssrc = caps_ssrc;
 485     self->caps_pt = caps_pt;
 486   }
 487
 488   if (forward)
 489     return gst_pad_push_event (self->srcpad, event);
 490   gst_event_unref (event);
 491   return TRUE;
 492 }
 493
 494 static void
 495 gst_rtp_ulpfec_dec_init (GstRtpUlpFecDec * self)
 496 {
 497   self->srcpad = gst_pad_new_from_static_template (&srctemplate, "src");
 498   self->sinkpad = gst_pad_new_from_static_template (&sinktemplate, "sink");
 499   GST_PAD_SET_PROXY_CAPS (self->sinkpad);
 500   GST_PAD_SET_PROXY_ALLOCATION (self->sinkpad);
 501   gst_pad_set_chain_function (self->sinkpad,
 502       GST_DEBUG_FUNCPTR (gst_rtp_ulpfec_dec_chain));
 503   gst_pad_set_event_function (self->sinkpad,
 504       GST_DEBUG_FUNCPTR (gst_rtp_ulpfec_dec_handle_sink_event));
 505
 506   gst_element_add_pad (GST_ELEMENT (self), self->srcpad);
 507   gst_element_add_pad (GST_ELEMENT (self), self->sinkpad);
 508
 509   self->fec_pt = DEFAULT_FEC_PT;
 510
 511   self->chain_return_val = GST_FLOW_OK;
 512   self->have_caps_ssrc = FALSE;
 513   self->caps_ssrc = 0;
 514   self->info_fec = g_ptr_array_new ();
 515   self->info_arr = g_array_new (FALSE, TRUE, sizeof (RtpUlpFecMapInfo));
 516   g_array_set_clear_func (self->info_arr,
 517       (GDestroyNotify) rtp_ulpfec_map_info_unmap);
 518   self->scratch_buf = g_array_new (FALSE, TRUE, sizeof (guint8));
 519 }
 520
 521 static void
 522 gst_rtp_ulpfec_dec_dispose (GObject * obj)
 523 {
 524   GstRtpUlpFecDec *self = GST_RTP_ULPFEC_DEC (obj);
 525
 526   GST_INFO_OBJECT (self,
 527       " ssrc=0x%08x pt=%u"
 528       " packets_recovered=%" G_GSIZE_FORMAT
 529       " packets_unrecovered=%" G_GSIZE_FORMAT,
 530       self->caps_ssrc, self->caps_pt,
 531       self->packets_recovered, self->packets_unrecovered);
 532
 533   if (self->storage)
 534     g_object_unref (self->storage);
 535
 536   g_assert (NULL == self->info_media);
 537   g_assert (0 == self->info_fec->len);
 538   g_assert (0 == self->info_arr->len);
 539
 540   if (self->fec_packets_received) {
 541     GST_INFO_OBJECT (self,
 542         " fec_packets_received=%" G_GSIZE_FORMAT
 543         " fec_packets_rejected=%" G_GSIZE_FORMAT
 544         " packets_rejected=%" G_GSIZE_FORMAT,
 545         self->fec_packets_received,
 546         self->fec_packets_rejected, self->packets_rejected);
 547   }
 548
 549   g_ptr_array_free (self->info_fec, TRUE);
 550   g_array_free (self->info_arr, TRUE);
 551   g_array_free (self->scratch_buf, TRUE);
 552
 553   G_OBJECT_CLASS (gst_rtp_ulpfec_dec_parent_class)->dispose (obj);
 554 }
 555
 556 static void
 557 gst_rtp_ulpfec_dec_set_property (GObject * object, guint prop_id,
 558     const GValue * value, GParamSpec * pspec)
 559 {
 560   GstRtpUlpFecDec *self = GST_RTP_ULPFEC_DEC (object);
 561
 562   switch (prop_id) {
 563     case PROP_PT:
 564       self->fec_pt = g_value_get_uint (value);
 565       break;
 566     case PROP_STORAGE:
 567       if (self->storage)
 568         g_object_unref (self->storage);
 569       self->storage = g_value_get_object (value);
 570       if (self->storage)
 571         g_object_ref (self->storage);
 572       break;
 573     default:
 574       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 575       break;
 576   }
 577 }
 578
 579 static void
 580 gst_rtp_ulpfec_dec_get_property (GObject * object, guint prop_id,
 581     GValue * value, GParamSpec * pspec)
 582 {
 583   GstRtpUlpFecDec *self = GST_RTP_ULPFEC_DEC (object);
 584
 585   switch (prop_id) {
 586     case PROP_PT:
 587       g_value_set_uint (value, self->fec_pt);
 588       break;
 589     case PROP_STORAGE:
 590       g_value_set_object (value, self->storage);
 591       break;
 592     case PROP_RECOVERED:
 593       g_value_set_uint (value, (guint) self->packets_recovered);
 594       break;
 595     case PROP_UNRECOVERED:
 596       g_value_set_uint (value, (guint) self->packets_unrecovered);
 597       break;
 598     default:
 599       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 600       break;
 601   }
 602 }
 603
 604 static void
 605 gst_rtp_ulpfec_dec_class_init (GstRtpUlpFecDecClass * klass)
 606 {
 607   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 608   GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
 609
 610   GST_DEBUG_CATEGORY_INIT (gst_rtp_ulpfec_dec_debug,
 611       "rtpulpfecdec", 0, "RTP FEC Decoder");
 612
 613   gst_element_class_add_pad_template (element_class,
 614       gst_static_pad_template_get (&srctemplate));
 615   gst_element_class_add_pad_template (element_class,
 616       gst_static_pad_template_get (&sinktemplate));
 617
 618   gst_element_class_set_static_metadata (element_class,
 619       "RTP FEC Decoder",
 620       "Codec/Depayloader/Network/RTP",
 621       "Decodes RTP FEC (RFC5109)", "Mikhail Fludkov <misha@pexip.com>");
 622
 623   gobject_class->set_property =
 624       GST_DEBUG_FUNCPTR (gst_rtp_ulpfec_dec_set_property);
 625   gobject_class->get_property =
 626       GST_DEBUG_FUNCPTR (gst_rtp_ulpfec_dec_get_property);
 627   gobject_class->dispose = GST_DEBUG_FUNCPTR (gst_rtp_ulpfec_dec_dispose);
 628
 629   klass_properties[PROP_PT] = g_param_spec_uint ("pt", "pt",
 630       "FEC packets payload type", 0, 127,
 631       DEFAULT_FEC_PT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
 632   klass_properties[PROP_STORAGE] =
 633       g_param_spec_object ("storage", "RTP storage", "RTP storage",
 634       G_TYPE_OBJECT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
 635   klass_properties[PROP_RECOVERED] =
 636       g_param_spec_uint ("recovered", "recovered",
 637       "The number of recovered packets", 0, G_MAXUINT, 0,
 638       G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
 639   klass_properties[PROP_UNRECOVERED] =
 640       g_param_spec_uint ("unrecovered", "unrecovered",
 641       "The number of unrecovered packets", 0, G_MAXUINT, 0,
 642       G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
 643
 644   g_object_class_install_properties (gobject_class, N_PROPERTIES,
 645       klass_properties);
 646
 647   g_assert (rtp_ulpfec_ctz64 (G_GUINT64_CONSTANT (0x1)) == 0);
 648   g_assert (rtp_ulpfec_ctz64 (G_GUINT64_CONSTANT (0x8000000000000000)) == 63);
 649 }