mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-11-09 10:59:39 +00:00
099ac9faf2
Modernizing the documentation, making it simpler to read an modify and allowing us to possibly switch to hotdoc in the future.
367 lines
11 KiB
C
367 lines
11 KiB
C
/* 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;
|
|
}
|