/* GStreamer

 * Copyright (C) 2003 Benjamin Otte <in7y118@public.uni-hamburg.de>

 * Copyright (C) 2005 Thomas Vander Stichele <thomas at apestaart dot org>

 * Copyright (C) 2005 Wim Taymans <wim at fluendo dot com>

 *

 * gstaudioconvert.c: Convert audio to different audio formats automatically

 *

 * 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., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

/**

 * SECTION:element-audioconvert

 *

 * <refsect2>

 * <para>

 * Audioconvert converts raw audio buffers between various possible formats.

 * It supports integer to float conversion, width/depth conversion,

 * signedness and endianness conversion.

 * </para>

 * <para>

 * Some format conversion are not carried out in an optimal way right now.

 * E.g. converting from double to float would cause a loss of precision.

 * </para>

 * <title>Example launch line</title>

 * <para>

 * <programlisting>

 * gst-launch -v -m audiotestsrc ! audioconvert ! audio/x-raw-int,channels=2,width=8,depth=8 ! level ! fakesink silent=TRUE

 * </programlisting>

 * This pipeline converts audio to 8-bit.  The level element shows that

 * the output levels still match the one for a sine wave.

 * </para>

 * <para>

 * <programlisting>

 * gst-launch -v -m audiotestsrc ! audioconvert ! vorbisenc ! fakesink silent=TRUE

 * </programlisting>

 * The vorbis encoder takes float audio data instead of the integer data

 * generated by audiotestsrc.

 * </para>

 * </refsect2>

 *

 * Last reviewed on 2006-03-02 (0.10.4)

 */

/*

 * design decisions:

 * - audioconvert converts buffers in a set of supported caps. If it supports

 *   a caps, it supports conversion from these caps to any other caps it

 *   supports. (example: if it does A=>B and A=>C, it also does B=>C)

 * - audioconvert does not save state between buffers. Every incoming buffer is

 *   converted and the converted buffer is pushed out.

 * conclusion:

 * audioconvert is not supposed to be a one-element-does-anything solution for

 * audio conversions.

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <string.h>

#include "gstaudioconvert.h"

#include "gstchannelmix.h"

#include "gstaudioquantize.h"

#include "plugin.h"

GST_DEBUG_CATEGORY (audio_convert_debug);

/*** DEFINITIONS **************************************************************/

static const GstElementDetails audio_convert_details =

GST_ELEMENT_DETAILS ("Audio converter",

    "Filter/Converter/Audio",

    "Convert audio to different formats",

    "Benjamin Otte <in7y118@public.uni-hamburg.de>");

/* type functions */

static void gst_audio_convert_dispose (GObject * obj);

/* gstreamer functions */

static gboolean gst_audio_convert_get_unit_size (GstBaseTransform * base,

    GstCaps * caps, guint * size);

static GstCaps *gst_audio_convert_transform_caps (GstBaseTransform * base,

    GstPadDirection direction, GstCaps * caps);

static void gst_audio_convert_fixate_caps (GstBaseTransform * base,

    GstPadDirection direction, GstCaps * caps, GstCaps * othercaps);

static gboolean gst_audio_convert_set_caps (GstBaseTransform * base,

    GstCaps * incaps, GstCaps * outcaps);

static GstFlowReturn gst_audio_convert_transform (GstBaseTransform * base,

    GstBuffer * inbuf, GstBuffer * outbuf);

static GstFlowReturn gst_audio_convert_transform_ip (GstBaseTransform * base,

    GstBuffer * buf);

static void gst_audio_convert_set_property (GObject * object, guint prop_id,

    const GValue * value, GParamSpec * pspec);

static void gst_audio_convert_get_property (GObject * object, guint prop_id,

    GValue * value, GParamSpec * pspec);

/* AudioConvert signals and args */

enum

{

  /* FILL ME */

  LAST_SIGNAL

};

enum

{

  ARG_0,

  ARG_DITHERING,

  ARG_NOISE_SHAPING,

};

#define DEBUG_INIT(bla) \

  GST_DEBUG_CATEGORY_INIT (audio_convert_debug, "audioconvert", 0, "audio conversion element");

GST_BOILERPLATE_FULL (GstAudioConvert, gst_audio_convert, GstBaseTransform,

    GST_TYPE_BASE_TRANSFORM, DEBUG_INIT);

/*** GSTREAMER PROTOTYPES *****************************************************/

#define STATIC_CAPS \

GST_STATIC_CAPS ( \

  "audio/x-raw-float, " \

    "rate = (int) [ 1, MAX ], " \

    "channels = (int) [ 1, 8 ], " \

    "endianness = (int) { LITTLE_ENDIAN, BIG_ENDIAN }, " \

    "width = (int) 64;" \

  "audio/x-raw-float, " \

    "rate = (int) [ 1, MAX ], " \

    "channels = (int) [ 1, 8 ], " \

    "endianness = (int) { LITTLE_ENDIAN, BIG_ENDIAN }, " \

    "width = (int) 32;" \

  "audio/x-raw-int, " \

    "rate = (int) [ 1, MAX ], " \

    "channels = (int) [ 1, 8 ], " \

    "endianness = (int) { LITTLE_ENDIAN, BIG_ENDIAN }, " \

    "width = (int) 32, " \

    "depth = (int) [ 1, 32 ], " \

    "signed = (boolean) { true, false }; " \

  "audio/x-raw-int, "   \

    "rate = (int) [ 1, MAX ], " \

    "channels = (int) [ 1, 8 ], "       \

    "endianness = (int) { LITTLE_ENDIAN, BIG_ENDIAN }, "        \

    "width = (int) 24, "        \

    "depth = (int) [ 1, 24 ], " "signed = (boolean) { true, false }; "  \

  "audio/x-raw-int, " \

    "rate = (int) [ 1, MAX ], " \

    "channels = (int) [ 1, 8 ], " \

    "endianness = (int) { LITTLE_ENDIAN, BIG_ENDIAN }, " \

    "width = (int) 16, " \

    "depth = (int) [ 1, 16 ], " \

    "signed = (boolean) { true, false }; " \

  "audio/x-raw-int, " \

    "rate = (int) [ 1, MAX ], " \

    "channels = (int) [ 1, 8 ], " \

    "endianness = (int) { LITTLE_ENDIAN, BIG_ENDIAN }, " \

    "width = (int) 8, " \

    "depth = (int) [ 1, 8 ], " \

    "signed = (boolean) { true, false } " \

)

static GstAudioChannelPosition *supported_positions;

static GstStaticPadTemplate gst_audio_convert_src_template =

GST_STATIC_PAD_TEMPLATE ("src",

    GST_PAD_SRC,

    GST_PAD_ALWAYS,

    STATIC_CAPS);

static GstStaticPadTemplate gst_audio_convert_sink_template =

GST_STATIC_PAD_TEMPLATE ("sink",

    GST_PAD_SINK,

    GST_PAD_ALWAYS,

    STATIC_CAPS);

#define GST_TYPE_AUDIO_CONVERT_DITHERING (gst_audio_convert_dithering_get_type ())

static GType

gst_audio_convert_dithering_get_type (void)

{

  static GType gtype = 0;

  if (gtype == 0) {

    static const GEnumValue values[] = {

      {DITHER_NONE, "No dithering",

          "none"},

      {DITHER_RPDF, "Rectangular dithering", "rpdf"},

      {DITHER_TPDF, "Triangular dithering (default)", "tpdf"},

      {DITHER_TPDF_HF, "High frequency triangular dithering", "tpdf-hf"},

      {0, NULL, NULL}

    };

    gtype = g_enum_register_static ("GstAudioConvertDithering", values);

  }

  return gtype;

}

#define GST_TYPE_AUDIO_CONVERT_NOISE_SHAPING (gst_audio_convert_ns_get_type ())

static GType

gst_audio_convert_ns_get_type (void)

{

  static GType gtype = 0;

  if (gtype == 0) {

    static const GEnumValue values[] = {

      {NOISE_SHAPING_NONE, "No noise shaping (default)",

          "none"},

      {NOISE_SHAPING_ERROR_FEEDBACK, "Error feedback", "error-feedback"},

      {NOISE_SHAPING_SIMPLE, "Simple 2-pole noise shaping", "simple"},

      {NOISE_SHAPING_MEDIUM, "Medium 5-pole noise shaping", "medium"},

      {NOISE_SHAPING_HIGH, "High 8-pole noise shaping", "high"},

      {0, NULL, NULL}

    };

    gtype = g_enum_register_static ("GstAudioConvertNoiseShaping", values);

  }

  return gtype;

}

/*** TYPE FUNCTIONS ***********************************************************/

static void

gst_audio_convert_base_init (gpointer g_class)

{

  GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);

  gst_element_class_add_pad_template (element_class,

      gst_static_pad_template_get (&gst_audio_convert_src_template));

  gst_element_class_add_pad_template (element_class,

      gst_static_pad_template_get (&gst_audio_convert_sink_template));

  gst_element_class_set_details (element_class, &audio_convert_details);

}

static void

gst_audio_convert_class_init (GstAudioConvertClass * klass)

{

  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);

  GstBaseTransformClass *basetransform_class = GST_BASE_TRANSFORM_CLASS (klass);

  gint i;

  gobject_class->dispose = gst_audio_convert_dispose;

  gobject_class->set_property = gst_audio_convert_set_property;

  gobject_class->get_property = gst_audio_convert_get_property;

  supported_positions = g_new0 (GstAudioChannelPosition,

      GST_AUDIO_CHANNEL_POSITION_NUM);

  for (i = 0; i < GST_AUDIO_CHANNEL_POSITION_NUM; i++)

    supported_positions[i] = i;

  g_object_class_install_property (gobject_class, ARG_DITHERING,

      g_param_spec_enum ("dithering", "Dithering",

          "Selects between different dithering methods.",

          GST_TYPE_AUDIO_CONVERT_DITHERING, DITHER_TPDF, G_PARAM_READWRITE));

  g_object_class_install_property (gobject_class, ARG_NOISE_SHAPING,

      g_param_spec_enum ("noise-shaping", "Noise shaping",

          "Selects between different noise shaping methods.",

          GST_TYPE_AUDIO_CONVERT_NOISE_SHAPING, NOISE_SHAPING_NONE,

          G_PARAM_READWRITE));

  basetransform_class->get_unit_size =

      GST_DEBUG_FUNCPTR (gst_audio_convert_get_unit_size);

  basetransform_class->transform_caps =

      GST_DEBUG_FUNCPTR (gst_audio_convert_transform_caps);

  basetransform_class->fixate_caps =

      GST_DEBUG_FUNCPTR (gst_audio_convert_fixate_caps);

  basetransform_class->set_caps =

      GST_DEBUG_FUNCPTR (gst_audio_convert_set_caps);

  basetransform_class->transform_ip =

      GST_DEBUG_FUNCPTR (gst_audio_convert_transform_ip);

  basetransform_class->transform =

      GST_DEBUG_FUNCPTR (gst_audio_convert_transform);

  basetransform_class->passthrough_on_same_caps = TRUE;

}

static void

gst_audio_convert_init (GstAudioConvert * this, GstAudioConvertClass * g_class)

{

  this->dither = DITHER_TPDF;

  this->ns = NOISE_SHAPING_NONE;

  memset (&this->ctx, 0, sizeof (AudioConvertCtx));

}

static void

gst_audio_convert_dispose (GObject * obj)

{

  GstAudioConvert *this = GST_AUDIO_CONVERT (obj);

  audio_convert_clean_context (&this->ctx);

  G_OBJECT_CLASS (parent_class)->dispose (obj);

}

/*** GSTREAMER FUNCTIONS ******************************************************/

/* convert the given GstCaps to our format */

static gboolean

gst_audio_convert_parse_caps (const GstCaps * caps, AudioConvertFmt * fmt)

{

  GstStructure *structure = gst_caps_get_structure (caps, 0);

  GST_DEBUG ("parse caps %p and %" GST_PTR_FORMAT, caps, caps);

  g_return_val_if_fail (gst_caps_is_fixed (caps), FALSE);

  g_return_val_if_fail (fmt != NULL, FALSE);

  /* cleanup old */

  audio_convert_clean_fmt (fmt);

  fmt->endianness = G_BYTE_ORDER;

  fmt->is_int =

      (strcmp (gst_structure_get_name (structure), "audio/x-raw-int") == 0);

  /* parse common fields */

  if (!gst_structure_get_int (structure, "channels", &fmt->channels))

    goto no_values;

  if (!(fmt->pos = gst_audio_get_channel_positions (structure)))

    goto no_values;

  if (!gst_structure_get_int (structure, "width", &fmt->width))

    goto no_values;

  if (!gst_structure_get_int (structure, "rate", &fmt->rate))

    goto no_values;

  /* width != 8 needs an endianness field */

  if (fmt->width != 8) {

    if (!gst_structure_get_int (structure, "endianness", &fmt->endianness))

      goto no_values;

  }

  if (fmt->is_int) {

    /* int specific fields */

    if (!gst_structure_get_boolean (structure, "signed", &fmt->sign))

      goto no_values;

    if (!gst_structure_get_int (structure, "depth", &fmt->depth))

      goto no_values;

    /* depth cannot be bigger than the width */

    if (fmt->depth > fmt->width)

      goto not_allowed;

  }

  fmt->unit_size = (fmt->width * fmt->channels) / 8;

  return TRUE;

  /* ERRORS */

no_values:

  {

    GST_DEBUG ("could not get some values from structure");

    audio_convert_clean_fmt (fmt);

    return FALSE;

  }

not_allowed:

  {

    GST_DEBUG ("width > depth, not allowed - make us advertise correct fmt");

    audio_convert_clean_fmt (fmt);

    return FALSE;

  }

}

/* BaseTransform vmethods */

static gboolean

gst_audio_convert_get_unit_size (GstBaseTransform * base, GstCaps * caps,

    guint * size)

{

  AudioConvertFmt fmt = { 0 };

  g_assert (size);

  if (!gst_audio_convert_parse_caps (caps, &fmt))

    goto parse_error;

  GST_INFO_OBJECT (base, "unit_size = %u", fmt.unit_size);

  *size = fmt.unit_size;

  audio_convert_clean_fmt (&fmt);

  return TRUE;

parse_error:

  {

    GST_INFO_OBJECT (base, "failed to parse caps to get unit_size");

    return FALSE;

  }

}

/* Set widths (a list); multiples of 8 between min and max */

static void

set_structure_widths (GstStructure * s, int min, int max)

{

  GValue list = { 0 };

  GValue val = { 0 };

  int width;

  if (min == max) {

    gst_structure_set (s, "width", G_TYPE_INT, min, NULL);

    return;

  }

  g_value_init (&list, GST_TYPE_LIST);

  g_value_init (&val, G_TYPE_INT);

  for (width = min; width <= max; width += 8) {

    g_value_set_int (&val, width);

    gst_value_list_append_value (&list, &val);

  }

  gst_structure_set_value (s, "width", &list);

  g_value_unset (&val);

  g_value_unset (&list);

}

/* Set widths of 32 bits and 64 bits (as list) */

static void

set_structure_widths_32_and_64 (GstStructure * s)

{

  GValue list = { 0 };

  GValue val = { 0 };

  g_value_init (&list, GST_TYPE_LIST);

  g_value_init (&val, G_TYPE_INT);

  g_value_set_int (&val, 32);

  gst_value_list_append_value (&list, &val);

  g_value_set_int (&val, 64);

  gst_value_list_append_value (&list, &val);

  gst_structure_set_value (s, "width", &list);

  g_value_unset (&val);

  g_value_unset (&list);

}

/* Modify the structure so that things that must always have a single

 * value (for float), or can always be losslessly converted (for int), have

 * appropriate values.

 */

static GstStructure *

make_lossless_changes (GstStructure * s, gboolean isfloat)

{

  GValue list = { 0 };

  GValue val = { 0 };

  int i;

  const gint endian[] = { G_LITTLE_ENDIAN, G_BIG_ENDIAN };

  const gboolean booleans[] = { TRUE, FALSE };

  g_value_init (&list, GST_TYPE_LIST);

  g_value_init (&val, G_TYPE_INT);

  for (i = 0; i < 2; i++) {

    g_value_set_int (&val, endian[i]);

    gst_value_list_append_value (&list, &val);

  }

  gst_structure_set_value (s, "endianness", &list);

  g_value_unset (&val);

  g_value_unset (&list);

  if (isfloat) {

    /* float doesn't have a depth or signedness field and only supports

     * widths of 32 and 64 bits */

    gst_structure_remove_field (s, "depth");

    gst_structure_remove_field (s, "signed");

    set_structure_widths_32_and_64 (s);

  } else {

    /* int supports signed and unsigned. GValues are a pain */

    g_value_init (&list, GST_TYPE_LIST);

    g_value_init (&val, G_TYPE_BOOLEAN);

    for (i = 0; i < 2; i++) {

      g_value_set_boolean (&val, booleans[i]);

      gst_value_list_append_value (&list, &val);

    }

    gst_structure_set_value (s, "signed", &list);

    g_value_unset (&val);

    g_value_unset (&list);

  }

  return s;

}

static void

strip_width_64 (GstStructure * s)

{

  const GValue *v = gst_structure_get_value (s, "width");

  GValue widths = { 0 };

  if (GST_VALUE_HOLDS_LIST (v)) {

    int i;

    int len = gst_value_list_get_size (v);

    g_value_init (&widths, GST_TYPE_LIST);

    for (i = 0; i < len; i++) {

      const GValue *width = gst_value_list_get_value (v, i);

      if (g_value_get_int (width) != 64)

        gst_value_list_append_value (&widths, width);

    }

    gst_structure_set_value (s, "width", &widths);

    g_value_unset (&widths);

  }

}

/* Little utility function to create a related structure for float/int */

static void

append_with_other_format (GstCaps * caps, GstStructure * s, gboolean isfloat)

{

  GstStructure *s2;

  if (isfloat) {

    s2 = gst_structure_copy (s);

    gst_structure_set_name (s2, "audio/x-raw-int");

    s = make_lossless_changes (s2, FALSE);

    /* If 64 bit float was allowed; remove width 64: we don't support it for 

     * integer*/

    strip_width_64 (s);

    gst_caps_append_structure (caps, s2);

  } else {

    s2 = gst_structure_copy (s);

    gst_structure_set_name (s2, "audio/x-raw-float");

    s = make_lossless_changes (s2, TRUE);

    gst_caps_append_structure (caps, s2);