| /* GStreamer audio helper functions for IEC 61937 payloading |
| * (c) 2011 Intel Corporation |
| * 2011 Collabora Multimedia |
| * 2011 Arun Raghavan <arun.raghavan@collabora.co.uk> |
| * |
| * 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:gstaudioiec61937 |
| * @title: GstAudio IEC61937 |
| * @short_description: Utility functions for IEC 61937 payloading |
| * |
| * This module contains some helper functions for encapsulating various |
| * audio formats in IEC 61937 headers and padding. |
| * |
| */ |
| |
| #ifdef HAVE_CONFIG_H |
| #include "config.h" |
| #endif |
| |
| #include <string.h> |
| |
| #include <gst/audio/audio.h> |
| #include "gstaudioiec61937.h" |
| |
| #define IEC61937_HEADER_SIZE 8 |
| #define IEC61937_PAYLOAD_SIZE_AC3 (1536 * 4) |
| #define IEC61937_PAYLOAD_SIZE_EAC3 (6144 * 4) |
| #define IEC61937_PAYLOAD_SIZE_AAC (1024 * 4) |
| |
| static gint |
| caps_get_int_field (const GstCaps * caps, const gchar * field) |
| { |
| const GstStructure *st; |
| gint ret = 0; |
| |
| st = gst_caps_get_structure (caps, 0); |
| gst_structure_get_int (st, field, &ret); |
| |
| return ret; |
| } |
| |
| static const gchar * |
| caps_get_string_field (const GstCaps * caps, const gchar * field) |
| { |
| const GstStructure *st = gst_caps_get_structure (caps, 0); |
| return gst_structure_get_string (st, field); |
| } |
| |
| /** |
| * gst_audio_iec61937_frame_size: |
| * @spec: the ringbufer spec |
| * |
| * Calculated the size of the buffer expected by gst_audio_iec61937_payload() for |
| * payloading type from @spec. |
| * |
| * Returns: the size or 0 if the given @type is not supported or cannot be |
| * payloaded. |
| */ |
| guint |
| gst_audio_iec61937_frame_size (const GstAudioRingBufferSpec * spec) |
| { |
| switch (spec->type) { |
| case GST_AUDIO_RING_BUFFER_FORMAT_TYPE_AC3: |
| return IEC61937_PAYLOAD_SIZE_AC3; |
| |
| case GST_AUDIO_RING_BUFFER_FORMAT_TYPE_EAC3: |
| /* Check that the parser supports /some/ alignment. Need to be less |
| * strict about this at checking time since the alignment is dynamically |
| * set at the moment. */ |
| if (caps_get_string_field (spec->caps, "alignment")) |
| return IEC61937_PAYLOAD_SIZE_EAC3; |
| else |
| return 0; |
| |
| case GST_AUDIO_RING_BUFFER_FORMAT_TYPE_DTS: |
| { |
| gint dts_frame_size = caps_get_int_field (spec->caps, "frame-size"); |
| gint iec_frame_size = caps_get_int_field (spec->caps, "block-size") * 4; |
| |
| /* Note: this will also (correctly) fail if either field is missing */ |
| if (iec_frame_size >= (dts_frame_size + IEC61937_HEADER_SIZE)) |
| return iec_frame_size; |
| else |
| return 0; |
| } |
| |
| case GST_AUDIO_RING_BUFFER_FORMAT_TYPE_MPEG: |
| { |
| int version, layer, channels, frames; |
| |
| version = caps_get_int_field (spec->caps, "mpegaudioversion"); |
| layer = caps_get_int_field (spec->caps, "layer"); |
| channels = caps_get_int_field (spec->caps, "channels"); |
| |
| /* Bail out if we can't figure out either, if it's MPEG 2.5, or if it's |
| * MP3 with multichannel audio */ |
| if (!version || !layer || version == 3 || channels > 2) |
| return 0; |
| |
| if (version == 1 && layer == 1) |
| frames = 384; |
| else if (version == 2 && layer == 1 && spec->info.rate <= 12000) |
| frames = 768; |
| else if (version == 2 && layer == 2 && spec->info.rate <= 12000) |
| frames = 2304; |
| else { |
| /* MPEG-1 layer 2,3, MPEG-2 with or without extension, |
| * MPEG-2 layer 3 low sample freq. */ |
| frames = 1152; |
| } |
| |
| return frames * 4; |
| } |
| |
| case GST_AUDIO_RING_BUFFER_FORMAT_TYPE_MPEG2_AAC: |
| case GST_AUDIO_RING_BUFFER_FORMAT_TYPE_MPEG4_AAC: |
| { |
| return IEC61937_PAYLOAD_SIZE_AAC; |
| } |
| |
| default: |
| return 0; |
| } |
| } |
| |
| /** |
| * gst_audio_iec61937_payload: |
| * @src: (array length=src_n): a buffer containing the data to payload |
| * @src_n: size of @src in bytes |
| * @dst: (array length=dst_n): the destination buffer to store the |
| * payloaded contents in. Should not overlap with @src |
| * @dst_n: size of @dst in bytes |
| * @spec: the ringbufer spec for @src |
| * @endianness: the expected byte order of the payloaded data |
| * |
| * Payloads @src in the form specified by IEC 61937 for the type from @spec and |
| * stores the result in @dst. @src must contain exactly one frame of data and |
| * the frame is not checked for errors. |
| * |
| * Returns: transfer-full: %TRUE if the payloading was successful, %FALSE |
| * otherwise. |
| */ |
| gboolean |
| gst_audio_iec61937_payload (const guint8 * src, guint src_n, guint8 * dst, |
| guint dst_n, const GstAudioRingBufferSpec * spec, gint endianness) |
| { |
| guint i, tmp; |
| #if G_BYTE_ORDER == G_BIG_ENDIAN |
| guint8 zero = 0, one = 1, two = 2, three = 3, four = 4, five = 5, six = 6, |
| seven = 7; |
| #else |
| /* We need to send the data byte-swapped */ |
| guint8 zero = 1, one = 0, two = 3, three = 2, four = 5, five = 4, six = 7, |
| seven = 6; |
| #endif |
| |
| g_return_val_if_fail (src != NULL, FALSE); |
| g_return_val_if_fail (dst != NULL, FALSE); |
| g_return_val_if_fail (src != dst, FALSE); |
| g_return_val_if_fail (dst_n >= gst_audio_iec61937_frame_size (spec), FALSE); |
| |
| if (dst_n < src_n + IEC61937_HEADER_SIZE) |
| return FALSE; |
| |
| /* Pa, Pb */ |
| dst[zero] = 0xF8; |
| dst[one] = 0x72; |
| dst[two] = 0x4E; |
| dst[three] = 0x1F; |
| |
| switch (spec->type) { |
| case GST_AUDIO_RING_BUFFER_FORMAT_TYPE_AC3: |
| { |
| g_return_val_if_fail (src_n >= 6, FALSE); |
| |
| /* Pc: bit 13-15 - stream number (0) |
| * bit 11-12 - reserved (0) |
| * bit 8-10 - bsmod from AC3 frame */ |
| dst[four] = src[5] & 0x7; |
| /* Pc: bit 7 - error bit (0) |
| * bit 5-6 - subdata type (0) |
| * bit 0-4 - data type (1) */ |
| dst[five] = 1; |
| /* Pd: bit 15-0 - frame size in bits */ |
| tmp = src_n * 8; |
| dst[six] = (guint8) (tmp >> 8); |
| dst[seven] = (guint8) (tmp & 0xff); |
| |
| break; |
| } |
| |
| case GST_AUDIO_RING_BUFFER_FORMAT_TYPE_EAC3: |
| { |
| if (g_str_equal (caps_get_string_field (spec->caps, "alignment"), |
| "iec61937")) |
| return FALSE; |
| |
| /* Pc: bit 13-15 - stream number (0) |
| * bit 11-12 - reserved (0) |
| * bit 8-10 - bsmod from E-AC3 frame if present */ |
| /* FIXME: this works, but nicer if we can put in the actual bsmod */ |
| dst[four] = 0; |
| /* Pc: bit 7 - error bit (0) |
| * bit 5-6 - subdata type (0) |
| * bit 0-4 - data type (21) */ |
| dst[five] = 21; |
| /* Pd: bit 15-0 - frame size in bytes */ |
| dst[six] = ((guint16) src_n) >> 8; |
| dst[seven] = ((guint16) src_n) & 0xff; |
| |
| break; |
| } |
| |
| case GST_AUDIO_RING_BUFFER_FORMAT_TYPE_DTS: |
| { |
| int blocksize = caps_get_int_field (spec->caps, "block-size"); |
| |
| g_return_val_if_fail (src_n != 0, FALSE); |
| |
| if (blocksize == 0) |
| return FALSE; |
| |
| /* Pc: bit 13-15 - stream number (0) |
| * bit 11-12 - reserved (0) |
| * bit 8-10 - for DTS type I-III (0) */ |
| dst[four] = 0; |
| /* Pc: bit 7 - error bit (0) |
| * bit 5-6 - reserved (0) |
| * bit 0-4 - data type (11 = type I, 12 = type II, |
| * 13 = type III) */ |
| dst[five] = 11 + (blocksize / 1024); |
| /* Pd: bit 15-0 - frame size, in bits (for type I-III) */ |
| tmp = src_n * 8; |
| dst[six] = ((guint16) tmp) >> 8; |
| dst[seven] = ((guint16) tmp) & 0xff; |
| break; |
| } |
| |
| case GST_AUDIO_RING_BUFFER_FORMAT_TYPE_MPEG: |
| { |
| int version, layer; |
| |
| version = caps_get_int_field (spec->caps, "mpegaudioversion"); |
| layer = caps_get_int_field (spec->caps, "layer"); |
| |
| g_return_val_if_fail (version > 0 && layer > 0, FALSE); |
| |
| /* NOTE: multichannel audio (MPEG-2) is not supported */ |
| |
| /* Pc: bit 13-15 - stream number (0) |
| * bit 11-12 - reserved (0) |
| * bit 9-10 - 0 - no dynamic range control |
| * - 2 - dynamic range control exists |
| * - 1,3 - reserved |
| * bit 8 - Normal (0) or Karaoke (1) mode */ |
| dst[four] = 0; |
| /* Pc: bit 7 - error bit (0) |
| * bit 5-6 - reserved (0) |
| * bit 0-4 - data type (04 = MPEG 1, Layer 1 |
| * 05 = MPEG 1, Layer 2, 3 / MPEG 2, w/o ext. |
| * 06 = MPEG 2, with extension |
| * 08 - MPEG 2 LSF, Layer 1 |
| * 09 - MPEG 2 LSF, Layer 2 |
| * 10 - MPEG 2 LSF, Layer 3 |
| * FIXME: we don't handle type 06 at the moment */ |
| if (version == 1 && layer == 1) |
| dst[five] = 0x04; |
| else if ((version == 1 && (layer == 2 || layer == 3)) || |
| (version == 2 && spec->info.rate >= 12000)) |
| dst[five] = 0x05; |
| else if (version == 2 && layer == 1 && spec->info.rate < 12000) |
| dst[five] = 0x08; |
| else if (version == 2 && layer == 2 && spec->info.rate < 12000) |
| dst[five] = 0x09; |
| else if (version == 2 && layer == 3 && spec->info.rate < 12000) |
| dst[five] = 0x0A; |
| else |
| g_return_val_if_reached (FALSE); |
| /* Pd: bit 15-0 - frame size in bits */ |
| dst[six] = ((guint16) src_n * 8) >> 8; |
| dst[seven] = ((guint16) src_n * 8) & 0xff; |
| |
| break; |
| } |
| |
| case GST_AUDIO_RING_BUFFER_FORMAT_TYPE_MPEG2_AAC: |
| /* HACK. disguising MPEG4 AAC as MPEG2 AAC seems to work. */ |
| /* TODO: set the right Pc,Pd for MPEG4 in accordance with IEC61937-6 */ |
| case GST_AUDIO_RING_BUFFER_FORMAT_TYPE_MPEG4_AAC: |
| { |
| int num_rd_blks; |
| |
| g_return_val_if_fail (src_n >= 7, FALSE); |
| num_rd_blks = (src[6] & 0x03) + 1; |
| |
| /* Pc: bit 13-15 - stream number (0) |
| * bit 11-12 - reserved (0) |
| * bit 8-10 - reserved? (0) */ |
| dst[four] = 0; |
| /* Pc: bit 7 - error bit (0) |
| * bit 5-6 - reserved (0) |
| * bit 0-4 - data type (07 = MPEG2 AAC ADTS |
| * 19 = MPEG2 AAC ADTS half-rate LSF |
| * 51 = MPEG2 AAC ADTS quater-rate LSF */ |
| if (num_rd_blks == 1) |
| dst[five] = 0x07; |
| else if (num_rd_blks == 2) |
| dst[five] = 0x13; |
| else if (num_rd_blks == 4) |
| dst[five] = 0x33; |
| else |
| g_return_val_if_reached (FALSE); |
| |
| /* Pd: bit 15-0 - frame size in bits */ |
| tmp = GST_ROUND_UP_2 (src_n) * 8; |
| dst[six] = (guint8) (tmp >> 8); |
| dst[seven] = (guint8) (tmp & 0xff); |
| break; |
| } |
| |
| default: |
| return FALSE; |
| } |
| |
| /* Copy the payload */ |
| i = 8; |
| |
| if (G_BYTE_ORDER == endianness) { |
| memcpy (dst + i, src, src_n); |
| } else { |
| /* Byte-swapped again */ |
| /* FIXME: orc-ify this */ |
| for (tmp = 1; tmp < src_n; tmp += 2) { |
| dst[i + tmp - 1] = src[tmp]; |
| dst[i + tmp] = src[tmp - 1]; |
| } |
| /* Do we have 1 byte remaining? */ |
| if (src_n % 2) { |
| dst[i + src_n - 1] = 0; |
| dst[i + src_n] = src[src_n - 1]; |
| i++; |
| } |
| } |
| |
| i += src_n; |
| |
| /* Zero the rest */ |
| memset (dst + i, 0, dst_n - i); |
| |
| return TRUE; |
| } |
