/* GStreamer

 * Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>

 *               2000,2005 Wim Taymans <wim@fluendo.com>

 *

 * gstdevsoundsink.c:

 *

 * 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 "common.h"

#include "gstdevsoundsink.h"

#include "gsterrorconcealmentinterface.h"

#include "gstg711decoderinterface.h"

#include "gstg729decoderinterface.h"

#include "gstilbcdecoderinterface.h"

#include "string.h"

#include <glib_global.h>

#ifdef AV_SYNC

#include <gst/audio/gstaudioclock.h>

#endif /*AV_SYNC*/

GST_DEBUG_CATEGORY_EXTERN (devsound_debug);

#define GST_CAT_DEFAULT devsound_debug

/* elementfactory information */

static const GstElementDetails gst_devsound_sink_details=

GST_ELEMENT_DETAILS ("Audio Sink (DEVSOUND)",

        "Sink/Audio",

        "Output to a speaker via Devsound",

        " "

);

static void gst_devsound_sink_base_init(gpointer g_class);

static void gst_devsound_sink_class_init(GstDevsoundSinkClass * klass);

static void gst_devsound_sink_init(GstDevsoundSink * devsoundsink);

static void gst_devsound_sink_dispose(GObject * object);

static void gst_devsound_sink_finalise(GObject * object);

static void gst_devsound_sink_get_property(GObject * object, guint prop_id,

        GValue * value, GParamSpec * pspec);

static void gst_devsound_sink_set_property(GObject * object, guint prop_id,

        const GValue * value, GParamSpec * pspec);

static GstCaps *gst_devsound_sink_getcaps(GstBaseSink * bsink);

static gboolean gst_devsound_sink_setcaps(GstBaseSink *bsink, GstCaps *caps);

static gboolean gst_devsound_sink_event(GstBaseSink * asink, GstEvent * event);

#ifdef AV_SYNC

static void gst_devsound_sink_get_times(GstBaseSink * bsink, GstBuffer * buffer,

    GstClockTime * start, GstClockTime * end);

static GstClock *gst_devsound_sink_provide_clock (GstElement * element);

static GstClockTime gst_devsound_sink_get_time (GstClock * clock,

    gpointer user_data);

#endif /*AV_SYNC*/

static GstStateChangeReturn gst_devsound_sink_change_state (GstElement * element,

    GstStateChange transition);

static void *StartDevSoundThread(void *threadid);

//Error concealment interface impl

static void gst_error_concealment_handler_init (gpointer g_iface,

    gpointer iface_data);

static gint gst_ConcealErrorForNextBuffer();

static gint gst_SetFrameMode(gboolean aFrameMode);

static gint gst_FrameModeRqrdForEC(gboolean* aFrameModeRqrd);

static void gst_Apply_ErrorConcealment_Update(GstDevsoundSink* dssink);

//G711 interface impl

static void gst_g711_decoder_handler_init (gpointer g_iface,

    gpointer iface_data);

static gint gst_SetDecoderMode(enum TG711DecodeMode aDecodeMode);

static gint gst_SetCng(gboolean aCng);

static gint gst_GetCng(gboolean* aCng);

static gint gst_SetPlc(gboolean aPlc);

static void gst_Apply_G711_Decoder_Update(GstDevsoundSink* dssink );

//G729 interface impl

static void gst_g729_decoder_handler_init (gpointer g_iface,

    gpointer iface_data);

static gint gst_BadLsfNextBuffer();

static void gst_Apply_G729_Decoder_Update(GstDevsoundSink* dssink );

//Ilbc interface impl

static void gst_ilbc_decoder_handler_init (gpointer g_iface,

    gpointer iface_data);

static gint gst_GetIlbcCng(gboolean* aCng);

static gint gst_SetIlbcCng(gboolean aCng);

static gint gst_SetIlbcDecoderMode(enum TIlbcDecodeMode aDecodeMode);

static void  gst_Apply_Ilbc_Decoder_Update(GstDevsoundSink* dssink );

static void get_PopulateIntfcProperties(GstDevsoundSink* dssink);

static gboolean gst_sink_start (GstBaseSink * sink);

static gboolean gst_sink_stop (GstBaseSink * sink);

static GstFlowReturn gst_sink_render (GstBaseSink * sink,

    GstBuffer * buffer);

pthread_t ds_thread;

pthread_mutex_t ds_mutex;

pthread_cond_t ds_condition;

enum consumer_thread_state_enum {

   CONSUMER_THREAD_UNINITIALIZED,

   CONSUMER_THREAD_INITIALIZING,

   CONSUMER_THREAD_INITIALIZED

};

enum consumer_thread_state_enum consumer_thread_state;

GQueue *   buffer_queue = NULL;

gboolean framemode;

gboolean framemodereq;

gboolean concealerror = FALSE;

gboolean g711decodemode;

gboolean g711cng;

gboolean g711plc;

gboolean ilbccng;

enum TIlbcDecodeMode ilbcdecodemode;

gint output;

enum

    {

    LAST_SIGNAL

    };

typedef struct _GstCustomIfaceUpdate GstCustomIfaceUpdate;

struct _GstCustomIfaceUpdate{

gboolean  framemodeupdate;

gboolean  framemoderequpdate;

gboolean  concealerrorupate;

gboolean  g711decodemodeupdate;

gboolean  g711setcngupdate;

gboolean  g711setplcupdate;

gboolean  g729badlsfnextbufferupdate;

gboolean  ilbccngupdate;

gboolean  ilbcdecodermodeupdate;

};

GstCustomIfaceUpdate customInfaceUpdate = {0,0,0,0,0,0,0,0,0};

#define DEFAULT_DEVICE  "default"

enum

    {

    PROP_0,

    PROP_DEVICE,

    VOLUME,

    MAXVOLUME,

    VOLUMERAMP,

/*    CHANNELS,*/

    LEFTBALANCE,

    RIGHTBALANCE,

/*    RATE,*/

    PRIORITY,

    PREFERENCE,

/*    SAMPLESPLAYED,*/

/*    FOURCC, //FOURCC is not needed*/

/*    MIMETYPE,*/

    OUTPUTDEVICE

    };

enum command_to_consumer_thread_enum

    {

    OPEN = 2,

    PLAYING,

    PAUSE,

    RESUME,

    /*UPDATE,*/

    WAIT,

    CLOSE

    };

enum command_to_consumer_thread_enum cmd;

static GstStaticPadTemplate devsoundsink_sink_factory=

    GST_STATIC_PAD_TEMPLATE ("sink",

        GST_PAD_SINK,

        GST_PAD_ALWAYS,

        GST_STATIC_CAPS ("audio/x-raw-int, " "endianness = (int) { " G_STRINGIFY (G_BYTE_ORDER) " }, " "signed = (boolean) TRUE, " "width = (int) 16, " "depth = (int) 16, " "rate = (int) [ 8000, 48000 ]," "channels = (int) [ 1, 2 ]; "

                "audio/amr, " "rate = (int) 8000, " "channels = (int) 1 ; "

                "audio/AMR, " "rate = (int) 8000, " "channels = (int) 1 ; "

                "audio/x-alaw, " "rate = (int) [ 8000, 48000 ], " "channels = (int) [ 1, 2 ]; "

                "audio/g729, " "rate = (int) [ 8000, 48000 ], " "channels = (int) [ 1, 2 ]; "

                "audio/mp3, " "rate = (int) [ 8000, 48000 ], " "channels = (int) [ 1, 2 ]; "                

                "audio/ilbc, " "rate = (int) [ 8000, 48000 ], " "channels = (int) [ 1, 2 ]; "

                "audio/x-mulaw, " "rate = (int) [ 8000, 48000 ], " "channels = (int) [ 1, 2 ]")

                );

static GstElementClass *parent_class= NULL;

GType gst_devsound_sink_get_type(void)

    {

    static GType devsoundsink_type = 0;

    if (!devsoundsink_type)

        {

        static const GTypeInfo devsoundsink_info =

            {

                    sizeof(GstDevsoundSinkClass),

                    gst_devsound_sink_base_init,

                    NULL,

                    (GClassInitFunc) gst_devsound_sink_class_init,

                    NULL,

                    NULL,

                    sizeof(GstDevsoundSink),

                    0,

                    (GInstanceInitFunc) gst_devsound_sink_init

,        };

        static const GInterfaceInfo error_concealment_info = {

            gst_error_concealment_handler_init,

           NULL,

           NULL

             };

        static const GInterfaceInfo g711_decoder_info = {

             gst_g711_decoder_handler_init,

            NULL,

            NULL

            };

        static const GInterfaceInfo g729_decoder_info = {

                gst_g729_decoder_handler_init,

               NULL,

               NULL

               };

        static const GInterfaceInfo ilbc_decoder_info = {

                gst_ilbc_decoder_handler_init,

               NULL,

               NULL

               };

        devsoundsink_type =

        g_type_register_static (GST_TYPE_BASE_SINK, "GstDevsoundSink",

            &devsoundsink_info, 0);

        g_type_add_interface_static (devsoundsink_type, GST_TYPE_ERROR_CONCEALMENT,

         &error_concealment_info);

        g_type_add_interface_static (devsoundsink_type, GST_TYPE_G711_DECODER,

             &g711_decoder_info);

        g_type_add_interface_static (devsoundsink_type, GST_TYPE_G729_DECODER,

               &g729_decoder_info);

        g_type_add_interface_static (devsoundsink_type, GST_TYPE_ILBC_DECODER,

               &ilbc_decoder_info);

        }

    return devsoundsink_type;

    }

static void gst_devsound_sink_dispose(GObject * object)

    {

    GstDevsoundSink *devsoundsink = GST_DEVSOUND_SINK (object);

    if (devsoundsink->probed_caps)

        {

        gst_caps_unref(devsoundsink->probed_caps);

        devsoundsink->probed_caps = NULL;

        }

#ifdef AV_SYNC

    if (devsoundsink->clock)

        {

        gst_object_unref (devsoundsink->clock);

        }

    devsoundsink->clock = NULL;

#endif /*AV_SYNC*/

    G_OBJECT_CLASS (parent_class)->dispose (object);

    }

static void gst_devsound_sink_base_init(gpointer g_class)

    {

    GstElementClass *element_class= GST_ELEMENT_CLASS (g_class);

    gst_element_class_set_details(element_class, &gst_devsound_sink_details);

    gst_element_class_add_pad_template(element_class,

            gst_static_pad_template_get(&devsoundsink_sink_factory));

    }

static void gst_devsound_sink_class_init(GstDevsoundSinkClass * klass)

    {

    GObjectClass *gobject_class;

    GstElementClass *gstelement_class;

    GstBaseSinkClass *gstbasesink_class;

    gobject_class = (GObjectClass *) klass;

    gstelement_class = (GstElementClass *) klass;

    gstbasesink_class = (GstBaseSinkClass *) klass;

    parent_class = g_type_class_peek_parent(klass);

    gobject_class->dispose = GST_DEBUG_FUNCPTR (gst_devsound_sink_dispose);

    gobject_class->finalize = GST_DEBUG_FUNCPTR (gst_devsound_sink_finalise);

    gobject_class->get_property = GST_DEBUG_FUNCPTR (gst_devsound_sink_get_property);

    gobject_class->set_property = GST_DEBUG_FUNCPTR (gst_devsound_sink_set_property);

    gstelement_class->change_state = GST_DEBUG_FUNCPTR(gst_devsound_sink_change_state);

    g_object_class_install_property(gobject_class, PROP_DEVICE,

            g_param_spec_string("device", "Device", "Devsound device ",

            DEFAULT_DEVICE, G_PARAM_READWRITE));

    g_object_class_install_property(gobject_class, VOLUME,

                g_param_spec_int("volume", "Volume", "Devsound volume",

                        -1, G_MAXINT, -1, G_PARAM_READWRITE));

    g_object_class_install_property(gobject_class, VOLUMERAMP,

              g_param_spec_int("volumeramp", "VolumeRamp", "Devsound volume ramp",

                      -1, G_MAXINT, -1, G_PARAM_READWRITE));

    g_object_class_install_property(gobject_class, MAXVOLUME,

            g_param_spec_int("maxvolume", "MaxVolume", "Devsound max volume",

                    -1, G_MAXINT, -1, G_PARAM_READABLE));

    g_object_class_install_property(gobject_class, LEFTBALANCE,

                  g_param_spec_int("leftbalance", "Left Balance", "Left Balance",

                          -1, G_MAXINT, -1, G_PARAM_READWRITE));

    g_object_class_install_property(gobject_class, RIGHTBALANCE,

                   g_param_spec_int("rightbalance", "Right Balance", "Right Balance",

                           -1, G_MAXINT, -1, G_PARAM_READWRITE));

/*

    g_object_class_install_property(gobject_class, SAMPLESPLAYED,

                      g_param_spec_int("samplesplayed", "Samples Played", "Samples Played",

                              -1, G_MAXINT, -1, G_PARAM_READABLE));

*/

    g_object_class_install_property(gobject_class, PRIORITY,

            g_param_spec_int("priority", "Priority", "Priority ", -1,

                    G_MAXINT, -1,

                    G_PARAM_READWRITE));

    g_object_class_install_property(gobject_class, PREFERENCE,

            g_param_spec_int("preference", "Preference", "Preference ", -1,

                    G_MAXINT, -1,

                    G_PARAM_READWRITE));

/*

    g_object_class_install_property(gobject_class, RATE,

            g_param_spec_int("rate", "Rate", "Rate ", -1,

                    G_MAXINT, -1,

                    G_PARAM_READWRITE));

    g_object_class_install_property(gobject_class, CHANNELS,

            g_param_spec_int("channels", "Channels", "Channels ", -1,

                    G_MAXINT, -1,

                    G_PARAM_READWRITE));

*/

    g_object_class_install_property(gobject_class, OUTPUTDEVICE,

             g_param_spec_int("outputdevice", "Output Device", "Output Device ", -1,

                     G_MAXINT, -1,

                     G_PARAM_READWRITE));

#ifdef AV_SYNC

    gstelement_class->provide_clock = GST_DEBUG_FUNCPTR (gst_devsound_sink_provide_clock);

#endif /*AV_SYNC*/

    gstbasesink_class->start = GST_DEBUG_FUNCPTR (gst_sink_start);

    gstbasesink_class->stop = GST_DEBUG_FUNCPTR (gst_sink_stop);

    gstbasesink_class->render = GST_DEBUG_FUNCPTR (gst_sink_render);

    gstbasesink_class->get_caps = GST_DEBUG_FUNCPTR (gst_devsound_sink_getcaps);

    gstbasesink_class->set_caps = GST_DEBUG_FUNCPTR (gst_devsound_sink_setcaps);

    gstbasesink_class->event    = GST_DEBUG_FUNCPTR (gst_devsound_sink_event);

#ifdef AV_SYNC

    gstbasesink_class->get_times = GST_DEBUG_FUNCPTR (gst_devsound_sink_get_times);

#endif /*AV_SYNC*/

    }

static void gst_devsound_sink_init(GstDevsoundSink * dssink)

    {

    GST_DEBUG_OBJECT(dssink, "initializing devsoundsink");

    dssink->device = g_strdup(DEFAULT_DEVICE);

    dssink->handle = NULL;

    dssink->preference = 0; //default=>EMdaPriorityPreferenceNone;

    dssink->priority = 0;   //default=>EMdaPriorityNormal;

#ifdef AV_SYNC

    dssink->time_or_samples_played = 0;

    dssink->timeplayedavailable = FALSE;

    /* Create the provided clock. */

    dssink->clock = gst_audio_clock_new ("clock", gst_devsound_sink_get_time, dssink);

#endif /*AV_SYNC*/

    pthread_mutex_init(&ds_mutex, NULL);

    pthread_cond_init(&ds_condition, NULL);

    }

static void *StartDevSoundThread(void *threadarg)

    {

    GstDevsoundSink *dssink;

    gint remainingDataLen = 0;

    GstBuffer *buffer = NULL;

    gboolean lastBufferSet=FALSE;

    dssink = (GstDevsoundSink*) threadarg;

    // TODO handle error here

    open_devsound(&(dssink->handle));

#ifdef AV_SYNC

    dssink->timeplayedavailable = is_timeplayed_supported(dssink->handle);

#endif /*AV_SYNC*/

    //get supported (in/out)put datatypes

    //from devsound to build caps

    getsupporteddatatypes(dssink);

    // TODO obtain mutex to update variable here???

    consumer_thread_state = CONSUMER_THREAD_INITIALIZED;

    // Signal any waiting threads that consumer thread creation was successful.

    pthread_mutex_lock(&ds_mutex);

    pthread_cond_signal(&ds_condition);

    pthread_mutex_unlock(&ds_mutex);

    // Wait until we receive a command from the main thread

    // TODO obtain mutex to read variable here???

    while ( cmd == OPEN )

        {

        pthread_mutex_lock(&ds_mutex);

        pthread_cond_wait(&ds_condition, &ds_mutex);

        pthread_mutex_unlock(&ds_mutex);

        }

    // This could happen if client creates sink and deletes it

    // without putting it to play state

    if ( cmd != CLOSE )

        {

        //TODO if there is preemption we have to somehow signal

        //the pipeline in the render

        initialize_devsound(dssink);

        playinit(dssink->handle);

        dssink->eosreceived = FALSE;

        initproperties(dssink);

        }

    while (1)

        {

        switch (cmd)

            {

            case PAUSE:

                pause_devsound(dssink);

                cmd = WAIT;

                break;

            case RESUME:

                resume_devsound(dssink);

                cmd = PLAYING;

                break;

            case WAIT:

                pthread_mutex_lock(&ds_mutex);

                pthread_cond_signal(&ds_condition);

                pthread_mutex_unlock(&ds_mutex);

                pthread_mutex_lock(&ds_mutex);

                pthread_cond_wait(&ds_condition, &ds_mutex);

                pthread_mutex_unlock(&ds_mutex);

                break;

            case PLAYING:

                {

                pre_init_setconf(dssink);

                gst_Apply_ErrorConcealment_Update(dssink);

                gst_Apply_G711_Decoder_Update(dssink);

                gst_Apply_G729_Decoder_Update(dssink);

                gst_Apply_Ilbc_Decoder_Update(dssink);

                // TODO we could do this in BTBF callback

                populateproperties(dssink);

                get_PopulateIntfcProperties(dssink);

                if(buffer_queue->length > 0)

                    {

                    if (remainingDataLen == 0)

                        {

                        // TODO enable lock and unlock

                        GST_OBJECT_LOCK (dssink);

                        buffer = GST_BUFFER_CAST(g_queue_peek_head(buffer_queue));

                        GST_OBJECT_UNLOCK(dssink);

                        remainingDataLen = GST_BUFFER_SIZE(buffer);

                        }

                    lastBufferSet =  GST_BUFFER_FLAG_IS_SET(buffer,GST_BUFFER_FLAG_LAST);