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 #if defined(__has_builtin) && __has_builtin(__builtin_ctzll)
 282 #define rtp_ulpfec_ctz64 __builtin_ctzll
 283 #elif defined(__GNUC__) && __GNUC__ >= 4
 284 #define rtp_ulpfec_ctz64 __builtin_ctzll
 285 #else
 286 static inline gint
 287 rtp_ulpfec_ctz64_inline (guint64 mask)
 288 {
 289   gint nth_bit = 0;
 290
 291   do {
 292     if ((mask & 1))
 293       return nth_bit;
 294     mask = mask >> 1;
 295   } while (++nth_bit < 64);
 296
 297   return -1;                    /* should not be reached, since mask must not be 0 */
 298 }
 299
 300 #define rtp_ulpfec_ctz64 rtp_ulpfec_ctz64_inline
 301 #endif
 302
 303 static GstBuffer *
 304 gst_rtp_ulpfec_dec_recover (GstRtpUlpFecDec * self, guint32 ssrc, gint media_pt,
 305     guint8 * dst_pt, guint16 * dst_seq)
 306 {
 307   guint64 media_mask = 0;
 308   gint media_mask_seq_base = -1;
 309
 310   if (self->lost_packet_from_storage)
 311     return gst_rtp_ulpfec_dec_recover_from_storage (self, dst_pt, dst_seq);
 312
 313   /* Looking for a FEC packet which can be used for recovery */
 314   for (gsize i = 0; i < self->info_fec->len; ++i) {
 315     RtpUlpFecMapInfo *info = RTP_FEC_MAP_INFO_NTH (self,
 316         g_ptr_array_index (self->info_fec, i));
 317     guint16 seq_base = rtp_ulpfec_buffer_get_seq_base (&info->rtp);
 318     guint64 fec_mask = rtp_ulpfec_buffer_get_mask (&info->rtp);
 319     guint64 missing_packets_mask;
 320
 321     if (media_mask_seq_base != (gint) seq_base) {
 322       media_mask_seq_base = seq_base;
 323       media_mask = gst_rtp_ulpfec_dec_get_media_buffers_mask (self, seq_base);
 324     }
 325
 326     /* media_mask has 1s if packet exist.
 327      * fec_mask is the mask of protected packets
 328      * The statement below excludes existing packets from the protected. So
 329      * we are left with 1s only for missing packets which can be recovered
 330      * by this FEC packet. */
 331     missing_packets_mask = fec_mask & (~media_mask);
 332
 333     /* Do we have any 1s? Checking if current FEC packet can be used for recovery */
 334     if (0 != missing_packets_mask) {
 335       guint trailing_zeros = rtp_ulpfec_ctz64 (missing_packets_mask);
 336
 337       /* Is it the only 1 in the mask? Checking if we lacking single packet in
 338        * that case FEC packet can be used for recovery */
 339       if (missing_packets_mask == (1ULL << trailing_zeros)) {
 340         GstBuffer *ret;
 341
 342         *dst_seq =
 343             seq_base + (RTP_ULPFEC_SEQ_BASE_OFFSET_MAX (TRUE) - trailing_zeros);
 344         ret =
 345             gst_rtp_ulpfec_dec_recover_from_fec (self, info, ssrc, media_pt,
 346             *dst_seq, dst_pt);
 347         if (ret)
 348           return ret;
 349       }
 350     }
 351   }
 352   return NULL;
 353 }
 354
 355 static GstFlowReturn
 356 gst_rtp_ulpfec_dec_chain (GstPad * pad, GstObject * parent, GstBuffer * buf)
 357 {
 358   GstRtpUlpFecDec *self = GST_RTP_ULPFEC_DEC (parent);
 359
 360   if (G_LIKELY (GST_FLOW_OK == self->chain_return_val)) {
 361     if (G_UNLIKELY (self->unset_discont_flag)) {
 362       self->unset_discont_flag = FALSE;
 363       buf = gst_buffer_make_writable (buf);
 364       GST_BUFFER_FLAG_UNSET (buf, GST_BUFFER_FLAG_DISCONT);
 365     }
 366     return gst_pad_push (self->srcpad, buf);
 367   }
 368
 369   gst_buffer_unref (buf);
 370   return self->chain_return_val;
 371 }
 372
 373 static gboolean
 374 gst_rtp_ulpfec_dec_handle_packet_loss (GstRtpUlpFecDec * self, guint16 seqnum,
 375     GstClockTime timestamp, GstClockTime duration)
 376 {
 377   gint caps_pt = self->have_caps_pt ? self->caps_pt : -1;
 378   gboolean ret = TRUE;
 379   GstBufferList *buflist =
 380       rtp_storage_get_packets_for_recovery (self->storage, self->fec_pt,
 381       self->caps_ssrc, seqnum);
 382
 383   if (buflist) {
 384     GstBuffer *recovered_buffer = NULL;
 385     guint16 recovered_seq = 0;
 386     guint8 recovered_pt = 0;
 387
 388     gst_rtp_ulpfec_dec_start (self, buflist, self->fec_pt, seqnum);
 389
 390     while (NULL != (recovered_buffer =
 391             gst_rtp_ulpfec_dec_recover (self, self->caps_ssrc, caps_pt,
 392                 &recovered_pt, &recovered_seq))) {
 393       if (seqnum == recovered_seq) {
 394         recovered_buffer = gst_buffer_make_writable (recovered_buffer);
 395         GST_BUFFER_PTS (recovered_buffer) = timestamp;
 396         /* GST_BUFFER_DURATION (recovered_buffer) = duration;
 397          * JB does not set the duration, so we will not too */
 398
 399         if (!self->lost_packet_from_storage)
 400           rtp_storage_put_recovered_packet (self->storage,
 401               gst_buffer_ref (recovered_buffer), recovered_pt, self->caps_ssrc,
 402               recovered_seq);
 403
 404         GST_DEBUG_OBJECT (self,
 405             "Pushing recovered packet ssrc=0x%08x seq=%u %" GST_PTR_FORMAT,
 406             self->caps_ssrc, seqnum, recovered_buffer);
 407
 408         ret = FALSE;
 409         self->unset_discont_flag = TRUE;
 410         self->chain_return_val = gst_pad_push (self->srcpad, recovered_buffer);
 411         break;
 412       }
 413
 414       rtp_storage_put_recovered_packet (self->storage,
 415           recovered_buffer, recovered_pt, self->caps_ssrc, recovered_seq);
 416     }
 417
 418     gst_rtp_ulpfec_dec_stop (self);
 419     gst_buffer_list_unref (buflist);
 420   }
 421
 422   GST_DEBUG_OBJECT (self, "Packet lost ssrc=0x%08x seq=%u", self->caps_ssrc,
 423       seqnum);
 424
 425   return ret;
 426 }
 427
 428 static gboolean
 429 gst_rtp_ulpfec_dec_handle_sink_event (GstPad * pad, GstObject * parent,
 430     GstEvent * event)
 431 {
 432   GstRtpUlpFecDec *self = GST_RTP_ULPFEC_DEC (parent);
 433   gboolean forward = TRUE;
 434
 435   GST_LOG_OBJECT (self, "Received event %" GST_PTR_FORMAT, event);
 436
 437   if (GST_FLOW_OK == self->chain_return_val &&
 438       GST_EVENT_CUSTOM_DOWNSTREAM == GST_EVENT_TYPE (event) &&
 439       gst_event_has_name (event, "GstRTPPacketLost")) {
 440     guint seqnum;
 441     GstClockTime timestamp, duration;
 442
 443     g_assert (self->have_caps_ssrc);
 444     g_assert (self->storage);
 445
 446     if (!gst_structure_get (gst_event_get_structure (event),
 447             "seqnum", G_TYPE_UINT, &seqnum,
 448             "timestamp", G_TYPE_UINT64, &timestamp,
 449             "duration", G_TYPE_UINT64, &duration, NULL))
 450       g_assert_not_reached ();
 451
 452     forward =
 453         gst_rtp_ulpfec_dec_handle_packet_loss (self, seqnum, timestamp,
 454         duration);
 455     if (forward)
 456       ++self->packets_unrecovered;
 457     else
 458       ++self->packets_recovered;
 459     GST_DEBUG_OBJECT (self, "Unrecovered / Recovered: %lu / %lu",
 460         (gulong) self->packets_unrecovered, (gulong) self->packets_recovered);
 461   } else if (GST_EVENT_CAPS == GST_EVENT_TYPE (event)) {
 462     GstCaps *caps;
 463     gboolean have_caps_pt = FALSE;
 464     gboolean have_caps_ssrc = FALSE;
 465     guint caps_ssrc = 0;
 466     gint caps_pt = 0;
 467
 468     gst_event_parse_caps (event, &caps);
 469     have_caps_ssrc =
 470         gst_structure_get_uint (gst_caps_get_structure (caps, 0), "ssrc",
 471         &caps_ssrc);
 472     have_caps_pt =
 473         gst_structure_get_int (gst_caps_get_structure (caps, 0), "payload",
 474         &caps_pt);
 475
 476     if (self->have_caps_ssrc != have_caps_ssrc || self->caps_ssrc != caps_ssrc)
 477       GST_DEBUG_OBJECT (self, "SSRC changed %u, 0x%08x -> %u, 0x%08x",
 478           self->have_caps_ssrc, self->caps_ssrc, have_caps_ssrc, caps_ssrc);
 479     if (self->have_caps_pt != have_caps_pt || self->caps_pt != caps_pt)
 480       GST_DEBUG_OBJECT (self, "PT changed %u, %u -> %u, %u",
 481           self->have_caps_pt, self->caps_pt, have_caps_pt, caps_pt);
 482
 483     self->have_caps_ssrc = have_caps_ssrc;
 484     self->have_caps_pt = have_caps_pt;
 485     self->caps_ssrc = caps_ssrc;
 486     self->caps_pt = caps_pt;
 487   }
 488
 489   if (forward)
 490     return gst_pad_push_event (self->srcpad, event);
 491   gst_event_unref (event);
 492   return TRUE;
 493 }
 494
 495 static void
 496 gst_rtp_ulpfec_dec_init (GstRtpUlpFecDec * self)
 497 {
 498   self->srcpad = gst_pad_new_from_static_template (&srctemplate, "src");
 499   self->sinkpad = gst_pad_new_from_static_template (&sinktemplate, "sink");
 500   GST_PAD_SET_PROXY_CAPS (self->sinkpad);
 501   GST_PAD_SET_PROXY_ALLOCATION (self->sinkpad);
 502   gst_pad_set_chain_function (self->sinkpad,
 503       GST_DEBUG_FUNCPTR (gst_rtp_ulpfec_dec_chain));
 504   gst_pad_set_event_function (self->sinkpad,
 505       GST_DEBUG_FUNCPTR (gst_rtp_ulpfec_dec_handle_sink_event));
 506
 507   gst_element_add_pad (GST_ELEMENT (self), self->srcpad);
 508   gst_element_add_pad (GST_ELEMENT (self), self->sinkpad);
 509
 510   self->fec_pt = DEFAULT_FEC_PT;
 511
 512   self->chain_return_val = GST_FLOW_OK;
 513   self->have_caps_ssrc = FALSE;
 514   self->caps_ssrc = 0;
 515   self->info_fec = g_ptr_array_new ();
 516   self->info_arr = g_array_new (FALSE, TRUE, sizeof (RtpUlpFecMapInfo));
 517   g_array_set_clear_func (self->info_arr,
 518       (GDestroyNotify) rtp_ulpfec_map_info_unmap);
 519   self->scratch_buf = g_array_new (FALSE, TRUE, sizeof (guint8));
 520 }
 521
 522 static void
 523 gst_rtp_ulpfec_dec_dispose (GObject * obj)
 524 {
 525   GstRtpUlpFecDec *self = GST_RTP_ULPFEC_DEC (obj);
 526
 527   GST_INFO_OBJECT (self,
 528       " ssrc=0x%08x pt=%u"
 529       " packets_recovered=%" G_GSIZE_FORMAT
 530       " packets_unrecovered=%" G_GSIZE_FORMAT,
 531       self->caps_ssrc, self->caps_pt,
 532       self->packets_recovered, self->packets_unrecovered);
 533
 534   if (self->storage)
 535     g_object_unref (self->storage);
 536
 537   g_assert (NULL == self->info_media);
 538   g_assert (0 == self->info_fec->len);
 539   g_assert (0 == self->info_arr->len);
 540
 541   if (self->fec_packets_received) {
 542     GST_INFO_OBJECT (self,
 543         " fec_packets_received=%" G_GSIZE_FORMAT
 544         " fec_packets_rejected=%" G_GSIZE_FORMAT
 545         " packets_rejected=%" G_GSIZE_FORMAT,
 546         self->fec_packets_received,
 547         self->fec_packets_rejected, self->packets_rejected);
 548   }
 549
 550   g_ptr_array_free (self->info_fec, TRUE);
 551   g_array_free (self->info_arr, TRUE);
 552   g_array_free (self->scratch_buf, TRUE);
 553
 554   G_OBJECT_CLASS (gst_rtp_ulpfec_dec_parent_class)->dispose (obj);
 555 }
 556
 557 static void
 558 gst_rtp_ulpfec_dec_set_property (GObject * object, guint prop_id,
 559     const GValue * value, GParamSpec * pspec)
 560 {
 561   GstRtpUlpFecDec *self = GST_RTP_ULPFEC_DEC (object);
 562
 563   switch (prop_id) {
 564     case PROP_PT:
 565       self->fec_pt = g_value_get_uint (value);
 566       break;
 567     case PROP_STORAGE:
 568       if (self->storage)
 569         g_object_unref (self->storage);
 570       self->storage = g_value_get_object (value);
 571       if (self->storage)
 572         g_object_ref (self->storage);
 573       break;
 574     default:
 575       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 576       break;
 577   }
 578 }
 579
 580 static void
 581 gst_rtp_ulpfec_dec_get_property (GObject * object, guint prop_id,
 582     GValue * value, GParamSpec * pspec)
 583 {
 584   GstRtpUlpFecDec *self = GST_RTP_ULPFEC_DEC (object);
 585
 586   switch (prop_id) {
 587     case PROP_PT:
 588       g_value_set_uint (value, self->fec_pt);
 589       break;
 590     case PROP_STORAGE:
 591       g_value_set_object (value, self->storage);
 592       break;
 593     case PROP_RECOVERED:
 594       g_value_set_uint (value, (guint) self->packets_recovered);
 595       break;
 596     case PROP_UNRECOVERED:
 597       g_value_set_uint (value, (guint) self->packets_unrecovered);
 598       break;
 599     default:
 600       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 601       break;
 602   }
 603 }
 604
 605 static void
 606 gst_rtp_ulpfec_dec_class_init (GstRtpUlpFecDecClass * klass)
 607 {
 608   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 609   GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
 610
 611   GST_DEBUG_CATEGORY_INIT (gst_rtp_ulpfec_dec_debug,
 612       "rtpulpfecdec", 0, "RTP FEC Decoder");
 613
 614   gst_element_class_add_pad_template (element_class,
 615       gst_static_pad_template_get (&srctemplate));
 616   gst_element_class_add_pad_template (element_class,
 617       gst_static_pad_template_get (&sinktemplate));
 618
 619   gst_element_class_set_static_metadata (element_class,
 620       "RTP FEC Decoder",
 621       "Codec/Depayloader/Network/RTP",
 622       "Decodes RTP FEC (RFC5109)", "Mikhail Fludkov <misha@pexip.com>");
 623
 624   gobject_class->set_property =
 625       GST_DEBUG_FUNCPTR (gst_rtp_ulpfec_dec_set_property);
 626   gobject_class->get_property =
 627       GST_DEBUG_FUNCPTR (gst_rtp_ulpfec_dec_get_property);
 628   gobject_class->dispose = GST_DEBUG_FUNCPTR (gst_rtp_ulpfec_dec_dispose);
 629
 630   klass_properties[PROP_PT] = g_param_spec_uint ("pt", "pt",
 631       "FEC packets payload type", 0, 127,
 632       DEFAULT_FEC_PT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
 633   klass_properties[PROP_STORAGE] =
 634       g_param_spec_object ("storage", "RTP storage", "RTP storage",
 635       G_TYPE_OBJECT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
 636   klass_properties[PROP_RECOVERED] =
 637       g_param_spec_uint ("recovered", "recovered",
 638       "The number of recovered packets", 0, G_MAXUINT, 0,
 639       G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
 640   klass_properties[PROP_UNRECOVERED] =
 641       g_param_spec_uint ("unrecovered", "unrecovered",
 642       "The number of unrecovered packets", 0, G_MAXUINT, 0,
 643       G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
 644
 645   g_object_class_install_properties (gobject_class, N_PROPERTIES,
 646       klass_properties);
 647
 648   g_assert (rtp_ulpfec_ctz64 (G_GUINT64_CONSTANT (0x1)) == 0);
 649   g_assert (rtp_ulpfec_ctz64 (G_GUINT64_CONSTANT (0x8000000000000000)) == 63);
 650 }