/* GStreamer * Copyright (C) 2004 Wim Taymans * Copyright (C) 2006 Tim-Philipp Müller * Copyright (C) 2008 Sebastian Dröge * Copyright (C) 2011-2012 Vincent Penquerc'h * * 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. */ /* * Based on the speexdec element. */ /** * SECTION:element-opusdec * @see_also: opusenc, oggdemux * * This element decodes a OPUS stream to raw integer audio. * * * Example pipelines * |[ * gst-launch-1.0 -v filesrc location=opus.ogg ! oggdemux ! opusdec ! audioconvert ! audioresample ! alsasink * ]| Decode an Ogg/Opus file. To create an Ogg/Opus file refer to the documentation of opusenc. * */ #ifdef HAVE_CONFIG_H #include "config.h" #endif #include #include #include #include "gstopusheader.h" #include "gstopuscommon.h" #include "gstopusdec.h" #include GST_DEBUG_CATEGORY_STATIC (opusdec_debug); #define GST_CAT_DEFAULT opusdec_debug static GstStaticPadTemplate opus_dec_src_factory = GST_STATIC_PAD_TEMPLATE ("src", GST_PAD_SRC, GST_PAD_ALWAYS, GST_STATIC_CAPS ("audio/x-raw, " "format = (string) " GST_AUDIO_NE (S16) ", " "layout = (string) interleaved, " "rate = (int) { 48000, 24000, 16000, 12000, 8000 }, " "channels = (int) [ 1, 8 ] ") ); static GstStaticPadTemplate opus_dec_sink_factory = GST_STATIC_PAD_TEMPLATE ("sink", GST_PAD_SINK, GST_PAD_ALWAYS, GST_STATIC_CAPS ("audio/x-opus, " "channel-mapping-family = (int) 0; " "audio/x-opus, " "channel-mapping-family = (int) [1, 255], " "channels = (int) [1, 255], " "stream-count = (int) [1, 255], " "coupled-count = (int) [0, 255]") ); G_DEFINE_TYPE (GstOpusDec, gst_opus_dec, GST_TYPE_AUDIO_DECODER); #define DB_TO_LINEAR(x) pow (10., (x) / 20.) #define DEFAULT_USE_INBAND_FEC FALSE #define DEFAULT_APPLY_GAIN TRUE enum { PROP_0, PROP_USE_INBAND_FEC, PROP_APPLY_GAIN }; static GstFlowReturn gst_opus_dec_parse_header (GstOpusDec * dec, GstBuffer * buf); static gboolean gst_opus_dec_start (GstAudioDecoder * dec); static gboolean gst_opus_dec_stop (GstAudioDecoder * dec); static GstFlowReturn gst_opus_dec_handle_frame (GstAudioDecoder * dec, GstBuffer * buffer); static gboolean gst_opus_dec_set_format (GstAudioDecoder * bdec, GstCaps * caps); static void gst_opus_dec_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec); static void gst_opus_dec_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec); static GstCaps *gst_opus_dec_getcaps (GstAudioDecoder * dec, GstCaps * filter); static void gst_opus_dec_class_init (GstOpusDecClass * klass) { GObjectClass *gobject_class; GstAudioDecoderClass *adclass; GstElementClass *element_class; gobject_class = (GObjectClass *) klass; adclass = (GstAudioDecoderClass *) klass; element_class = (GstElementClass *) klass; gobject_class->set_property = gst_opus_dec_set_property; gobject_class->get_property = gst_opus_dec_get_property; adclass->start = GST_DEBUG_FUNCPTR (gst_opus_dec_start); adclass->stop = GST_DEBUG_FUNCPTR (gst_opus_dec_stop); adclass->handle_frame = GST_DEBUG_FUNCPTR (gst_opus_dec_handle_frame); adclass->set_format = GST_DEBUG_FUNCPTR (gst_opus_dec_set_format); adclass->getcaps = GST_DEBUG_FUNCPTR (gst_opus_dec_getcaps); gst_element_class_add_pad_template (element_class, gst_static_pad_template_get (&opus_dec_src_factory)); gst_element_class_add_pad_template (element_class, gst_static_pad_template_get (&opus_dec_sink_factory)); gst_element_class_set_static_metadata (element_class, "Opus audio decoder", "Codec/Decoder/Audio", "decode opus streams to audio", "Vincent Penquerc'h "); g_object_class_install_property (gobject_class, PROP_USE_INBAND_FEC, g_param_spec_boolean ("use-inband-fec", "Use in-band FEC", "Use forward error correction if available (needs PLC enabled)", DEFAULT_USE_INBAND_FEC, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_APPLY_GAIN, g_param_spec_boolean ("apply-gain", "Apply gain", "Apply gain if any is specified in the header", DEFAULT_APPLY_GAIN, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); GST_DEBUG_CATEGORY_INIT (opusdec_debug, "opusdec", 0, "opus decoding element"); } static void gst_opus_dec_reset (GstOpusDec * dec) { dec->packetno = 0; if (dec->state) { opus_multistream_decoder_destroy (dec->state); dec->state = NULL; } gst_buffer_replace (&dec->streamheader, NULL); gst_buffer_replace (&dec->vorbiscomment, NULL); gst_buffer_replace (&dec->last_buffer, NULL); dec->primed = FALSE; dec->pre_skip = 0; dec->r128_gain = 0; dec->sample_rate = 0; dec->n_channels = 0; dec->leftover_plc_duration = 0; } static void gst_opus_dec_init (GstOpusDec * dec) { dec->use_inband_fec = FALSE; dec->apply_gain = DEFAULT_APPLY_GAIN; gst_audio_decoder_set_needs_format (GST_AUDIO_DECODER (dec), TRUE); gst_audio_decoder_set_use_default_pad_acceptcaps (GST_AUDIO_DECODER_CAST (dec), TRUE); GST_PAD_SET_ACCEPT_TEMPLATE (GST_AUDIO_DECODER_SINK_PAD (dec)); gst_opus_dec_reset (dec); } static gboolean gst_opus_dec_start (GstAudioDecoder * dec) { GstOpusDec *odec = GST_OPUS_DEC (dec); gst_opus_dec_reset (odec); /* we know about concealment */ gst_audio_decoder_set_plc_aware (dec, TRUE); if (odec->use_inband_fec) { /* opusdec outputs samples directly from an input buffer, except if * FEC is on, in which case it buffers one buffer in case one buffer * goes missing. */ gst_audio_decoder_set_latency (dec, 120 * GST_MSECOND, 120 * GST_MSECOND); } return TRUE; } static gboolean gst_opus_dec_stop (GstAudioDecoder * dec) { GstOpusDec *odec = GST_OPUS_DEC (dec); gst_opus_dec_reset (odec); return TRUE; } static double gst_opus_dec_get_r128_gain (gint16 r128_gain) { return r128_gain / (double) (1 << 8); } static double gst_opus_dec_get_r128_volume (gint16 r128_gain) { return DB_TO_LINEAR (gst_opus_dec_get_r128_gain (r128_gain)); } static gboolean gst_opus_dec_negotiate (GstOpusDec * dec, const GstAudioChannelPosition * pos) { GstCaps *caps = gst_pad_get_allowed_caps (GST_AUDIO_DECODER_SRC_PAD (dec)); GstStructure *s; GstAudioInfo info; if (caps) { gint rate = dec->sample_rate, channels = dec->n_channels; GstCaps *constraint, *inter; constraint = gst_caps_from_string ("audio/x-raw"); if (dec->sample_rate == 0 || dec->sample_rate == 48000) { gst_caps_set_simple (constraint, "rate", G_TYPE_INT, 48000, NULL); } else { GValue v = { 0 } , l = { 0}; g_value_init (&l, GST_TYPE_LIST); g_value_init (&v, G_TYPE_INT); g_value_set_int (&v, dec->sample_rate); gst_value_list_append_value (&l, &v); g_value_set_int (&v, 48000); gst_value_list_append_value (&l, &v); gst_caps_set_value (constraint, "rate", &l); g_value_unset (&v); g_value_unset (&l); } if (dec->n_channels <= 2) { /* including 0 */ gst_caps_set_simple (constraint, "channels", GST_TYPE_INT_RANGE, 1, 2, NULL); } else { gst_caps_set_simple (constraint, "channels", G_TYPE_INT, dec->n_channels, NULL); } inter = gst_caps_intersect (caps, constraint); gst_caps_unref (constraint); if (gst_caps_is_empty (inter)) { GST_DEBUG_OBJECT (dec, "Empty intersection, failed to negotiate"); gst_caps_unref (inter); return FALSE; } inter = gst_caps_truncate (inter); s = gst_caps_get_structure (inter, 0); rate = dec->sample_rate > 0 ? dec->sample_rate : 48000; gst_structure_fixate_field_nearest_int (s, "rate", dec->sample_rate); gst_structure_get_int (s, "rate", &rate); channels = dec->n_channels > 0 ? dec->n_channels : 2; gst_structure_fixate_field_nearest_int (s, "channels", dec->n_channels); gst_structure_get_int (s, "channels", &channels); gst_caps_unref (inter); dec->sample_rate = rate; dec->n_channels = channels; } if (dec->n_channels == 0) { GST_DEBUG_OBJECT (dec, "Using a default of 2 channels"); dec->n_channels = 2; pos = NULL; } if (dec->sample_rate == 0) { GST_DEBUG_OBJECT (dec, "Using a default of 48kHz sample rate"); dec->sample_rate = 48000; } GST_INFO_OBJECT (dec, "Negotiated %d channels, %d Hz", dec->n_channels, dec->sample_rate); /* pass valid order to audio info */ if (pos) { memcpy (dec->opus_pos, pos, sizeof (pos[0]) * dec->n_channels); gst_audio_channel_positions_to_valid_order (dec->opus_pos, dec->n_channels); } /* set up source format */ gst_audio_info_init (&info); gst_audio_info_set_format (&info, GST_AUDIO_FORMAT_S16, dec->sample_rate, dec->n_channels, pos ? dec->opus_pos : NULL); gst_audio_decoder_set_output_format (GST_AUDIO_DECODER (dec), &info); /* but we still need the opus order for later reordering */ if (pos) { memcpy (dec->opus_pos, pos, sizeof (pos[0]) * dec->n_channels); } else { dec->opus_pos[0] = GST_AUDIO_CHANNEL_POSITION_INVALID; } dec->info = info; return TRUE; } static GstFlowReturn gst_opus_dec_parse_header (GstOpusDec * dec, GstBuffer * buf) { GstAudioChannelPosition pos[64]; const GstAudioChannelPosition *posn = NULL; if (!gst_opus_header_is_id_header (buf)) { GST_ERROR_OBJECT (dec, "Header is not an Opus ID header"); return GST_FLOW_ERROR; } if (!gst_codec_utils_opus_parse_header (buf, &dec->sample_rate, &dec->n_channels, &dec->channel_mapping_family, &dec->n_streams, &dec->n_stereo_streams, dec->channel_mapping, &dec->pre_skip, &dec->r128_gain)) { GST_ERROR_OBJECT (dec, "Failed to parse Opus ID header"); return GST_FLOW_ERROR; } dec->r128_gain_volume = gst_opus_dec_get_r128_volume (dec->r128_gain); GST_INFO_OBJECT (dec, "Found pre-skip of %u samples, R128 gain %d (volume %f)", dec->pre_skip, dec->r128_gain, dec->r128_gain_volume); if (dec->channel_mapping_family == 1) { GST_INFO_OBJECT (dec, "Channel mapping family 1, Vorbis mapping"); switch (dec->n_channels) { case 1: case 2: /* nothing */ break; case 3: case 4: case 5: case 6: case 7: case 8: posn = gst_opus_channel_positions[dec->n_channels - 1]; break; default:{ gint i; GST_ELEMENT_WARNING (GST_ELEMENT (dec), STREAM, DECODE, (NULL), ("Using NONE channel layout for more than 8 channels")); for (i = 0; i < dec->n_channels; i++) pos[i] = GST_AUDIO_CHANNEL_POSITION_NONE; posn = pos; } } } else { GST_INFO_OBJECT (dec, "Channel mapping family %d", dec->channel_mapping_family); } if (!gst_opus_dec_negotiate (dec, posn)) return GST_FLOW_NOT_NEGOTIATED; return GST_FLOW_OK; } static GstFlowReturn gst_opus_dec_parse_comments (GstOpusDec * dec, GstBuffer * buf) { return GST_FLOW_OK; } static GstFlowReturn opus_dec_chain_parse_data (GstOpusDec * dec, GstBuffer * buffer) { GstFlowReturn res = GST_FLOW_OK; gsize size; guint8 *data; GstBuffer *outbuf, *bufd; gint16 *out_data; int n, err; int samples; unsigned int packet_size; GstBuffer *buf; GstMapInfo map, omap; GstAudioClippingMeta *cmeta = NULL; if (dec->state == NULL) { /* If we did not get any headers, default to 2 channels */ if (dec->n_channels == 0) { GST_INFO_OBJECT (dec, "No header, assuming single stream"); dec->n_channels = 2; dec->sample_rate = 48000; /* default stereo mapping */ dec->channel_mapping_family = 0; dec->channel_mapping[0] = 0; dec->channel_mapping[1] = 1; dec->n_streams = 1; dec->n_stereo_streams = 1; if (!gst_opus_dec_negotiate (dec, NULL)) return GST_FLOW_NOT_NEGOTIATED; } if (dec->n_channels == 2 && dec->n_streams == 1 && dec->n_stereo_streams == 0) { /* if we are automatically decoding 2 channels, but only have a single encoded one, direct both channels to it */ dec->channel_mapping[1] = 0; } GST_DEBUG_OBJECT (dec, "Creating decoder with %d channels, %d Hz", dec->n_channels, dec->sample_rate); #ifndef GST_DISABLE_GST_DEBUG gst_opus_common_log_channel_mapping_table (GST_ELEMENT (dec), opusdec_debug, "Mapping table", dec->n_channels, dec->channel_mapping); #endif GST_DEBUG_OBJECT (dec, "%d streams, %d stereo", dec->n_streams, dec->n_stereo_streams); dec->state = opus_multistream_decoder_create (dec->sample_rate, dec->n_channels, dec->n_streams, dec->n_stereo_streams, dec->channel_mapping, &err); if (!dec->state || err != OPUS_OK) goto creation_failed; } if (buffer) { GST_DEBUG_OBJECT (dec, "Received buffer of size %" G_GSIZE_FORMAT, gst_buffer_get_size (buffer)); } else { GST_DEBUG_OBJECT (dec, "Received missing buffer"); } /* if using in-band FEC, we introdude one extra frame's delay as we need to potentially wait for next buffer to decode a missing buffer */ if (dec->use_inband_fec && !dec->primed) { GST_DEBUG_OBJECT (dec, "First buffer received in FEC mode, early out"); gst_buffer_replace (&dec->last_buffer, buffer); dec->primed = TRUE; goto done; } /* That's the buffer we'll be sending to the opus decoder. */ buf = (dec->use_inband_fec && gst_buffer_get_size (dec->last_buffer) > 0) ? dec->last_buffer : buffer; /* That's the buffer we get duration from */ bufd = dec->use_inband_fec ? dec->last_buffer : buffer; if (buf && gst_buffer_get_size (buf) > 0) { gst_buffer_map (buf, &map, GST_MAP_READ); data = map.data; size = map.size; GST_DEBUG_OBJECT (dec, "Using buffer of size %" G_GSIZE_FORMAT, size); } else { /* concealment data, pass NULL as the bits parameters */ GST_DEBUG_OBJECT (dec, "Using NULL buffer"); data = NULL; size = 0; } if (gst_buffer_get_size (bufd) == 0) { GstClockTime const opus_plc_alignment = 2500 * GST_USECOND; GstClockTime aligned_missing_duration; GstClockTime missing_duration = GST_BUFFER_DURATION (bufd); GST_DEBUG_OBJECT (dec, "missing buffer, doing PLC duration %" GST_TIME_FORMAT " plus leftover %" GST_TIME_FORMAT, GST_TIME_ARGS (missing_duration), GST_TIME_ARGS (dec->leftover_plc_duration)); /* add the leftover PLC duration to that of the buffer */ missing_duration += dec->leftover_plc_duration; /* align the combined buffer and leftover PLC duration to multiples * of 2.5ms, rounding to nearest, and store excess duration for later */ aligned_missing_duration = ((missing_duration + opus_plc_alignment / 2) / opus_plc_alignment) * opus_plc_alignment; dec->leftover_plc_duration = missing_duration - aligned_missing_duration; /* Opus' PLC cannot operate with less than 2.5ms; skip PLC * and accumulate the missing duration in the leftover_plc_duration * for the next PLC attempt */ if (aligned_missing_duration < opus_plc_alignment) { GST_DEBUG_OBJECT (dec, "current duration %" GST_TIME_FORMAT " of missing data not enough for PLC (minimum needed: %" GST_TIME_FORMAT ") - skipping", GST_TIME_ARGS (missing_duration), GST_TIME_ARGS (opus_plc_alignment)); goto done; } /* convert the duration (in nanoseconds) to sample count */ samples = gst_util_uint64_scale_int (aligned_missing_duration, dec->sample_rate, GST_SECOND); GST_DEBUG_OBJECT (dec, "calculated PLC frame length: %" GST_TIME_FORMAT " num frame samples: %d new leftover: %" GST_TIME_FORMAT, GST_TIME_ARGS (aligned_missing_duration), samples, GST_TIME_ARGS (dec->leftover_plc_duration)); } else { /* use maximum size (120 ms) as the number of returned samples is not constant over the stream. */ samples = 120 * dec->sample_rate / 1000; } packet_size = samples * dec->n_channels * 2; outbuf = gst_audio_decoder_allocate_output_buffer (GST_AUDIO_DECODER (dec), packet_size); if (!outbuf) { goto buffer_failed; } gst_buffer_map (outbuf, &omap, GST_MAP_WRITE); out_data = (gint16 *) omap.data; if (dec->use_inband_fec) { if (gst_buffer_get_size (dec->last_buffer) > 0) { /* normal delayed decode */ GST_LOG_OBJECT (dec, "FEC enabled, decoding last delayed buffer"); n = opus_multistream_decode (dec->state, data, size, out_data, samples, 0); } else { /* FEC reconstruction decode */ GST_LOG_OBJECT (dec, "FEC enabled, reconstructing last buffer"); n = opus_multistream_decode (dec->state, data, size, out_data, samples, 1); } } else { /* normal decode */ GST_LOG_OBJECT (dec, "FEC disabled, decoding buffer"); n = opus_multistream_decode (dec->state, data, size, out_data, samples, 0); } gst_buffer_unmap (outbuf, &omap); if (data != NULL) gst_buffer_unmap (buf, &map); if (n < 0) { GST_ELEMENT_ERROR (dec, STREAM, DECODE, ("Decoding error: %d", n), (NULL)); gst_buffer_unref (outbuf); return GST_FLOW_ERROR; } GST_DEBUG_OBJECT (dec, "decoded %d samples", n); gst_buffer_set_size (outbuf, n * 2 * dec->n_channels); cmeta = gst_buffer_get_audio_clipping_meta (buf); g_assert (!cmeta || cmeta->format == GST_FORMAT_DEFAULT); /* Skip any samples that need skipping */ if (cmeta && cmeta->start) { guint pre_skip = cmeta->start; guint scaled_pre_skip = pre_skip * dec->sample_rate / 48000; guint skip = scaled_pre_skip > n ? n : scaled_pre_skip; guint scaled_skip = skip * 48000 / dec->sample_rate; gst_buffer_resize (outbuf, skip * 2 * dec->n_channels, -1); GST_INFO_OBJECT (dec, "Skipping %u samples at the beginning (%u at 48000 Hz)", skip, scaled_skip); } if (cmeta && cmeta->end) { guint post_skip = cmeta->end; guint scaled_post_skip = post_skip * dec->sample_rate / 48000; guint skip = scaled_post_skip > n ? n : scaled_post_skip; guint scaled_skip = skip * 48000 / dec->sample_rate; guint outsize = gst_buffer_get_size (outbuf); guint skip_bytes = skip * 2 * dec->n_channels; if (outsize > skip_bytes) outsize -= skip_bytes; else outsize = 0; gst_buffer_resize (outbuf, 0, outsize); GST_INFO_OBJECT (dec, "Skipping %u samples at the end (%u at 48000 Hz)", skip, scaled_skip); } if (gst_buffer_get_size (outbuf) == 0) { gst_buffer_unref (outbuf); outbuf = NULL; } else if (dec->opus_pos[0] != GST_AUDIO_CHANNEL_POSITION_INVALID) { gst_audio_buffer_reorder_channels (outbuf, GST_AUDIO_FORMAT_S16, dec->n_channels, dec->opus_pos, dec->info.position); } /* Apply gain */ /* Would be better off leaving this to a volume element, as this is a naive conversion that does too many int/float conversions. However, we don't have control over the pipeline... So make it optional if the user program wants to use a volume, but do it by default so the correct volume goes out by default */ if (dec->apply_gain && outbuf && dec->r128_gain) { gsize rsize; unsigned int i, nsamples; double volume = dec->r128_gain_volume; gint16 *samples; gst_buffer_map (outbuf, &omap, GST_MAP_READWRITE); samples = (gint16 *) omap.data; rsize = omap.size; GST_DEBUG_OBJECT (dec, "Applying gain: volume %f", volume); nsamples = rsize / 2; for (i = 0; i < nsamples; ++i) { int sample = (int) (samples[i] * volume + 0.5); samples[i] = sample < -32768 ? -32768 : sample > 32767 ? 32767 : sample; } gst_buffer_unmap (outbuf, &omap); } if (dec->use_inband_fec) { gst_buffer_replace (&dec->last_buffer, buffer); } res = gst_audio_decoder_finish_frame (GST_AUDIO_DECODER (dec), outbuf, 1); if (res != GST_FLOW_OK) GST_DEBUG_OBJECT (dec, "flow: %s", gst_flow_get_name (res)); done: return res; creation_failed: GST_ERROR_OBJECT (dec, "Failed to create Opus decoder: %d", err); return GST_FLOW_ERROR; buffer_failed: GST_ERROR_OBJECT (dec, "Failed to create %u byte buffer", packet_size); return GST_FLOW_ERROR; } static gboolean gst_opus_dec_set_format (GstAudioDecoder * bdec, GstCaps * caps) { GstOpusDec *dec = GST_OPUS_DEC (bdec); gboolean ret = TRUE; GstStructure *s; const GValue *streamheader; GstCaps *old_caps; GST_DEBUG_OBJECT (dec, "set_format: %" GST_PTR_FORMAT, caps); if ((old_caps = gst_pad_get_current_caps (GST_AUDIO_DECODER_SINK_PAD (bdec)))) { if (gst_caps_is_equal (caps, old_caps)) { gst_caps_unref (old_caps); GST_DEBUG_OBJECT (dec, "caps didn't change"); goto done; } GST_DEBUG_OBJECT (dec, "caps have changed, resetting decoder"); gst_opus_dec_reset (dec); gst_caps_unref (old_caps); } s = gst_caps_get_structure (caps, 0); if ((streamheader = gst_structure_get_value (s, "streamheader")) && G_VALUE_HOLDS (streamheader, GST_TYPE_ARRAY) && gst_value_array_get_size (streamheader) >= 2) { const GValue *header, *vorbiscomment; GstBuffer *buf; GstFlowReturn res = GST_FLOW_OK; header = gst_value_array_get_value (streamheader, 0); if (header && G_VALUE_HOLDS (header, GST_TYPE_BUFFER)) { buf = gst_value_get_buffer (header); res = gst_opus_dec_parse_header (dec, buf); if (res != GST_FLOW_OK) { ret = FALSE; goto done; } gst_buffer_replace (&dec->streamheader, buf); } vorbiscomment = gst_value_array_get_value (streamheader, 1); if (vorbiscomment && G_VALUE_HOLDS (vorbiscomment, GST_TYPE_BUFFER)) { buf = gst_value_get_buffer (vorbiscomment); res = gst_opus_dec_parse_comments (dec, buf); if (res != GST_FLOW_OK) { ret = FALSE; goto done; } gst_buffer_replace (&dec->vorbiscomment, buf); } } else { const GstAudioChannelPosition *posn = NULL; if (!gst_codec_utils_opus_parse_caps (caps, &dec->sample_rate, &dec->n_channels, &dec->channel_mapping_family, &dec->n_streams, &dec->n_stereo_streams, dec->channel_mapping)) { ret = FALSE; goto done; } if (dec->channel_mapping_family == 1 && dec->n_channels <= 8) posn = gst_opus_channel_positions[dec->n_channels - 1]; if (!gst_opus_dec_negotiate (dec, posn)) return FALSE; } done: return ret; } static gboolean memcmp_buffers (GstBuffer * buf1, GstBuffer * buf2) { gsize size1, size2; gboolean res; GstMapInfo map; size1 = gst_buffer_get_size (buf1); size2 = gst_buffer_get_size (buf2); if (size1 != size2) return FALSE; gst_buffer_map (buf1, &map, GST_MAP_READ); res = gst_buffer_memcmp (buf2, 0, map.data, map.size) == 0; gst_buffer_unmap (buf1, &map); return res; } static GstFlowReturn gst_opus_dec_handle_frame (GstAudioDecoder * adec, GstBuffer * buf) { GstFlowReturn res; GstOpusDec *dec; /* no fancy draining */ if (G_UNLIKELY (!buf)) return GST_FLOW_OK; dec = GST_OPUS_DEC (adec); GST_LOG_OBJECT (dec, "Got buffer ts %" GST_TIME_FORMAT ", duration %" GST_TIME_FORMAT, GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf)), GST_TIME_ARGS (GST_BUFFER_DURATION (buf))); /* If we have the streamheader and vorbiscomment from the caps already * ignore them here */ if (dec->streamheader && dec->vorbiscomment) { if (memcmp_buffers (dec->streamheader, buf)) { GST_DEBUG_OBJECT (dec, "found streamheader"); gst_audio_decoder_finish_frame (adec, NULL, 1); res = GST_FLOW_OK; } else if (memcmp_buffers (dec->vorbiscomment, buf)) { GST_DEBUG_OBJECT (dec, "found vorbiscomments"); gst_audio_decoder_finish_frame (adec, NULL, 1); res = GST_FLOW_OK; } else { res = opus_dec_chain_parse_data (dec, buf); } } else { /* Otherwise fall back to packet counting and assume that the * first two packets might be the headers, checking magic. */ switch (dec->packetno) { case 0: if (gst_opus_header_is_header (buf, "OpusHead", 8)) { GST_DEBUG_OBJECT (dec, "found streamheader"); res = gst_opus_dec_parse_header (dec, buf); gst_audio_decoder_finish_frame (adec, NULL, 1); } else { res = opus_dec_chain_parse_data (dec, buf); } break; case 1: if (gst_opus_header_is_header (buf, "OpusTags", 8)) { GST_DEBUG_OBJECT (dec, "counted vorbiscomments"); res = gst_opus_dec_parse_comments (dec, buf); gst_audio_decoder_finish_frame (adec, NULL, 1); } else { res = opus_dec_chain_parse_data (dec, buf); } break; default: { res = opus_dec_chain_parse_data (dec, buf); break; } } } dec->packetno++; return res; } static void gst_opus_dec_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) { GstOpusDec *dec = GST_OPUS_DEC (object); switch (prop_id) { case PROP_USE_INBAND_FEC: g_value_set_boolean (value, dec->use_inband_fec); break; case PROP_APPLY_GAIN: g_value_set_boolean (value, dec->apply_gain); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } static void gst_opus_dec_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstOpusDec *dec = GST_OPUS_DEC (object); switch (prop_id) { case PROP_USE_INBAND_FEC: dec->use_inband_fec = g_value_get_boolean (value); break; case PROP_APPLY_GAIN: dec->apply_gain = g_value_get_boolean (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } GstCaps * gst_opus_dec_getcaps (GstAudioDecoder * dec, GstCaps * filter) { GstCaps *caps; unsigned n; int channels; if (filter) { filter = gst_caps_copy (filter); for (n = 0; n < gst_caps_get_size (filter); ++n) { GstStructure *s = gst_caps_get_structure (filter, n); if (gst_structure_get_int (s, "channels", &channels)) { if (channels == 1 || channels == 2) { GValue v = { 0 }; g_value_init (&v, GST_TYPE_INT_RANGE); gst_value_set_int_range (&v, 1, 2); gst_structure_set_value (s, "channels", &v); g_value_unset (&v); } } } } caps = gst_audio_decoder_proxy_getcaps (dec, NULL, filter); if (filter) gst_caps_unref (filter); if (caps) { caps = gst_caps_copy (caps); for (n = 0; n < gst_caps_get_size (caps); ++n) { GstStructure *s = gst_caps_get_structure (caps, n); if (gst_structure_get_int (s, "channels", &channels)) { if (channels == 1 || channels == 2) { GValue v = { 0 }; g_value_init (&v, GST_TYPE_INT_RANGE); gst_value_set_int_range (&v, 1, 2); gst_structure_set_value (s, "channels", &v); g_value_unset (&v); } } } } return caps; }