| /* GStreamer |
| * Copyright (C) <2016> Carlos Rafael Giani <dv at pseudoterminal dot org> |
| * |
| * 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. |
| */ |
| |
| /** |
| * SECTION:element-rawaudioparse |
| * @title: rawaudioparse |
| * |
| * This element parses incoming data as raw audio samples and timestamps it. |
| * It also handles seek queries in said raw audio data, and ensures that output |
| * buffers contain an integer number of samples, even if the input buffers don't. |
| * For example, with sample format S16LE and 2 channels, an input buffer of 411 |
| * bytes contains 102.75 samples. rawaudioparse will then output 102 samples |
| * (= 408 bytes) and keep the remaining 3 bytes. These will then be prepended to |
| * the next input data. |
| * |
| * The element implements the properties and sink caps configuration as specified |
| * in the #GstRawBaseParse documentation. The properties configuration can be |
| * modified by using the sample-rate, num-channels, channel-positions, format, |
| * and pcm-format properties. |
| * |
| * Currently, this parser supports raw data in a-law, mu-law, or linear PCM format. |
| * |
| * To facilitate operation with the unalignedaudioparse element, rawaudioparse |
| * supports the "audio/x-unaligned-raw" media type. This is treated identically to |
| * "audio/x-raw", except that it is used by source elements which do not guarantee |
| * that the buffers they push out are timestamped and contain an integer amount of |
| * samples (see the 411 bytes example above). By using a different media type, it |
| * is guaranteed that unalignedaudioparse is autoplugged, making sure that the |
| * autoplugged chain does not push unparsed content downstream. The source caps' |
| * media type with linear PCM data is always "audio/x-raw", even if the sink caps |
| * use "audio/x-unaligned-raw". |
| * |
| * The channel-positions property can be used to set explicit position information |
| * for each channel. If the array that is passed to this property does not match |
| * the number of channels indicated by num-channels, then said number of channels |
| * is updated to the array length. If channel-positions is NULL, then the default |
| * GStreamer positioning is used. This property is also useful for swapping left |
| * and right in a stereo signal for example. |
| * |
| * ## Example pipelines |
| * |[ |
| * gst-launch-1.0 souphttpsrc http://my-dlna-server/track.l16 \ |
| * rawaudioparse ! audioconvert ! audioresample ! autoaudiosink |
| * ]| |
| * Receive L16 data from a DLNA server, parse and timestamp it with |
| * rawaudioparse, and play it. use-sink-caps is set to true since souphttpsrc |
| * will set its source pad's caps to audio/x-unaligned-raw for the L16 stream. |
| * |[ |
| * gst-launch-1.0 filesrc location=audio.raw ! rawaudioparse use-sink-caps=false \ |
| * format=pcm pcm-format=s16le sample-rate=48000 num-channels=2 \ |
| * audioconvert ! audioresample ! autoaudiosink |
| * ]| |
| * Read raw data from a local file and parse it as PCM data with 48000 Hz sample |
| * rate, signed 16 bit integer samples, and 2 channels. use-sink-caps is set to |
| * false to ensure the property information is used and the parser does not expect |
| * audio/x-raw or audio/x-unaligned-raw caps. |
| * |
| */ |
| |
| #ifdef HAVE_CONFIG_H |
| # include "config.h" |
| #endif |
| |
| /* FIXME: GValueArray is deprecated, but there is currently no viabla alternative |
| * See https://bugzilla.gnome.org/show_bug.cgi?id=667228 */ |
| #define GLIB_DISABLE_DEPRECATION_WARNINGS |
| |
| #include <string.h> |
| #include "gstrawaudioparse.h" |
| #include "unalignedaudio.h" |
| |
| GST_DEBUG_CATEGORY_STATIC (raw_audio_parse_debug); |
| #define GST_CAT_DEFAULT raw_audio_parse_debug |
| |
| enum |
| { |
| PROP_0, |
| PROP_FORMAT, |
| PROP_PCM_FORMAT, |
| PROP_SAMPLE_RATE, |
| PROP_NUM_CHANNELS, |
| PROP_INTERLEAVED, |
| PROP_CHANNEL_POSITIONS |
| }; |
| |
| #define DEFAULT_FORMAT GST_RAW_AUDIO_PARSE_FORMAT_PCM |
| #define DEFAULT_PCM_FORMAT GST_AUDIO_FORMAT_S16 |
| #define DEFAULT_SAMPLE_RATE 44100 |
| #define DEFAULT_NUM_CHANNELS 2 |
| #define DEFAULT_INTERLEAVED TRUE |
| |
| #define GST_RAW_AUDIO_PARSE_CAPS \ |
| GST_AUDIO_CAPS_MAKE(GST_AUDIO_FORMATS_ALL) \ |
| ", layout = (string) { interleaved, non-interleaved }; " \ |
| "audio/x-alaw, rate = (int) [ 1, MAX ], channels = (int) [ 1, MAX ]; " \ |
| "audio/x-mulaw, rate = (int) [ 1, MAX ], channels = (int) [ 1, MAX ]; " |
| |
| static GstStaticPadTemplate static_sink_template = |
| GST_STATIC_PAD_TEMPLATE ("sink", |
| GST_PAD_SINK, |
| GST_PAD_ALWAYS, |
| GST_STATIC_CAPS (GST_UNALIGNED_RAW_AUDIO_CAPS "; " GST_RAW_AUDIO_PARSE_CAPS) |
| ); |
| |
| static GstStaticPadTemplate static_src_template = |
| GST_STATIC_PAD_TEMPLATE ("src", |
| GST_PAD_SRC, |
| GST_PAD_ALWAYS, |
| GST_STATIC_CAPS (GST_RAW_AUDIO_PARSE_CAPS) |
| ); |
| |
| #define gst_raw_audio_parse_parent_class parent_class |
| G_DEFINE_TYPE (GstRawAudioParse, gst_raw_audio_parse, GST_TYPE_RAW_BASE_PARSE); |
| |
| static void gst_raw_audio_parse_set_property (GObject * object, guint prop_id, |
| GValue const *value, GParamSpec * pspec); |
| static void gst_raw_audio_parse_get_property (GObject * object, guint prop_id, |
| GValue * value, GParamSpec * pspec); |
| |
| static gboolean gst_raw_audio_parse_stop (GstBaseParse * parse); |
| |
| static gboolean gst_raw_audio_parse_set_current_config (GstRawBaseParse * |
| raw_base_parse, GstRawBaseParseConfig config); |
| static GstRawBaseParseConfig |
| gst_raw_audio_parse_get_current_config (GstRawBaseParse * raw_base_parse); |
| static gboolean gst_raw_audio_parse_set_config_from_caps (GstRawBaseParse * |
| raw_base_parse, GstRawBaseParseConfig config, GstCaps * caps); |
| static gboolean gst_raw_audio_parse_get_caps_from_config (GstRawBaseParse * |
| raw_base_parse, GstRawBaseParseConfig config, GstCaps ** caps); |
| static gsize gst_raw_audio_parse_get_config_frame_size (GstRawBaseParse * |
| raw_base_parse, GstRawBaseParseConfig config); |
| static gboolean gst_raw_audio_parse_is_config_ready (GstRawBaseParse * |
| raw_base_parse, GstRawBaseParseConfig config); |
| static gboolean gst_raw_audio_parse_process (GstRawBaseParse * raw_base_parse, |
| GstRawBaseParseConfig config, GstBuffer * in_data, gsize total_num_in_bytes, |
| gsize num_valid_in_bytes, GstBuffer ** processed_data); |
| static gboolean gst_raw_audio_parse_is_unit_format_supported (GstRawBaseParse * |
| raw_base_parse, GstFormat format); |
| static void gst_raw_audio_parse_get_units_per_second (GstRawBaseParse * |
| raw_base_parse, GstFormat format, GstRawBaseParseConfig config, |
| gsize * units_per_sec_n, gsize * units_per_sec_d); |
| static gint gst_raw_audio_parse_get_alignment (GstRawBaseParse * raw_base_parse, |
| GstRawBaseParseConfig config); |
| |
| static gboolean gst_raw_audio_parse_is_using_sink_caps (GstRawAudioParse * |
| raw_audio_parse); |
| static GstRawAudioParseConfig |
| * gst_raw_audio_parse_get_config_ptr (GstRawAudioParse * raw_audio_parse, |
| GstRawBaseParseConfig config); |
| |
| static void gst_raw_audio_parse_init_config (GstRawAudioParseConfig * config); |
| static gboolean gst_raw_audio_parse_set_config_channels (GstRawAudioParseConfig |
| * config, guint num_channels, guint64 channel_mask, gboolean set_positions); |
| static gboolean |
| gst_raw_audio_parse_update_channel_reordering_flag (GstRawAudioParseConfig * |
| config); |
| static void gst_raw_audio_parse_update_config_bpf (GstRawAudioParseConfig * |
| config); |
| static gboolean gst_raw_audio_parse_caps_to_config (GstRawAudioParse * |
| raw_audio_parse, GstCaps * caps, GstRawAudioParseConfig * config); |
| static gboolean gst_raw_audio_parse_config_to_caps (GstRawAudioParse * |
| raw_audio_parse, GstCaps ** caps, GstRawAudioParseConfig * config); |
| |
| static void |
| gst_raw_audio_parse_class_init (GstRawAudioParseClass * klass) |
| { |
| GObjectClass *object_class; |
| GstElementClass *element_class; |
| GstBaseParseClass *baseparse_class; |
| GstRawBaseParseClass *rawbaseparse_class; |
| |
| GST_DEBUG_CATEGORY_INIT (raw_audio_parse_debug, "rawaudioparse", 0, |
| "rawaudioparse element"); |
| |
| object_class = G_OBJECT_CLASS (klass); |
| element_class = GST_ELEMENT_CLASS (klass); |
| baseparse_class = GST_BASE_PARSE_CLASS (klass); |
| rawbaseparse_class = GST_RAW_BASE_PARSE_CLASS (klass); |
| |
| gst_element_class_add_pad_template (element_class, |
| gst_static_pad_template_get (&static_sink_template)); |
| gst_element_class_add_pad_template (element_class, |
| gst_static_pad_template_get (&static_src_template)); |
| |
| object_class->set_property = |
| GST_DEBUG_FUNCPTR (gst_raw_audio_parse_set_property); |
| object_class->get_property = |
| GST_DEBUG_FUNCPTR (gst_raw_audio_parse_get_property); |
| |
| baseparse_class->stop = GST_DEBUG_FUNCPTR (gst_raw_audio_parse_stop); |
| |
| rawbaseparse_class->set_current_config = |
| GST_DEBUG_FUNCPTR (gst_raw_audio_parse_set_current_config); |
| rawbaseparse_class->get_current_config = |
| GST_DEBUG_FUNCPTR (gst_raw_audio_parse_get_current_config); |
| rawbaseparse_class->set_config_from_caps = |
| GST_DEBUG_FUNCPTR (gst_raw_audio_parse_set_config_from_caps); |
| rawbaseparse_class->get_caps_from_config = |
| GST_DEBUG_FUNCPTR (gst_raw_audio_parse_get_caps_from_config); |
| rawbaseparse_class->get_config_frame_size = |
| GST_DEBUG_FUNCPTR (gst_raw_audio_parse_get_config_frame_size); |
| rawbaseparse_class->is_config_ready = |
| GST_DEBUG_FUNCPTR (gst_raw_audio_parse_is_config_ready); |
| rawbaseparse_class->process = GST_DEBUG_FUNCPTR (gst_raw_audio_parse_process); |
| rawbaseparse_class->is_unit_format_supported = |
| GST_DEBUG_FUNCPTR (gst_raw_audio_parse_is_unit_format_supported); |
| rawbaseparse_class->get_units_per_second = |
| GST_DEBUG_FUNCPTR (gst_raw_audio_parse_get_units_per_second); |
| rawbaseparse_class->get_alignment = |
| GST_DEBUG_FUNCPTR (gst_raw_audio_parse_get_alignment); |
| |
| g_object_class_install_property (object_class, |
| PROP_FORMAT, |
| g_param_spec_enum ("format", |
| "Format", |
| "Format of the raw audio stream", |
| gst_raw_audio_parse_format_get_type (), |
| GST_RAW_AUDIO_PARSE_FORMAT_PCM, |
| G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS) |
| ); |
| g_object_class_install_property (object_class, |
| PROP_PCM_FORMAT, |
| g_param_spec_enum ("pcm-format", |
| "PCM format", |
| "Format of audio samples in PCM stream (ignored if format property is not set to pcm)", |
| GST_TYPE_AUDIO_FORMAT, |
| GST_RAW_AUDIO_PARSE_FORMAT_PCM, |
| G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS) |
| ); |
| g_object_class_install_property (object_class, |
| PROP_SAMPLE_RATE, |
| g_param_spec_int ("sample-rate", |
| "Sample rate", |
| "Rate of audio samples in raw stream", |
| 1, INT_MAX, |
| DEFAULT_SAMPLE_RATE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS) |
| ); |
| g_object_class_install_property (object_class, |
| PROP_NUM_CHANNELS, |
| g_param_spec_int ("num-channels", |
| "Number of channels", |
| "Number of channels in raw stream", |
| 1, INT_MAX, |
| DEFAULT_NUM_CHANNELS, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS) |
| ); |
| g_object_class_install_property (object_class, |
| PROP_INTERLEAVED, |
| g_param_spec_boolean ("interleaved", |
| "Interleaved layout", |
| "True if audio has interleaved layout", |
| DEFAULT_INTERLEAVED, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS) |
| ); |
| g_object_class_install_property (object_class, |
| PROP_CHANNEL_POSITIONS, |
| g_param_spec_value_array ("channel-positions", |
| "Channel positions", |
| "Channel positions used on the output", |
| g_param_spec_enum ("channel-position", |
| "Channel position", |
| "Channel position of the n-th input", |
| GST_TYPE_AUDIO_CHANNEL_POSITION, |
| GST_AUDIO_CHANNEL_POSITION_NONE, |
| G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS), |
| G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS) |
| ); |
| |
| gst_element_class_set_static_metadata (element_class, |
| "rawaudioparse", |
| "Codec/Parser/Audio", |
| "Converts unformatted data streams into timestamped raw audio frames", |
| "Carlos Rafael Giani <dv@pseudoterminal.org>"); |
| } |
| |
| static void |
| gst_raw_audio_parse_init (GstRawAudioParse * raw_audio_parse) |
| { |
| /* Setup configs and select which one shall be the current one from the start. */ |
| gst_raw_audio_parse_init_config (&(raw_audio_parse->properties_config)); |
| gst_raw_audio_parse_init_config (&(raw_audio_parse->sink_caps_config)); |
| /* As required by GstRawBaseParse, ensure that the current configuration |
| * is initially set to be the properties config */ |
| raw_audio_parse->current_config = &(raw_audio_parse->properties_config); |
| |
| /* Properties config must be valid from the start, so set its ready value |
| * to TRUE, and make sure its bpf value is valid. */ |
| raw_audio_parse->properties_config.ready = TRUE; |
| gst_raw_audio_parse_update_config_bpf (&(raw_audio_parse->properties_config)); |
| } |
| |
| static void |
| gst_raw_audio_parse_set_property (GObject * object, guint prop_id, |
| GValue const *value, GParamSpec * pspec) |
| { |
| GstBaseParse *base_parse = GST_BASE_PARSE (object); |
| GstRawBaseParse *raw_base_parse = GST_RAW_BASE_PARSE (object); |
| GstRawAudioParse *raw_audio_parse = GST_RAW_AUDIO_PARSE (object); |
| |
| /* All properties are handled similarly: |
| * - if the new value is the same as the current value, nothing is done |
| * - the parser lock is held while the new value is set |
| * - if the properties config is the current config, the source caps are |
| * invalidated to ensure that the code in handle_frame pushes a new CAPS |
| * event out |
| * - properties that affect the bpf value call the function to update |
| * the bpf and also call gst_base_parse_set_min_frame_size() to ensure |
| * that the minimum frame size can hold 1 frame (= one sample for each |
| * channel) |
| */ |
| |
| switch (prop_id) { |
| case PROP_FORMAT: |
| { |
| GstRawAudioParseFormat new_format = g_value_get_enum (value); |
| |
| GST_RAW_BASE_PARSE_CONFIG_MUTEX_LOCK (object); |
| |
| if (new_format != raw_audio_parse->properties_config.format) { |
| raw_audio_parse->properties_config.format = new_format; |
| gst_raw_audio_parse_update_config_bpf (& |
| (raw_audio_parse->properties_config)); |
| |
| if (!gst_raw_audio_parse_is_using_sink_caps (raw_audio_parse)) { |
| gst_raw_base_parse_invalidate_src_caps (raw_base_parse); |
| gst_base_parse_set_min_frame_size (base_parse, |
| raw_audio_parse->properties_config.bpf); |
| } |
| } |
| |
| GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (object); |
| break; |
| } |
| |
| case PROP_PCM_FORMAT: |
| { |
| GstAudioFormat new_pcm_format = g_value_get_enum (value); |
| |
| GST_RAW_BASE_PARSE_CONFIG_MUTEX_LOCK (object); |
| |
| if (new_pcm_format != raw_audio_parse->properties_config.pcm_format) { |
| raw_audio_parse->properties_config.pcm_format = new_pcm_format; |
| gst_raw_audio_parse_update_config_bpf (& |
| (raw_audio_parse->properties_config)); |
| |
| if (!gst_raw_audio_parse_is_using_sink_caps (raw_audio_parse)) { |
| gst_raw_base_parse_invalidate_src_caps (raw_base_parse); |
| gst_base_parse_set_min_frame_size (base_parse, |
| raw_audio_parse->properties_config.bpf); |
| } |
| } |
| |
| GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (object); |
| break; |
| } |
| |
| case PROP_SAMPLE_RATE: |
| { |
| guint new_sample_rate = g_value_get_int (value); |
| |
| GST_RAW_BASE_PARSE_CONFIG_MUTEX_LOCK (object); |
| |
| if (new_sample_rate != raw_audio_parse->properties_config.sample_rate) { |
| raw_audio_parse->properties_config.sample_rate = new_sample_rate; |
| |
| if (!gst_raw_audio_parse_is_using_sink_caps (raw_audio_parse)) |
| gst_raw_base_parse_invalidate_src_caps (raw_base_parse); |
| } |
| |
| GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (object); |
| break; |
| } |
| |
| case PROP_NUM_CHANNELS: |
| { |
| guint new_num_channels = g_value_get_int (value); |
| |
| GST_RAW_BASE_PARSE_CONFIG_MUTEX_LOCK (object); |
| |
| if (new_num_channels != raw_audio_parse->properties_config.num_channels) { |
| gst_raw_audio_parse_set_config_channels (& |
| (raw_audio_parse->properties_config), new_num_channels, 0, TRUE); |
| |
| raw_audio_parse->properties_config.num_channels = new_num_channels; |
| gst_raw_audio_parse_update_config_bpf (& |
| (raw_audio_parse->properties_config)); |
| |
| if (!gst_raw_audio_parse_is_using_sink_caps (raw_audio_parse)) { |
| gst_raw_base_parse_invalidate_src_caps (raw_base_parse); |
| gst_base_parse_set_min_frame_size (base_parse, |
| raw_audio_parse->properties_config.bpf); |
| } |
| } |
| |
| GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (object); |
| break; |
| } |
| |
| case PROP_INTERLEAVED: |
| { |
| gboolean new_interleaved = g_value_get_boolean (value); |
| |
| GST_RAW_BASE_PARSE_CONFIG_MUTEX_LOCK (object); |
| |
| if (new_interleaved != raw_audio_parse->properties_config.interleaved) { |
| raw_audio_parse->properties_config.interleaved = new_interleaved; |
| |
| if (!gst_raw_audio_parse_is_using_sink_caps (raw_audio_parse)) |
| gst_raw_base_parse_invalidate_src_caps (raw_base_parse); |
| } |
| |
| GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (object); |
| break; |
| } |
| |
| case PROP_CHANNEL_POSITIONS: |
| { |
| GValueArray *valarray = g_value_get_boxed (value); |
| GstRawAudioParseConfig *config = &(raw_audio_parse->properties_config); |
| |
| /* Sanity check - reject empty arrays */ |
| if ((valarray != NULL) && (valarray->n_values == 0)) { |
| GST_ELEMENT_ERROR (raw_audio_parse, LIBRARY, SETTINGS, |
| ("channel position property holds an empty array"), (NULL)); |
| break; |
| } |
| |
| GST_RAW_BASE_PARSE_CONFIG_MUTEX_LOCK (object); |
| |
| if ((valarray == NULL) && (config->num_channels > 0)) { |
| /* NULL value given, and number of channels is nonzero. |
| * Use the default GStreamer positioning. Call |
| * set_config_channels with the set_positions parameter |
| * set to TRUE to ensure the position values are filled. */ |
| gst_raw_audio_parse_set_config_channels (& |
| (raw_audio_parse->properties_config), config->num_channels, 0, |
| TRUE); |
| } else if (valarray != NULL) { |
| /* Non-NULL value given. Make sure the channel_positions |
| * array in the properties config has enough room, and that |
| * the num_channels value equals the array length. Then copy |
| * the values from the valarray to channel_positions, and |
| * produce a copy of that array in case its channel positions |
| * are not in a valid GStreamer order (to be able to apply |
| * channel reordering later). |
| */ |
| |
| guint i; |
| |
| if (valarray->n_values != config->num_channels) { |
| /* Call with set_positions == FALSE to ensure that |
| * the array is properly allocated but not filled |
| * (it is filled below) */ |
| gst_raw_audio_parse_set_config_channels (config, valarray->n_values, |
| 0, FALSE); |
| } |
| |
| for (i = 0; i < config->num_channels; ++i) { |
| GValue *val = g_value_array_get_nth (valarray, i); |
| config->channel_positions[i] = g_value_get_enum (val); |
| } |
| |
| gst_raw_audio_parse_update_channel_reordering_flag (config); |
| } |
| |
| gst_raw_audio_parse_update_config_bpf (& |
| (raw_audio_parse->properties_config)); |
| |
| if (!gst_raw_audio_parse_is_using_sink_caps (raw_audio_parse)) { |
| gst_raw_base_parse_invalidate_src_caps (raw_base_parse); |
| gst_base_parse_set_min_frame_size (base_parse, |
| raw_audio_parse->properties_config.bpf); |
| } |
| |
| GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (object); |
| break; |
| } |
| |
| default: |
| G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); |
| break; |
| } |
| } |
| |
| static void |
| gst_raw_audio_parse_get_property (GObject * object, guint prop_id, |
| GValue * value, GParamSpec * pspec) |
| { |
| GstRawAudioParse *raw_audio_parse = GST_RAW_AUDIO_PARSE (object); |
| |
| switch (prop_id) { |
| case PROP_FORMAT: |
| GST_RAW_BASE_PARSE_CONFIG_MUTEX_LOCK (object); |
| g_value_set_enum (value, raw_audio_parse->properties_config.format); |
| GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (object); |
| break; |
| |
| case PROP_PCM_FORMAT: |
| GST_RAW_BASE_PARSE_CONFIG_MUTEX_LOCK (object); |
| g_value_set_enum (value, raw_audio_parse->properties_config.pcm_format); |
| GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (object); |
| break; |
| |
| case PROP_SAMPLE_RATE: |
| GST_RAW_BASE_PARSE_CONFIG_MUTEX_LOCK (object); |
| g_value_set_int (value, raw_audio_parse->properties_config.sample_rate); |
| GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (object); |
| break; |
| |
| case PROP_NUM_CHANNELS: |
| GST_RAW_BASE_PARSE_CONFIG_MUTEX_LOCK (object); |
| g_value_set_int (value, raw_audio_parse->properties_config.num_channels); |
| GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (object); |
| break; |
| |
| case PROP_INTERLEAVED: |
| GST_RAW_BASE_PARSE_CONFIG_MUTEX_LOCK (object); |
| g_value_set_boolean (value, |
| raw_audio_parse->properties_config.interleaved); |
| GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (object); |
| break; |
| |
| case PROP_CHANNEL_POSITIONS: |
| { |
| GstRawAudioParseConfig *config; |
| GValueArray *valarray; |
| |
| GST_RAW_BASE_PARSE_CONFIG_MUTEX_LOCK (object); |
| |
| valarray = NULL; |
| config = &(raw_audio_parse->properties_config); |
| |
| /* Copy channel positions into the valuearray */ |
| if (config->num_channels > 0) { |
| guint i; |
| GValue val = G_VALUE_INIT; |
| g_assert (config->channel_positions); |
| |
| g_value_init (&val, GST_TYPE_AUDIO_CHANNEL_POSITION); |
| valarray = g_value_array_new (config->num_channels); |
| |
| for (i = 0; i < config->num_channels; ++i) { |
| g_value_set_enum (&val, config->channel_positions[i]); |
| g_value_array_insert (valarray, i, &val); |
| } |
| |
| g_value_unset (&val); |
| } |
| |
| GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (object); |
| |
| /* Pass on ownership to the value array, |
| * since we don't need it anymore */ |
| g_value_take_boxed (value, valarray); |
| |
| break; |
| } |
| |
| default: |
| G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); |
| break; |
| } |
| } |
| |
| static gboolean |
| gst_raw_audio_parse_stop (GstBaseParse * parse) |
| { |
| GstRawAudioParse *raw_audio_parse = GST_RAW_AUDIO_PARSE (parse); |
| |
| /* Sink caps config is not ready until caps come in. |
| * We are stopping processing, the element is being reset, |
| * so the config has to be un-readied. |
| * (Since the properties config is not depending on caps, |
| * its ready status is always TRUE.) */ |
| raw_audio_parse->sink_caps_config.ready = FALSE; |
| |
| return GST_BASE_PARSE_CLASS (parent_class)->stop (parse); |
| } |
| |
| static gboolean |
| gst_raw_audio_parse_set_current_config (GstRawBaseParse * raw_base_parse, |
| GstRawBaseParseConfig config) |
| { |
| GstRawAudioParse *raw_audio_parse = GST_RAW_AUDIO_PARSE (raw_base_parse); |
| |
| switch (config) { |
| case GST_RAW_BASE_PARSE_CONFIG_PROPERTIES: |
| raw_audio_parse->current_config = &(raw_audio_parse->properties_config); |
| break; |
| |
| case GST_RAW_BASE_PARSE_CONFIG_SINKCAPS: |
| raw_audio_parse->current_config = &(raw_audio_parse->sink_caps_config); |
| break; |
| |
| default: |
| g_assert_not_reached (); |
| } |
| |
| return TRUE; |
| } |
| |
| static GstRawBaseParseConfig |
| gst_raw_audio_parse_get_current_config (GstRawBaseParse * raw_base_parse) |
| { |
| GstRawAudioParse *raw_audio_parse = GST_RAW_AUDIO_PARSE (raw_base_parse); |
| return gst_raw_audio_parse_is_using_sink_caps (raw_audio_parse) ? |
| GST_RAW_BASE_PARSE_CONFIG_SINKCAPS : GST_RAW_BASE_PARSE_CONFIG_PROPERTIES; |
| } |
| |
| static gboolean |
| gst_raw_audio_parse_set_config_from_caps (GstRawBaseParse * raw_base_parse, |
| GstRawBaseParseConfig config, GstCaps * caps) |
| { |
| GstRawAudioParse *raw_audio_parse = GST_RAW_AUDIO_PARSE (raw_base_parse); |
| return gst_raw_audio_parse_caps_to_config (raw_audio_parse, caps, |
| gst_raw_audio_parse_get_config_ptr (raw_audio_parse, config)); |
| } |
| |
| static gboolean |
| gst_raw_audio_parse_get_caps_from_config (GstRawBaseParse * raw_base_parse, |
| GstRawBaseParseConfig config, GstCaps ** caps) |
| { |
| GstRawAudioParse *raw_audio_parse = GST_RAW_AUDIO_PARSE (raw_base_parse); |
| return gst_raw_audio_parse_config_to_caps (raw_audio_parse, caps, |
| gst_raw_audio_parse_get_config_ptr (raw_audio_parse, config)); |
| } |
| |
| static gsize |
| gst_raw_audio_parse_get_config_frame_size (GstRawBaseParse * raw_base_parse, |
| GstRawBaseParseConfig config) |
| { |
| GstRawAudioParse *raw_audio_parse = GST_RAW_AUDIO_PARSE (raw_base_parse); |
| return gst_raw_audio_parse_get_config_ptr (raw_audio_parse, config)->bpf; |
| } |
| |
| static gboolean |
| gst_raw_audio_parse_is_config_ready (GstRawBaseParse * raw_base_parse, |
| GstRawBaseParseConfig config) |
| { |
| GstRawAudioParse *raw_audio_parse = GST_RAW_AUDIO_PARSE (raw_base_parse); |
| return gst_raw_audio_parse_get_config_ptr (raw_audio_parse, config)->ready; |
| } |
| |
| static guint |
| round_up_pow2 (guint n) |
| { |
| n = n - 1; |
| n = n | (n >> 1); |
| n = n | (n >> 2); |
| n = n | (n >> 4); |
| n = n | (n >> 8); |
| n = n | (n >> 16); |
| return n + 1; |
| } |
| |
| static gint |
| gst_raw_audio_parse_get_alignment (GstRawBaseParse * raw_base_parse, |
| GstRawBaseParseConfig config) |
| { |
| GstRawAudioParse *raw_audio_parse = GST_RAW_AUDIO_PARSE (raw_base_parse); |
| GstRawAudioParseConfig *config_ptr = |
| gst_raw_audio_parse_get_config_ptr (raw_audio_parse, config); |
| gint width; |
| |
| if (config_ptr->format != GST_RAW_AUDIO_PARSE_FORMAT_PCM) |
| return 1; |
| |
| width = |
| GST_AUDIO_FORMAT_INFO_WIDTH (gst_audio_format_get_info |
| (config_ptr->pcm_format)) / 8; |
| width = GST_ROUND_UP_8 (width); |
| width = round_up_pow2 (width); |
| |
| return width; |
| } |
| |
| static gboolean |
| gst_raw_audio_parse_process (GstRawBaseParse * raw_base_parse, |
| GstRawBaseParseConfig config, GstBuffer * in_data, gsize total_num_in_bytes, |
| gsize num_valid_in_bytes, GstBuffer ** processed_data) |
| { |
| GstRawAudioParse *raw_audio_parse = GST_RAW_AUDIO_PARSE (raw_base_parse); |
| GstRawAudioParseConfig *config_ptr = |
| gst_raw_audio_parse_get_config_ptr (raw_audio_parse, config); |
| |
| if ((config_ptr->format == GST_RAW_AUDIO_PARSE_FORMAT_PCM) |
| && config_ptr->needs_channel_reordering) { |
| /* Need to reorder samples, since they are in an invalid |
| * channel order. */ |
| |
| GstBuffer *outbuf; |
| |
| GST_LOG_OBJECT (raw_audio_parse, |
| "using %" G_GSIZE_FORMAT " bytes out of the %" G_GSIZE_FORMAT |
| " bytes from the input buffer with reordering", num_valid_in_bytes, |
| total_num_in_bytes); |
| |
| outbuf = |
| gst_buffer_copy_region (in_data, |
| GST_BUFFER_COPY_FLAGS | GST_BUFFER_COPY_TIMESTAMPS | |
| GST_BUFFER_COPY_META | GST_BUFFER_COPY_MEMORY, 0, num_valid_in_bytes); |
| |
| gst_audio_buffer_reorder_channels (outbuf, |
| config_ptr->pcm_format, |
| config_ptr->num_channels, |
| config_ptr->channel_positions, config_ptr->reordered_channel_positions); |
| |
| *processed_data = outbuf; |
| } else { |
| /* Nothing needs to be done with the sample data. |
| * Instruct the baseparse class to just take out_size bytes |
| * from the input buffer */ |
| |
| GST_LOG_OBJECT (raw_audio_parse, |
| "using %" G_GSIZE_FORMAT " bytes out of the %" G_GSIZE_FORMAT |
| " bytes from the input buffer without reordering", num_valid_in_bytes, |
| total_num_in_bytes); |
| |
| *processed_data = NULL; |
| } |
| |
| return TRUE; |
| } |
| |
| static gboolean |
| gst_raw_audio_parse_is_unit_format_supported (G_GNUC_UNUSED GstRawBaseParse * |
| raw_base_parse, GstFormat format) |
| { |
| switch (format) { |
| case GST_FORMAT_BYTES: |
| case GST_FORMAT_DEFAULT: |
| return TRUE; |
| default: |
| return FALSE; |
| } |
| } |
| |
| static void |
| gst_raw_audio_parse_get_units_per_second (GstRawBaseParse * raw_base_parse, |
| GstFormat format, GstRawBaseParseConfig config, gsize * units_per_sec_n, |
| gsize * units_per_sec_d) |
| { |
| GstRawAudioParse *raw_audio_parse = GST_RAW_AUDIO_PARSE (raw_base_parse); |
| GstRawAudioParseConfig *config_ptr = |
| gst_raw_audio_parse_get_config_ptr (raw_audio_parse, config); |
| |
| switch (format) { |
| case GST_FORMAT_BYTES: |
| *units_per_sec_n = config_ptr->sample_rate * config_ptr->bpf; |
| *units_per_sec_d = 1; |
| break; |
| |
| case GST_FORMAT_DEFAULT: |
| *units_per_sec_n = config_ptr->sample_rate; |
| *units_per_sec_d = 1; |
| break; |
| |
| default: |
| g_assert_not_reached (); |
| } |
| } |
| |
| static gboolean |
| gst_raw_audio_parse_is_using_sink_caps (GstRawAudioParse * raw_audio_parse) |
| { |
| return raw_audio_parse->current_config == |
| &(raw_audio_parse->sink_caps_config); |
| } |
| |
| static GstRawAudioParseConfig * |
| gst_raw_audio_parse_get_config_ptr (GstRawAudioParse * raw_audio_parse, |
| GstRawBaseParseConfig config) |
| { |
| g_assert (raw_audio_parse->current_config != NULL); |
| |
| switch (config) { |
| case GST_RAW_BASE_PARSE_CONFIG_PROPERTIES: |
| return &(raw_audio_parse->properties_config); |
| |
| case GST_RAW_BASE_PARSE_CONFIG_SINKCAPS: |
| return &(raw_audio_parse->sink_caps_config); |
| |
| default: |
| g_assert (raw_audio_parse->current_config != NULL); |
| return raw_audio_parse->current_config; |
| } |
| } |
| |
| static void |
| gst_raw_audio_parse_init_config (GstRawAudioParseConfig * config) |
| { |
| config->ready = FALSE; |
| config->format = DEFAULT_FORMAT; |
| config->pcm_format = DEFAULT_PCM_FORMAT; |
| config->bpf = 0; |
| config->sample_rate = DEFAULT_SAMPLE_RATE; |
| config->num_channels = DEFAULT_NUM_CHANNELS; |
| config->interleaved = DEFAULT_INTERLEAVED; |
| config->needs_channel_reordering = FALSE; |
| |
| gst_raw_audio_parse_set_config_channels (config, config->num_channels, 0, |
| TRUE); |
| } |
| |
| static gboolean |
| gst_raw_audio_parse_set_config_channels (GstRawAudioParseConfig * config, |
| guint num_channels, guint64 channel_mask, gboolean set_positions) |
| { |
| g_assert (num_channels > 0); |
| |
| config->num_channels = num_channels; |
| /* Setting this to FALSE, since initially, after setting the channels, |
| * the default GStreamer channel ordering is used. */ |
| config->needs_channel_reordering = FALSE; |
| |
| /* Set the channel positions based on the given channel mask if set_positions |
| * is set to TRUE. A channel mask of 0 signifies that a fallback mask should be |
| * used for the given number of channels. */ |
| if (set_positions) { |
| if (channel_mask == 0) |
| channel_mask = gst_audio_channel_get_fallback_mask (config->num_channels); |
| |
| return gst_audio_channel_positions_from_mask (config->num_channels, |
| channel_mask, config->channel_positions); |
| } else { |
| return TRUE; |
| } |
| } |
| |
| static gboolean |
| gst_raw_audio_parse_update_channel_reordering_flag (GstRawAudioParseConfig * |
| config) |
| { |
| g_assert (config->num_channels > 0); |
| |
| /* If the channel_positions array contains channel positions which are in an |
| * order that conforms to the valid GStreamer order, ensure that channel |
| * reordering is disabled. |
| * Otherwise, if the order of the positions in the channel_positions array |
| * does not conform to the GStreamer order, ensure it is enabled. |
| */ |
| |
| if (gst_audio_check_valid_channel_positions (config->channel_positions, |
| config->num_channels, TRUE)) { |
| |
| config->needs_channel_reordering = FALSE; |
| |
| return TRUE; |
| } else { |
| config->needs_channel_reordering = TRUE; |
| memcpy (config->reordered_channel_positions, config->channel_positions, |
| sizeof (GstAudioChannelPosition) * config->num_channels); |
| return |
| gst_audio_channel_positions_to_valid_order |
| (config->reordered_channel_positions, config->num_channels); |
| } |
| } |
| |
| static void |
| gst_raw_audio_parse_update_config_bpf (GstRawAudioParseConfig * config) |
| { |
| switch (config->format) { |
| case GST_RAW_AUDIO_PARSE_FORMAT_PCM: |
| { |
| GstAudioFormatInfo const *fmt_info = |
| gst_audio_format_get_info (config->pcm_format); |
| g_assert (fmt_info != NULL); |
| |
| config->bpf = |
| GST_AUDIO_FORMAT_INFO_WIDTH (fmt_info) * config->num_channels / 8; |
| |
| break; |
| } |
| |
| case GST_RAW_AUDIO_PARSE_FORMAT_ALAW: |
| case GST_RAW_AUDIO_PARSE_FORMAT_MULAW: |
| /* A-law and mu-law both use 1 byte per sample */ |
| config->bpf = 1 * config->num_channels; |
| break; |
| |
| default: |
| g_assert_not_reached (); |
| } |
| } |
| |
| static gboolean |
| gst_raw_audio_parse_caps_to_config (GstRawAudioParse * raw_audio_parse, |
| GstCaps * caps, GstRawAudioParseConfig * config) |
| { |
| gboolean ret = FALSE; |
| GstStructure *structure; |
| |
| /* Caps might get copied, and the copy needs to be unref'd. |
| * Also, the caller retains ownership over the original caps. |
| * So, to make this mechanism also work with cases where the |
| * caps are *not* copied, ref the original caps here first. */ |
| gst_caps_ref (caps); |
| |
| structure = gst_caps_get_structure (caps, 0); |
| |
| /* For unaligned raw data, the output caps stay the same, |
| * except that audio/x-unaligned-raw becomes audio/x-raw, |
| * since the parser aligns the sample data */ |
| if (gst_structure_has_name (structure, "audio/x-unaligned-raw")) { |
| /* Copy the caps to be able to modify them */ |
| GstCaps *new_caps = gst_caps_copy (caps); |
| gst_caps_unref (caps); |
| caps = new_caps; |
| |
| /* Change the media type to audio/x-raw , otherwise |
| * gst_audio_info_from_caps() won't work */ |
| structure = gst_caps_get_structure (caps, 0); |
| gst_structure_set_name (structure, "audio/x-raw"); |
| } |
| |
| if (gst_structure_has_name (structure, "audio/x-raw")) { |
| guint num_channels; |
| GstAudioInfo info; |
| if (!gst_audio_info_from_caps (&info, caps)) { |
| GST_ERROR_OBJECT (raw_audio_parse, |
| "failed to parse caps %" GST_PTR_FORMAT, (gpointer) caps); |
| goto done; |
| } |
| |
| num_channels = GST_AUDIO_INFO_CHANNELS (&info); |
| |
| config->format = GST_RAW_AUDIO_PARSE_FORMAT_PCM; |
| config->pcm_format = GST_AUDIO_INFO_FORMAT (&info); |
| config->bpf = GST_AUDIO_INFO_BPF (&info); |
| config->sample_rate = GST_AUDIO_INFO_RATE (&info); |
| config->interleaved = |
| (GST_AUDIO_INFO_LAYOUT (&info) == GST_AUDIO_LAYOUT_INTERLEAVED); |
| |
| gst_raw_audio_parse_set_config_channels (config, num_channels, 0, FALSE); |
| memcpy (config->channel_positions, &(GST_AUDIO_INFO_POSITION (&info, 0)), |
| sizeof (GstAudioChannelPosition) * num_channels); |
| } else if (gst_structure_has_name (structure, "audio/x-alaw") |
| || gst_structure_has_name (structure, "audio/x-mulaw")) { |
| gint i; |
| guint64 channel_mask; |
| guint num_channels; |
| |
| config->format = |
| gst_structure_has_name (structure, |
| "audio/x-alaw") ? GST_RAW_AUDIO_PARSE_FORMAT_ALAW : |
| GST_RAW_AUDIO_PARSE_FORMAT_MULAW; |
| |
| if (!gst_structure_get_int (structure, "rate", &i)) { |
| GST_ERROR_OBJECT (raw_audio_parse, |
| "missing rate value in caps %" GST_PTR_FORMAT, (gpointer) caps); |
| goto done; |
| } |
| config->sample_rate = i; |
| |
| if (!gst_structure_get_int (structure, "channels", &i)) { |
| GST_ERROR_OBJECT (raw_audio_parse, |
| "missing channels value in caps %" GST_PTR_FORMAT, (gpointer) caps); |
| goto done; |
| } |
| num_channels = i; |
| |
| if (!gst_structure_get (structure, "channel-mask", GST_TYPE_BITMASK, |
| &channel_mask, NULL)) { |
| channel_mask = gst_audio_channel_get_fallback_mask (num_channels); |
| GST_DEBUG_OBJECT (raw_audio_parse, |
| "input caps have no channel mask - using fallback mask %#" |
| G_GINT64_MODIFIER "x for %u channels", channel_mask, num_channels); |
| } |
| |
| if (!gst_raw_audio_parse_set_config_channels (config, num_channels, |
| channel_mask, TRUE)) { |
| GST_ERROR_OBJECT (raw_audio_parse, |
| "could not use channel mask %#" G_GINT64_MODIFIER |
| "x for channel positions", channel_mask); |
| goto done; |
| } |
| |
| /* A-law and mu-law both use 1 byte per sample */ |
| config->bpf = 1 * num_channels; |
| } else { |
| GST_ERROR_OBJECT (raw_audio_parse, |
| "caps %" GST_PTR_FORMAT " have an unsupported media type", |
| (gpointer) caps); |
| goto done; |
| } |
| |
| ret = TRUE; |
| |
| done: |
| gst_caps_unref (caps); |
| if (ret) |
| config->ready = TRUE; |
| return ret; |
| } |
| |
| static gboolean |
| gst_raw_audio_parse_config_to_caps (GstRawAudioParse * raw_audio_parse, |
| GstCaps ** caps, GstRawAudioParseConfig * config) |
| { |
| gboolean ret = TRUE; |
| GstAudioChannelPosition *channel_positions; |
| |
| g_assert (caps != NULL); |
| |
| if (config->bpf == 0) { |
| GST_ERROR_OBJECT (raw_audio_parse, |
| "cannot convert config to caps - config not filled with valid values"); |
| *caps = NULL; |
| return FALSE; |
| } |
| |
| channel_positions = |
| config->needs_channel_reordering ? &(config-> |
| reordered_channel_positions[0]) : &(config->channel_positions[0]); |
| |
| switch (config->format) { |
| case GST_RAW_AUDIO_PARSE_FORMAT_PCM: |
| { |
| GstAudioInfo info; |
| gst_audio_info_init (&info); |
| gst_audio_info_set_format (&info, |
| config->pcm_format, |
| config->sample_rate, config->num_channels, channel_positions); |
| |
| *caps = gst_audio_info_to_caps (&info); |
| |
| break; |
| } |
| |
| case GST_RAW_AUDIO_PARSE_FORMAT_ALAW: |
| case GST_RAW_AUDIO_PARSE_FORMAT_MULAW: |
| { |
| guint64 channel_mask; |
| |
| if (!gst_audio_channel_positions_to_mask (channel_positions, |
| config->num_channels, TRUE, &channel_mask)) { |
| GST_ERROR_OBJECT (raw_audio_parse, "invalid channel positions"); |
| ret = FALSE; |
| break; |
| } |
| |
| *caps = gst_caps_new_simple ( |
| (config->format == |
| GST_RAW_AUDIO_PARSE_FORMAT_ALAW) ? "audio/x-alaw" : |
| "audio/x-mulaw", "rate", G_TYPE_INT, config->sample_rate, "channels", |
| G_TYPE_INT, config->num_channels, "channel-mask", GST_TYPE_BITMASK, |
| channel_mask, NULL); |
| |
| break; |
| } |
| |
| default: |
| g_assert_not_reached (); |
| ret = FALSE; |
| } |
| |
| if (!ret) |
| *caps = NULL; |
| |
| return ret; |
| } |
| |
| GType |
| gst_raw_audio_parse_format_get_type (void) |
| { |
| static GType audio_parse_format_gtype = 0; |
| static const GEnumValue types[] = { |
| {GST_RAW_AUDIO_PARSE_FORMAT_PCM, "PCM", "pcm"}, |
| {GST_RAW_AUDIO_PARSE_FORMAT_ALAW, "A-Law", "alaw"}, |
| {GST_RAW_AUDIO_PARSE_FORMAT_MULAW, "\302\265-Law", "mulaw"}, |
| {0, NULL, NULL} |
| }; |
| |
| if (!audio_parse_format_gtype) |
| audio_parse_format_gtype = |
| g_enum_register_static ("GstRawAudioParseFormat", types); |
| |
| return audio_parse_format_gtype; |
| } |