/* GStreamer Framed Audio Encoder

 * Copyright 2009 Collabora Ltd,

 * Copyright 2009 Nokia Corporation

 *  @author: Mark Nauwelaerts <mark.nauwelaerts@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., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <gst/gst.h>

#include <gst/audio/audio.h>

#include <string.h>

#include "gstframedaudioenc.h"

/* generic part */

#ifndef RAW_FRAME_SIZE

/* this will reference caller's debug category;

 * there is a copy of this per plugin lib (= debug category) */

GST_DEBUG_CATEGORY_STATIC (framedaudioenc_debug);

#define GST_CAT_DEFAULT framedaudioenc_debug

void

gst_framed_audio_enc_reset (GstFramedAudioEnc * enc)

{

  gst_adapter_clear (enc->adapter);

  enc->next_ts = GST_CLOCK_TIME_NONE;

}

/* installs @enc as element private for @element's pad,

 * and possibly some event and query handler.

 * if these need overriding, chain up to them

 * chain and setcaps still need to be set by @element */

void

gst_framed_audio_enc_init (GstFramedAudioEnc * enc, GstElement * element,

    GstDebugCategory * cat)

{

  enc->element = element;

#ifndef GST_DISABLE_GST_DEBUG

  framedaudioenc_debug = cat;

#endif

  enc->adapter = gst_adapter_new ();

  /* hook some */

  enc->sinkpad = gst_element_get_pad (enc->element, "sink");

  g_assert (enc->sinkpad);

  gst_pad_set_element_private (enc->sinkpad, enc);

  /* watch downstream events */

  gst_pad_set_event_function (enc->sinkpad,

      GST_DEBUG_FUNCPTR (gst_framed_audio_enc_sink_event));

  gst_framed_audio_enc_reset (enc);

}

void

gst_framed_audio_enc_finalize (GstFramedAudioEnc * enc)

{

  gst_object_unref (enc->adapter);

  gst_pad_set_element_private (enc->sinkpad, NULL);

  gst_object_unref (enc->sinkpad);

}

GstPad *

gst_framed_audio_enc_request_new_pad (GstFramedAudioEnc * enc,

    GstPadTemplate * templ, const gchar * req_name, GstPad ** pad_p)

{

  GstElement *element;

  GstPad *newpad;

  GstElementClass *klass;

  GstCaps *caps;

  g_return_val_if_fail (templ != NULL, NULL);

  element = enc->element;

  klass = GST_ELEMENT_GET_CLASS (element);

  if (templ != gst_element_class_get_pad_template (klass, "cn"))

    goto wrong_template;

  GST_DEBUG_OBJECT (enc->element, "adding cn pad");

  newpad = gst_pad_new_from_template (templ, "cn");

  /* set template caps */

  caps = gst_caps_copy (gst_pad_get_pad_template_caps (newpad));

  gst_pad_set_caps (newpad, caps);

  gst_caps_unref (caps);

  gst_pad_use_fixed_caps (newpad);

  gst_pad_set_active (newpad, TRUE);

  /* only 1 pad by name can be added */

  if (gst_element_add_pad (element, newpad)) {

    GST_OBJECT_LOCK (element);

    gst_object_replace ((GstObject **) pad_p, GST_OBJECT_CAST (newpad));

    GST_OBJECT_UNLOCK (element);

    GST_DEBUG_OBJECT (enc->element, "cn pad added");

  } else {

    gst_object_unref (newpad);

    goto already_requested;

  }

  return newpad;

  /* ERRORS */

wrong_template:

  {

    GST_ERROR_OBJECT (element, "not our template!");

    return NULL;

  }

already_requested:

  {

    GST_ERROR_OBJECT (element, "only 1 instance of a pad can be requested");

    return NULL;

  }

}

void

gst_framed_audio_enc_release_pad (GstFramedAudioEnc * enc, GstPad * pad,

    GstPad ** pad_p, void (disable_cn) (GstElement *))

{

  GstElement *element = enc->element;

  GST_DEBUG_OBJECT (enc->element, "releasing cn pad");

  GST_OBJECT_LOCK (element);

  if (pad != *pad_p)

    goto wrong_pad;

  GST_OBJECT_UNLOCK (element);

  /* reconfigure encoder */

  disable_cn (element);

  if (gst_element_remove_pad (element, pad)) {

    GST_OBJECT_LOCK (element);

    gst_object_replace ((GstObject **) pad_p, NULL);

    GST_OBJECT_UNLOCK (element);

    GST_DEBUG_OBJECT (enc->element, "cn pad released");

  }

  /* ERRORS */

wrong_pad:

  {

    GST_OBJECT_UNLOCK (element);

    GST_ERROR_OBJECT (element, "pad not requested; can not be released!");

    return;

  }

}

gboolean

gst_framed_audio_enc_sink_event (GstPad * pad, GstEvent * event)

{

  GstFramedAudioEnc *enc;

  enc = gst_pad_get_element_private (pad);

  g_return_val_if_fail (enc, FALSE);

  GST_LOG_OBJECT (enc->element, "received %s", GST_EVENT_TYPE_NAME (event));

  switch (GST_EVENT_TYPE (event)) {

    case GST_EVENT_FLUSH_STOP:

      /* fall-through */

    case GST_EVENT_EOS:

      gst_adapter_clear (enc->adapter);

      enc->next_ts = GST_CLOCK_TIME_NONE;

      break;

    default:

      break;

  }

  return gst_pad_event_default (pad, event);

}

#else

/* included part */

/* parameters:

     RAW_FRAME_SIZE

     CODEC_FRAME_SIZE

     FRAME_DURATION

     AUDIO_SAMPLE_RATE (optional)

   callback:

     codec_get_data(enc, in, out, dtx)

   If one does not mind a few cycles, include'ing can also be replaced by

   a regular include & call, at the expense of some additional parameters

   passed some way or another.

*/

#ifndef AUDIO_SAMPLE_RATE

#define AUDIO_SAMPLE_RATE   (8000)

#endif

/* quite some conditional stuff;

 * the (ugly?) cost of trying to stay inner loop optimal */

static GstFlowReturn

gst_framed_audio_enc_chain (GstFramedAudioEnc * enc, GstBuffer * buf,

    GstPad * srcpad, GstPad ** _cnpad)

{

  GstFlowReturn ret = GST_FLOW_OK;

  GstBuffer *obuf = NULL;

#ifdef CN_PAD

  GstBuffer *cnbuf = NULL;

  GstPad *cnpad = NULL;

#endif

  gboolean discont = FALSE;

  const guint8 *data;

  guint8 *odata;

  gint av, flush, osize;

#ifdef CN_PAD

  GST_OBJECT_LOCK (enc->element);

  if (_cnpad)

    cnpad = *_cnpad;

  if (cnpad)

    gst_object_ref (cnpad);

  GST_OBJECT_UNLOCK (enc->element);

#endif

  if (G_LIKELY (buf)) {

    GST_LOG_OBJECT (enc->element, "input buffer of size %d with ts: %"

        GST_TIME_FORMAT, GST_BUFFER_SIZE (buf),

        GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf)));

    discont = GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_DISCONT);

    /* reposition to the new buffer's timestamp,

     * while correcting for some minor left-over */

    if (GST_BUFFER_TIMESTAMP_IS_VALID (buf)) {

      if (GST_CLOCK_TIME_IS_VALID (enc->next_ts)) {

        GstClockTimeDiff diff, limit;

        GstClockTime tleft;

        tleft = GST_FRAMES_TO_CLOCK_TIME

            (gst_adapter_available (enc->adapter) / 2, AUDIO_SAMPLE_RATE);

        diff =

            GST_CLOCK_DIFF (enc->next_ts + tleft, GST_BUFFER_TIMESTAMP (buf));

        limit = GST_SECOND / AUDIO_SAMPLE_RATE / 2;

        /* try for a perfect stream if possible, do not act on rounding errors */

        if (diff > limit || diff < -limit) {

          enc->next_ts = GST_BUFFER_TIMESTAMP (buf);

          if (enc->next_ts > tleft)

            enc->next_ts -= tleft;

          GST_LOG_OBJECT (enc->element, "marking discont based on timestamps");

          discont = TRUE;

        }

      } else

        enc->next_ts = GST_BUFFER_TIMESTAMP (buf);

    }

    gst_adapter_push (enc->adapter, buf);

    buf = NULL;

  }

  av = gst_adapter_available (enc->adapter);

  if (G_UNLIKELY (av < RAW_FRAME_SIZE))

    goto done;

  data = gst_adapter_peek (enc->adapter, av);

  obuf = gst_buffer_new_and_alloc (av / RAW_FRAME_SIZE * CODEC_FRAME_SIZE);

  odata = GST_BUFFER_DATA (obuf);

  osize = 0;

  flush = 0;

  while (TRUE) {

    gint esize;

#ifdef CN_PAD

    GstDtxDecision dtx;

    /* safe default to start with, should get set */

    dtx = GST_DTX_DECISION_VOICE;

    esize = codec_get_data (enc->element, data + flush, odata, &dtx);

#else

    esize = codec_get_data (enc->element, data + flush, odata, NULL);

#endif

    if (G_UNLIKELY (esize < 0))

      goto encode_failed;

#ifdef CN_PAD

    /* cn in a separate stream */

    switch (dtx) {

      case GST_DTX_DECISION_VOICE:

#endif

        flush += RAW_FRAME_SIZE;

        av -= RAW_FRAME_SIZE;

        odata += esize;

        osize += esize;

#ifdef CN_PAD

        break;

      case GST_DTX_DECISION_SID_UPDATE:

        GST_LOG_OBJECT (enc->element, "dtx: SID_UPDATE %d", esize);

        /* if already data before, need to put SID data separately */

        if (G_UNLIKELY (osize)) {

          cnbuf = gst_buffer_new_and_alloc (esize);

          memcpy (GST_BUFFER_DATA (cnbuf), data + osize, esize);

        } else {

          cnbuf = obuf;

          obuf = NULL;

        }

        /* and send one or both */

        goto send;

        break;

      case GST_DTX_DECISION_SID_NONE:

        GST_LOG_OBJECT (enc->element, "dtx: SID_NONE %d", esize);

        /* maybe send preceding voice, if any */

        goto send;

        break;

    }

#endif

#ifdef CODEC_FRAME_VARIABLE

    /* flush output after insufficient data */

    if (av >= RAW_FRAME_SIZE)

      continue;

#else

    /* ... or some reduced (e.g. silence) frame */

    if (esize >= CODEC_FRAME_SIZE && av >= RAW_FRAME_SIZE)

      continue;

#endif

#ifdef CN_PAD

  send:

#endif

    /* maybe a silent discarded frame */

    if (G_LIKELY (osize)) {

      GST_BUFFER_SIZE (obuf) = osize;

      GST_BUFFER_DURATION (obuf)

          = FRAME_DURATION * (flush / RAW_FRAME_SIZE);

      GST_BUFFER_TIMESTAMP (obuf) = enc->next_ts;

      if (G_UNLIKELY (discont)) {

        GST_BUFFER_FLAG_SET (obuf, GST_BUFFER_FLAG_DISCONT);

        discont = FALSE;

      }

      GST_LOG_OBJECT (enc->element,

          "pushing buffer of size %d with ts: %" GST_TIME_FORMAT,

          GST_BUFFER_SIZE (obuf), GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (obuf)));

      gst_buffer_set_caps (obuf, GST_PAD_CAPS (srcpad));

      ret = gst_pad_push (srcpad, obuf);

      obuf = NULL;

    } else {

      ret = GST_FLOW_OK;

    }

#ifdef CN_PAD

    /* check for stuff to send on cn pad */

    if (cnbuf && cnpad) {

      /* only at most 1 SID update per buffer */

      GST_BUFFER_SIZE (cnbuf) = esize;

      GST_BUFFER_DURATION (cnbuf) = FRAME_DURATION;

      GST_BUFFER_TIMESTAMP (cnbuf) = enc->next_ts;

      GST_LOG_OBJECT (enc->element,

          "pushing cn buffer of size %d with ts: %" GST_TIME_FORMAT,

          GST_BUFFER_SIZE (cnbuf),

          GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (cnbuf)));

      gst_buffer_set_caps (cnbuf, GST_PAD_CAPS (cnpad));

      if (G_LIKELY (ret == GST_FLOW_OK)) {

        ret = gst_pad_push (cnpad, cnbuf);

        /* cn pad may not be linked */

        if (G_UNLIKELY (ret == GST_FLOW_NOT_LINKED))

          ret = GST_FLOW_OK;

      } else

        gst_pad_push (cnpad, cnbuf);

      cnbuf = NULL;

    } else if (G_UNLIKELY (cnbuf)) {

      /* should not occur */

      gst_buffer_unref (cnbuf);

      cnbuf = NULL;

    }

    if (dtx != GST_DTX_DECISION_VOICE) {

      /* still need to count non-voice encoded frame */

      flush += RAW_FRAME_SIZE;

      av -= RAW_FRAME_SIZE;

    }

#endif /* CN_PAD */

    /* remove used part */

    gst_adapter_flush (enc->adapter, flush);

    if (GST_CLOCK_TIME_IS_VALID (enc->next_ts))

      enc->next_ts += FRAME_DURATION * (flush / RAW_FRAME_SIZE);

    /* end if insufficient left or error */

    if (av < RAW_FRAME_SIZE || ret != GST_FLOW_OK)

      break;

    /* allocate new buffer */

    if (!obuf) {

      obuf = gst_buffer_new_and_alloc (av / RAW_FRAME_SIZE * CODEC_FRAME_SIZE);

      odata = GST_BUFFER_DATA (obuf);

      osize = 0;

    }

    /* and prepare to consume again */

    data = gst_adapter_peek (enc->adapter, av);

    flush = 0;

  }

  if (!av) {

    enc->next_ts = GST_CLOCK_TIME_NONE;

  }

done:

#ifdef CN_PAD

  GST_OBJECT_LOCK (enc->element);

  if (cnpad)

    gst_object_unref (cnpad);

  GST_OBJECT_UNLOCK (enc->element);

#endif

  return ret;

  /* ERRORS */

encode_failed:

  {

    GST_ELEMENT_ERROR (enc, STREAM, ENCODE, (NULL), (NULL));

    ret = GST_FLOW_ERROR;

    gst_buffer_unref (obuf);

    goto done;

  }

}

#endif