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

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);

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 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,

    WRITEDATA,

    /*UPDATE,*/

    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, "

                //"width = (int) 8, "

                //"depth = (int) 8, "

                "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;

        }

    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);

    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));

    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);

    }

static void gst_devsound_sink_init(GstDevsoundSink * devsoundsink)

    {

    GST_DEBUG_OBJECT(devsoundsink, "initializing devsoundsink");

    devsoundsink->device = g_strdup(DEFAULT_DEVICE);

    devsoundsink->handle = NULL;

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

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

    pthread_mutex_init(&ds_mutex, NULL);

    pthread_cond_init(&ds_condition, NULL);

    }

static void *StartDevSoundThread(void *threadarg)

    {

    GstDevsoundSink *devsound;

    gint remainingDataLen = 0;

    GstBuffer *buffer = NULL;

    gboolean lastBufferSet=FALSE;

    devsound = (GstDevsoundSink*) threadarg;

    open_devsound(&(devsound->handle));

    //get supported (in/out)put datatypes

    //from devsound to build caps

    getsupporteddatatypes(devsound);

    // 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(devsound);

        playinit(devsound->handle);

        initproperties(devsound);

        }

    while (1)

        {

        switch (cmd)

            {

            case WRITEDATA:

                {

                pre_init_setconf(devsound);

                gst_Apply_ErrorConcealment_Update(devsound);

                gst_Apply_G711_Decoder_Update(devsound);

                gst_Apply_G729_Decoder_Update(devsound);

                gst_Apply_Ilbc_Decoder_Update(devsound);

                // TODO we could do this in BTBF callback

                populateproperties(devsound);

                framemodereq = devsound->framemodereq;

                g711cng = devsound->g711cng;

                ilbccng = devsound->ilbccng;

                output = devsound->output;

                if(buffer_queue->length > 0)

                    {

                    if (remainingDataLen == 0)

                        {

                        // TODO enable lock and unlock

                        GST_OBJECT_LOCK (devsound);

                        buffer = GST_BUFFER_CAST(g_queue_peek_head(buffer_queue));

                        GST_OBJECT_UNLOCK(devsound);

                        remainingDataLen = GST_BUFFER_SIZE(buffer);

                        }

                    lastBufferSet =  GST_BUFFER_FLAG_IS_SET(buffer,GST_BUFFER_FLAG_LAST);

                    remainingDataLen = write_data(devsound->handle,

                            GST_BUFFER_DATA(buffer) + (GST_BUFFER_SIZE(buffer) - remainingDataLen),

                            remainingDataLen,

                            lastBufferSet);

                    if (remainingDataLen == 0)

                        {

                        GST_OBJECT_LOCK (devsound);

                        buffer = GST_BUFFER_CAST(g_queue_pop_head(buffer_queue));

                        GST_OBJECT_UNLOCK(devsound);

                        gst_buffer_unref(buffer);

                        buffer = NULL;

                        }

                    if (lastBufferSet && remainingDataLen == 0)

                        {

                        // Last Buffer is already sent to DevSound

                        // and we have received PlayError so now we exit

                        // from the big loop next time

/*

                        pthread_mutex_lock(&ds_mutex);

                        pthread_cond_signal(&ds_condition);

                        pthread_mutex_unlock(&ds_mutex);

*/

                        cmd = CLOSE;

                       }

                    }

                else

                    {

                    pthread_mutex_lock(&ds_mutex);

                    pthread_cond_wait(&ds_condition, &ds_mutex);

                    pthread_mutex_unlock(&ds_mutex);

                    }

                }

                break;

            case CLOSE:

                {

                close_devsound(devsound);

                devsound->handle= NULL;

                pthread_mutex_lock(&ds_mutex);

                pthread_cond_signal(&ds_condition);

                pthread_mutex_unlock(&ds_mutex);

                // TODO obtain mutex here

                consumer_thread_state = CONSUMER_THREAD_UNINITIALIZED;

                pthread_exit(NULL);

                }

                break;

            default:

                // TODO obtain mutex here

                consumer_thread_state = CONSUMER_THREAD_UNINITIALIZED;

                pthread_exit(NULL);