gst/rtp/gstrtph265depay.c

   1 /* GStreamer
   2  * Copyright (C) <2006> Wim Taymans <wim.taymans@gmail.com>
   3  * Copyright (C) <2014> Jurgen Slowack <jurgenslowack@gmail.com>
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Library General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Library General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Library General Public
  16  * License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  18  * Boston, MA 02110-1301, USA.
  19  */
  20
  21 #ifdef HAVE_CONFIG_H
  22 #  include "config.h"
  23 #endif
  24
  25 #include <stdio.h>
  26 #include <string.h>
  27
  28 #include <gst/base/gstbitreader.h>
  29 #include <gst/rtp/gstrtpbuffer.h>
  30 #include <gst/video/video.h>
  31 #include "gstrtph265depay.h"
  32 #include "gstrtputils.h"
  33
  34 GST_DEBUG_CATEGORY_STATIC (rtph265depay_debug);
  35 #define GST_CAT_DEFAULT (rtph265depay_debug)
  36
  37 /* This is what we'll default to when downstream hasn't
  38  * expressed a restriction or preference via caps */
  39 #define DEFAULT_BYTE_STREAM   TRUE
  40 #define DEFAULT_ACCESS_UNIT   FALSE
  41
  42 /* 3 zero bytes syncword */
  43 static const guint8 sync_bytes[] = { 0, 0, 0, 1 };
  44
  45 static GstStaticPadTemplate gst_rtp_h265_depay_src_template =
  46     GST_STATIC_PAD_TEMPLATE ("src",
  47     GST_PAD_SRC,
  48     GST_PAD_ALWAYS,
  49     GST_STATIC_CAPS (
  50         /* FIXME - hvc1 and hev1 formats are not supported yet */
  51         /*"video/x-h265, "
  52            "stream-format = (string) hvc1, alignment = (string) au; "
  53            "video/x-h265, "
  54            "stream-format = (string) hev1, alignment = (string) au; " */
  55         "video/x-h265, "
  56         "stream-format = (string) byte-stream, alignment = (string) { nal, au }")
  57     );
  58
  59 static GstStaticPadTemplate gst_rtp_h265_depay_sink_template =
  60 GST_STATIC_PAD_TEMPLATE ("sink",
  61     GST_PAD_SINK,
  62     GST_PAD_ALWAYS,
  63     GST_STATIC_CAPS ("application/x-rtp, "
  64         "media = (string) \"video\", "
  65         "clock-rate = (int) 90000, " "encoding-name = (string) \"H265\"")
  66         /** optional parameters **/
  67     /* "profile-space = (int) [ 0, 3 ], " */
  68     /* "profile-id = (int) [ 0, 31 ], " */
  69     /* "tier-flag = (int) [ 0, 1 ], " */
  70     /* "level-id = (int) [ 0, 255 ], " */
  71     /* "interop-constraints = (string) ANY, " */
  72     /* "profile-compatibility-indicator = (string) ANY, " */
  73     /* "sprop-sub-layer-id = (int) [ 0, 6 ], " */
  74     /* "recv-sub-layer-id = (int) [ 0, 6 ], " */
  75     /* "max-recv-level-id = (int) [ 0, 255 ], " */
  76     /* "tx-mode = (string) {MST , SST}, " */
  77     /* "sprop-vps = (string) ANY, " */
  78     /* "sprop-sps = (string) ANY, " */
  79     /* "sprop-pps = (string) ANY, " */
  80     /* "sprop-sei = (string) ANY, " */
  81     /* "max-lsr = (int) ANY, " *//* MUST be in the range of MaxLumaSR to 16 * MaxLumaSR, inclusive */
  82     /* "max-lps = (int) ANY, " *//* MUST be in the range of MaxLumaPS to 16 * MaxLumaPS, inclusive */
  83     /* "max-cpb = (int) ANY, " *//* MUST be in the range of MaxCPB to 16 * MaxCPB, inclusive */
  84     /* "max-dpb = (int) [1, 16], " */
  85     /* "max-br = (int) ANY, " *//* MUST be in the range of MaxBR to 16 * MaxBR, inclusive, for the highest level */
  86     /* "max-tr = (int) ANY, " *//* MUST be in the range of MaxTileRows to 16 * MaxTileRows, inclusive, for the highest level */
  87     /* "max-tc = (int) ANY, " *//* MUST be in the range of MaxTileCols to 16 * MaxTileCols, inclusive, for the highest level */
  88     /* "max-fps = (int) ANY, " */
  89     /* "sprop-max-don-diff = (int) [0, 32767], " */
  90     /* "sprop-depack-buf-nalus = (int) [0, 32767], " */
  91     /* "sprop-depack-buf-nalus = (int) [0, 4294967295], " */
  92     /* "depack-buf-cap = (int) [1, 4294967295], " */
  93     /* "sprop-segmentation-id = (int) [0, 3], " */
  94     /* "sprop-spatial-segmentation-idc = (string) ANY, " */
  95     /* "dec-parallel-cap = (string) ANY, " */
  96     );
  97
  98 #define gst_rtp_h265_depay_parent_class parent_class
  99 G_DEFINE_TYPE (GstRtpH265Depay, gst_rtp_h265_depay,
 100     GST_TYPE_RTP_BASE_DEPAYLOAD);
 101
 102 static void gst_rtp_h265_depay_finalize (GObject * object);
 103
 104 static GstStateChangeReturn gst_rtp_h265_depay_change_state (GstElement *
 105     element, GstStateChange transition);
 106
 107 static GstBuffer *gst_rtp_h265_depay_process (GstRTPBaseDepayload * depayload,
 108     GstRTPBuffer * rtp);
 109 static gboolean gst_rtp_h265_depay_setcaps (GstRTPBaseDepayload * filter,
 110     GstCaps * caps);
 111 static gboolean gst_rtp_h265_depay_handle_event (GstRTPBaseDepayload * depay,
 112     GstEvent * event);
 113
 114 static void
 115 gst_rtp_h265_depay_class_init (GstRtpH265DepayClass * klass)
 116 {
 117   GObjectClass *gobject_class;
 118   GstElementClass *gstelement_class;
 119   GstRTPBaseDepayloadClass *gstrtpbasedepayload_class;
 120
 121   gobject_class = (GObjectClass *) klass;
 122   gstelement_class = (GstElementClass *) klass;
 123   gstrtpbasedepayload_class = (GstRTPBaseDepayloadClass *) klass;
 124
 125   gobject_class->finalize = gst_rtp_h265_depay_finalize;
 126
 127   gst_element_class_add_static_pad_template (gstelement_class,
 128       &gst_rtp_h265_depay_src_template);
 129   gst_element_class_add_static_pad_template (gstelement_class,
 130       &gst_rtp_h265_depay_sink_template);
 131
 132   gst_element_class_set_static_metadata (gstelement_class,
 133       "RTP H265 depayloader", "Codec/Depayloader/Network/RTP",
 134       "Extracts H265 video from RTP packets (draft-ietf-payload-rtp-h265-03.txt)",
 135       "Jurgen Slowack <jurgenslowack@gmail.com>");
 136   gstelement_class->change_state = gst_rtp_h265_depay_change_state;
 137
 138   gstrtpbasedepayload_class->process_rtp_packet = gst_rtp_h265_depay_process;
 139   gstrtpbasedepayload_class->set_caps = gst_rtp_h265_depay_setcaps;
 140   gstrtpbasedepayload_class->handle_event = gst_rtp_h265_depay_handle_event;
 141 }
 142
 143 static void
 144 gst_rtp_h265_depay_init (GstRtpH265Depay * rtph265depay)
 145 {
 146   rtph265depay->adapter = gst_adapter_new ();
 147   rtph265depay->picture_adapter = gst_adapter_new ();
 148   rtph265depay->byte_stream = DEFAULT_BYTE_STREAM;
 149   rtph265depay->stream_format = NULL;
 150   rtph265depay->merge = DEFAULT_ACCESS_UNIT;
 151   rtph265depay->vps = g_ptr_array_new_with_free_func (
 152       (GDestroyNotify) gst_buffer_unref);
 153   rtph265depay->sps = g_ptr_array_new_with_free_func (
 154       (GDestroyNotify) gst_buffer_unref);
 155   rtph265depay->pps = g_ptr_array_new_with_free_func (
 156       (GDestroyNotify) gst_buffer_unref);
 157 }
 158
 159 static void
 160 gst_rtp_h265_depay_reset (GstRtpH265Depay * rtph265depay)
 161 {
 162   gst_adapter_clear (rtph265depay->adapter);
 163   rtph265depay->wait_start = TRUE;
 164   gst_adapter_clear (rtph265depay->picture_adapter);
 165   rtph265depay->picture_start = FALSE;
 166   rtph265depay->last_keyframe = FALSE;
 167   rtph265depay->last_ts = 0;
 168   rtph265depay->current_fu_type = 0;
 169   rtph265depay->new_codec_data = FALSE;
 170   g_ptr_array_set_size (rtph265depay->vps, 0);
 171   g_ptr_array_set_size (rtph265depay->sps, 0);
 172   g_ptr_array_set_size (rtph265depay->pps, 0);
 173 }
 174
 175 static void
 176 gst_rtp_h265_depay_finalize (GObject * object)
 177 {
 178   GstRtpH265Depay *rtph265depay;
 179
 180   rtph265depay = GST_RTP_H265_DEPAY (object);
 181
 182   if (rtph265depay->codec_data)
 183     gst_buffer_unref (rtph265depay->codec_data);
 184
 185   g_free (rtph265depay->stream_format);
 186
 187   g_object_unref (rtph265depay->adapter);
 188   g_object_unref (rtph265depay->picture_adapter);
 189
 190   g_ptr_array_free (rtph265depay->vps, TRUE);
 191   g_ptr_array_free (rtph265depay->sps, TRUE);
 192   g_ptr_array_free (rtph265depay->pps, TRUE);
 193
 194   G_OBJECT_CLASS (parent_class)->finalize (object);
 195 }
 196
 197 static void
 198 gst_rtp_h265_depay_negotiate (GstRtpH265Depay * rtph265depay)
 199 {
 200   GstCaps *caps;
 201   gint byte_stream = -1;
 202   gint merge = -1;
 203
 204   caps =
 205       gst_pad_get_allowed_caps (GST_RTP_BASE_DEPAYLOAD_SRCPAD (rtph265depay));
 206
 207   GST_DEBUG_OBJECT (rtph265depay, "allowed caps: %" GST_PTR_FORMAT, caps);
 208
 209   if (caps) {
 210     if (gst_caps_get_size (caps) > 0) {
 211       GstStructure *s = gst_caps_get_structure (caps, 0);
 212       const gchar *str = NULL;
 213
 214       if ((str = gst_structure_get_string (s, "stream-format"))) {
 215         g_free (rtph265depay->stream_format);
 216         rtph265depay->stream_format = g_strdup (str);
 217
 218         if (strcmp (str, "hev1") == 0) {
 219           byte_stream = FALSE;
 220         } else if (strcmp (str, "hvc1") == 0) {
 221           byte_stream = FALSE;
 222         } else if (strcmp (str, "byte-stream") == 0) {
 223           byte_stream = TRUE;
 224         } else {
 225           GST_DEBUG_OBJECT (rtph265depay, "unknown stream-format: %s", str);
 226         }
 227       }
 228
 229       if ((str = gst_structure_get_string (s, "alignment"))) {
 230         if (strcmp (str, "au") == 0) {
 231           merge = TRUE;
 232         } else if (strcmp (str, "nal") == 0) {
 233           merge = FALSE;
 234         } else {
 235           GST_DEBUG_OBJECT (rtph265depay, "unknown alignment: %s", str);
 236         }
 237       }
 238     }
 239     gst_caps_unref (caps);
 240   }
 241
 242   if (byte_stream != -1) {
 243     GST_DEBUG_OBJECT (rtph265depay, "downstream requires byte-stream %d",
 244         byte_stream);
 245     rtph265depay->byte_stream = byte_stream;
 246   } else {
 247     GST_DEBUG_OBJECT (rtph265depay, "defaulting to byte-stream %d",
 248         DEFAULT_BYTE_STREAM);
 249     g_free (rtph265depay->stream_format);
 250     rtph265depay->stream_format = g_strdup ("byte-stream");
 251     rtph265depay->byte_stream = DEFAULT_BYTE_STREAM;
 252   }
 253   if (merge != -1) {
 254     GST_DEBUG_OBJECT (rtph265depay, "downstream requires merge %d", merge);
 255     rtph265depay->merge = merge;
 256   } else {
 257     GST_DEBUG_OBJECT (rtph265depay, "defaulting to merge %d",
 258         DEFAULT_ACCESS_UNIT);
 259     rtph265depay->merge = DEFAULT_ACCESS_UNIT;
 260   }
 261 }
 262
 263 static gboolean
 264 parse_sps (GstMapInfo * map, guint32 * sps_id)
 265 {                               /* To parse seq_parameter_set_id */
 266   GstBitReader br = GST_BIT_READER_INIT (map->data + 15,
 267       map->size - 15);
 268
 269   if (map->size < 16)
 270     return FALSE;
 271
 272   if (!gst_rtp_read_golomb (&br, sps_id))
 273     return FALSE;
 274
 275   return TRUE;
 276 }
 277
 278 static gboolean
 279 parse_pps (GstMapInfo * map, guint32 * sps_id, guint32 * pps_id)
 280 {                               /* To parse picture_parameter_set_id */
 281   GstBitReader br = GST_BIT_READER_INIT (map->data + 2,
 282       map->size - 2);
 283
 284   if (map->size < 3)
 285     return FALSE;
 286
 287   if (!gst_rtp_read_golomb (&br, pps_id))
 288     return FALSE;
 289   if (!gst_rtp_read_golomb (&br, sps_id))
 290     return FALSE;
 291
 292   return TRUE;
 293 }
 294
 295
 296 static gboolean
 297 gst_rtp_h265_set_src_caps (GstRtpH265Depay * rtph265depay)
 298 {
 299   gboolean res;
 300   GstCaps *old_caps;
 301   GstCaps *srccaps;
 302
 303   if (!rtph265depay->byte_stream &&
 304       (!rtph265depay->new_codec_data ||
 305           rtph265depay->vps->len == 0 || rtph265depay->sps->len == 0
 306           || rtph265depay->pps->len == 0))
 307     return TRUE;
 308
 309   srccaps = gst_caps_new_simple ("video/x-h265",
 310       "stream-format", G_TYPE_STRING, rtph265depay->stream_format,
 311       "alignment", G_TYPE_STRING, rtph265depay->merge ? "au" : "nal", NULL);
 312
 313   if (!rtph265depay->byte_stream) {
 314     GstBuffer *codec_data;
 315     gint i = 0;
 316     gint len;
 317     guint num_vps = rtph265depay->vps->len;
 318     guint num_sps = rtph265depay->sps->len;
 319     guint num_pps = rtph265depay->pps->len;
 320     GstMapInfo map, nalmap;
 321     guint8 *data;
 322     gint nl;
 323     guint8 num_arrays = 0;
 324     guint new_size;
 325     GstBitReader br;
 326     guint32 tmp;
 327     guint8 tmp8 = 0;
 328     guint32 max_sub_layers_minus1, temporal_id_nesting_flag, chroma_format_idc,
 329         bit_depth_luma_minus8, bit_depth_chroma_minus8,
 330         min_spatial_segmentation_idc;
 331
 332     /* Fixme: Current implementation is not embedding SEI in codec_data */
 333
 334     if (num_sps == 0)
 335       return FALSE;
 336
 337     /* start with 23 bytes header */
 338     len = 23;
 339
 340     num_arrays = (num_vps > 0) + (num_sps > 0) + (num_pps > 0);
 341     len += num_arrays;
 342
 343     /* add size of vps, sps & pps */
 344     for (i = 0; i < num_vps; i++)
 345       len += 2 + gst_buffer_get_size (g_ptr_array_index (rtph265depay->vps, i));
 346     for (i = 0; i < num_sps; i++)
 347       len += 2 + gst_buffer_get_size (g_ptr_array_index (rtph265depay->sps, i));
 348     for (i = 0; i < num_pps; i++)
 349       len += 2 + gst_buffer_get_size (g_ptr_array_index (rtph265depay->pps, i));
 350
 351     GST_DEBUG_OBJECT (rtph265depay,
 352         "constructing codec_data: num_vps =%d num_sps=%d, num_pps=%d", num_vps,
 353         num_sps, num_pps);
 354
 355     codec_data = gst_buffer_new_and_alloc (len);
 356     g_debug ("alloc_len: %u", len);
 357     gst_buffer_map (codec_data, &map, GST_MAP_READWRITE);
 358     data = map.data;
 359
 360     memset (data, 0, map.size);
 361
 362     /* Parsing sps to get the info required further on */
 363
 364     gst_buffer_map (g_ptr_array_index (rtph265depay->sps, 0), &nalmap,
 365         GST_MAP_READ);
 366
 367     max_sub_layers_minus1 = ((nalmap.data[2]) >> 1) & 0x07;
 368     temporal_id_nesting_flag = nalmap.data[2] & 0x01;
 369
 370     gst_bit_reader_init (&br, nalmap.data + 15, nalmap.size - 15);
 371
 372     gst_rtp_read_golomb (&br, &tmp);    /* sps_seq_parameter_set_id */
 373     gst_rtp_read_golomb (&br, &chroma_format_idc);      /* chroma_format_idc */
 374
 375     if (chroma_format_idc == 3)
 376
 377       gst_bit_reader_get_bits_uint8 (&br, &tmp8, 1);    /* separate_colour_plane_flag */
 378
 379     gst_rtp_read_golomb (&br, &tmp);    /* pic_width_in_luma_samples */
 380     gst_rtp_read_golomb (&br, &tmp);    /* pic_height_in_luma_samples */
 381
 382     gst_bit_reader_get_bits_uint8 (&br, &tmp8, 1);      /* conformance_window_flag */
 383     if (tmp8) {
 384       gst_rtp_read_golomb (&br, &tmp);  /* conf_win_left_offset */
 385       gst_rtp_read_golomb (&br, &tmp);  /* conf_win_right_offset */
 386       gst_rtp_read_golomb (&br, &tmp);  /* conf_win_top_offset */
 387       gst_rtp_read_golomb (&br, &tmp);  /* conf_win_bottom_offset */
 388     }
 389
 390     gst_rtp_read_golomb (&br, &bit_depth_luma_minus8);  /* bit_depth_luma_minus8 */
 391     gst_rtp_read_golomb (&br, &bit_depth_chroma_minus8);        /* bit_depth_chroma_minus8 */
 392
 393     GST_DEBUG_OBJECT (rtph265depay,
 394         "Ignoring min_spatial_segmentation for now (assuming zero)");
 395
 396     min_spatial_segmentation_idc = 0;   /* NOTE - we ignore this for now, but in a perfect world, we should continue parsing to obtain the real value */
 397
 398     nl = nalmap.size;
 399
 400     gst_buffer_unmap (g_ptr_array_index (rtph265depay->sps, 0), &nalmap);
 401
 402     /* HEVCDecoderConfigurationVersion = 1 */
 403     data[0] = 1;
 404
 405     /* Copy from profile_tier_level (Rec. ITU-T H.265 (04/2013) section 7.3.3
 406      *
 407      * profile_space | tier_flat | profile_idc |
 408      * profile_compatibility_flags | constraint_indicator_flags |
 409      * level_idc | progressive_source_flag | interlaced_source_flag
 410      * non_packed_constraint_flag | frame_only_constraint_flag
 411      * reserved_zero_44bits | level_idc */
 412     gst_buffer_map (g_ptr_array_index (rtph265depay->sps, 0), &nalmap,
 413         GST_MAP_READ);
 414     for (i = 0; i < 12; i++)
 415       data[i + 1] = nalmap.data[i];
 416     gst_buffer_unmap (g_ptr_array_index (rtph265depay->sps, 0), &nalmap);
 417
 418     /* min_spatial_segmentation_idc */
 419     GST_WRITE_UINT16_BE (data + 13, min_spatial_segmentation_idc);
 420     data[13] |= 0xf0;
 421     data[15] = 0xfc;            /* keeping parrallelismType as zero (unknown) */
 422     data[16] = 0xfc | chroma_format_idc;
 423     data[17] = 0xf8 | bit_depth_luma_minus8;
 424     data[18] = 0xf8 | bit_depth_chroma_minus8;
 425     data[19] = 0x00;            /* keep avgFrameRate as unspecified */
 426     data[20] = 0x00;            /* keep avgFrameRate as unspecified */
 427     /* constFrameRate(2 bits): 0, stream may or may not be of constant framerate
 428      * numTemporalLayers (3 bits): number of temporal layers, value from SPS
 429      * TemporalIdNested (1 bit): sps_temporal_id_nesting_flag from SPS
 430      * lengthSizeMinusOne (2 bits): plus 1 indicates the length of the NALUnitLength */
 431     data[21] =
 432         0x00 | ((max_sub_layers_minus1 +
 433             1) << 3) | (temporal_id_nesting_flag << 2) | (nl - 1);
 434     GST_WRITE_UINT8 (data + 22, num_arrays);    /* numOfArrays */
 435
 436     data += 23;
 437
 438     /* copy all VPS */
 439     if (num_vps > 0) {
 440       /* array_completeness | reserved_zero bit | nal_unit_type */
 441       data[0] = 0x00 | 0x20;
 442       data++;
 443
 444       GST_WRITE_UINT16_BE (data, num_vps);
 445       data += 2;
 446
 447       for (i = 0; i < num_vps; i++) {
 448         gsize nal_size =
 449             gst_buffer_get_size (g_ptr_array_index (rtph265depay->vps, i));
 450         GST_WRITE_UINT16_BE (data, nal_size);
 451         gst_buffer_extract (g_ptr_array_index (rtph265depay->vps, i), 0,
 452             data + 2, nal_size);
 453         data += 2 + nal_size;
 454         GST_DEBUG_OBJECT (rtph265depay, "Copied VPS %d of length %u", i,
 455             (guint) nal_size);
 456       }
 457     }
 458
 459     /* copy all SPS */
 460     if (num_sps > 0) {
 461       /* array_completeness | reserved_zero bit | nal_unit_type */
 462       data[0] = 0x00 | 0x21;
 463       data++;
 464
 465       GST_WRITE_UINT16_BE (data, num_sps);
 466       data += 2;
 467
 468       for (i = 0; i < num_sps; i++) {
 469         gsize nal_size =
 470             gst_buffer_get_size (g_ptr_array_index (rtph265depay->sps, i));
 471         GST_WRITE_UINT16_BE (data, nal_size);
 472         gst_buffer_extract (g_ptr_array_index (rtph265depay->sps, i), 0,
 473             data + 2, nal_size);
 474         data += 2 + nal_size;
 475         GST_DEBUG_OBJECT (rtph265depay, "Copied SPS %d of length %u", i,
 476             (guint) nal_size);
 477       }
 478     }
 479
 480     /* copy all PPS */
 481     if (num_pps > 0) {
 482       /* array_completeness | reserved_zero bit | nal_unit_type */
 483       data[0] = 0x00 | 0x22;
 484       data++;
 485
 486       GST_WRITE_UINT16_BE (data, num_pps);
 487       data += 2;
 488
 489       for (i = 0; i < num_pps; i++) {
 490         gsize nal_size =
 491             gst_buffer_get_size (g_ptr_array_index (rtph265depay->pps, i));
 492         GST_WRITE_UINT16_BE (data, nal_size);
 493         gst_buffer_extract (g_ptr_array_index (rtph265depay->pps, i), 0,
 494             data + 2, nal_size);
 495         data += 2 + nal_size;
 496         GST_DEBUG_OBJECT (rtph265depay, "Copied PPS %d of length %u", i,
 497             (guint) nal_size);
 498       }
 499     }
 500
 501     new_size = data - map.data;
 502     gst_buffer_unmap (codec_data, &map);
 503     gst_buffer_set_size (codec_data, new_size);
 504
 505     gst_caps_set_simple (srccaps,
 506         "codec_data", GST_TYPE_BUFFER, codec_data, NULL);
 507     gst_buffer_unref (codec_data);
 508   }
 509
 510   old_caps =
 511       gst_pad_get_current_caps (GST_RTP_BASE_DEPAYLOAD_SRCPAD (rtph265depay));
 512   if (old_caps != NULL) {
 513
 514     /* Only update the caps if they are not equal. For
 515      * AVC we don't update caps if only the codec_data
 516      * changes. This is the same behaviour as in h264parse
 517      * and gstrtph264depay
 518      */
 519     if (rtph265depay->byte_stream) {
 520       if (!gst_caps_is_equal (srccaps, old_caps))
 521         res =
 522             gst_pad_set_caps (GST_RTP_BASE_DEPAYLOAD_SRCPAD (rtph265depay),
 523             srccaps);
 524       else
 525         res = TRUE;
 526     } else {
 527       GstCaps *tmp_caps = gst_caps_copy (srccaps);
 528       GstStructure *old_s, *tmp_s;
 529
 530       old_s = gst_caps_get_structure (old_caps, 0);
 531       tmp_s = gst_caps_get_structure (tmp_caps, 0);
 532       if (gst_structure_has_field (old_s, "codec_data"))
 533         gst_structure_set_value (tmp_s, "codec_data",
 534             gst_structure_get_value (old_s, "codec_data"));
 535
 536       if (!gst_caps_is_equal (old_caps, tmp_caps))
 537         res =
 538             gst_pad_set_caps (GST_RTP_BASE_DEPAYLOAD_SRCPAD (rtph265depay),
 539             srccaps);
 540       else
 541         res = TRUE;
 542
 543       gst_caps_unref (tmp_caps);
 544     }
 545   } else {
 546     res =
 547         gst_pad_set_caps (GST_RTP_BASE_DEPAYLOAD_SRCPAD (rtph265depay),
 548         srccaps);
 549   }
 550
 551   gst_caps_unref (srccaps);
 552
 553   /* Insert SPS and PPS into the stream on next opportunity */
 554   if (rtph265depay->sps->len > 0 || rtph265depay->pps->len > 0) {
 555     gint i;
 556     GstBuffer *codec_data;
 557     GstMapInfo map;
 558     guint8 *data;
 559     guint len = 0;
 560
 561     for (i = 0; i < rtph265depay->sps->len; i++) {
 562       len += 4 + gst_buffer_get_size (g_ptr_array_index (rtph265depay->sps, i));
 563     }
 564
 565     for (i = 0; i < rtph265depay->pps->len; i++) {
 566       len += 4 + gst_buffer_get_size (g_ptr_array_index (rtph265depay->pps, i));
 567     }
 568
 569     codec_data = gst_buffer_new_and_alloc (len);
 570     gst_buffer_map (codec_data, &map, GST_MAP_WRITE);
 571     data = map.data;
 572
 573     for (i = 0; i < rtph265depay->sps->len; i++) {
 574       GstBuffer *sps_buf = g_ptr_array_index (rtph265depay->sps, i);
 575       guint sps_size = gst_buffer_get_size (sps_buf);
 576
 577       if (rtph265depay->byte_stream)
 578         memcpy (data, sync_bytes, sizeof (sync_bytes));
 579       else
 580         GST_WRITE_UINT32_BE (data, sps_size);
 581       gst_buffer_extract (sps_buf, 0, data + 4, -1);
 582       data += 4 + sps_size;
 583     }
 584
 585     for (i = 0; i < rtph265depay->pps->len; i++) {
 586       GstBuffer *pps_buf = g_ptr_array_index (rtph265depay->pps, i);
 587       guint pps_size = gst_buffer_get_size (pps_buf);
 588
 589       if (rtph265depay->byte_stream)
 590         memcpy (data, sync_bytes, sizeof (sync_bytes));
 591       else
 592         GST_WRITE_UINT32_BE (data, pps_size);
 593       gst_buffer_extract (pps_buf, 0, data + 4, -1);
 594       data += 4 + pps_size;
 595     }
 596
 597     gst_buffer_unmap (codec_data, &map);
 598     if (rtph265depay->codec_data)
 599       gst_buffer_unref (rtph265depay->codec_data);
 600     rtph265depay->codec_data = codec_data;
 601   }
 602
 603   if (res)
 604     rtph265depay->new_codec_data = FALSE;
 605
 606   return res;
 607 }
 608
 609 gboolean
 610 gst_rtp_h265_add_vps_sps_pps (GstElement * rtph265, GPtrArray * vps_array,
 611     GPtrArray * sps_array, GPtrArray * pps_array, GstBuffer * nal)
 612 {
 613   GstMapInfo map;
 614   guchar type;
 615   guint i;
 616
 617   gst_buffer_map (nal, &map, GST_MAP_READ);
 618
 619   type = (map.data[0] >> 1) & 0x3f;
 620
 621   if (type == GST_H265_VPS_NUT) {
 622     guint32 vps_id = (map.data[2] >> 4) & 0x0f;
 623
 624     for (i = 0; i < vps_array->len; i++) {
 625       GstBuffer *vps = g_ptr_array_index (vps_array, i);
 626       GstMapInfo vpsmap;
 627       guint32 tmp_vps_id;
 628
 629       gst_buffer_map (vps, &vpsmap, GST_MAP_READ);
 630       tmp_vps_id = (vpsmap.data[2] >> 4) & 0x0f;
 631
 632       if (vps_id == tmp_vps_id) {
 633         if (map.size == vpsmap.size &&
 634             memcmp (map.data, vpsmap.data, vpsmap.size) == 0) {
 635           GST_LOG_OBJECT (rtph265, "Unchanged VPS %u, not updating", vps_id);
 636           gst_buffer_unmap (vps, &vpsmap);
 637           goto drop;
 638         } else {
 639           gst_buffer_unmap (vps, &vpsmap);
 640           g_ptr_array_remove_index_fast (vps_array, i);
 641           g_ptr_array_add (vps_array, nal);
 642           GST_LOG_OBJECT (rtph265, "Modified VPS %u, replacing", vps_id);
 643           goto done;
 644         }
 645       }
 646       gst_buffer_unmap (vps, &vpsmap);
 647     }
 648     GST_LOG_OBJECT (rtph265, "Adding new VPS %u", vps_id);
 649     g_ptr_array_add (vps_array, nal);
 650   } else if (type == GST_H265_SPS_NUT) {
 651     guint32 sps_id;
 652
 653     if (!parse_sps (&map, &sps_id)) {
 654       GST_WARNING_OBJECT (rtph265, "Invalid SPS,"
 655           " can't parse seq_parameter_set_id");
 656       goto drop;
 657     }
 658
 659     for (i = 0; i < sps_array->len; i++) {
 660       GstBuffer *sps = g_ptr_array_index (sps_array, i);
 661       GstMapInfo spsmap;
 662       guint32 tmp_sps_id;
 663
 664       gst_buffer_map (sps, &spsmap, GST_MAP_READ);
 665       parse_sps (&spsmap, &tmp_sps_id);
 666
 667       if (sps_id == tmp_sps_id) {
 668         if (map.size == spsmap.size &&
 669             memcmp (map.data, spsmap.data, spsmap.size) == 0) {
 670           GST_LOG_OBJECT (rtph265, "Unchanged SPS %u, not updating", sps_id);
 671           gst_buffer_unmap (sps, &spsmap);
 672           goto drop;
 673         } else {
 674           gst_buffer_unmap (sps, &spsmap);
 675           g_ptr_array_remove_index_fast (sps_array, i);
 676           g_ptr_array_add (sps_array, nal);
 677           GST_LOG_OBJECT (rtph265, "Modified SPS %u, replacing", sps_id);
 678           goto done;
 679         }
 680       }
 681       gst_buffer_unmap (sps, &spsmap);
 682     }
 683     GST_LOG_OBJECT (rtph265, "Adding new SPS %u", sps_id);
 684     g_ptr_array_add (sps_array, nal);
 685   } else if (type == GST_H265_PPS_NUT) {
 686     guint32 sps_id;
 687     guint32 pps_id;
 688
 689     if (!parse_pps (&map, &sps_id, &pps_id)) {
 690       GST_WARNING_OBJECT (rtph265, "Invalid PPS,"
 691           " can't parse seq_parameter_set_id or pic_parameter_set_id");
 692       goto drop;
 693     }
 694
 695     for (i = 0; i < pps_array->len; i++) {
 696       GstBuffer *pps = g_ptr_array_index (pps_array, i);
 697       GstMapInfo ppsmap;
 698       guint32 tmp_sps_id;
 699       guint32 tmp_pps_id;
 700
 701
 702       gst_buffer_map (pps, &ppsmap, GST_MAP_READ);
 703       parse_pps (&ppsmap, &tmp_sps_id, &tmp_pps_id);
 704
 705       if (pps_id == tmp_pps_id) {
 706         if (map.size == ppsmap.size &&
 707             memcmp (map.data, ppsmap.data, ppsmap.size) == 0) {
 708           GST_LOG_OBJECT (rtph265, "Unchanged PPS %u:%u, not updating", sps_id,
 709               pps_id);
 710           gst_buffer_unmap (pps, &ppsmap);
 711           goto drop;
 712         } else {
 713           gst_buffer_unmap (pps, &ppsmap);
 714           g_ptr_array_remove_index_fast (pps_array, i);
 715           g_ptr_array_add (pps_array, nal);
 716           GST_LOG_OBJECT (rtph265, "Modified PPS %u:%u, replacing",
 717               sps_id, pps_id);
 718           goto done;
 719         }
 720       }
 721       gst_buffer_unmap (pps, &ppsmap);
 722     }
 723     GST_LOG_OBJECT (rtph265, "Adding new PPS %u:%i", sps_id, pps_id);
 724     g_ptr_array_add (pps_array, nal);
 725   } else {
 726     goto drop;
 727   }
 728
 729 done:
 730   gst_buffer_unmap (nal, &map);
 731
 732   return TRUE;
 733
 734 drop:
 735   gst_buffer_unmap (nal, &map);
 736   gst_buffer_unref (nal);
 737
 738   return FALSE;
 739 }
 740
 741
 742 static void
 743 gst_rtp_h265_depay_add_vps_sps_pps (GstRtpH265Depay * rtph265depay,
 744     GstBuffer * nal)
 745 {
 746   if (gst_rtp_h265_add_vps_sps_pps (GST_ELEMENT (rtph265depay),
 747           rtph265depay->vps, rtph265depay->sps, rtph265depay->pps, nal))
 748     rtph265depay->new_codec_data = TRUE;
 749 }
 750
 751 static gboolean
 752 gst_rtp_h265_depay_setcaps (GstRTPBaseDepayload * depayload, GstCaps * caps)
 753 {
 754   gint clock_rate;
 755   GstStructure *structure = gst_caps_get_structure (caps, 0);
 756   GstRtpH265Depay *rtph265depay;
 757   const gchar *ps;
 758   GstBuffer *codec_data;
 759   GstMapInfo map;
 760   guint8 *ptr;
 761
 762   rtph265depay = GST_RTP_H265_DEPAY (depayload);
 763
 764   if (!gst_structure_get_int (structure, "clock-rate", &clock_rate))
 765     clock_rate = 90000;
 766   depayload->clock_rate = clock_rate;
 767
 768   /* Base64 encoded, comma separated config NALs */
 769   ps = gst_structure_get_string (structure, "sprop-parameter-sets");
 770
 771   /* negotiate with downstream w.r.t. output format and alignment */
 772   gst_rtp_h265_depay_negotiate (rtph265depay);
 773
 774   if (rtph265depay->byte_stream && ps != NULL) {
 775     /* for bytestream we only need the parameter sets but we don't error out
 776      * when they are not there, we assume they are in the stream. */
 777     gchar **params;
 778     guint len, total;
 779     gint i;
 780
 781     params = g_strsplit (ps, ",", 0);
 782
 783     /* count total number of bytes in base64. Also include the sync bytes in
 784      * front of the params. */
 785     len = 0;
 786     for (i = 0; params[i]; i++) {
 787       len += strlen (params[i]);
 788       len += sizeof (sync_bytes);
 789     }
 790     /* we seriously overshoot the length, but it's fine. */
 791     codec_data = gst_buffer_new_and_alloc (len);
 792
 793     gst_buffer_map (codec_data, &map, GST_MAP_WRITE);
 794     ptr = map.data;
 795     total = 0;
 796     for (i = 0; params[i]; i++) {
 797       guint save = 0;
 798       gint state = 0;
 799
 800       GST_DEBUG_OBJECT (depayload, "decoding param %d (%s)", i, params[i]);
 801       memcpy (ptr, sync_bytes, sizeof (sync_bytes));
 802       ptr += sizeof (sync_bytes);
 803       len =
 804           g_base64_decode_step (params[i], strlen (params[i]), ptr, &state,
 805           &save);
 806       GST_DEBUG_OBJECT (depayload, "decoded %d bytes", len);
 807       total += len + sizeof (sync_bytes);
 808       ptr += len;
 809     }
 810     gst_buffer_unmap (codec_data, &map);
 811     gst_buffer_resize (codec_data, 0, total);
 812     g_strfreev (params);
 813
 814     /* keep the codec_data, we need to send it as the first buffer. We cannot
 815      * push it in the adapter because the adapter might be flushed on discont.
 816      */
 817     if (rtph265depay->codec_data)
 818       gst_buffer_unref (rtph265depay->codec_data);
 819     rtph265depay->codec_data = codec_data;
 820   } else if (!rtph265depay->byte_stream) {
 821     gchar **params;
 822     gint i;
 823
 824     if (ps == NULL)
 825       goto incomplete_caps;
 826
 827     params = g_strsplit (ps, ",", 0);
 828
 829     GST_DEBUG_OBJECT (depayload, "we have %d params", g_strv_length (params));
 830
 831     /* start with 23 bytes header */
 832     for (i = 0; params[i]; i++) {
 833       GstBuffer *nal;
 834       GstMapInfo nalmap;
 835       gsize nal_len;
 836       guint save = 0;
 837       gint state = 0;
 838
 839       nal_len = strlen (params[i]);
 840       nal = gst_buffer_new_and_alloc (nal_len);
 841       gst_buffer_map (nal, &nalmap, GST_MAP_READWRITE);
 842
 843       nal_len =
 844           g_base64_decode_step (params[i], nal_len, nalmap.data, &state, &save);
 845
 846       GST_DEBUG_OBJECT (depayload, "adding param %d as %s", i,
 847           (((nalmap.data[0] >> 1) & 0x3f) ==
 848               32) ? "VPS" : (((nalmap.data[0] >> 1) & 0x3f) ==
 849               33) ? "SPS" : "PPS");
 850
 851       gst_buffer_unmap (nal, &nalmap);
 852       gst_buffer_set_size (nal, nal_len);
 853
 854       gst_rtp_h265_depay_add_vps_sps_pps (rtph265depay, nal);
 855     }
 856     g_strfreev (params);
 857
 858     if (rtph265depay->sps->len == 0 || rtph265depay->pps->len == 0)
 859       goto incomplete_caps;
 860   }
 861
 862   return gst_rtp_h265_set_src_caps (rtph265depay);
 863
 864   /* ERRORS */
 865 incomplete_caps:
 866   {
 867     GST_DEBUG_OBJECT (depayload, "we have incomplete caps,"
 868         " doing setcaps later");
 869     return TRUE;
 870   }
 871 }
 872
 873 static GstBuffer *
 874 gst_rtp_h265_complete_au (GstRtpH265Depay * rtph265depay,
 875     GstClockTime * out_timestamp, gboolean * out_keyframe)
 876 {
 877   guint outsize;
 878   GstBuffer *outbuf;
 879
 880   /* we had a picture in the adapter and we completed it */
 881   GST_DEBUG_OBJECT (rtph265depay, "taking completed AU");
 882   outsize = gst_adapter_available (rtph265depay->picture_adapter);
 883   outbuf = gst_adapter_take_buffer (rtph265depay->picture_adapter, outsize);
 884
 885   *out_timestamp = rtph265depay->last_ts;
 886   *out_keyframe = rtph265depay->last_keyframe;
 887
 888   rtph265depay->last_keyframe = FALSE;
 889   rtph265depay->picture_start = FALSE;
 890
 891   return outbuf;
 892 }
 893
 894 /* VPS/SPS/PPS/RADL/TSA/RASL/IDR/CRA is considered key, all others DELTA;
 895  * so downstream waiting for keyframe can pick up at VPS/SPS/PPS/IDR */
 896
 897 #define NAL_TYPE_IS_PARAMETER_SET(nt) (         ((nt) == GST_H265_VPS_NUT)\
 898                                                                                 ||  ((nt) == GST_H265_SPS_NUT)\
 899                                                                                 ||  ((nt) == GST_H265_PPS_NUT)                          )
 900
 901 #define NAL_TYPE_IS_CODED_SLICE_SEGMENT(nt) (           ((nt) == GST_H265_NAL_SLICE_TRAIL_N)\
 902                                                                                                 ||      ((nt) == GST_H265_NAL_SLICE_TRAIL_R)\
 903                                                                                                 ||  ((nt) == GST_H265_NAL_SLICE_TSA_N)\
 904                                                                                                 ||  ((nt) == GST_H265_NAL_SLICE_TSA_R)\
 905                                                                                                 ||  ((nt) == GST_H265_NAL_SLICE_STSA_N)\
 906                                                                                                 ||  ((nt) == GST_H265_NAL_SLICE_STSA_R)\
 907                                                                                                 ||  ((nt) == GST_H265_NAL_SLICE_RASL_N)\
 908                                                                                                 ||  ((nt) == GST_H265_NAL_SLICE_RASL_R)\
 909                                                                                                 ||  ((nt) == GST_H265_NAL_SLICE_BLA_W_LP)\
 910                                                                                                 ||  ((nt) == GST_H265_NAL_SLICE_BLA_W_RADL)\
 911                                                                                                 ||  ((nt) == GST_H265_NAL_SLICE_BLA_N_LP)\
 912                                                                                                 ||  ((nt) == GST_H265_NAL_SLICE_IDR_W_RADL)\
 913                                                                                                 ||  ((nt) == GST_H265_NAL_SLICE_IDR_N_LP)\
 914                                                                                                 ||  ((nt) == GST_H265_NAL_SLICE_CRA_NUT)                )
 915
 916 #define NAL_TYPE_IS_KEY(nt) (NAL_TYPE_IS_PARAMETER_SET(nt) || NAL_TYPE_IS_CODED_SLICE_SEGMENT(nt))
 917
 918 static GstBuffer *
 919 gst_rtp_h265_depay_handle_nal (GstRtpH265Depay * rtph265depay, GstBuffer * nal,
 920     GstClockTime in_timestamp, gboolean marker)
 921 {
 922   GstRTPBaseDepayload *depayload = GST_RTP_BASE_DEPAYLOAD (rtph265depay);
 923   gint nal_type;
 924   GstMapInfo map;
 925   GstBuffer *outbuf = NULL;
 926   GstClockTime out_timestamp;
 927   gboolean keyframe, out_keyframe;
 928
 929   gst_buffer_map (nal, &map, GST_MAP_READ);
 930   if (G_UNLIKELY (map.size < 5))
 931     goto short_nal;
 932
 933   nal_type = (map.data[4] >> 1) & 0x3f;
 934   GST_DEBUG_OBJECT (rtph265depay, "handle NAL type %d (RTP marker bit %d)",
 935       nal_type, marker);
 936
 937   keyframe = NAL_TYPE_IS_KEY (nal_type);
 938
 939   out_keyframe = keyframe;
 940   out_timestamp = in_timestamp;
 941
 942   if (!rtph265depay->byte_stream) {
 943     if (NAL_TYPE_IS_PARAMETER_SET (nal_type)) {
 944       gst_rtp_h265_depay_add_vps_sps_pps (rtph265depay,
 945           gst_buffer_copy_region (nal, GST_BUFFER_COPY_ALL,
 946               4, gst_buffer_get_size (nal) - 4));
 947       gst_buffer_unmap (nal, &map);
 948       gst_buffer_unref (nal);
 949       return NULL;
 950     } else if (rtph265depay->sps->len == 0 || rtph265depay->pps->len == 0) {
 951       /* Down push down any buffer in non-bytestream mode if the SPS/PPS haven't
 952        * go through yet
 953        */
 954       gst_pad_push_event (GST_RTP_BASE_DEPAYLOAD_SINKPAD (depayload),
 955           gst_event_new_custom (GST_EVENT_CUSTOM_UPSTREAM,
 956               gst_structure_new ("GstForceKeyUnit",
 957                   "all-headers", G_TYPE_BOOLEAN, TRUE, NULL)));
 958       gst_buffer_unmap (nal, &map);
 959       gst_buffer_unref (nal);
 960       return NULL;
 961     }
 962
 963     if (rtph265depay->new_codec_data &&
 964         rtph265depay->sps->len > 0 && rtph265depay->pps->len > 0)
 965       gst_rtp_h265_set_src_caps (rtph265depay);
 966   }
 967
 968   if (rtph265depay->merge) {
 969     gboolean start = FALSE, complete = FALSE;
 970
 971     /* marker bit isn't mandatory so in the following code we try to detect
 972      * an AU boundary (see H.265 spec section 7.4.2.4.4) */
 973     if (!marker) {
 974       if (NAL_TYPE_IS_CODED_SLICE_SEGMENT (nal_type)) {
 975         /* A NAL unit (X) ends an access unit if the next-occurring VCL NAL unit (Y) has the high-order bit of the first byte after its NAL unit header equal to 1 */
 976         start = TRUE;
 977         if (((map.data[6] >> 7) & 0x01) == 1) {
 978           complete = TRUE;
 979         }
 980       } else if ((nal_type >= 32 && nal_type <= 35)
 981           || nal_type == 39 || (nal_type >= 41 && nal_type <= 44)
 982           || (nal_type >= 48 && nal_type <= 55)) {
 983         /* VPS, SPS, PPS, SEI, ... terminate an access unit */
 984         complete = TRUE;
 985       }
 986       GST_DEBUG_OBJECT (depayload, "start %d, complete %d", start, complete);
 987
 988       if (complete && rtph265depay->picture_start)
 989         outbuf = gst_rtp_h265_complete_au (rtph265depay, &out_timestamp,
 990             &out_keyframe);
 991     }
 992     /* add to adapter */
 993     gst_buffer_unmap (nal, &map);
 994
 995     GST_DEBUG_OBJECT (depayload, "adding NAL to picture adapter");
 996     gst_adapter_push (rtph265depay->picture_adapter, nal);
 997     rtph265depay->last_ts = in_timestamp;
 998     rtph265depay->last_keyframe |= keyframe;
 999     rtph265depay->picture_start |= start;
1000
1001     if (marker)
1002       outbuf = gst_rtp_h265_complete_au (rtph265depay, &out_timestamp,
1003           &out_keyframe);
1004   } else {
1005     /* no merge, output is input nal */
1006     GST_DEBUG_OBJECT (depayload, "using NAL as output");
1007     outbuf = nal;
1008     gst_buffer_unmap (nal, &map);
1009   }
1010
1011   if (outbuf) {
1012     /* prepend codec_data */
1013     if (rtph265depay->codec_data) {
1014       GST_DEBUG_OBJECT (depayload, "prepending codec_data");
1015       gst_rtp_copy_meta (GST_ELEMENT_CAST (rtph265depay),
1016           rtph265depay->codec_data, outbuf,
1017           g_quark_from_static_string (GST_META_TAG_VIDEO_STR));
1018       outbuf = gst_buffer_append (rtph265depay->codec_data, outbuf);
1019       rtph265depay->codec_data = NULL;
1020       out_keyframe = TRUE;
1021     }
1022     outbuf = gst_buffer_make_writable (outbuf);
1023
1024     gst_rtp_drop_meta (GST_ELEMENT_CAST (rtph265depay), outbuf,
1025         g_quark_from_static_string (GST_META_TAG_VIDEO_STR));
1026
1027     GST_BUFFER_PTS (outbuf) = out_timestamp;
1028
1029     if (out_keyframe)
1030       GST_BUFFER_FLAG_UNSET (outbuf, GST_BUFFER_FLAG_DELTA_UNIT);
1031     else
1032       GST_BUFFER_FLAG_SET (outbuf, GST_BUFFER_FLAG_DELTA_UNIT);
1033   }
1034
1035   return outbuf;
1036
1037   /* ERRORS */
1038 short_nal:
1039   {
1040     GST_WARNING_OBJECT (depayload, "dropping short NAL");
1041     gst_buffer_unmap (nal, &map);
1042     gst_buffer_unref (nal);
1043     return NULL;
1044   }
1045 }
1046
1047 static GstBuffer *
1048 gst_rtp_h265_push_fragmentation_unit (GstRtpH265Depay * rtph265depay,
1049     gboolean send)
1050 {
1051   guint outsize;
1052   GstMapInfo map;
1053   GstBuffer *outbuf;
1054
1055   outsize = gst_adapter_available (rtph265depay->adapter);
1056   outbuf = gst_adapter_take_buffer (rtph265depay->adapter, outsize);
1057
1058   gst_buffer_map (outbuf, &map, GST_MAP_WRITE);
1059   GST_DEBUG_OBJECT (rtph265depay, "output %d bytes", outsize);
1060
1061   if (rtph265depay->byte_stream) {
1062     memcpy (map.data, sync_bytes, sizeof (sync_bytes));
1063   } else {
1064     goto not_implemented;
1065   }
1066   gst_buffer_unmap (outbuf, &map);
1067
1068   rtph265depay->current_fu_type = 0;
1069
1070   outbuf = gst_rtp_h265_depay_handle_nal (rtph265depay, outbuf,
1071       rtph265depay->fu_timestamp, rtph265depay->fu_marker);
1072
1073   if (send && outbuf) {
1074     gst_rtp_base_depayload_push (GST_RTP_BASE_DEPAYLOAD (rtph265depay), outbuf);
1075     outbuf = NULL;
1076   }
1077   return outbuf;
1078
1079 not_implemented:
1080   {
1081     GST_ERROR_OBJECT (rtph265depay,
1082         ("Only bytestream format is currently supported."));
1083     gst_buffer_unmap (outbuf, &map);
1084     return NULL;
1085   }
1086 }
1087
1088 static GstBuffer *
1089 gst_rtp_h265_depay_process (GstRTPBaseDepayload * depayload, GstRTPBuffer * rtp)
1090 {
1091   GstRtpH265Depay *rtph265depay;
1092   GstBuffer *outbuf = NULL;
1093   guint8 nal_unit_type;
1094
1095   rtph265depay = GST_RTP_H265_DEPAY (depayload);
1096
1097   /* flush remaining data on discont */
1098   if (GST_BUFFER_IS_DISCONT (rtp->buffer)) {
1099     gst_adapter_clear (rtph265depay->adapter);
1100     rtph265depay->wait_start = TRUE;
1101     rtph265depay->current_fu_type = 0;
1102   }
1103
1104   {
1105     gint payload_len;
1106     guint8 *payload;
1107     guint header_len;
1108     GstMapInfo map;
1109     guint outsize, nalu_size;
1110     GstClockTime timestamp;
1111     gboolean marker;
1112     guint8 nuh_layer_id, nuh_temporal_id_plus1;
1113     guint8 S, E;
1114     guint16 nal_header;
1115 #if 0
1116     gboolean donl_present = FALSE;
1117 #endif
1118
1119     timestamp = GST_BUFFER_PTS (rtp->buffer);
1120
1121     payload_len = gst_rtp_buffer_get_payload_len (rtp);
1122     payload = gst_rtp_buffer_get_payload (rtp);
1123     marker = gst_rtp_buffer_get_marker (rtp);
1124
1125     GST_DEBUG_OBJECT (rtph265depay, "receiving %d bytes", payload_len);
1126
1127     if (payload_len == 0)
1128       goto empty_packet;
1129
1130     /* +---------------+---------------+
1131      * |0|1|2|3|4|5|6|7|0|1|2|3|4|5|6|7|
1132      * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1133      * |F|   Type    |  LayerId  | TID |
1134      * +-------------+-----------------+
1135      *
1136      * F must be 0.
1137      *
1138      */
1139     nal_unit_type = (payload[0] >> 1) & 0x3f;
1140     nuh_layer_id = ((payload[0] & 0x01) << 5) | (payload[1] >> 3);      /* should be zero for now but this could change in future HEVC extensions */
1141     nuh_temporal_id_plus1 = payload[1] & 0x03;
1142
1143     /* At least two byte header with type */
1144     header_len = 2;
1145
1146     GST_DEBUG_OBJECT (rtph265depay,
1147         "NAL header nal_unit_type %d, nuh_temporal_id_plus1 %d", nal_unit_type,
1148         nuh_temporal_id_plus1);
1149
1150     GST_FIXME_OBJECT (rtph265depay, "Assuming DONL field is not present");
1151
1152     /* FIXME - assuming DONL field is not present for now */
1153     /*donl_present = (tx-mode == "MST") || (sprop-max-don-diff > 0); */
1154
1155     /* If FU unit was being processed, but the current nal is of a different
1156      * type.  Assume that the remote payloader is buggy (didn't set the end bit
1157      * when the FU ended) and send out what we gathered thusfar */
1158     if (G_UNLIKELY (rtph265depay->current_fu_type != 0 &&
1159             nal_unit_type != rtph265depay->current_fu_type))
1160       gst_rtp_h265_push_fragmentation_unit (rtph265depay, TRUE);
1161
1162     switch (nal_unit_type) {
1163       case 48:
1164       {
1165         GST_DEBUG_OBJECT (rtph265depay, "Processing aggregation packet");
1166
1167         /* Aggregation packet (section 4.7) */
1168
1169         /*  An example of an AP packet containing two aggregation units
1170            without the DONL and DOND fields
1171
1172            0                   1                   2                   3
1173            0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
1174            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1175            |                          RTP Header                           |
1176            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1177            |   PayloadHdr (Type=48)        |         NALU 1 Size           |
1178            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1179            |          NALU 1 HDR           |                               |
1180            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+         NALU 1 Data           |
1181            |                   . . .                                       |
1182            |                                                               |
1183            +               +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1184            |  . . .        | NALU 2 Size                   | NALU 2 HDR    |
1185            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1186            | NALU 2 HDR    |                                               |
1187            +-+-+-+-+-+-+-+-+              NALU 2 Data                      |
1188            |                   . . .                                       |
1189            |                               +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1190            |                               :...OPTIONAL RTP padding        |
1191            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1192          */
1193
1194         /* strip headers */
1195         payload += header_len;
1196         payload_len -= header_len;
1197
1198         rtph265depay->wait_start = FALSE;
1199
1200 #if 0
1201         if (donl_present)
1202           goto not_implemented_donl_present;
1203 #endif
1204
1205         while (payload_len > 2) {
1206
1207           nalu_size = (payload[0] << 8) | payload[1];
1208
1209           /* dont include nalu_size */
1210           if (nalu_size > (payload_len - 2))
1211             nalu_size = payload_len - 2;
1212
1213           outsize = nalu_size + sizeof (sync_bytes);
1214           outbuf = gst_buffer_new_and_alloc (outsize);
1215
1216           gst_buffer_map (outbuf, &map, GST_MAP_WRITE);
1217           if (rtph265depay->byte_stream) {
1218             memcpy (map.data, sync_bytes, sizeof (sync_bytes));
1219           } else {
1220             goto not_implemented;
1221           }
1222
1223           /* strip NALU size */
1224           payload += 2;
1225           payload_len -= 2;
1226
1227           memcpy (map.data + sizeof (sync_bytes), payload, nalu_size);
1228           gst_buffer_unmap (outbuf, &map);
1229
1230           gst_rtp_copy_meta (GST_ELEMENT_CAST (rtph265depay), outbuf,
1231               rtp->buffer, g_quark_from_static_string (GST_META_TAG_VIDEO_STR));
1232
1233           outbuf =
1234               gst_rtp_h265_depay_handle_nal (rtph265depay, outbuf, timestamp,
1235               marker);
1236           if (outbuf)
1237             gst_adapter_push (rtph265depay->adapter, outbuf);
1238
1239           payload += nalu_size;
1240           payload_len -= nalu_size;
1241         }
1242
1243         outsize = gst_adapter_available (rtph265depay->adapter);
1244         if (outsize > 0) {
1245           outbuf = gst_adapter_take_buffer (rtph265depay->adapter, outsize);
1246           outbuf =
1247               gst_rtp_h265_depay_handle_nal (rtph265depay, outbuf, timestamp,
1248               marker);
1249         }
1250         break;
1251       }
1252       case 49:
1253       {
1254         GST_DEBUG_OBJECT (rtph265depay, "Processing Fragmentation Unit");
1255
1256         /* Fragmentation units (FUs)  Section 4.8 */
1257
1258         /*    The structure of a Fragmentation Unit (FU)
1259          *
1260          *    0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
1261          +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1262          |    PayloadHdr (Type=49)       |   FU header   | DONL (cond)   |
1263          +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-|
1264          | DONL (cond)   |                                               |
1265          |-+-+-+-+-+-+-+-+                                               |
1266          |                         FU payload                            |
1267          |                                                               |
1268          |                               +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1269          |                               :...OPTIONAL RTP padding        |
1270          +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1271          *
1272          *
1273          */
1274
1275         /* strip headers */
1276         payload += header_len;
1277         payload_len -= header_len;
1278
1279         /* processing FU header */
1280         S = (payload[0] & 0x80) == 0x80;
1281         E = (payload[0] & 0x40) == 0x40;
1282
1283         GST_DEBUG_OBJECT (rtph265depay,
1284             "FU header with S %d, E %d, nal_unit_type %d", S, E,
1285             payload[0] & 0x3f);
1286
1287         if (rtph265depay->wait_start && !S)
1288           goto waiting_start;
1289
1290 #if 0
1291         if (donl_present)
1292           goto not_implemented_donl_present;
1293 #endif
1294
1295         if (S) {
1296
1297           GST_DEBUG_OBJECT (rtph265depay, "Start of Fragmentation Unit");
1298
1299           /* If a new FU unit started, while still processing an older one.
1300            * Assume that the remote payloader is buggy (doesn't set the end
1301            * bit) and send out what we've gathered thusfar */
1302           if (G_UNLIKELY (rtph265depay->current_fu_type != 0))
1303             gst_rtp_h265_push_fragmentation_unit (rtph265depay, TRUE);
1304
1305           rtph265depay->current_fu_type = nal_unit_type;
1306           rtph265depay->fu_timestamp = timestamp;
1307
1308           rtph265depay->wait_start = FALSE;
1309
1310           /* reconstruct NAL header */
1311           nal_header =
1312               ((payload[0] & 0x3f) << 9) | (nuh_layer_id << 3) |
1313               nuh_temporal_id_plus1;
1314
1315           /* go back one byte so we can copy the payload + two bytes more in the front which
1316            * will be overwritten by the nal_header
1317            */
1318           payload -= 1;
1319           payload_len += 1;
1320
1321           nalu_size = payload_len;
1322           outsize = nalu_size + sizeof (sync_bytes);
1323           outbuf = gst_buffer_new_and_alloc (outsize);
1324
1325           gst_buffer_map (outbuf, &map, GST_MAP_WRITE);
1326           memcpy (map.data + sizeof (sync_bytes), payload, nalu_size);
1327           map.data[sizeof (sync_bytes)] = nal_header >> 8;
1328           map.data[sizeof (sync_bytes) + 1] = nal_header & 0xff;
1329           gst_buffer_unmap (outbuf, &map);
1330
1331           gst_rtp_copy_meta (GST_ELEMENT_CAST (rtph265depay), outbuf,
1332               rtp->buffer, g_quark_from_static_string (GST_META_TAG_VIDEO_STR));
1333
1334           GST_DEBUG_OBJECT (rtph265depay, "queueing %d bytes", outsize);
1335
1336           /* and assemble in the adapter */
1337           gst_adapter_push (rtph265depay->adapter, outbuf);
1338         } else {
1339
1340           GST_DEBUG_OBJECT (rtph265depay,
1341               "Following part of Fragmentation Unit");
1342
1343           /* strip off FU header byte */
1344           payload += 1;
1345           payload_len -= 1;
1346
1347           outsize = payload_len;
1348           outbuf = gst_buffer_new_and_alloc (outsize);
1349           gst_buffer_fill (outbuf, 0, payload, outsize);
1350
1351           gst_rtp_copy_meta (GST_ELEMENT_CAST (rtph265depay), outbuf,
1352               rtp->buffer, g_quark_from_static_string (GST_META_TAG_VIDEO_STR));
1353
1354           GST_DEBUG_OBJECT (rtph265depay, "queueing %d bytes", outsize);
1355
1356           /* and assemble in the adapter */
1357           gst_adapter_push (rtph265depay->adapter, outbuf);
1358         }
1359
1360         outbuf = NULL;
1361         rtph265depay->fu_marker = marker;
1362
1363         /* if NAL unit ends, flush the adapter */
1364         if (E) {
1365           outbuf = gst_rtp_h265_push_fragmentation_unit (rtph265depay, FALSE);
1366           GST_DEBUG_OBJECT (rtph265depay, "End of Fragmentation Unit");
1367         }
1368         break;
1369       }
1370       case 50:
1371         goto not_implemented;   /* PACI packets  Section 4.9 */
1372       default:
1373       {
1374         rtph265depay->wait_start = FALSE;
1375
1376         /* All other cases: Single NAL unit packet   Section 4.6 */
1377         /* the entire payload is the output buffer */
1378
1379 #if 0
1380         if (donl_present)
1381           goto not_implemented_donl_present;
1382 #endif
1383
1384         nalu_size = payload_len;
1385         outsize = nalu_size + sizeof (sync_bytes);
1386         outbuf = gst_buffer_new_and_alloc (outsize);
1387
1388         gst_buffer_map (outbuf, &map, GST_MAP_WRITE);
1389         if (rtph265depay->byte_stream) {
1390           memcpy (map.data, sync_bytes, sizeof (sync_bytes));
1391         } else {
1392           goto not_implemented;
1393         }
1394         memcpy (map.data + sizeof (sync_bytes), payload, nalu_size);
1395         gst_buffer_unmap (outbuf, &map);
1396
1397         gst_rtp_copy_meta (GST_ELEMENT_CAST (rtph265depay), outbuf,
1398             rtp->buffer, g_quark_from_static_string (GST_META_TAG_VIDEO_STR));
1399
1400         outbuf = gst_rtp_h265_depay_handle_nal (rtph265depay, outbuf, timestamp,
1401             marker);
1402         break;
1403       }
1404     }
1405   }
1406
1407   return outbuf;
1408
1409   /* ERRORS */
1410 empty_packet:
1411   {
1412     GST_DEBUG_OBJECT (rtph265depay, "empty packet");
1413     return NULL;
1414   }
1415 waiting_start:
1416   {
1417     GST_DEBUG_OBJECT (rtph265depay, "waiting for start");
1418     return NULL;
1419   }
1420 #if 0
1421 not_implemented_donl_present:
1422   {
1423     GST_ELEMENT_ERROR (rtph265depay, STREAM, FORMAT,
1424         (NULL), ("DONL field present not supported yet"));
1425     return NULL;
1426   }
1427 #endif
1428 not_implemented:
1429   {
1430     GST_ELEMENT_ERROR (rtph265depay, STREAM, FORMAT,
1431         (NULL), ("NAL unit type %d not supported yet", nal_unit_type));
1432     return NULL;
1433   }
1434 }
1435
1436 static gboolean
1437 gst_rtp_h265_depay_handle_event (GstRTPBaseDepayload * depay, GstEvent * event)
1438 {
1439   GstRtpH265Depay *rtph265depay;
1440
1441   rtph265depay = GST_RTP_H265_DEPAY (depay);
1442
1443   switch (GST_EVENT_TYPE (event)) {
1444     case GST_EVENT_FLUSH_STOP:
1445       gst_rtp_h265_depay_reset (rtph265depay);
1446       break;
1447     default:
1448       break;
1449   }
1450
1451   return
1452       GST_RTP_BASE_DEPAYLOAD_CLASS (parent_class)->handle_event (depay, event);
1453 }
1454
1455 static GstStateChangeReturn
1456 gst_rtp_h265_depay_change_state (GstElement * element,
1457     GstStateChange transition)
1458 {
1459   GstRtpH265Depay *rtph265depay;
1460   GstStateChangeReturn ret;
1461
1462   rtph265depay = GST_RTP_H265_DEPAY (element);
1463
1464   switch (transition) {
1465     case GST_STATE_CHANGE_NULL_TO_READY:
1466       break;
1467     case GST_STATE_CHANGE_READY_TO_PAUSED:
1468       gst_rtp_h265_depay_reset (rtph265depay);
1469       break;
1470     default:
1471       break;
1472   }
1473
1474   ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
1475
1476   switch (transition) {
1477     case GST_STATE_CHANGE_READY_TO_NULL:
1478       break;
1479     default:
1480       break;
1481   }
1482   return ret;
1483 }
1484
1485 gboolean
1486 gst_rtp_h265_depay_plugin_init (GstPlugin * plugin)
1487 {
1488   GST_DEBUG_CATEGORY_INIT (rtph265depay_debug, "rtph265depay", 0,
1489       "H265 Video RTP Depayloader");
1490
1491   return gst_element_register (plugin, "rtph265depay",
1492       GST_RANK_SECONDARY, GST_TYPE_RTP_H265_DEPAY);
1493 }