[Multisense tizen snd player] mono/stereo snd play issue fix, run time updation of...

diff --git a/src/tizen_sound_player/tizen_sound_player.c b/src/tizen_sound_player/tizen_sound_player.c
index 648dceb..d052f1e 100644 (file)
--- a/src/tizen_sound_player/tizen_sound_player.c
+++ b/src/tizen_sound_player/tizen_sound_player.c
@@ -15,6 +15,7 @@
 #ifdef HAVE_LIBSNDFILE
 #include <sndfile.h>
 #endif
+#include <vconf.h>
 
 int _edje_multisense_default_log_dom = -1;
 
@@ -22,8 +23,12 @@ int _edje_multisense_default_log_dom = -1;
 # undef ERR
 #endif
 #define ERR(...) EINA_LOG_DOM_ERR(_edje_multisense_default_log_dom, __VA_ARGS__)
+#ifdef WRN
+# undef WRN
+#endif
+#define WRN(...) EINA_LOG_DOM_WARN(_edje_multisense_default_log_dom, __VA_ARGS__)
 
-#define STREAM_PLAYER_BUFFERLEN 4096
+#define STREAM_PLAYER_BUFFERLEN 2048
 #define DEFAULT_FORMAT MMSOUND_PCM_S16_LE
 
 typedef struct _RemixPlayerData RemixPlayerData;
@@ -34,19 +39,23 @@ struct _RemixPlayerData {
    PLAYER_PCM *playbuffer;
    MMSoundPcmHandle_t handle;
    MMSoundPcmChannel_t channel;
+   RemixPCM max_value;
+   RemixEnv *env;
+   RemixBase *base;
+   int snd_on;
    unsigned int buffer_size;
    int stereo;
    int frequency;
 };
 
 /* Optimisation dependencies: none */
-static RemixBase * remix_player_optimise (RemixEnv * env, RemixBase * base);
+static RemixBase *remix_player_optimise (RemixEnv *env, RemixBase *base);
 
 static RemixBase *
 remix_player_reset_device (RemixEnv *env, RemixBase *base)
 {
    int old_buffer_size;
-   RemixPlayerData * player_data = remix_base_get_instance_data(env, base);
+   RemixPlayerData *player_data = remix_base_get_instance_data(env, base);
 
    if (player_data->handle)
      {
@@ -78,11 +87,28 @@ remix_player_reset_device (RemixEnv *env, RemixBase *base)
    return base;
 }
 
+static void
+_vconf_noti_key_changed_cb(keynode_t *node, void *data)
+{
+   RemixPlayerData *player = (RemixPlayerData *)data;
+   char *keyname = vconf_keynode_get_name(node);
+
+   if (strcmp(keyname, VCONFKEY_SETAPPL_SOUND_STATUS_BOOL) == 0)
+     player->snd_on = vconf_keynode_get_bool(node);
+
+   else if (strcmp(keyname, VCONFKEY_SYSMAN_EARJACK) == 0)
+     {
+        int ear_jack = vconf_keynode_get_int(node);
+        if (ear_jack == VCONFKEY_SYSMAN_EARJACK_REMOVED)
+          remix_player_reset_device (player->env, player->base);
+     }
+}
+
 static RemixBase *
-remix_player_init (RemixEnv * env, RemixBase * base, CDSet * parameters)
+remix_player_init (RemixEnv *env, RemixBase *base, CDSet *parameters)
    {
    RemixCount nr_channels;
-   CDSet * channels;
+   CDSet *channels;
    RemixPlayerData *player_data = calloc(1, sizeof (RemixPlayerData));
 
    if (!player_data)
@@ -92,7 +118,6 @@ remix_player_init (RemixEnv * env, RemixBase * base, CDSet * parameters)
      }
 
    remix_base_set_instance_data(env, base, player_data);
-   remix_set_channels(env, REMIX_STEREO);
    channels = remix_get_channels (env);
 
     nr_channels = cd_set_size (env, channels);
@@ -109,28 +134,43 @@ remix_player_init (RemixEnv * env, RemixBase * base, CDSet * parameters)
 
    player_data->frequency = remix_get_samplerate(env);
    player_data->buffer_size = 0;
+   player_data->max_value = (RemixPCM) SHRT_MAX / 2;
 
    remix_player_reset_device (env, (RemixBase *)base);
 
    base = remix_player_optimise (env, base);
+   player_data->env = env;
+   player_data->base = base;
+   if (vconf_get_bool(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL, &player_data->snd_on) < 0)
+     WRN("\nFail to get VCONFKEY_SETAPPL_SOUND_STATUS_BOOL boolean value");
+
+   if (vconf_notify_key_changed(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL,_vconf_noti_key_changed_cb, player_data) < 0)
+     WRN("\nFail to register VCONFKEY_SETAPPL_SOUND_STATUS_BOOL key callback");
+   if (vconf_notify_key_changed(VCONFKEY_SYSMAN_EARJACK, _vconf_noti_key_changed_cb, player_data) < 0)
+     WRN("\nFail to register VCONFKEY_SYSMAN_EARJACK key callback");
 
    return base;
 }
 
 
 static RemixBase *
-remix_player_clone (RemixEnv * env, RemixBase * base)
+remix_player_clone (RemixEnv *env, RemixBase *base)
 {
-   RemixBase * new_player = remix_base_new (env);
+   RemixBase *new_player = remix_base_new (env);
 
    remix_player_init( env, new_player,  NULL);
    return new_player;
 }
 
 static int
-remix_player_destroy (RemixEnv * env, RemixBase * base)
+remix_player_destroy (RemixEnv *env, RemixBase *base)
 {
-   RemixPlayerData * player_data = remix_base_get_instance_data(env, base);
+   RemixPlayerData *player_data = remix_base_get_instance_data(env, base);
+
+   if (vconf_ignore_key_changed(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL,_vconf_noti_key_changed_cb) < 0)
+     WRN("\nFail to unregister VCONFKEY_SETAPPL_SOUND_STATUS_BOOL key callback");
+   if (vconf_ignore_key_changed(VCONFKEY_SYSMAN_EARJACK, _vconf_noti_key_changed_cb) < 0)
+     WRN("\nFail to unregister VCONFKEY_SYSMAN_EARJACK key callback");
 
    if(player_data->handle)
      mm_sound_pcm_play_close(player_data->handle);
@@ -140,11 +180,11 @@ remix_player_destroy (RemixEnv * env, RemixBase * base)
 }
 
 static int
-remix_player_ready (RemixEnv * env, RemixBase * base)
+remix_player_ready (RemixEnv *env, RemixBase *base)
 {
-   RemixPlayerData * player_data = remix_base_get_instance_data(env, base);
+   RemixPlayerData *player_data = remix_base_get_instance_data(env, base);
    RemixCount nr_channels;
-   CDSet * channels;
+   CDSet *channels;
    int samplerate;
 
    channels = remix_get_channels (env);
@@ -158,44 +198,46 @@ remix_player_ready (RemixEnv * env, RemixBase * base)
 }
 
 static RemixBase *
-remix_player_prepare (RemixEnv * env, RemixBase * base)
+remix_player_prepare (RemixEnv *env, RemixBase *base)
 {
    remix_player_reset_device (env, base);
    return base;
 }
 
 static RemixCount
-remix_player_playbuffer (RemixEnv * env, RemixPlayerData * player, RemixPCM * data,
+remix_player_playbuffer (RemixEnv *env, RemixPlayerData *player, RemixPCM *data,
           RemixCount count)
 {
    RemixCount i;
    RemixPCM value;
    int ret = count;
-   const RemixPCM max_value = (RemixPCM) (SHRT_MAX);
+   size_t length;
+
+   length = count * sizeof(RemixCount);
 
    for (i = 0; i < count; i++)
      {
-        value = *data++ * max_value;
+        value = *data++ * (player->max_value);
         *(player->playbuffer + i) = (PLAYER_PCM) value;
      }
 
    ret = mm_sound_pcm_play_write(player->handle,
                                      player->playbuffer,
-                                     2 * count);
+                                     length);
    if(ret < 0)
      ERR("Write Fail\n");
 
-   return ret;
+   return length;
 }
 
 /* An RemixChunkFunc for making noise */
 static RemixCount
-remix_player_chunk (RemixEnv * env, RemixChunk * chunk, RemixCount offset,
-          RemixCount count, int channelname, void * data)
+remix_player_chunk (RemixEnv *env, RemixChunk *chunk, RemixCount offset,
+          RemixCount count, int channelname, void *data)
 {
-   RemixPlayerData * player = (RemixPlayerData *)data;
+   RemixPlayerData *player = (RemixPlayerData *)data;
    RemixCount remaining = count, written = 0, n, playcount;
-   RemixPCM * d;
+   RemixPCM *d;
 
    while (remaining > 0)
      {
@@ -218,12 +260,14 @@ remix_player_chunk (RemixEnv * env, RemixChunk * chunk, RemixCount offset,
 }
 
 static RemixCount
-remix_player_process (RemixEnv * env, RemixBase * base, RemixCount count,
-            RemixStream * input, RemixStream * output)
+remix_player_process (RemixEnv *env, RemixBase *base, RemixCount count,
+            RemixStream *input, RemixStream *output)
 {
-   RemixPlayerData * player_data = remix_base_get_instance_data(env, base);
-   RemixCount nr_channels = remix_stream_nr_channels (env, input);
-   RemixCount remaining = count, processed = 0, n, nn;
+   RemixCount remaining = count, processed = 0, n, nn, nr_channels;
+   RemixPlayerData *player_data = remix_base_get_instance_data(env, base);
+
+   if (!player_data->snd_on) return count;
+   nr_channels = remix_stream_nr_channels (env, input);
 
    if (nr_channels == 1 && player_data->stereo == 0)
      { /* MONO */
@@ -234,7 +278,7 @@ remix_player_process (RemixEnv * env, RemixBase * base, RemixCount count,
      { /* STEREO */
         while (remaining > 0)
           {
-             n = MIN (remaining, (player_data->buffer_size/2) );
+             n = MIN (remaining, (player_data->buffer_size / 2) );
              n = remix_stream_interleave_2 (env, input,
                  REMIX_CHANNEL_LEFT, REMIX_CHANNEL_RIGHT,
                  player_data->databuffer, n);
@@ -256,21 +300,21 @@ remix_player_process (RemixEnv * env, RemixBase * base, RemixCount count,
 }
 
 static RemixCount
-remix_player_length (RemixEnv * env, RemixBase * base)
+remix_player_length (RemixEnv *env, RemixBase *base)
 {
    return REMIX_COUNT_INFINITE;
 }
 
 static RemixCount
-remix_player_seek (RemixEnv * env, RemixBase * base, RemixCount count)
+remix_player_seek (RemixEnv *env, RemixBase *base, RemixCount count)
 {
    return count;
 }
 
 static int
-remix_player_flush (RemixEnv * env, RemixBase * base)
+remix_player_flush (RemixEnv *env, RemixBase *base)
 {
-   RemixPlayerData * player_data = remix_base_get_instance_data(env, base);
+   RemixPlayerData *player_data = remix_base_get_instance_data(env, base);
    remix_player_reset_device (env, base);
     return 0;
 }
@@ -287,7 +331,7 @@ static struct _RemixMethods _remix_player_methods = {
 };
 
 static RemixBase *
-remix_player_optimise (RemixEnv * env, RemixBase * base)
+remix_player_optimise (RemixEnv *env, RemixBase *base)
 {
    remix_base_set_methods (env, base, &_remix_player_methods);
    return base;
@@ -314,9 +358,9 @@ static struct _RemixPlugin tizen_player_plugin = {
 };
 
 EAPI CDList *
-remix_load (RemixEnv * env)
+remix_load (RemixEnv *env)
 {
-   CDList * plugins = cd_list_new (env);
+   CDList *plugins = cd_list_new (env);
    plugins = cd_list_prepend (env, plugins,
                              CD_POINTER(&tizen_player_plugin));
    return plugins;