/* * Copyright 2006, 2007, 2008, 2009, 2010 Fluendo S.A. * Authors: Jan Schmidt * Kapil Agrawal * Julien Moutte * * Copyright (C) 2011 Jan Schmidt * * This library is licensed under 3 different licenses and you * can choose to use it under the terms of any one of them. The * three licenses are the MPL 1.1, the LGPL and the MIT license. * * MPL: * * The contents of this file are subject to the Mozilla Public License * Version 1.1 (the "License"); you may not use this file except in * compliance with the License. You may obtain a copy of the License at * http://www.mozilla.org/MPL/. * * Software distributed under the License is distributed on an "AS IS" * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the * License for the specific language governing rights and limitations * under the License. * * LGPL: * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Library General Public License for more details. * * You should have received a copy of the GNU Library General Public * License along with this library; if not, write to the * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, * Boston, MA 02110-1301, USA. * * MIT: * * Unless otherwise indicated, Source Code is licensed under MIT license. * See further explanation attached in License Statement (distributed in the file * LICENSE). * * Permission is hereby granted, free of charge, to any person obtaining a copy of * this software and associated documentation files (the "Software"), to deal in * the Software without restriction, including without limitation the rights to * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies * of the Software, and to permit persons to whom the Software is furnished to do * so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in all * copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. * * SPDX-License-Identifier: MPL-1.1 OR MIT OR LGPL-2.0-or-later */ #ifdef HAVE_CONFIG_H #include "config.h" #endif #include #include #include #include #include #include #include #include #include #include "gstbasetsmux.h" #include "gstbasetsmuxaac.h" #include "gstbasetsmuxttxt.h" #include "gstbasetsmuxopus.h" #include "gstbasetsmuxjpeg2000.h" #include "gstbasetsmuxjpegxs.h" GST_DEBUG_CATEGORY (gst_base_ts_mux_debug); #define GST_CAT_DEFAULT gst_base_ts_mux_debug /* GstBaseTsMuxPad */ G_DEFINE_TYPE (GstBaseTsMuxPad, gst_base_ts_mux_pad, GST_TYPE_AGGREGATOR_PAD); #define DEFAULT_PAD_STREAM_NUMBER 0 enum { PAD_PROP_0, PAD_PROP_STREAM_NUMBER, }; /* Internals */ static void gst_base_ts_mux_pad_reset (GstBaseTsMuxPad * pad) { pad->dts = GST_CLOCK_STIME_NONE; pad->prog_id = -1; if (pad->free_func) pad->free_func (pad->prepare_data); pad->prepare_data = NULL; pad->prepare_func = NULL; pad->free_func = NULL; if (pad->codec_data) gst_buffer_replace (&pad->codec_data, NULL); /* reference owned elsewhere */ pad->stream = NULL; pad->prog = NULL; if (pad->language) { g_free (pad->language); pad->language = NULL; } pad->bitrate = 0; pad->max_bitrate = 0; } /* GstAggregatorPad implementation */ static GstFlowReturn gst_base_ts_mux_pad_flush (GstAggregatorPad * agg_pad, GstAggregator * agg) { GList *cur; GstBaseTsMux *mux = GST_BASE_TS_MUX (agg); /* Send initial segments again after a flush-stop, and also resend the * header sections */ g_mutex_lock (&mux->lock); mux->first = TRUE; /* output PAT, SI tables */ tsmux_resend_pat (mux->tsmux); tsmux_resend_si (mux->tsmux); /* output PMT for each program */ for (cur = mux->tsmux->programs; cur; cur = cur->next) { TsMuxProgram *program = (TsMuxProgram *) cur->data; tsmux_resend_pmt (program); } g_mutex_unlock (&mux->lock); return GST_FLOW_OK; } /* GObject implementation */ static void gst_base_ts_mux_pad_dispose (GObject * obj) { GstBaseTsMuxPad *ts_pad = GST_BASE_TS_MUX_PAD (obj); gst_base_ts_mux_pad_reset (ts_pad); G_OBJECT_CLASS (gst_base_ts_mux_pad_parent_class)->dispose (obj); } static void gst_base_ts_mux_pad_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstBaseTsMuxPad *ts_pad = GST_BASE_TS_MUX_PAD (object); switch (prop_id) { case PAD_PROP_STREAM_NUMBER: ts_pad->stream_number = g_value_get_int (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } static void gst_base_ts_mux_pad_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) { GstBaseTsMuxPad *ts_pad = GST_BASE_TS_MUX_PAD (object); switch (prop_id) { case PAD_PROP_STREAM_NUMBER: g_value_set_int (value, ts_pad->stream_number); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } static void gst_base_ts_mux_pad_class_init (GstBaseTsMuxPadClass * klass) { GObjectClass *gobject_class = G_OBJECT_CLASS (klass); GstAggregatorPadClass *gstaggpad_class = GST_AGGREGATOR_PAD_CLASS (klass); gobject_class->dispose = gst_base_ts_mux_pad_dispose; gobject_class->set_property = gst_base_ts_mux_pad_set_property; gobject_class->get_property = gst_base_ts_mux_pad_get_property; gstaggpad_class->flush = gst_base_ts_mux_pad_flush; gst_type_mark_as_plugin_api (GST_TYPE_BASE_TS_MUX, 0); /** * GstBaseTsMuxPad:stream-number: * * Set stream number for AVC video stream * or AAC audio streams. * * video stream number is stored in 4 bits * audio stream number is stored in 5 bits. * See Table 2-22 of ITU-T H222.0 for details on AAC and AVC stream numbers * * Since: 1.24 */ g_object_class_install_property (gobject_class, PAD_PROP_STREAM_NUMBER, g_param_spec_int ("stream-number", "stream number", "stream number", 0x0, 0x1F, DEFAULT_PAD_STREAM_NUMBER, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); } static void gst_base_ts_mux_pad_init (GstBaseTsMuxPad * vaggpad) { } /* GstBaseTsMux */ enum { PROP_0, PROP_PROG_MAP, PROP_PAT_INTERVAL, PROP_PMT_INTERVAL, PROP_ALIGNMENT, PROP_SI_INTERVAL, PROP_BITRATE, PROP_PCR_INTERVAL, PROP_SCTE_35_PID, PROP_SCTE_35_NULL_INTERVAL }; #define DEFAULT_SCTE_35_PID 0 #define BASETSMUX_DEFAULT_ALIGNMENT -1 #define CLOCK_BASE 9LL #define CLOCK_FREQ (CLOCK_BASE * 10000) /* 90 kHz PTS clock */ #define CLOCK_FREQ_SCR (CLOCK_FREQ * 300) /* 27 MHz SCR clock */ #define TS_MUX_CLOCK_BASE (TSMUX_CLOCK_FREQ * 10 * 360) #define GSTTIME_TO_MPEGTIME(time) \ (((time) > 0 ? (gint64) 1 : (gint64) -1) * \ (gint64) gst_util_uint64_scale (ABS(time), CLOCK_BASE, GST_MSECOND/10)) /* 27 MHz SCR conversions: */ #define MPEG_SYS_TIME_TO_GSTTIME(time) (gst_util_uint64_scale ((time), \ GST_USECOND, CLOCK_FREQ_SCR / 1000000)) #define GSTTIME_TO_MPEG_SYS_TIME(time) (gst_util_uint64_scale ((time), \ CLOCK_FREQ_SCR / 1000000, GST_USECOND)) #define DEFAULT_PROG_ID 0 static GstStaticPadTemplate gst_base_ts_mux_src_factory = GST_STATIC_PAD_TEMPLATE ("src", GST_PAD_SRC, GST_PAD_ALWAYS, GST_STATIC_CAPS ("video/mpegts, " "systemstream = (boolean) true, " "packetsize = (int) { 188, 192} ") ); typedef struct { GstMapInfo map_info; GstBuffer *buffer; } StreamData; G_DEFINE_TYPE_WITH_CODE (GstBaseTsMux, gst_base_ts_mux, GST_TYPE_AGGREGATOR, gst_mpegts_initialize ()); /* Internals */ /* Takes over the ref on the buffer */ static StreamData * stream_data_new (GstBuffer * buffer) { StreamData *res = g_new (StreamData, 1); res->buffer = buffer; gst_buffer_map (buffer, &(res->map_info), GST_MAP_READ); return res; } static void stream_data_free (StreamData * data) { if (data) { gst_buffer_unmap (data->buffer, &data->map_info); gst_buffer_unref (data->buffer); g_free (data); } } #define parent_class gst_base_ts_mux_parent_class static void gst_base_ts_mux_set_header_on_caps (GstBaseTsMux * mux) { GstBuffer *buf; GstStructure *structure; GValue array = { 0 }; GValue value = { 0 }; GstCaps *caps; caps = gst_pad_get_pad_template_caps (GST_AGGREGATOR_SRC_PAD (mux)); caps = gst_caps_make_writable (caps); structure = gst_caps_get_structure (caps, 0); gst_structure_set (structure, "packetsize", G_TYPE_INT, mux->packet_size, NULL); g_value_init (&array, GST_TYPE_ARRAY); GST_LOG_OBJECT (mux, "setting %u packets into streamheader", g_queue_get_length (&mux->streamheader)); while ((buf = GST_BUFFER (g_queue_pop_head (&mux->streamheader)))) { g_value_init (&value, GST_TYPE_BUFFER); gst_value_take_buffer (&value, buf); gst_value_array_append_value (&array, &value); g_value_unset (&value); } gst_structure_set_value (structure, "streamheader", &array); gst_aggregator_set_src_caps (GST_AGGREGATOR (mux), caps); g_value_unset (&array); gst_caps_unref (caps); } static gboolean steal_si_section (GstMpegtsSectionType * type, TsMuxSection * section, TsMux * mux) { g_hash_table_insert (mux->si_sections, type, section); return TRUE; } /* Must be called with mux->lock held */ static void gst_base_ts_mux_reset (GstBaseTsMux * mux, gboolean alloc) { GstBuffer *buf; GstBaseTsMuxClass *klass = GST_BASE_TS_MUX_GET_CLASS (mux); GHashTable *si_sections = NULL; GList *l; mux->first = TRUE; mux->last_flow_ret = GST_FLOW_OK; mux->last_ts = GST_CLOCK_TIME_NONE; mux->is_delta = TRUE; mux->is_header = FALSE; mux->streamheader_sent = FALSE; mux->pending_key_unit_ts = GST_CLOCK_TIME_NONE; gst_event_replace (&mux->force_key_unit_event, NULL); if (mux->out_adapter) gst_adapter_clear (mux->out_adapter); mux->output_ts_offset = GST_CLOCK_STIME_NONE; if (mux->tsmux) { if (mux->tsmux->si_sections) si_sections = g_hash_table_ref (mux->tsmux->si_sections); tsmux_free (mux->tsmux); mux->tsmux = NULL; } if (mux->programs) { g_hash_table_destroy (mux->programs); } mux->programs = g_hash_table_new (g_direct_hash, g_direct_equal); while ((buf = GST_BUFFER (g_queue_pop_head (&mux->streamheader)))) gst_buffer_unref (buf); gst_event_replace (&mux->force_key_unit_event, NULL); gst_buffer_replace (&mux->out_buffer, NULL); GST_OBJECT_LOCK (mux); for (l = GST_ELEMENT (mux)->sinkpads; l; l = l->next) { gst_base_ts_mux_pad_reset (GST_BASE_TS_MUX_PAD (l->data)); } GST_OBJECT_UNLOCK (mux); if (alloc) { g_assert (klass->create_ts_mux); mux->tsmux = klass->create_ts_mux (mux); /* Preserve user-specified sections across resets */ if (si_sections) g_hash_table_foreach_steal (si_sections, (GHRFunc) steal_si_section, mux->tsmux); } if (si_sections) g_hash_table_unref (si_sections); mux->last_scte35_event_seqnum = GST_SEQNUM_INVALID; if (klass->reset) klass->reset (mux); } static void release_buffer_cb (guint8 * data, void *user_data) { stream_data_free ((StreamData *) user_data); } static GstMpegtsJpegXsDescriptor * gst_base_ts_mux_jpegxs_descriptor (GstBaseTsMux * mux, GstBaseTsMuxPad * ts_pad, GstCaps * caps) { GstStructure *s = gst_caps_get_structure (caps, 0); gint codestream_length, depth; GstMpegtsJpegXsDescriptor *jpegxs_descriptor; GstVideoInfo video_info; const gchar *sampling; if (!gst_video_info_from_caps (&video_info, caps)) return NULL; /* Get (and calculate) all fields from the caps information */ sampling = gst_structure_get_string (s, "sampling"); if (!gst_structure_get_int (s, "codestream-length", &codestream_length) || !sampling || !gst_structure_get_int (s, "depth", &depth) || !depth) { GST_ERROR_OBJECT (ts_pad, "JPEG-XS caps doesn't contain all required fields"); return NULL; } jpegxs_descriptor = g_new0 (GstMpegtsJpegXsDescriptor, 1); jpegxs_descriptor->horizontal_size = GST_VIDEO_INFO_WIDTH (&video_info); jpegxs_descriptor->vertical_size = GST_VIDEO_INFO_HEIGHT (&video_info); { /* FIXME : Cap according to limit defined by profile/level */ guint32 brat = G_MAXUINT32; if (GST_VIDEO_INFO_FPS_N (&video_info) > 0 && GST_VIDEO_INFO_FPS_D (&video_info) > 0) { // 125000 = * 8 / 1000000 (convert to bits, divide to Mbps) guint64 v = gst_util_uint64_scale_ceil (GST_VIDEO_INFO_FPS_N (&video_info), codestream_length, GST_VIDEO_INFO_FPS_D (&video_info) * 125000); if (v < G_MAXUINT32) brat = v & 0xffffffff; } jpegxs_descriptor->brat = brat; } { guint32 frat = 0; gint fps_n = GST_VIDEO_INFO_FPS_N (&video_info); gint fps_d = GST_VIDEO_INFO_FPS_D (&video_info); gint denom_value = 1; /* Only framerate divisible by 1 or 1.001 are allowed */ if (fps_d == 1001) { fps_n /= 1000; denom_value = 2; } else if (fps_d != 1) { GST_ERROR_OBJECT (ts_pad, "framerate %d/%d is not allowed for JPEG-XS", fps_n, fps_d); goto free_return; } if (fps_n > G_MAXUINT16) { GST_ERROR_OBJECT (ts_pad, "framerate %d/%d exceeds limits for JPEG-XS", fps_n, fps_d); goto free_return; } if (GST_VIDEO_INFO_IS_INTERLACED (&video_info)) { if (GST_VIDEO_INFO_FIELD_ORDER (&video_info) == GST_VIDEO_FIELD_ORDER_TOP_FIELD_FIRST) { frat |= 1 << 30; } else if (GST_VIDEO_INFO_FIELD_ORDER (&video_info) == GST_VIDEO_FIELD_ORDER_BOTTOM_FIELD_FIRST) { frat |= 1 << 31; } else { GST_ERROR_OBJECT (ts_pad, "Unknown interlace mode"); goto free_return; } } frat |= denom_value << 24; frat |= fps_n; jpegxs_descriptor->frat = frat; } { guint16 schar = ((depth - 1) & 0xf) << 4; /* FIXME : Support all other variants */ if (!g_strcmp0 (sampling, "YCbCr-4:2:2")) { schar |= 0; } else if (!g_strcmp0 (sampling, "YCbCr-4:4:4")) { schar |= 1; } else { GST_ERROR_OBJECT (ts_pad, "Unsupported sampling %s", sampling); goto free_return; } /* schar is valid */ schar |= 1 << 15; jpegxs_descriptor->schar = schar; } /* FIXME : Handle profile/level/sublevel once provided by caps. For now we are unrestricted */ jpegxs_descriptor->Ppih = 0; jpegxs_descriptor->Plev = 0; /* FIXME : Calculate max_buffer_size based on profile/level if specified */ jpegxs_descriptor->max_buffer_size = jpegxs_descriptor->brat / 160; /* Hardcoded buffer_model_type of 2 accordingly to H.222.0 specification */ jpegxs_descriptor->buffer_model_type = 2; jpegxs_descriptor->colour_primaries = gst_video_color_primaries_to_iso (video_info.colorimetry.primaries); jpegxs_descriptor->transfer_characteristics = gst_video_transfer_function_to_iso (video_info.colorimetry.transfer); jpegxs_descriptor->matrix_coefficients = gst_video_color_matrix_to_iso (video_info.colorimetry.matrix); jpegxs_descriptor->video_full_range_flag = video_info.colorimetry.range == GST_VIDEO_COLOR_RANGE_0_255; /* We don't accept still pictures */ jpegxs_descriptor->still_mode = FALSE; /* FIXME : Add support for Mastering Display Metadata parsing */ return jpegxs_descriptor; free_return: { g_free (jpegxs_descriptor); return NULL; } } /* Must be called with mux->lock held */ static GstFlowReturn gst_base_ts_mux_create_or_update_stream (GstBaseTsMux * mux, GstBaseTsMuxPad * ts_pad, GstCaps * caps) { GstStructure *s; guint st = TSMUX_ST_RESERVED; const gchar *mt; const GValue *value = NULL; GstBuffer *codec_data = NULL; guint8 opus_channel_config[1 + 2 + 1 + 1 + 255] = { 0, }; gsize opus_channel_config_len = 0; guint16 profile = GST_JPEG2000_PARSE_PROFILE_NONE; guint8 main_level = 0; guint32 max_rate = 0; guint8 color_spec = 0; const gchar *stream_format = NULL; const char *interlace_mode = NULL; gchar *pmt_name; GstMpegtsDescriptor *pmt_descriptor = NULL; GST_DEBUG_OBJECT (ts_pad, "%s stream with PID 0x%04x for caps %" GST_PTR_FORMAT, ts_pad->stream ? "Recreating" : "Creating", ts_pad->pid, caps); s = gst_caps_get_structure (caps, 0); mt = gst_structure_get_name (s); value = gst_structure_get_value (s, "codec_data"); if (value != NULL) codec_data = gst_value_get_buffer (value); g_clear_pointer (&ts_pad->codec_data, gst_buffer_unref); ts_pad->prepare_func = NULL; stream_format = gst_structure_get_string (s, "stream-format"); if (strcmp (mt, "video/x-dirac") == 0) { st = TSMUX_ST_VIDEO_DIRAC; } else if (strcmp (mt, "audio/x-ac3") == 0) { st = TSMUX_ST_PS_AUDIO_AC3; } else if (strcmp (mt, "audio/x-dts") == 0) { st = TSMUX_ST_PS_AUDIO_DTS; } else if (strcmp (mt, "audio/x-lpcm") == 0) { st = TSMUX_ST_PS_AUDIO_LPCM; } else if (strcmp (mt, "video/x-h264") == 0) { st = TSMUX_ST_VIDEO_H264; } else if (strcmp (mt, "video/x-h265") == 0) { st = TSMUX_ST_VIDEO_HEVC; } else if (strcmp (mt, "audio/mpeg") == 0) { gint mpegversion; if (!gst_structure_get_int (s, "mpegversion", &mpegversion)) { GST_ERROR_OBJECT (ts_pad, "caps missing mpegversion"); goto not_negotiated; } switch (mpegversion) { case 1:{ int mpegaudioversion = 1; /* Assume mpegaudioversion=1 for backwards compatibility */ (void) gst_structure_get_int (s, "mpegaudioversion", &mpegaudioversion); if (mpegaudioversion == 1) st = TSMUX_ST_AUDIO_MPEG1; else st = TSMUX_ST_AUDIO_MPEG2; break; } case 2:{ /* mpegversion=2 in GStreamer refers to MPEG-2 Part 7 audio, */ st = TSMUX_ST_AUDIO_AAC; /* Check the stream format. If raw, make dummy internal codec data from the caps */ if (g_strcmp0 (stream_format, "raw") == 0) { ts_pad->codec_data = gst_base_ts_mux_aac_mpeg2_make_codec_data (mux, caps); ts_pad->prepare_func = gst_base_ts_mux_prepare_aac_mpeg2; if (ts_pad->codec_data == NULL) { GST_ERROR_OBJECT (mux, "Invalid or incomplete caps for MPEG-2 AAC"); goto not_negotiated; } } break; } case 4: { st = TSMUX_ST_AUDIO_AAC; /* Check the stream format. We need codec_data with RAW streams and mpegversion=4 */ if (g_strcmp0 (stream_format, "raw") == 0) { if (codec_data) { GST_DEBUG_OBJECT (ts_pad, "we have additional codec data (%" G_GSIZE_FORMAT " bytes)", gst_buffer_get_size (codec_data)); ts_pad->codec_data = gst_buffer_ref (codec_data); ts_pad->prepare_func = gst_base_ts_mux_prepare_aac_mpeg4; } else { ts_pad->codec_data = NULL; GST_ERROR_OBJECT (mux, "Need codec_data for raw MPEG-4 AAC"); goto not_negotiated; } } else if (codec_data) { ts_pad->codec_data = gst_buffer_ref (codec_data); } else { ts_pad->codec_data = NULL; } break; } default: GST_WARNING_OBJECT (ts_pad, "unsupported mpegversion %d", mpegversion); goto not_negotiated; } } else if (strcmp (mt, "video/mpeg") == 0) { gint mpegversion; if (!gst_structure_get_int (s, "mpegversion", &mpegversion)) { GST_ERROR_OBJECT (ts_pad, "caps missing mpegversion"); goto not_negotiated; } switch (mpegversion) { case 1: st = TSMUX_ST_VIDEO_MPEG1; break; case 2: st = TSMUX_ST_VIDEO_MPEG2; break; case 4: st = TSMUX_ST_VIDEO_MPEG4; break; default: GST_WARNING_OBJECT (ts_pad, "unsupported mpegversion %d", mpegversion); goto not_negotiated; } } else if (strcmp (mt, "subpicture/x-dvb") == 0) { st = TSMUX_ST_PS_DVB_SUBPICTURE; } else if (strcmp (mt, "application/x-teletext") == 0) { st = TSMUX_ST_PS_TELETEXT; /* needs a particularly sized layout */ ts_pad->prepare_func = gst_base_ts_mux_prepare_teletext; } else if (strcmp (mt, "audio/x-opus") == 0) { guint8 channels, mapping_family, stream_count, coupled_count; guint8 channel_mapping[256]; if (!gst_codec_utils_opus_parse_caps (caps, NULL, &channels, &mapping_family, &stream_count, &coupled_count, channel_mapping)) { GST_ERROR_OBJECT (ts_pad, "Incomplete Opus caps"); goto not_negotiated; } if (channels <= 2 && mapping_family == 0) { opus_channel_config[0] = channels; opus_channel_config_len = 1; } else if (channels == 2 && mapping_family == 255 && ((stream_count == 1 && coupled_count == 1) || (stream_count == 2 && coupled_count == 0))) { /* Dual mono */ opus_channel_config[0] = coupled_count == 0 ? 0x80 : 0x00; opus_channel_config_len = 1; } else if (channels >= 2 && channels <= 8 && mapping_family == 1) { static const guint8 coupled_stream_counts[9] = { 1, 0, 1, 1, 2, 2, 2, 3, 3 }; static const guint8 channel_map_a[8][8] = { {0}, {0, 1}, {0, 2, 1}, {0, 1, 2, 3}, {0, 4, 1, 2, 3}, {0, 4, 1, 2, 3, 5}, {0, 4, 1, 2, 3, 5, 6}, {0, 6, 1, 2, 3, 4, 5, 7}, }; static const guint8 channel_map_b[8][8] = { {0}, {0, 1}, {0, 1, 2}, {0, 1, 2, 3}, {0, 1, 2, 3, 4}, {0, 1, 2, 3, 4, 5}, {0, 1, 2, 3, 4, 5, 6}, {0, 1, 2, 3, 4, 5, 6, 7}, }; /* Vorbis mapping */ if (stream_count == channels - coupled_stream_counts[channels] && coupled_count == coupled_stream_counts[channels] && memcmp (channel_mapping, channel_map_a[channels - 1], channels) == 0) { opus_channel_config[0] = channels; opus_channel_config_len = 1; } else if (stream_count == channels - coupled_stream_counts[channels] && coupled_count == coupled_stream_counts[channels] && memcmp (channel_mapping, channel_map_b[channels - 1], channels) == 0) { opus_channel_config[0] = channels | 0x80; opus_channel_config_len = 1; } else { GST_FIXME_OBJECT (ts_pad, "Opus channel mapping not handled"); goto not_negotiated; } } else { GstBitWriter writer; guint i; guint n_bits; gst_bit_writer_init_with_data (&writer, opus_channel_config, sizeof (opus_channel_config), FALSE); gst_bit_writer_put_bits_uint8_unchecked (&writer, 0x81, 8); gst_bit_writer_put_bits_uint8_unchecked (&writer, channels, 8); gst_bit_writer_put_bits_uint8_unchecked (&writer, mapping_family, 8); n_bits = g_bit_storage (channels); gst_bit_writer_put_bits_uint8_unchecked (&writer, stream_count - 1, n_bits); n_bits = g_bit_storage (stream_count + 1); gst_bit_writer_put_bits_uint8_unchecked (&writer, coupled_count, n_bits); n_bits = g_bit_storage (stream_count + coupled_count + 1); for (i = 0; i < channels; i++) { gst_bit_writer_put_bits_uint8_unchecked (&writer, channel_mapping[i], n_bits); } gst_bit_writer_align_bytes_unchecked (&writer, 0); g_assert (writer.bit_size % 8 == 0); opus_channel_config_len = writer.bit_size / 8; } st = TSMUX_ST_PS_OPUS; ts_pad->prepare_func = gst_base_ts_mux_prepare_opus; } else if (strcmp (mt, "meta/x-klv") == 0) { st = TSMUX_ST_PS_KLV; } else if (strcmp (mt, "meta/x-st-2038") == 0) { st = TSMUX_ST_PS_ST_2038; } else if (strcmp (mt, "meta/x-id3") == 0) { st = TSMUX_ST_PS_ID3; } else if (strcmp (mt, "image/x-jxsc") == 0) { /* FIXME: Get actual values from caps */ GstMpegtsJpegXsDescriptor *jpegxs_descriptor = gst_base_ts_mux_jpegxs_descriptor (mux, ts_pad, caps); if (!jpegxs_descriptor) goto not_negotiated; pmt_descriptor = gst_mpegts_descriptor_from_jpeg_xs (jpegxs_descriptor); if (!pmt_descriptor) { g_free (jpegxs_descriptor); goto not_negotiated; } st = TSMUX_ST_VIDEO_JPEG_XS; ts_pad->prepare_func = gst_base_ts_mux_prepare_jpegxs; ts_pad->prepare_data = jpegxs_descriptor; ts_pad->free_func = gst_base_ts_mux_free_jpegxs; } else if (strcmp (mt, "image/x-jpc") == 0) { /* * See this document for more details on standard: * * https://www.itu.int/rec/T-REC-H.222.0-201206-S/en * Annex S describes J2K details * Page 104 of this document describes J2k video descriptor */ const GValue *vProfile = gst_structure_get_value (s, "profile"); const GValue *vMainlevel = gst_structure_get_value (s, "main-level"); const GValue *vFramerate = gst_structure_get_value (s, "framerate"); const GValue *vColorimetry = gst_structure_get_value (s, "colorimetry"); j2k_private_data *private_data; /* for now, we relax the condition that profile must exist and equal * GST_JPEG2000_PARSE_PROFILE_BC_SINGLE */ if (vProfile) { profile = g_value_get_int (vProfile); if (profile != GST_JPEG2000_PARSE_PROFILE_BC_SINGLE) { GST_LOG_OBJECT (ts_pad, "Invalid JPEG 2000 profile %d", profile); /* goto not_negotiated; */ } } /* for now, we will relax the condition that the main level must be present */ if (vMainlevel) { main_level = g_value_get_uint (vMainlevel); if (main_level > 11) { GST_ERROR_OBJECT (ts_pad, "Invalid main level %d", main_level); goto not_negotiated; } if (main_level >= 6) { max_rate = 2 ^ (main_level - 6) * 1600 * 1000000; } else { switch (main_level) { case 0: case 1: case 2: case 3: max_rate = 200 * 1000000; break; case 4: max_rate = 400 * 1000000; break; case 5: max_rate = 800 * 1000000; break; default: break; } } } else { /* GST_ERROR_OBJECT (ts_pad, "Missing main level"); * goto not_negotiated; */ } /* We always mux video in J2K-over-MPEG-TS non-interlaced mode */ private_data = g_new0 (j2k_private_data, 1); private_data->interlace = FALSE; private_data->den = 0; private_data->num = 0; private_data->max_bitrate = max_rate; private_data->color_spec = 1; /* these two fields are not used, since we always mux as non-interlaced */ private_data->Fic = 1; private_data->Fio = 0; /* Get Framerate */ if (vFramerate != NULL) { /* Data for ELSM header */ private_data->num = gst_value_get_fraction_numerator (vFramerate); private_data->den = gst_value_get_fraction_denominator (vFramerate); } /* Get Colorimetry */ if (vColorimetry) { const char *colorimetry = g_value_get_string (vColorimetry); color_spec = GST_MPEGTS_JPEG2000_COLORSPEC_SRGB; /* RGB as default */ if (g_str_equal (colorimetry, GST_VIDEO_COLORIMETRY_BT601)) { color_spec = GST_MPEGTS_JPEG2000_COLORSPEC_REC601; } else { if (g_str_equal (colorimetry, GST_VIDEO_COLORIMETRY_BT709) || g_str_equal (colorimetry, GST_VIDEO_COLORIMETRY_SMPTE240M)) { color_spec = GST_MPEGTS_JPEG2000_COLORSPEC_REC709; } } private_data->color_spec = color_spec; } else { GST_ERROR_OBJECT (ts_pad, "Colorimetry not present in caps"); g_free (private_data); goto not_negotiated; } st = TSMUX_ST_VIDEO_JP2K; ts_pad->prepare_func = gst_base_ts_mux_prepare_jpeg2000; ts_pad->prepare_data = private_data; ts_pad->free_func = gst_base_ts_mux_free_jpeg2000; } else { GstBaseTsMuxClass *klass = GST_BASE_TS_MUX_GET_CLASS (mux); if (klass->handle_media_type) { st = klass->handle_media_type (mux, mt, ts_pad); } } if (st == TSMUX_ST_RESERVED) { GST_ERROR_OBJECT (ts_pad, "Failed to determine stream type"); goto error; } if (ts_pad->stream && st != ts_pad->stream->stream_type) { GST_ELEMENT_ERROR (mux, STREAM, MUX, ("Stream type change from %02x to %02x not supported", ts_pad->stream->stream_type, st), NULL); goto error; } if (ts_pad->stream == NULL) { gint stream_number = DEFAULT_PAD_STREAM_NUMBER; g_object_get (ts_pad, "stream-number", &stream_number, NULL); ts_pad->stream = tsmux_create_stream (mux->tsmux, st, stream_number, ts_pad->pid, ts_pad->language, ts_pad->bitrate, ts_pad->max_bitrate); if (ts_pad->stream == NULL) goto error; } if (pmt_descriptor) { ts_pad->stream->pmt_descriptor = pmt_descriptor; } pmt_name = g_strdup_printf ("PMT_%d", ts_pad->pid); if (mux->prog_map && gst_structure_has_field (mux->prog_map, pmt_name)) { gst_structure_get_int (mux->prog_map, pmt_name, &ts_pad->stream->pmt_index); } g_free (pmt_name); interlace_mode = gst_structure_get_string (s, "interlace-mode"); gst_structure_get_int (s, "rate", &ts_pad->stream->audio_sampling); gst_structure_get_int (s, "channels", &ts_pad->stream->audio_channels); gst_structure_get_int (s, "bitrate", &ts_pad->stream->audio_bitrate); /* frame rate */ gst_structure_get_fraction (s, "framerate", &ts_pad->stream->num, &ts_pad->stream->den); /* Interlace mode */ ts_pad->stream->interlace_mode = FALSE; if (interlace_mode) { ts_pad->stream->interlace_mode = g_str_equal (interlace_mode, "interleaved"); } /* Width and Height */ gst_structure_get_int (s, "width", &ts_pad->stream->horizontal_size); gst_structure_get_int (s, "height", &ts_pad->stream->vertical_size); ts_pad->stream->color_spec = color_spec; ts_pad->stream->max_bitrate = max_rate; ts_pad->stream->profile_and_level = profile | main_level; memcpy (ts_pad->stream->opus_channel_config, opus_channel_config, sizeof (opus_channel_config)); ts_pad->stream->opus_channel_config_len = opus_channel_config_len; tsmux_stream_set_buffer_release_func (ts_pad->stream, release_buffer_cb); return GST_FLOW_OK; /* ERRORS */ not_negotiated: if (pmt_descriptor) gst_mpegts_descriptor_free (pmt_descriptor); return GST_FLOW_NOT_NEGOTIATED; error: if (pmt_descriptor) gst_mpegts_descriptor_free (pmt_descriptor); return GST_FLOW_ERROR; } static gboolean is_valid_pmt_pid (guint16 pmt_pid) { if (pmt_pid < 0x0010 || pmt_pid > 0x1ffe) return FALSE; return TRUE; } /* Must be called with mux->lock held */ static GstFlowReturn gst_base_ts_mux_create_stream (GstBaseTsMux * mux, GstBaseTsMuxPad * ts_pad, GstCaps * caps) { GstFlowReturn ret; ret = gst_base_ts_mux_create_or_update_stream (mux, ts_pad, caps); if (ret == GST_FLOW_OK) { tsmux_program_add_stream (ts_pad->prog, ts_pad->stream); } return ret; } static guint16 get_pmt_pcr_pid (GstBaseTsMux * mux, const gchar * prop_name) { if (mux->prog_map == NULL) return 0; gint pcr_pid = 0; if (!gst_structure_get (mux->prog_map, prop_name, G_TYPE_INT, &pcr_pid, NULL)) return 0; if (pcr_pid < 1 || pcr_pid > G_MAXUINT16) return 0; return (guint16) pcr_pid; } static gchar * get_pmt_pcr_sink (GstBaseTsMux * mux, const gchar * prop_name) { if (mux->prog_map == NULL) return 0; gchar *pcr_sink = NULL; if (!gst_structure_get (mux->prog_map, prop_name, G_TYPE_STRING, &pcr_sink, NULL)) { return NULL; } return pcr_sink; } /* Must be called with mux->lock held */ static GstFlowReturn gst_base_ts_mux_create_pad_stream (GstBaseTsMux * mux, GstPad * pad, gboolean allow_no_caps) { GstBaseTsMuxPad *ts_pad = GST_BASE_TS_MUX_PAD (pad); gchar *name = NULL; gchar *prop_name; GstFlowReturn ret = GST_FLOW_OK; GstCaps *caps = gst_pad_get_current_caps (pad); if (caps == NULL) { GST_DEBUG_OBJECT (ts_pad, "Sink pad caps were not set yet"); /* Try again later once the first buffer is pushed */ if (allow_no_caps) return GST_FLOW_OK; return GST_FLOW_NOT_NEGOTIATED; } if (ts_pad->prog_id == -1) { name = GST_PAD_NAME (pad); if (mux->prog_map != NULL && gst_structure_has_field (mux->prog_map, name)) { gint idx; gboolean ret = gst_structure_get_int (mux->prog_map, name, &idx); if (!ret) { GST_ELEMENT_ERROR (mux, STREAM, MUX, ("Reading program map failed. Assuming default"), (NULL)); idx = DEFAULT_PROG_ID; } if (idx < 0) { GST_DEBUG_OBJECT (mux, "Program number %d associate with pad %s less " "than zero; DEFAULT_PROGRAM = %d is used instead", idx, name, DEFAULT_PROG_ID); idx = DEFAULT_PROG_ID; } ts_pad->prog_id = idx; } else { ts_pad->prog_id = DEFAULT_PROG_ID; } } ts_pad->prog = (TsMuxProgram *) g_hash_table_lookup (mux->programs, GINT_TO_POINTER (ts_pad->prog_id)); if (ts_pad->prog == NULL) { ts_pad->prog = tsmux_program_new (mux->tsmux, ts_pad->prog_id); if (ts_pad->prog == NULL) goto no_program; tsmux_set_pmt_interval (ts_pad->prog, mux->pmt_interval); tsmux_program_set_scte35_pid (ts_pad->prog, mux->scte35_pid); tsmux_program_set_scte35_interval (ts_pad->prog, mux->scte35_null_interval); g_hash_table_insert (mux->programs, GINT_TO_POINTER (ts_pad->prog_id), ts_pad->prog); /* Check for user-specified PMT PID */ prop_name = g_strdup_printf ("PMT_%d", ts_pad->prog->pgm_number); if (mux->prog_map && gst_structure_has_field (mux->prog_map, prop_name)) { guint pmt_pid; if (gst_structure_get_uint (mux->prog_map, prop_name, &pmt_pid)) { if (is_valid_pmt_pid (pmt_pid)) { GST_DEBUG_OBJECT (mux, "User specified pid=%u as PMT for " "program (prog_id = %d)", pmt_pid, ts_pad->prog->pgm_number); tsmux_program_set_pmt_pid (ts_pad->prog, pmt_pid); } else { GST_ELEMENT_WARNING (mux, LIBRARY, SETTINGS, ("User specified PMT pid %u for program %d is not valid.", pmt_pid, ts_pad->prog->pgm_number), (NULL)); } } } g_free (prop_name); } if (ts_pad->stream == NULL) { ret = gst_base_ts_mux_create_stream (mux, ts_pad, caps); if (ret != GST_FLOW_OK) goto no_stream; } ts_pad->stream->program = ts_pad->prog; if (ts_pad->prog->pcr_stream == NULL) { /* Take the first stream of the program for the PCR */ GST_DEBUG_OBJECT (ts_pad, "Use stream (pid=%d) from pad as PCR for program (prog_id = %d)", ts_pad->pid, ts_pad->prog_id); tsmux_program_set_pcr_stream (ts_pad->prog, ts_pad->stream); } /* Check for user-specified PCR PID */ prop_name = g_strdup_printf ("PCR_%d", ts_pad->prog->pgm_number); guint16 pcr_pid = get_pmt_pcr_pid (mux, prop_name); if (pcr_pid) { GST_DEBUG_OBJECT (mux, "User specified PID %d as PCR for " "program (prog_id = %d)", pcr_pid, ts_pad->prog->pgm_number); tsmux_program_set_pcr_pid (ts_pad->prog, pcr_pid); goto have_pcr_pid; } gchar *pcr_sink_name = get_pmt_pcr_sink (mux, prop_name); if (!g_strcmp0 (GST_PAD_NAME (pad), pcr_sink_name)) { GST_DEBUG_OBJECT (mux, "User specified stream (pid=%d) as PCR for " "program (prog_id = %d)", ts_pad->pid, ts_pad->prog->pgm_number); tsmux_program_set_pcr_stream (ts_pad->prog, ts_pad->stream); } g_clear_pointer (&pcr_sink_name, g_free); have_pcr_pid: g_clear_pointer (&prop_name, g_free); gst_clear_caps (&caps); return ret; /* ERRORS */ no_program: { GST_ELEMENT_ERROR (mux, STREAM, MUX, ("Could not create new program"), (NULL)); gst_clear_caps (&caps); return GST_FLOW_ERROR; } no_stream: { GST_ELEMENT_ERROR (mux, STREAM, MUX, ("Could not create handler for stream"), (NULL)); gst_clear_caps (&caps); return ret; } } /* Must be called with mux->lock held */ static gboolean gst_base_ts_mux_create_pad_stream_func (GstElement * element, GstPad * pad, gpointer user_data) { GstFlowReturn *ret = user_data; *ret = gst_base_ts_mux_create_pad_stream (GST_BASE_TS_MUX (element), pad, TRUE); return *ret == GST_FLOW_OK; } /* Must be called with mux->lock held */ static GstFlowReturn gst_base_ts_mux_create_streams (GstBaseTsMux * mux) { GstFlowReturn ret = GST_FLOW_OK; gst_element_foreach_sink_pad (GST_ELEMENT_CAST (mux), gst_base_ts_mux_create_pad_stream_func, &ret); return ret; } static void new_packet_common_init (GstBaseTsMux * mux, GstBuffer * buf, guint8 * data, guint len) { /* Packets should be at least 188 bytes, but check anyway */ g_assert (len >= 2 || !data); if (!mux->streamheader_sent && data) { guint pid = ((data[1] & 0x1f) << 8) | data[2]; /* if it's a PAT or a PMT */ if (pid == 0x00 || (pid >= TSMUX_START_PMT_PID && pid < TSMUX_START_ES_PID)) { GstBuffer *hbuf; if (!buf) { hbuf = gst_buffer_new_and_alloc (len); gst_buffer_fill (hbuf, 0, data, len); } else { hbuf = gst_buffer_copy (buf); } GST_LOG_OBJECT (mux, "Collecting packet with pid 0x%04x into streamheaders", pid); g_queue_push_tail (&mux->streamheader, hbuf); } else if (!g_queue_is_empty (&mux->streamheader)) { gst_base_ts_mux_set_header_on_caps (mux); mux->streamheader_sent = TRUE; } } if (buf) { if (mux->is_header) { GST_LOG_OBJECT (mux, "marking as header buffer"); GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_HEADER); } if (mux->is_delta) { GST_LOG_OBJECT (mux, "marking as delta unit"); GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DELTA_UNIT); } else { GST_DEBUG_OBJECT (mux, "marking as non-delta unit"); mux->is_delta = TRUE; } } } static GstFlowReturn gst_base_ts_mux_push_packets (GstBaseTsMux * mux, gboolean force) { GstSegment *segment = &GST_AGGREGATOR_PAD (GST_AGGREGATOR_SRC_PAD (mux))->segment; GstBufferList *buffer_list; gint align = mux->alignment; gint av, packet_size; GstFlowReturn flow_ret; GstClockTime pts; packet_size = mux->packet_size; if (align < 0) align = mux->automatic_alignment; av = gst_adapter_available (mux->out_adapter); GST_LOG_OBJECT (mux, "align %d, av %d", align, av); if (av == 0) return GST_FLOW_OK; /* no alignment, just push all available data */ if (align == 0) { buffer_list = gst_adapter_take_buffer_list (mux->out_adapter, av); flow_ret = gst_aggregator_finish_buffer_list (GST_AGGREGATOR (mux), buffer_list); pts = gst_adapter_prev_pts (mux->out_adapter, NULL); if (GST_CLOCK_TIME_IS_VALID (pts) && (!GST_CLOCK_TIME_IS_VALID (segment->position) || segment->position < pts)) segment->position = pts; return flow_ret; } align *= packet_size; if (!force && align > av) return GST_FLOW_OK; buffer_list = gst_buffer_list_new_sized ((av / align) + 1); GST_LOG_OBJECT (mux, "aligning to %d bytes", align); while (align <= av) { GstBuffer *buf; pts = gst_adapter_prev_pts (mux->out_adapter, NULL); buf = gst_adapter_take_buffer (mux->out_adapter, align); GST_BUFFER_PTS (buf) = pts; gst_buffer_list_add (buffer_list, buf); av -= align; } if (av > 0 && force) { GstBuffer *buf; guint8 *data; guint32 header; gint dummy; GstMapInfo map; GST_LOG_OBJECT (mux, "handling %d leftover bytes", av); pts = gst_adapter_prev_pts (mux->out_adapter, NULL); buf = gst_buffer_new_and_alloc (align); GST_BUFFER_PTS (buf) = pts; gst_buffer_map (buf, &map, GST_MAP_READ); data = map.data; gst_adapter_copy (mux->out_adapter, data, 0, av); gst_adapter_clear (mux->out_adapter); data += av; header = GST_READ_UINT32_BE (data - packet_size); dummy = (map.size - av) / packet_size; GST_LOG_OBJECT (mux, "adding %d null packets", dummy); for (; dummy > 0; dummy--) { gint offset; if (packet_size > GST_BASE_TS_MUX_NORMAL_PACKET_LENGTH) { GST_WRITE_UINT32_BE (data, header); /* simply increase header a bit and never mind too much */ header++; offset = 4; } else { offset = 0; } GST_WRITE_UINT8 (data + offset, TSMUX_SYNC_BYTE); /* null packet PID */ GST_WRITE_UINT16_BE (data + offset + 1, 0x1FFF); /* no adaptation field exists | continuity counter undefined */ GST_WRITE_UINT8 (data + offset + 3, 0x10); /* payload */ memset (data + offset + 4, 0, GST_BASE_TS_MUX_NORMAL_PACKET_LENGTH - 4); data += packet_size; } gst_buffer_unmap (buf, &map); gst_buffer_list_add (buffer_list, buf); } flow_ret = gst_aggregator_finish_buffer_list (GST_AGGREGATOR (mux), buffer_list); pts = gst_adapter_prev_pts (mux->out_adapter, NULL); if (GST_CLOCK_TIME_IS_VALID (pts) && (!GST_CLOCK_TIME_IS_VALID (segment->position) || segment->position < pts)) segment->position = pts; return flow_ret; } static GstFlowReturn gst_base_ts_mux_collect_packet (GstBaseTsMux * mux, GstBuffer * buf) { GST_LOG_OBJECT (mux, "collecting packet size %" G_GSIZE_FORMAT, gst_buffer_get_size (buf)); gst_adapter_push (mux->out_adapter, buf); return GST_FLOW_OK; } static GstEvent * check_pending_key_unit_event (GstEvent * pending_event, GstSegment * segment, GstClockTime timestamp, guint flags, GstClockTime pending_key_unit_ts) { GstClockTime running_time, stream_time; gboolean all_headers; guint count; GstEvent *event = NULL; g_assert (segment != NULL); if (pending_event == NULL) goto out; if (GST_CLOCK_TIME_IS_VALID (pending_key_unit_ts) && timestamp == GST_CLOCK_TIME_NONE) goto out; running_time = timestamp; GST_INFO ("now %" GST_TIME_FORMAT " wanted %" GST_TIME_FORMAT, GST_TIME_ARGS (running_time), GST_TIME_ARGS (pending_key_unit_ts)); if (GST_CLOCK_TIME_IS_VALID (pending_key_unit_ts) && running_time < pending_key_unit_ts) goto out; if (flags & GST_BUFFER_FLAG_DELTA_UNIT) { GST_INFO ("pending force key unit, waiting for keyframe"); goto out; } stream_time = gst_segment_to_stream_time (segment, GST_FORMAT_TIME, timestamp); if (GST_EVENT_TYPE (pending_event) == GST_EVENT_CUSTOM_DOWNSTREAM) { gst_video_event_parse_downstream_force_key_unit (pending_event, NULL, NULL, NULL, &all_headers, &count); } else { gst_video_event_parse_upstream_force_key_unit (pending_event, NULL, &all_headers, &count); } event = gst_video_event_new_downstream_force_key_unit (timestamp, stream_time, running_time, all_headers, count); gst_event_set_seqnum (event, gst_event_get_seqnum (pending_event)); out: return event; } /* Called when the TsMux has prepared a packet for output. Return FALSE * on error */ static gboolean new_packet_cb (GstBuffer * buf, void *user_data, gint64 new_pcr) { GstBaseTsMux *mux = (GstBaseTsMux *) user_data; GstAggregator *agg = GST_AGGREGATOR (mux); GstBaseTsMuxClass *klass = GST_BASE_TS_MUX_GET_CLASS (mux); GstMapInfo map; GstSegment *agg_segment = &GST_AGGREGATOR_PAD (agg->srcpad)->segment; g_assert (klass->output_packet); gst_buffer_map (buf, &map, GST_MAP_READWRITE); if (!GST_CLOCK_TIME_IS_VALID (GST_BUFFER_PTS (buf))) { /* tsmux isn't generating timestamps. Use the input times */ GST_BUFFER_PTS (buf) = mux->last_ts; } if (GST_CLOCK_TIME_IS_VALID (GST_BUFFER_PTS (buf))) { if (!GST_CLOCK_STIME_IS_VALID (mux->output_ts_offset)) { GstClockTime output_start_time = agg_segment->position; if (agg_segment->position == -1 || agg_segment->position < agg_segment->start) { output_start_time = agg_segment->start; } mux->output_ts_offset = GST_CLOCK_DIFF (GST_BUFFER_PTS (buf), output_start_time); GST_DEBUG_OBJECT (mux, "New output ts offset %" GST_STIME_FORMAT, GST_STIME_ARGS (mux->output_ts_offset)); } GST_BUFFER_PTS (buf) += mux->output_ts_offset; agg_segment->position = GST_BUFFER_PTS (buf); } else if (agg_segment->position == -1 || agg_segment->position < agg_segment->start) { GST_BUFFER_PTS (buf) = agg_segment->start; } else { GST_BUFFER_PTS (buf) = agg_segment->position; } /* do common init (flags and streamheaders) */ new_packet_common_init (mux, buf, map.data, map.size); gst_buffer_unmap (buf, &map); return klass->output_packet (mux, buf, new_pcr); } /* called when TsMux needs new packet to write into */ static void alloc_packet_cb (GstBuffer ** buf, void *user_data) { GstBaseTsMux *mux = (GstBaseTsMux *) user_data; GstBaseTsMuxClass *klass = GST_BASE_TS_MUX_GET_CLASS (mux); g_assert (klass->allocate_packet); klass->allocate_packet (mux, buf); } static GstFlowReturn gst_base_ts_mux_aggregate_buffer (GstBaseTsMux * mux, GstAggregatorPad * agg_pad, GstBuffer * buf) { GstFlowReturn ret = GST_FLOW_OK; GstBaseTsMuxPad *best = GST_BASE_TS_MUX_PAD (agg_pad); TsMuxProgram *prog; gint64 pts = GST_CLOCK_STIME_NONE; gint64 dts = GST_CLOCK_STIME_NONE; gboolean delta = TRUE, header = FALSE; StreamData *stream_data; GstMpegtsSection *scte_section = NULL; GST_DEBUG_OBJECT (mux, "Pads collected"); if (buf && gst_buffer_get_size (buf) == 0 && GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_GAP)) { gst_buffer_unref (buf); return GST_FLOW_OK; } g_mutex_lock (&mux->lock); if (G_UNLIKELY (mux->first)) { ret = gst_base_ts_mux_create_streams (mux); if (G_UNLIKELY (ret != GST_FLOW_OK)) { if (buf) gst_buffer_unref (buf); g_mutex_unlock (&mux->lock); return ret; } mux->first = FALSE; } prog = best->prog; if (prog == NULL) { GList *cur; ret = gst_base_ts_mux_create_pad_stream (mux, GST_PAD (best), FALSE); if (G_UNLIKELY (ret != GST_FLOW_OK)) { if (buf) gst_buffer_unref (buf); g_mutex_unlock (&mux->lock); return ret; } tsmux_resend_pat (mux->tsmux); tsmux_resend_si (mux->tsmux); prog = best->prog; g_assert_nonnull (prog); /* output PMT for each program */ for (cur = mux->tsmux->programs; cur; cur = cur->next) { TsMuxProgram *program = (TsMuxProgram *) cur->data; tsmux_resend_pmt (program); } } g_assert (buf != NULL); if (best->prepare_func) { GstBuffer *tmp; tmp = best->prepare_func (buf, best, mux); g_assert (tmp); gst_buffer_unref (buf); buf = tmp; } if (mux->force_key_unit_event != NULL && best->stream->gst_stream_type == GST_STREAM_TYPE_VIDEO) { GstEvent *event; g_mutex_unlock (&mux->lock); event = check_pending_key_unit_event (mux->force_key_unit_event, &agg_pad->segment, GST_BUFFER_PTS (buf), GST_BUFFER_FLAGS (buf), mux->pending_key_unit_ts); if (event) { GstClockTime running_time; guint count; GList *cur; mux->pending_key_unit_ts = GST_CLOCK_TIME_NONE; gst_event_replace (&mux->force_key_unit_event, NULL); gst_video_event_parse_downstream_force_key_unit (event, NULL, NULL, &running_time, NULL, &count); GST_INFO_OBJECT (mux, "pushing downstream force-key-unit event %d " "%" GST_TIME_FORMAT " count %d", gst_event_get_seqnum (event), GST_TIME_ARGS (running_time), count); gst_aggregator_push_src_event (GST_AGGREGATOR (mux), event); g_mutex_lock (&mux->lock); /* output PAT, SI tables */ tsmux_resend_pat (mux->tsmux); tsmux_resend_si (mux->tsmux); /* output PMT for each program */ for (cur = mux->tsmux->programs; cur; cur = cur->next) { TsMuxProgram *program = (TsMuxProgram *) cur->data; tsmux_resend_pmt (program); } } else { g_mutex_lock (&mux->lock); } } if (!prog->pcr_pid && G_UNLIKELY (prog->pcr_stream == NULL)) { /* Take the first data stream for the PCR */ GST_DEBUG_OBJECT (best, "Use stream (pid=%d) from pad as PCR for program (prog_id = %d)", best->pid, best->prog_id); /* Set the chosen PCR stream */ tsmux_program_set_pcr_stream (prog, best->stream); } GST_DEBUG_OBJECT (best, "Chose stream for output (PID: 0x%04x)", best->pid); GST_OBJECT_LOCK (mux); scte_section = mux->pending_scte35_section; mux->pending_scte35_section = NULL; GST_OBJECT_UNLOCK (mux); if (G_UNLIKELY (scte_section)) { GST_DEBUG_OBJECT (mux, "Sending pending SCTE section"); if (!tsmux_send_section (mux->tsmux, scte_section)) GST_ERROR_OBJECT (mux, "Error sending SCTE section !"); } if (GST_CLOCK_TIME_IS_VALID (GST_BUFFER_PTS (buf))) { pts = GSTTIME_TO_MPEGTIME (GST_BUFFER_PTS (buf)); GST_DEBUG_OBJECT (mux, "Buffer has PTS %" GST_TIME_FORMAT " pts %" G_GINT64_FORMAT "%s", GST_TIME_ARGS (GST_BUFFER_PTS (buf)), pts, !GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_DELTA_UNIT) ? " (keyframe)" : ""); } if (GST_CLOCK_STIME_IS_VALID (best->dts)) { dts = GSTTIME_TO_MPEGTIME (best->dts); GST_DEBUG_OBJECT (mux, "Buffer has DTS %" GST_STIME_FORMAT " dts %" G_GINT64_FORMAT, GST_STIME_ARGS (best->dts), dts); } /* should not have a DTS without PTS */ if (!GST_CLOCK_STIME_IS_VALID (pts) && GST_CLOCK_STIME_IS_VALID (dts)) { GST_DEBUG_OBJECT (mux, "using DTS for unknown PTS"); pts = dts; } if (best->stream->gst_stream_type == GST_STREAM_TYPE_VIDEO) { delta = GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_DELTA_UNIT); header = GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_HEADER); } if (best->stream->internal_stream_type == TSMUX_ST_PS_KLV && gst_buffer_get_size (buf) > (G_MAXUINT16 - 3)) { GST_WARNING_OBJECT (mux, "KLV meta unit too big, splitting not supported"); gst_buffer_unref (buf); g_mutex_unlock (&mux->lock); return GST_FLOW_OK; } GST_DEBUG_OBJECT (mux, "delta: %d", delta); if (gst_buffer_get_size (buf) > 0) { stream_data = stream_data_new (buf); tsmux_stream_add_data (best->stream, stream_data->map_info.data, stream_data->map_info.size, stream_data, pts, dts, !delta); } /* outgoing ts follows ts of PCR program stream */ if (prog->pcr_stream == best->stream) { /* prefer DTS if present for PCR as it should be monotone */ mux->last_ts = GST_CLOCK_TIME_IS_VALID (GST_BUFFER_DTS (buf)) ? GST_BUFFER_DTS (buf) : GST_BUFFER_PTS (buf); } mux->is_delta = delta; mux->is_header = header; while (tsmux_stream_bytes_in_buffer (best->stream) > 0) { if (!tsmux_write_stream_packet (mux->tsmux, best->stream)) { /* Failed writing data for some reason. Set appropriate error */ GST_DEBUG_OBJECT (mux, "Failed to write data packet"); GST_ELEMENT_ERROR (mux, STREAM, MUX, ("Failed writing output data to stream %04x", best->stream->id), (NULL)); goto write_fail; } } g_mutex_unlock (&mux->lock); /* flush packet cache */ return gst_base_ts_mux_push_packets (mux, FALSE); /* ERRORS */ write_fail: { return mux->last_flow_ret; } } /* GstElement implementation */ static gboolean gst_base_ts_mux_has_pad_with_pid (GstBaseTsMux * mux, guint16 pid) { GList *l; gboolean res = FALSE; GST_OBJECT_LOCK (mux); for (l = GST_ELEMENT_CAST (mux)->sinkpads; l; l = l->next) { GstBaseTsMuxPad *tpad = GST_BASE_TS_MUX_PAD (l->data); if (tpad->pid == pid) { res = TRUE; break; } } GST_OBJECT_UNLOCK (mux); return res; } static GstPad * gst_base_ts_mux_request_new_pad (GstElement * element, GstPadTemplate * templ, const gchar * name, const GstCaps * caps) { GstBaseTsMux *mux = GST_BASE_TS_MUX (element); gint pid = -1; GstPad *pad = NULL; gchar *free_name = NULL; g_mutex_lock (&mux->lock); if (name != NULL && sscanf (name, "sink_%d", &pid) == 1) { if (tsmux_find_stream (mux->tsmux, pid)) { g_mutex_unlock (&mux->lock); goto stream_exists; } /* Make sure we don't use reserved PID. * FIXME : This should be extended to other variants (ex: ATSC) reserved PID */ if (pid < TSMUX_START_ES_PID) goto invalid_stream_pid; } else { do { pid = tsmux_get_new_pid (mux->tsmux); } while (gst_base_ts_mux_has_pad_with_pid (mux, pid)); /* Name the pad correctly after the selected pid */ name = free_name = g_strdup_printf ("sink_%d", pid); } g_mutex_unlock (&mux->lock); pad = (GstPad *) GST_ELEMENT_CLASS (parent_class)->request_new_pad (element, templ, name, caps); gst_base_ts_mux_pad_reset (GST_BASE_TS_MUX_PAD (pad)); GST_BASE_TS_MUX_PAD (pad)->pid = pid; g_free (free_name); return pad; /* ERRORS */ stream_exists: { GST_ELEMENT_ERROR (element, STREAM, MUX, ("Duplicate PID requested"), (NULL)); return NULL; } invalid_stream_pid: { GST_ELEMENT_ERROR (element, STREAM, MUX, ("Invalid Elementary stream PID (0x%02u < 0x40)", pid), (NULL)); return NULL; } } static void gst_base_ts_mux_release_pad (GstElement * element, GstPad * pad) { GstBaseTsMux *mux = GST_BASE_TS_MUX (element); g_mutex_lock (&mux->lock); if (mux->tsmux) { GList *cur; GstBaseTsMuxPad *ts_pad = GST_BASE_TS_MUX_PAD (pad); gint pid = ts_pad->pid; if (ts_pad->prog) { if (ts_pad->prog->pcr_stream == ts_pad->stream) { tsmux_program_set_pcr_stream (ts_pad->prog, NULL); } if (tsmux_remove_stream (mux->tsmux, pid, ts_pad->prog)) { g_hash_table_remove (mux->programs, GINT_TO_POINTER (ts_pad->prog_id)); } } tsmux_resend_pat (mux->tsmux); tsmux_resend_si (mux->tsmux); /* output PMT for each program */ for (cur = mux->tsmux->programs; cur; cur = cur->next) { TsMuxProgram *program = (TsMuxProgram *) cur->data; tsmux_resend_pmt (program); } } g_mutex_unlock (&mux->lock); GST_ELEMENT_CLASS (parent_class)->release_pad (element, pad); } /* GstAggregator implementation */ static void request_keyframe (GstBaseTsMux * mux, GstClockTime running_time) { GList *l; GST_OBJECT_LOCK (mux); for (l = GST_ELEMENT_CAST (mux)->sinkpads; l; l = l->next) { gst_pad_push_event (GST_PAD (l->data), gst_video_event_new_upstream_force_key_unit (running_time, TRUE, 0)); } GST_OBJECT_UNLOCK (mux); } static const guint32 crc_tab[256] = { 0x00000000, 0x04c11db7, 0x09823b6e, 0x0d4326d9, 0x130476dc, 0x17c56b6b, 0x1a864db2, 0x1e475005, 0x2608edb8, 0x22c9f00f, 0x2f8ad6d6, 0x2b4bcb61, 0x350c9b64, 0x31cd86d3, 0x3c8ea00a, 0x384fbdbd, 0x4c11db70, 0x48d0c6c7, 0x4593e01e, 0x4152fda9, 0x5f15adac, 0x5bd4b01b, 0x569796c2, 0x52568b75, 0x6a1936c8, 0x6ed82b7f, 0x639b0da6, 0x675a1011, 0x791d4014, 0x7ddc5da3, 0x709f7b7a, 0x745e66cd, 0x9823b6e0, 0x9ce2ab57, 0x91a18d8e, 0x95609039, 0x8b27c03c, 0x8fe6dd8b, 0x82a5fb52, 0x8664e6e5, 0xbe2b5b58, 0xbaea46ef, 0xb7a96036, 0xb3687d81, 0xad2f2d84, 0xa9ee3033, 0xa4ad16ea, 0xa06c0b5d, 0xd4326d90, 0xd0f37027, 0xddb056fe, 0xd9714b49, 0xc7361b4c, 0xc3f706fb, 0xceb42022, 0xca753d95, 0xf23a8028, 0xf6fb9d9f, 0xfbb8bb46, 0xff79a6f1, 0xe13ef6f4, 0xe5ffeb43, 0xe8bccd9a, 0xec7dd02d, 0x34867077, 0x30476dc0, 0x3d044b19, 0x39c556ae, 0x278206ab, 0x23431b1c, 0x2e003dc5, 0x2ac12072, 0x128e9dcf, 0x164f8078, 0x1b0ca6a1, 0x1fcdbb16, 0x018aeb13, 0x054bf6a4, 0x0808d07d, 0x0cc9cdca, 0x7897ab07, 0x7c56b6b0, 0x71159069, 0x75d48dde, 0x6b93dddb, 0x6f52c06c, 0x6211e6b5, 0x66d0fb02, 0x5e9f46bf, 0x5a5e5b08, 0x571d7dd1, 0x53dc6066, 0x4d9b3063, 0x495a2dd4, 0x44190b0d, 0x40d816ba, 0xaca5c697, 0xa864db20, 0xa527fdf9, 0xa1e6e04e, 0xbfa1b04b, 0xbb60adfc, 0xb6238b25, 0xb2e29692, 0x8aad2b2f, 0x8e6c3698, 0x832f1041, 0x87ee0df6, 0x99a95df3, 0x9d684044, 0x902b669d, 0x94ea7b2a, 0xe0b41de7, 0xe4750050, 0xe9362689, 0xedf73b3e, 0xf3b06b3b, 0xf771768c, 0xfa325055, 0xfef34de2, 0xc6bcf05f, 0xc27dede8, 0xcf3ecb31, 0xcbffd686, 0xd5b88683, 0xd1799b34, 0xdc3abded, 0xd8fba05a, 0x690ce0ee, 0x6dcdfd59, 0x608edb80, 0x644fc637, 0x7a089632, 0x7ec98b85, 0x738aad5c, 0x774bb0eb, 0x4f040d56, 0x4bc510e1, 0x46863638, 0x42472b8f, 0x5c007b8a, 0x58c1663d, 0x558240e4, 0x51435d53, 0x251d3b9e, 0x21dc2629, 0x2c9f00f0, 0x285e1d47, 0x36194d42, 0x32d850f5, 0x3f9b762c, 0x3b5a6b9b, 0x0315d626, 0x07d4cb91, 0x0a97ed48, 0x0e56f0ff, 0x1011a0fa, 0x14d0bd4d, 0x19939b94, 0x1d528623, 0xf12f560e, 0xf5ee4bb9, 0xf8ad6d60, 0xfc6c70d7, 0xe22b20d2, 0xe6ea3d65, 0xeba91bbc, 0xef68060b, 0xd727bbb6, 0xd3e6a601, 0xdea580d8, 0xda649d6f, 0xc423cd6a, 0xc0e2d0dd, 0xcda1f604, 0xc960ebb3, 0xbd3e8d7e, 0xb9ff90c9, 0xb4bcb610, 0xb07daba7, 0xae3afba2, 0xaafbe615, 0xa7b8c0cc, 0xa379dd7b, 0x9b3660c6, 0x9ff77d71, 0x92b45ba8, 0x9675461f, 0x8832161a, 0x8cf30bad, 0x81b02d74, 0x857130c3, 0x5d8a9099, 0x594b8d2e, 0x5408abf7, 0x50c9b640, 0x4e8ee645, 0x4a4ffbf2, 0x470cdd2b, 0x43cdc09c, 0x7b827d21, 0x7f436096, 0x7200464f, 0x76c15bf8, 0x68860bfd, 0x6c47164a, 0x61043093, 0x65c52d24, 0x119b4be9, 0x155a565e, 0x18197087, 0x1cd86d30, 0x029f3d35, 0x065e2082, 0x0b1d065b, 0x0fdc1bec, 0x3793a651, 0x3352bbe6, 0x3e119d3f, 0x3ad08088, 0x2497d08d, 0x2056cd3a, 0x2d15ebe3, 0x29d4f654, 0xc5a92679, 0xc1683bce, 0xcc2b1d17, 0xc8ea00a0, 0xd6ad50a5, 0xd26c4d12, 0xdf2f6bcb, 0xdbee767c, 0xe3a1cbc1, 0xe760d676, 0xea23f0af, 0xeee2ed18, 0xf0a5bd1d, 0xf464a0aa, 0xf9278673, 0xfde69bc4, 0x89b8fd09, 0x8d79e0be, 0x803ac667, 0x84fbdbd0, 0x9abc8bd5, 0x9e7d9662, 0x933eb0bb, 0x97ffad0c, 0xafb010b1, 0xab710d06, 0xa6322bdf, 0xa2f33668, 0xbcb4666d, 0xb8757bda, 0xb5365d03, 0xb1f740b4 }; static guint32 _calc_crc32 (const guint8 * data, guint datalen) { gint i; guint32 crc = 0xffffffff; for (i = 0; i < datalen; i++) { crc = (crc << 8) ^ crc_tab[((crc >> 24) ^ *data++) & 0xff]; } return crc; } #define MPEGTIME_TO_GSTTIME(t) ((t) * (guint64)100000 / 9) static GstMpegtsSCTESpliceEvent * copy_splice (GstMpegtsSCTESpliceEvent * splice) { return g_boxed_copy (GST_TYPE_MPEGTS_SCTE_SPLICE_EVENT, splice); } static void free_splice (GstMpegtsSCTESpliceEvent * splice) { g_boxed_free (GST_TYPE_MPEGTS_SCTE_SPLICE_EVENT, splice); } /* FIXME: get rid of this when depending on glib >= 2.62 */ static GPtrArray * _g_ptr_array_copy (GPtrArray * array, GCopyFunc func, GFreeFunc free_func, gpointer user_data) { GPtrArray *new_array; g_return_val_if_fail (array != NULL, NULL); new_array = g_ptr_array_new_with_free_func (free_func); g_ptr_array_set_size (new_array, array->len); if (func != NULL) { guint i; for (i = 0; i < array->len; i++) new_array->pdata[i] = func (array->pdata[i], user_data); } else if (array->len > 0) { memcpy (new_array->pdata, array->pdata, array->len * sizeof (*array->pdata)); } new_array->len = array->len; return new_array; } static GstMpegtsSCTESIT * deep_copy_sit (const GstMpegtsSCTESIT * sit) { GstMpegtsSCTESIT *sit_copy = g_boxed_copy (GST_TYPE_MPEGTS_SCTE_SIT, sit); GPtrArray *splices_copy = _g_ptr_array_copy (sit_copy->splices, (GCopyFunc) copy_splice, (GFreeFunc) free_splice, NULL); g_ptr_array_unref (sit_copy->splices); sit_copy->splices = splices_copy; return sit_copy; } /* Takes ownership of @section. * * This function is a bit complex because the SCTE sections can * have various origins: * * * Sections created by the application with the gst_mpegts_scte_*_new() * API. The splice times / durations contained by these are expressed * in the GStreamer running time domain, and must be translated to * our local PES time domain. In this case, we will packetize the section * ourselves. * * * Sections passed through from tsdemux: this case is complicated as * splice times in the incoming stream may be encrypted, with pts_adjustment * being the only timing field guaranteed *not* to be encrypted. In this * case, the original binary data (section->data) will be reinjected as is * in the output stream, with pts_adjustment adjusted. tsdemux provides us * with the pts_offset it introduces, the difference between the original * PES PTSs and the running times it outputs. * * Additionally, in either of these cases when the splice times aren't encrypted * we want to make use of those to request keyframes. For the passthrough case, * as the splice times are left untouched tsdemux provides us with the running * times the section originally referred to. We cannot calculate it locally * because we would need to have access to the information that the timestamps * in the original PES domain have wrapped around, and how many times they have * done so. While we could probably make educated guesses, tsdemux (more specifically * mpegtspacketizer) already keeps track of that, and it seemed more logical to * perform the calculation there and forward it alongside the downstream events. * * Finally, while we can't request keyframes at splice points in the encrypted * case, if the input stream was compliant in that regard and no reencoding took * place the splice times will still match with valid splice points, it is up * to the application to ensure that that is the case. */ static void handle_scte35_section (GstBaseTsMux * mux, GstEvent * event, GstMpegtsSection * section, guint64 mpeg_pts_offset, GstStructure * rtime_map) { GstMpegtsSCTESIT *sit; guint i; gboolean forward = TRUE; guint64 pts_adjust; guint8 *section_data; guint8 *crc; gboolean translate = FALSE; sit = (GstMpegtsSCTESIT *) gst_mpegts_section_get_scte_sit (section); /* When the application injects manually constructed splice events, * their time domain is the GStreamer running time, we receive them * unpacketized and translate the fields in the SIT to local PTS. * * We make a copy of the SIT in order to make sure we can rewrite it. */ if (sit->is_running_time) { sit = deep_copy_sit (sit); translate = TRUE; } switch (sit->splice_command_type) { case GST_MTS_SCTE_SPLICE_COMMAND_NULL: /* We implement heartbeating ourselves */ forward = FALSE; break; case GST_MTS_SCTE_SPLICE_COMMAND_SCHEDULE: /* No need to request keyframes at this point, splice_insert * messages will precede the future splice points and we * can request keyframes then. Only translate if needed. */ if (translate) { for (i = 0; i < sit->splices->len; i++) { GstMpegtsSCTESpliceEvent *sevent = g_ptr_array_index (sit->splices, i); if (sevent->program_splice_time_specified) sevent->program_splice_time = GSTTIME_TO_MPEGTIME (sevent->program_splice_time) + TS_MUX_CLOCK_BASE; if (sevent->duration_flag) sevent->break_duration = GSTTIME_TO_MPEGTIME (sevent->break_duration); } } break; case GST_MTS_SCTE_SPLICE_COMMAND_INSERT: /* We want keyframes at splice points */ if (sit->fully_parsed && (rtime_map || translate)) { for (i = 0; i < sit->splices->len; i++) { guint64 running_time = GST_CLOCK_TIME_NONE; GstMpegtsSCTESpliceEvent *sevent = g_ptr_array_index (sit->splices, i); if (sevent->program_splice_time_specified) { if (rtime_map) { gchar *field_name = g_strdup_printf ("event-%u-splice-time", sevent->splice_event_id); if (gst_structure_get_uint64 (rtime_map, field_name, &running_time)) { GST_DEBUG_OBJECT (mux, "Requesting keyframe for splice point at %" GST_TIME_FORMAT, GST_TIME_ARGS (running_time)); request_keyframe (mux, running_time); } g_free (field_name); } else { g_assert (translate == TRUE); running_time = sevent->program_splice_time; GST_DEBUG_OBJECT (mux, "Requesting keyframe for splice point at %" GST_TIME_FORMAT, GST_TIME_ARGS (running_time)); request_keyframe (mux, running_time); sevent->program_splice_time = GSTTIME_TO_MPEGTIME (running_time) + TS_MUX_CLOCK_BASE; } } else { GST_DEBUG_OBJECT (mux, "Requesting keyframe for immediate splice point"); request_keyframe (mux, GST_CLOCK_TIME_NONE); } if (sevent->duration_flag) { if (translate) { sevent->break_duration = GSTTIME_TO_MPEGTIME (sevent->break_duration); } /* Even if auto_return is FALSE, when a break_duration is specified it * is intended as a redundancy mechanism in case the follow-up * splice insert goes missing. * * Schedule a keyframe at that point (if we can calculate its position * accurately). */ if (GST_CLOCK_TIME_IS_VALID (running_time)) { running_time += MPEGTIME_TO_GSTTIME (sevent->break_duration); GST_DEBUG_OBJECT (mux, "Requesting keyframe for end of break at %" GST_TIME_FORMAT, GST_TIME_ARGS (running_time)); request_keyframe (mux, running_time); } } } } break; case GST_MTS_SCTE_SPLICE_COMMAND_TIME:{ /* Adjust timestamps and potentially request keyframes */ gboolean do_request_keyframes = FALSE; /* TODO: we can probably be a little more fine-tuned about determining * whether a keyframe is actually needed, but this at least takes care * of the requirement in 10.3.4 that a keyframe should not be created * when the signal contains only a time_descriptor. */ if (sit->fully_parsed && (rtime_map || translate)) { for (i = 0; i < sit->descriptors->len; i++) { GstMpegtsDescriptor *descriptor = g_ptr_array_index (sit->descriptors, i); switch (descriptor->tag) { case GST_MTS_SCTE_DESC_AVAIL: case GST_MTS_SCTE_DESC_DTMF: case GST_MTS_SCTE_DESC_SEGMENTATION: do_request_keyframes = TRUE; break; case GST_MTS_SCTE_DESC_TIME: case GST_MTS_SCTE_DESC_AUDIO: break; } if (do_request_keyframes) break; } if (sit->splice_time_specified) { GstClockTime running_time = GST_CLOCK_TIME_NONE; if (rtime_map) { if (do_request_keyframes && gst_structure_get_uint64 (rtime_map, "splice-time", &running_time)) { GST_DEBUG_OBJECT (mux, "Requesting keyframe for time signal at %" GST_TIME_FORMAT, GST_TIME_ARGS (running_time)); request_keyframe (mux, running_time); } } else { g_assert (translate); running_time = sit->splice_time; sit->splice_time = GSTTIME_TO_MPEGTIME (running_time) + TS_MUX_CLOCK_BASE; if (do_request_keyframes) { GST_DEBUG_OBJECT (mux, "Requesting keyframe for time signal at %" GST_TIME_FORMAT, GST_TIME_ARGS (running_time)); request_keyframe (mux, running_time); } } } else if (do_request_keyframes) { GST_DEBUG_OBJECT (mux, "Requesting keyframe for immediate time signal"); request_keyframe (mux, GST_CLOCK_TIME_NONE); } } break; } case GST_MTS_SCTE_SPLICE_COMMAND_BANDWIDTH: case GST_MTS_SCTE_SPLICE_COMMAND_PRIVATE: /* Just let those go through untouched, none of our business */ break; default: break; } if (!forward) { gst_mpegts_section_unref (section); return; } if (!translate) { g_assert (section->data); /* Calculate the final adjustment, as a sum of: * - The adjustment in the original packet * - The offset introduced between the original local PTS * and the GStreamer PTS output by tsdemux * - Our own 1-hour offset */ pts_adjust = sit->pts_adjustment + mpeg_pts_offset + TS_MUX_CLOCK_BASE; /* Account for offsets potentially introduced between the demuxer and us */ pts_adjust += GSTTIME_TO_MPEGTIME (gst_event_get_running_time_offset (event)); pts_adjust &= 0x1ffffffff; section_data = g_memdup2 (section->data, section->section_length); section_data[4] |= pts_adjust >> 32; section_data[5] = pts_adjust >> 24; section_data[6] = pts_adjust >> 16; section_data[7] = pts_adjust >> 8; section_data[8] = pts_adjust; /* Now rewrite our checksum */ crc = section_data + section->section_length - 4; GST_WRITE_UINT32_BE (crc, _calc_crc32 (section_data, crc - section_data)); GST_OBJECT_LOCK (mux); GST_DEBUG_OBJECT (mux, "Storing SCTE section"); if (mux->pending_scte35_section) gst_mpegts_section_unref (mux->pending_scte35_section); mux->pending_scte35_section = gst_mpegts_section_new (mux->scte35_pid, section_data, section->section_length); GST_OBJECT_UNLOCK (mux); gst_mpegts_section_unref (section); } else { GST_OBJECT_LOCK (mux); GST_DEBUG_OBJECT (mux, "Storing SCTE section"); gst_mpegts_section_unref (section); if (mux->pending_scte35_section) gst_mpegts_section_unref (mux->pending_scte35_section); mux->pending_scte35_section = gst_mpegts_section_from_scte_sit (sit, mux->scte35_pid);; GST_OBJECT_UNLOCK (mux); } } static gboolean gst_base_ts_mux_send_event (GstElement * element, GstEvent * event) { GstMpegtsSection *section; GstBaseTsMux *mux = GST_BASE_TS_MUX (element); section = gst_event_parse_mpegts_section (event); if (section) { GST_DEBUG ("Received event with mpegts section"); if (section->section_type == GST_MPEGTS_SECTION_SCTE_SIT) { handle_scte35_section (mux, event, section, 0, NULL); } else { g_mutex_lock (&mux->lock); /* TODO: Check that the section type is supported */ tsmux_add_mpegts_si_section (mux->tsmux, section); g_mutex_unlock (&mux->lock); } gst_event_unref (event); return TRUE; } return GST_ELEMENT_CLASS (parent_class)->send_event (element, event); } /* Must be called with mux->lock held */ static void gst_base_ts_mux_resend_all_pmts (GstBaseTsMux * mux) { GList *cur; /* output PMT for each program */ for (cur = mux->tsmux->programs; cur; cur = cur->next) { TsMuxProgram *program = (TsMuxProgram *) cur->data; program->pmt_changed = TRUE; tsmux_resend_pmt (program); } } /* GstAggregator implementation */ static gboolean gst_base_ts_mux_sink_event (GstAggregator * agg, GstAggregatorPad * agg_pad, GstEvent * event) { GstAggregatorClass *agg_class = GST_AGGREGATOR_CLASS (parent_class); GstBaseTsMux *mux = GST_BASE_TS_MUX (agg); GstBaseTsMuxPad *ts_pad = GST_BASE_TS_MUX_PAD (agg_pad); gboolean res = FALSE; gboolean forward = TRUE; switch (GST_EVENT_TYPE (event)) { case GST_EVENT_CAPS: { GstCaps *caps; GstFlowReturn ret; g_mutex_lock (&mux->lock); if (ts_pad->stream == NULL) { g_mutex_unlock (&mux->lock); break; } forward = FALSE; gst_event_parse_caps (event, &caps); if (!caps || !gst_caps_is_fixed (caps)) { g_mutex_unlock (&mux->lock); break; } ret = gst_base_ts_mux_create_or_update_stream (mux, ts_pad, caps); if (ret != GST_FLOW_OK) { g_mutex_unlock (&mux->lock); break; } mux->tsmux->pat_changed = TRUE; mux->tsmux->si_changed = TRUE; tsmux_resend_pat (mux->tsmux); tsmux_resend_si (mux->tsmux); gst_base_ts_mux_resend_all_pmts (mux); g_mutex_unlock (&mux->lock); res = TRUE; break; } case GST_EVENT_CUSTOM_DOWNSTREAM: { GstClockTime timestamp, stream_time, running_time; gboolean all_headers; guint count; const GstStructure *s; s = gst_event_get_structure (event); if (gst_structure_has_name (s, "scte-sit") && mux->scte35_pid != 0) { /* When operating downstream of tsdemux, tsdemux will send out events * on all its source pads for each splice table it encounters. If we * are remuxing multiple streams it has demuxed, this means we could * unnecessarily repeat the same table multiple times, we avoid that * by deduplicating thanks to the event sequm */ if (gst_event_get_seqnum (event) != mux->last_scte35_event_seqnum) { GstMpegtsSection *section; gst_structure_get (s, "section", GST_TYPE_MPEGTS_SECTION, §ion, NULL); if (section) { guint64 mpeg_pts_offset = 0; GstStructure *rtime_map = NULL; gst_structure_get (s, "running-time-map", GST_TYPE_STRUCTURE, &rtime_map, NULL); gst_structure_get_uint64 (s, "mpeg-pts-offset", &mpeg_pts_offset); handle_scte35_section (mux, event, section, mpeg_pts_offset, rtime_map); if (rtime_map) gst_structure_free (rtime_map); mux->last_scte35_event_seqnum = gst_event_get_seqnum (event); } else { GST_WARNING_OBJECT (ts_pad, "Ignoring scte-sit event without a section"); } } else { GST_DEBUG_OBJECT (ts_pad, "Ignoring duplicate scte-sit event"); } res = TRUE; forward = FALSE; goto out; } if (!gst_video_event_is_force_key_unit (event)) goto out; res = TRUE; forward = FALSE; gst_video_event_parse_downstream_force_key_unit (event, ×tamp, &stream_time, &running_time, &all_headers, &count); GST_INFO_OBJECT (ts_pad, "have downstream force-key-unit event, " "seqnum %d, running-time %" GST_TIME_FORMAT " count %d", gst_event_get_seqnum (event), GST_TIME_ARGS (running_time), count); if (mux->force_key_unit_event != NULL) { GST_INFO_OBJECT (mux, "skipping downstream force key unit event " "as an upstream force key unit is already queued"); goto out; } if (!all_headers) goto out; mux->pending_key_unit_ts = running_time; gst_event_replace (&mux->force_key_unit_event, event); break; } case GST_EVENT_TAG:{ GstTagList *list; gchar *lang = NULL; guint bitrate = 0; guint max_bitrate = 0; GST_DEBUG_OBJECT (mux, "received tag event"); gst_event_parse_tag (event, &list); /* MPEG wants ISO 639-2T code, taglist most likely contains 639-1 */ if (gst_tag_list_get_string (list, GST_TAG_LANGUAGE_CODE, &lang)) { const gchar *lang_code; lang_code = gst_tag_get_language_code_iso_639_2T (lang); if (lang_code) { g_mutex_lock (&mux->lock); if (g_strcmp0 (ts_pad->language, lang_code) != 0) { GST_DEBUG_OBJECT (ts_pad, "Setting language to '%s'", lang_code); g_free (ts_pad->language); ts_pad->language = g_strdup (lang_code); if (ts_pad->stream) { strncpy (ts_pad->stream->language, lang_code, 3); ts_pad->stream->language[3] = 0; gst_base_ts_mux_resend_all_pmts (mux); } } g_mutex_unlock (&mux->lock); } else { GST_WARNING_OBJECT (ts_pad, "Did not get language code for '%s'", lang); } g_free (lang); } if (gst_tag_list_get_uint (list, GST_TAG_BITRATE, &bitrate)) { ts_pad->bitrate = bitrate; } if (gst_tag_list_get_uint (list, GST_TAG_MAXIMUM_BITRATE, &max_bitrate)) { ts_pad->max_bitrate = bitrate; } /* handled this, don't want collectpads to forward it downstream */ res = TRUE; forward = gst_tag_list_get_scope (list) == GST_TAG_SCOPE_GLOBAL; break; } case GST_EVENT_STREAM_START:{ GstStreamFlags flags; gst_event_parse_stream_flags (event, &flags); /* Don't wait for data on sparse inputs like metadata streams */ /* if ((flags & GST_STREAM_FLAG_SPARSE)) { GST_COLLECT_PADS_STATE_UNSET (data, GST_COLLECT_PADS_STATE_LOCKED); gst_collect_pads_set_waiting (pads, data, FALSE); GST_COLLECT_PADS_STATE_SET (data, GST_COLLECT_PADS_STATE_LOCKED); } */ break; } default: break; } out: if (!forward) gst_event_unref (event); else res = agg_class->sink_event (agg, agg_pad, event); return res; } static gboolean gst_base_ts_mux_src_event (GstAggregator * agg, GstEvent * event) { GstAggregatorClass *agg_class = GST_AGGREGATOR_CLASS (parent_class); GstBaseTsMux *mux = GST_BASE_TS_MUX (agg); gboolean res = TRUE, forward = TRUE; switch (GST_EVENT_TYPE (event)) { case GST_EVENT_CUSTOM_UPSTREAM: { GstIterator *iter; GValue sinkpad_value = G_VALUE_INIT; GstClockTime running_time; gboolean all_headers, done = FALSE; guint count; if (!gst_video_event_is_force_key_unit (event)) break; forward = FALSE; gst_video_event_parse_upstream_force_key_unit (event, &running_time, &all_headers, &count); GST_INFO_OBJECT (mux, "received upstream force-key-unit event, " "seqnum %d running_time %" GST_TIME_FORMAT " all_headers %d count %d", gst_event_get_seqnum (event), GST_TIME_ARGS (running_time), all_headers, count); if (!all_headers) break; mux->pending_key_unit_ts = running_time; gst_event_replace (&mux->force_key_unit_event, event); iter = gst_element_iterate_sink_pads (GST_ELEMENT_CAST (mux)); while (!done) { switch (gst_iterator_next (iter, &sinkpad_value)) { case GST_ITERATOR_OK:{ GstPad *sinkpad = g_value_get_object (&sinkpad_value); gboolean tmp; GST_INFO_OBJECT (GST_AGGREGATOR_SRC_PAD (agg), "forwarding"); tmp = gst_pad_push_event (sinkpad, gst_event_ref (event)); GST_INFO_OBJECT (mux, "result %d", tmp); /* succeed if at least one pad succeeds */ res |= tmp; break; } case GST_ITERATOR_DONE: done = TRUE; break; case GST_ITERATOR_RESYNC: gst_iterator_resync (iter); break; case GST_ITERATOR_ERROR: g_assert_not_reached (); break; } g_value_reset (&sinkpad_value); } g_value_unset (&sinkpad_value); gst_iterator_free (iter); break; } default: break; } if (forward) res = agg_class->src_event (agg, event); else gst_event_unref (event); return res; } static GstBuffer * gst_base_ts_mux_clip (GstAggregator * agg, GstAggregatorPad * agg_pad, GstBuffer * buf) { GstBaseTsMuxPad *pad = GST_BASE_TS_MUX_PAD (agg_pad); GstClockTime time; GstBuffer *ret; ret = buf; /* PTS */ time = GST_BUFFER_PTS (buf); /* invalid left alone and passed */ if (G_LIKELY (GST_CLOCK_TIME_IS_VALID (time))) { time = gst_segment_to_running_time (&agg_pad->segment, GST_FORMAT_TIME, time); if (G_UNLIKELY (!GST_CLOCK_TIME_IS_VALID (time))) { GST_DEBUG_OBJECT (pad, "clipping buffer on pad outside segment"); gst_buffer_unref (buf); ret = NULL; goto beach; } else { GST_LOG_OBJECT (pad, "buffer pts %" GST_TIME_FORMAT " -> %" GST_TIME_FORMAT " running time", GST_TIME_ARGS (GST_BUFFER_PTS (buf)), GST_TIME_ARGS (time)); buf = ret = gst_buffer_make_writable (buf); GST_BUFFER_PTS (ret) = time; } } /* DTS */ time = GST_BUFFER_DTS (buf); /* invalid left alone and passed */ if (G_LIKELY (GST_CLOCK_TIME_IS_VALID (time))) { gint sign; gint64 dts; sign = gst_segment_to_running_time_full (&agg_pad->segment, GST_FORMAT_TIME, time, &time); if (sign > 0) dts = (gint64) time; else dts = -((gint64) time); GST_LOG_OBJECT (pad, "buffer dts %" GST_TIME_FORMAT " -> %" GST_STIME_FORMAT " running time", GST_TIME_ARGS (GST_BUFFER_DTS (buf)), GST_STIME_ARGS (dts)); if (GST_CLOCK_STIME_IS_VALID (pad->dts) && dts < pad->dts) { /* Ignore DTS going backward */ GST_WARNING_OBJECT (pad, "ignoring DTS going backward"); dts = pad->dts; } ret = gst_buffer_make_writable (buf); if (sign > 0) GST_BUFFER_DTS (ret) = time; else GST_BUFFER_DTS (ret) = GST_CLOCK_TIME_NONE; pad->dts = dts; } else { pad->dts = GST_CLOCK_STIME_NONE; } beach: return ret; } static GstBaseTsMuxPad * gst_base_ts_mux_find_best_pad (GstAggregator * aggregator, gboolean timeout) { GstBaseTsMuxPad *best = NULL; GstClockTime best_ts = GST_CLOCK_TIME_NONE; GList *l; GST_OBJECT_LOCK (aggregator); for (l = GST_ELEMENT_CAST (aggregator)->sinkpads; l; l = l->next) { GstBaseTsMuxPad *tpad = GST_BASE_TS_MUX_PAD (l->data); GstAggregatorPad *apad = GST_AGGREGATOR_PAD_CAST (tpad); GstBuffer *buffer; buffer = gst_aggregator_pad_peek_buffer (apad); if (!buffer) { if (!timeout && !GST_PAD_IS_EOS (apad)) { best = NULL; best_ts = GST_CLOCK_TIME_NONE; break; } continue; } if (best_ts == GST_CLOCK_TIME_NONE) { best = tpad; best_ts = GST_BUFFER_DTS_OR_PTS (buffer); } else if (GST_BUFFER_DTS_OR_PTS (buffer) != GST_CLOCK_TIME_NONE) { GstClockTime t = GST_BUFFER_DTS_OR_PTS (buffer); if (t < best_ts) { best = tpad; best_ts = t; } } gst_buffer_unref (buffer); } if (best) gst_object_ref (best); GST_OBJECT_UNLOCK (aggregator); GST_DEBUG_OBJECT (aggregator, "Best pad found with %" GST_TIME_FORMAT ": %" GST_PTR_FORMAT, GST_TIME_ARGS (best_ts), best); return best; } static gboolean gst_base_ts_mux_are_all_pads_eos (GstBaseTsMux * mux) { GList *l; gboolean ret = TRUE; GST_OBJECT_LOCK (mux); for (l = GST_ELEMENT_CAST (mux)->sinkpads; l; l = l->next) { GstBaseTsMuxPad *pad = GST_BASE_TS_MUX_PAD (l->data); if (!gst_aggregator_pad_is_eos (GST_AGGREGATOR_PAD (pad))) { ret = FALSE; break; } } GST_OBJECT_UNLOCK (mux); return ret; } static GstFlowReturn gst_base_ts_mux_aggregate (GstAggregator * agg, gboolean timeout) { GstBaseTsMux *mux = GST_BASE_TS_MUX (agg); GstFlowReturn ret = GST_FLOW_OK; GstBaseTsMuxPad *best = gst_base_ts_mux_find_best_pad (agg, timeout); GstCaps *caps; /* set caps on the srcpad if no caps were set yet */ if (!(caps = gst_pad_get_current_caps (agg->srcpad))) { GstStructure *structure; caps = gst_pad_get_pad_template_caps (GST_AGGREGATOR_SRC_PAD (mux)); caps = gst_caps_make_writable (caps); structure = gst_caps_get_structure (caps, 0); gst_structure_set (structure, "packetsize", G_TYPE_INT, mux->packet_size, NULL); gst_aggregator_set_src_caps (GST_AGGREGATOR (mux), caps); } gst_caps_unref (caps); if (best) { GstBuffer *buffer; buffer = gst_aggregator_pad_pop_buffer (GST_AGGREGATOR_PAD (best)); if (!buffer) { /* We might have gotten a flush event after we picked the pad */ goto done; } ret = gst_base_ts_mux_aggregate_buffer (GST_BASE_TS_MUX (agg), GST_AGGREGATOR_PAD (best), buffer); gst_object_unref (best); if (ret != GST_FLOW_OK) goto done; } if (gst_base_ts_mux_are_all_pads_eos (mux)) { GstBaseTsMuxClass *klass = GST_BASE_TS_MUX_GET_CLASS (mux); /* drain some possibly cached data */ if (klass->drain) klass->drain (mux); gst_base_ts_mux_push_packets (mux, TRUE); ret = GST_FLOW_EOS; } done: return ret; } static gboolean gst_base_ts_mux_start (GstAggregator * agg) { GstBaseTsMux *mux = GST_BASE_TS_MUX (agg); g_mutex_lock (&mux->lock); gst_base_ts_mux_reset (mux, TRUE); g_mutex_unlock (&mux->lock); return TRUE; } static gboolean gst_base_ts_mux_stop (GstAggregator * agg) { GstBaseTsMux *mux = GST_BASE_TS_MUX (agg); g_mutex_lock (&mux->lock); gst_base_ts_mux_reset (GST_BASE_TS_MUX (agg), TRUE); g_mutex_unlock (&mux->lock); return TRUE; } /* GObject implementation */ static void gst_base_ts_mux_dispose (GObject * object) { GstBaseTsMux *mux = GST_BASE_TS_MUX (object); g_mutex_lock (&mux->lock); gst_base_ts_mux_reset (mux, FALSE); if (mux->out_adapter) { g_object_unref (mux->out_adapter); mux->out_adapter = NULL; } if (mux->prog_map) { gst_structure_free (mux->prog_map); mux->prog_map = NULL; } if (mux->programs) { g_hash_table_destroy (mux->programs); mux->programs = NULL; } g_mutex_unlock (&mux->lock); GST_CALL_PARENT (G_OBJECT_CLASS, dispose, (object)); } static void gst_base_ts_mux_finalize (GObject * object) { GstBaseTsMux *mux = GST_BASE_TS_MUX (object); g_mutex_clear (&mux->lock); GST_CALL_PARENT (G_OBJECT_CLASS, finalize, (object)); } static void gst_base_ts_mux_constructed (GObject * object) { GstBaseTsMux *mux = GST_BASE_TS_MUX (object); /* initial state */ g_mutex_lock (&mux->lock); gst_base_ts_mux_reset (mux, TRUE); g_mutex_unlock (&mux->lock); } static void gst_base_ts_mux_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstBaseTsMux *mux = GST_BASE_TS_MUX (object); GList *l; switch (prop_id) { case PROP_PROG_MAP: { const GstStructure *s = gst_value_get_structure (value); if (mux->prog_map) { gst_structure_free (mux->prog_map); } if (s) mux->prog_map = gst_structure_copy (s); else mux->prog_map = NULL; break; } case PROP_PAT_INTERVAL: mux->pat_interval = g_value_get_uint (value); g_mutex_lock (&mux->lock); if (mux->tsmux) tsmux_set_pat_interval (mux->tsmux, mux->pat_interval); g_mutex_unlock (&mux->lock); break; case PROP_PMT_INTERVAL: mux->pmt_interval = g_value_get_uint (value); GST_OBJECT_LOCK (mux); for (l = GST_ELEMENT_CAST (mux)->sinkpads; l; l = l->next) { GstBaseTsMuxPad *ts_pad = GST_BASE_TS_MUX_PAD (l->data); g_mutex_lock (&mux->lock); tsmux_set_pmt_interval (ts_pad->prog, mux->pmt_interval); g_mutex_unlock (&mux->lock); } GST_OBJECT_UNLOCK (mux); break; case PROP_ALIGNMENT: mux->alignment = g_value_get_int (value); break; case PROP_SI_INTERVAL: mux->si_interval = g_value_get_uint (value); g_mutex_lock (&mux->lock); tsmux_set_si_interval (mux->tsmux, mux->si_interval); g_mutex_unlock (&mux->lock); break; case PROP_BITRATE: mux->bitrate = g_value_get_uint64 (value); g_mutex_lock (&mux->lock); if (mux->tsmux) tsmux_set_bitrate (mux->tsmux, mux->bitrate); g_mutex_unlock (&mux->lock); break; case PROP_PCR_INTERVAL: mux->pcr_interval = g_value_get_uint (value); g_mutex_lock (&mux->lock); if (mux->tsmux) tsmux_set_pcr_interval (mux->tsmux, mux->pcr_interval); g_mutex_unlock (&mux->lock); break; case PROP_SCTE_35_PID: mux->scte35_pid = g_value_get_uint (value); break; case PROP_SCTE_35_NULL_INTERVAL: mux->scte35_null_interval = g_value_get_uint (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } static void gst_base_ts_mux_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) { GstBaseTsMux *mux = GST_BASE_TS_MUX (object); switch (prop_id) { case PROP_PROG_MAP: gst_value_set_structure (value, mux->prog_map); break; case PROP_PAT_INTERVAL: g_value_set_uint (value, mux->pat_interval); break; case PROP_PMT_INTERVAL: g_value_set_uint (value, mux->pmt_interval); break; case PROP_ALIGNMENT: g_value_set_int (value, mux->alignment); break; case PROP_SI_INTERVAL: g_value_set_uint (value, mux->si_interval); break; case PROP_BITRATE: g_value_set_uint64 (value, mux->bitrate); break; case PROP_PCR_INTERVAL: g_value_set_uint (value, mux->pcr_interval); break; case PROP_SCTE_35_PID: g_value_set_uint (value, mux->scte35_pid); break; case PROP_SCTE_35_NULL_INTERVAL: g_value_set_uint (value, mux->scte35_null_interval); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } /* Default vmethods implementation */ static TsMux * gst_base_ts_mux_default_create_ts_mux (GstBaseTsMux * mux) { TsMux *tsmux = tsmux_new (); tsmux_set_write_func (tsmux, new_packet_cb, mux); tsmux_set_alloc_func (tsmux, alloc_packet_cb, mux); tsmux_set_pat_interval (tsmux, mux->pat_interval); tsmux_set_si_interval (tsmux, mux->si_interval); tsmux_set_bitrate (tsmux, mux->bitrate); tsmux_set_pcr_interval (tsmux, mux->pcr_interval); return tsmux; } static void gst_base_ts_mux_default_allocate_packet (GstBaseTsMux * mux, GstBuffer ** buffer) { GstBuffer *buf; buf = gst_buffer_new_and_alloc (mux->packet_size); *buffer = buf; } static gboolean gst_base_ts_mux_default_output_packet (GstBaseTsMux * mux, GstBuffer * buffer, gint64 new_pcr) { gst_base_ts_mux_collect_packet (mux, buffer); return TRUE; } /* Subclass API */ void gst_base_ts_mux_set_packet_size (GstBaseTsMux * mux, gsize size) { mux->packet_size = size; } void gst_base_ts_mux_set_automatic_alignment (GstBaseTsMux * mux, gsize alignment) { mux->automatic_alignment = alignment; } static void gst_base_ts_mux_class_init (GstBaseTsMuxClass * klass) { GstElementClass *gstelement_class = GST_ELEMENT_CLASS (klass); GstAggregatorClass *gstagg_class = GST_AGGREGATOR_CLASS (klass); GObjectClass *gobject_class = G_OBJECT_CLASS (klass); GST_DEBUG_CATEGORY_INIT (gst_base_ts_mux_debug, "basetsmux", 0, "MPEG Transport Stream muxer"); gst_element_class_set_static_metadata (gstelement_class, "MPEG Transport Stream Muxer", "Codec/Muxer", "Multiplexes media streams into an MPEG Transport Stream", "Fluendo "); gobject_class->set_property = GST_DEBUG_FUNCPTR (gst_base_ts_mux_set_property); gobject_class->get_property = GST_DEBUG_FUNCPTR (gst_base_ts_mux_get_property); gobject_class->dispose = gst_base_ts_mux_dispose; gobject_class->finalize = gst_base_ts_mux_finalize; gobject_class->constructed = gst_base_ts_mux_constructed; gstelement_class->request_new_pad = gst_base_ts_mux_request_new_pad; gstelement_class->release_pad = gst_base_ts_mux_release_pad; gstelement_class->send_event = gst_base_ts_mux_send_event; gstagg_class->negotiate = NULL; gstagg_class->aggregate = gst_base_ts_mux_aggregate; gstagg_class->clip = gst_base_ts_mux_clip; gstagg_class->sink_event = gst_base_ts_mux_sink_event; gstagg_class->src_event = gst_base_ts_mux_src_event; gstagg_class->start = gst_base_ts_mux_start; gstagg_class->stop = gst_base_ts_mux_stop; gstagg_class->get_next_time = gst_aggregator_simple_get_next_time; klass->create_ts_mux = gst_base_ts_mux_default_create_ts_mux; klass->allocate_packet = gst_base_ts_mux_default_allocate_packet; klass->output_packet = gst_base_ts_mux_default_output_packet; g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_PROG_MAP, g_param_spec_boxed ("prog-map", "Program map", "A GstStructure specifies the mapping from elementary streams to programs", GST_TYPE_STRUCTURE, (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS))); g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_PAT_INTERVAL, g_param_spec_uint ("pat-interval", "PAT interval", "Set the interval (in ticks of the 90kHz clock) for writing out the PAT table", 1, G_MAXUINT, TSMUX_DEFAULT_PAT_INTERVAL, (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS))); g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_PMT_INTERVAL, g_param_spec_uint ("pmt-interval", "PMT interval", "Set the interval (in ticks of the 90kHz clock) for writing out the PMT table", 1, G_MAXUINT, TSMUX_DEFAULT_PMT_INTERVAL, (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS))); g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_ALIGNMENT, g_param_spec_int ("alignment", "packet alignment", "Number of packets per buffer (padded with dummy packets on EOS) " "(-1 = auto, 0 = all available packets, 7 for UDP streaming)", -1, G_MAXINT, BASETSMUX_DEFAULT_ALIGNMENT, (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS))); g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_SI_INTERVAL, g_param_spec_uint ("si-interval", "SI interval", "Set the interval (in ticks of the 90kHz clock) for writing out the Service" "Information tables", 1, G_MAXUINT, TSMUX_DEFAULT_SI_INTERVAL, (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS))); g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_BITRATE, g_param_spec_uint64 ("bitrate", "Bitrate (in bits per second)", "Set the target bitrate, will insert null packets as padding " " to achieve multiplex-wide constant bitrate (0 means no padding)", 0, G_MAXUINT64, TSMUX_DEFAULT_BITRATE, (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS))); g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_PCR_INTERVAL, g_param_spec_uint ("pcr-interval", "PCR interval", "Set the interval (in ticks of the 90kHz clock) for writing PCR", 1, G_MAXUINT, TSMUX_DEFAULT_PCR_INTERVAL, (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS))); g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_SCTE_35_PID, g_param_spec_uint ("scte-35-pid", "SCTE-35 PID", "PID to use for inserting SCTE-35 packets (0: unused)", 0, G_MAXUINT, DEFAULT_SCTE_35_PID, (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS))); g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_SCTE_35_NULL_INTERVAL, g_param_spec_uint ("scte-35-null-interval", "SCTE-35 NULL packet interval", "Set the interval (in ticks of the 90kHz clock) for writing SCTE-35 NULL (heartbeat) packets. 0=disable" " (only valid if scte-35-pid is different from 0)", 0, G_MAXUINT, TSMUX_DEFAULT_SCTE_35_NULL_INTERVAL, (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS))); gst_element_class_add_static_pad_template_with_gtype (gstelement_class, &gst_base_ts_mux_src_factory, GST_TYPE_AGGREGATOR_PAD); gst_type_mark_as_plugin_api (GST_TYPE_BASE_TS_MUX_PAD, 0); } static void gst_base_ts_mux_init (GstBaseTsMux * mux) { mux->out_adapter = gst_adapter_new (); /* properties */ mux->pat_interval = TSMUX_DEFAULT_PAT_INTERVAL; mux->pmt_interval = TSMUX_DEFAULT_PMT_INTERVAL; mux->si_interval = TSMUX_DEFAULT_SI_INTERVAL; mux->pcr_interval = TSMUX_DEFAULT_PCR_INTERVAL; mux->prog_map = NULL; mux->alignment = BASETSMUX_DEFAULT_ALIGNMENT; mux->bitrate = TSMUX_DEFAULT_BITRATE; mux->scte35_pid = DEFAULT_SCTE_35_PID; mux->scte35_null_interval = TSMUX_DEFAULT_SCTE_35_NULL_INTERVAL; mux->packet_size = GST_BASE_TS_MUX_NORMAL_PACKET_LENGTH; mux->automatic_alignment = 0; g_mutex_init (&mux->lock); }