/* GStreamer

 * Copyright (C) <2018> Collabora Ltd.

 *   @author George Kiagiadakis <george.kiagiadakis@collabora.com>

 *

 * 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.

 */

#ifdef HAVE_CONFIG_H

#  include "config.h"

#endif

#include "audio-buffer.h"

static void

gst_audio_buffer_unmap_internal (GstAudioBuffer * buffer, guint n_unmap)

{

  guint i;

  /* Allow to unmap even if not mapped, to work nicely with

   * g_auto (GstAudioBuffer) buffer = GST_AUDIO_BUFFER_INIT;

   * This is also more consistent with gst_buffer_unmap() */

  if (!buffer->buffer)

    return;

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

    gst_buffer_unmap (buffer->buffer, &buffer->map_infos[i]);

  }

  if (buffer->planes != buffer->priv_planes_arr)

    g_clear_pointer (&buffer->planes, g_free);

  if (buffer->map_infos != buffer->priv_map_infos_arr)

    g_clear_pointer (&buffer->map_infos, g_free);

  /* Reset various fields to avoid use-after-frees.

   * This also makes it possible to call unmap() twice. */

  buffer->buffer = NULL;

  memset (&buffer->priv_planes_arr, 0, sizeof (buffer->priv_planes_arr));

  memset (&buffer->priv_map_infos_arr, 0, sizeof (buffer->priv_map_infos_arr));

}

/**

 * gst_audio_buffer_unmap:

 * @buffer: the #GstAudioBuffer to unmap

 *

 * Unmaps an audio buffer that was previously mapped with

 * gst_audio_buffer_map().

 *

 * Since: 1.16

 */

void

gst_audio_buffer_unmap (GstAudioBuffer * buffer)

{

  gst_audio_buffer_unmap_internal (buffer, buffer->n_planes);

}

/**

 * gst_audio_buffer_map:

 * @buffer: (out caller-allocates): pointer to a #GstAudioBuffer

 * @info: the audio properties of the buffer

 * @gstbuffer: (transfer none): the #GstBuffer to be mapped

 * @flags: the access mode for the memory

 *

 * Maps an audio @gstbuffer so that it can be read or written and stores the

 * result of the map operation in @buffer.

 *

 * This is especially useful when the @gstbuffer is in non-interleaved (planar)

 * layout, in which case this function will use the information in the

 * @gstbuffer's attached #GstAudioMeta in order to map each channel in a

 * separate "plane" in #GstAudioBuffer. If a #GstAudioMeta is not attached

 * on the @gstbuffer, then it must be in interleaved layout.

 *

 * If a #GstAudioMeta is attached, then the #GstAudioInfo on the meta is checked

 * against @info. Normally, they should be equal, but in case they are not,

 * a g_critical will be printed and the #GstAudioInfo from the meta will be

 * used.

 *

 * In non-interleaved buffers, it is possible to have each channel on a separate

 * #GstMemory. In this case, each memory will be mapped separately to avoid

 * copying their contents in a larger memory area. Do note though that it is

 * not supported to have a single channel spanning over two or more different

 * #GstMemory objects. Although the map operation will likely succeed in this

 * case, it will be highly sub-optimal and it is recommended to merge all the

 * memories in the buffer before calling this function.

 *

 * Note: The actual #GstBuffer is not ref'ed, but it is required to stay valid

 * as long as it's mapped.

 *

 * Returns: %TRUE if the map operation succeeded or %FALSE on failure

 *

 * Since: 1.16

 */

gboolean

gst_audio_buffer_map (GstAudioBuffer * buffer, const GstAudioInfo * info,

    GstBuffer * gstbuffer, GstMapFlags flags)

{

  GstAudioMeta *meta = NULL;

  guint i = 0, idx, length;

  gsize skip;

  g_return_val_if_fail (buffer != NULL, FALSE);

  g_return_val_if_fail (info != NULL, FALSE);

  g_return_val_if_fail (GST_AUDIO_INFO_IS_VALID (info), FALSE);

  g_return_val_if_fail (GST_AUDIO_INFO_FORMAT (info) !=

      GST_AUDIO_FORMAT_UNKNOWN, FALSE);

  g_return_val_if_fail (GST_IS_BUFFER (gstbuffer), FALSE);

  meta = gst_buffer_get_audio_meta (gstbuffer);

  /* be strict on the layout */

  g_return_val_if_fail ((!meta && info->layout == GST_AUDIO_LAYOUT_INTERLEAVED)

      || (meta && info->layout == meta->info.layout), FALSE);

  /* and not so strict on other fields */

  if (G_UNLIKELY (meta && !gst_audio_info_is_equal (&meta->info, info))) {

    g_critical ("the GstAudioInfo argument is not equal "

        "to the GstAudioMeta's attached info");

  }

  if (meta) {

    /* make sure that the meta doesn't imply having more samples than

     * what's actually possible to store in this buffer */

    g_return_val_if_fail (meta->samples <=

        gst_buffer_get_size (gstbuffer) / GST_AUDIO_INFO_BPF (&meta->info),

        FALSE);

    buffer->n_samples = meta->samples;

  } else {

    buffer->n_samples =

        gst_buffer_get_size (gstbuffer) / GST_AUDIO_INFO_BPF (info);

  }

  buffer->info = meta ? meta->info : *info;

  buffer->buffer = gstbuffer;

  if (GST_AUDIO_BUFFER_LAYOUT (buffer) == GST_AUDIO_LAYOUT_INTERLEAVED) {

    /* interleaved */

    buffer->n_planes = 1;

    buffer->planes = buffer->priv_planes_arr;

    buffer->map_infos = buffer->priv_map_infos_arr;

    if (!gst_buffer_map (gstbuffer, &buffer->map_infos[0], flags))

      return FALSE;

    buffer->planes[0] = buffer->map_infos[0].data;

  } else {

    /* non-interleaved */

    buffer->n_planes = GST_AUDIO_BUFFER_CHANNELS (buffer);

    if (G_UNLIKELY (buffer->n_planes > 8)) {

      buffer->planes = g_new (gpointer, buffer->n_planes);

      buffer->map_infos = g_new (GstMapInfo, buffer->n_planes);

    } else {

      buffer->planes = buffer->priv_planes_arr;

      buffer->map_infos = buffer->priv_map_infos_arr;

    }

    if (buffer->n_samples == 0) {

      memset (buffer->map_infos, 0,

          buffer->n_planes * sizeof (buffer->map_infos[0]));

      memset (buffer->planes, 0, buffer->n_planes * sizeof (buffer->planes[0]));

    } else {

      for (i = 0; i < buffer->n_planes; i++) {

        if (!gst_buffer_find_memory (gstbuffer, meta->offsets[i],

                GST_AUDIO_BUFFER_PLANE_SIZE (buffer), &idx, &length, &skip))

          goto no_memory;

        if (!gst_buffer_map_range (gstbuffer, idx, length,

                &buffer->map_infos[i], flags))

          goto cannot_map;

        buffer->planes[i] = buffer->map_infos[i].data + skip;

      }

    }

  }

  return TRUE;

no_memory:

  {

    GST_DEBUG ("plane %u, no memory at offset %" G_GSIZE_FORMAT, i,

        meta->offsets[i]);

    gst_audio_buffer_unmap_internal (buffer, i);

    return FALSE;

  }

cannot_map:

  {

    GST_DEBUG ("cannot map memory range %u-%u", idx, length);

    gst_audio_buffer_unmap_internal (buffer, i);

    return FALSE;

  }

}