Enlightenment CVS committal

Author  : mej
Project : e_modules
Module  : evolume

Dir     : e_modules/evolume/src/lib


Modified Files:
        alsa_mixer.c alsa_mixer.h e_mixer.c e_mixer.h 


Log Message:
Wed Apr  5 13:48:36 2006                        Michael Jennings (mej)

Indent!
----------------------------------------------------------------------

===================================================================
RCS file: /cvs/e/e_modules/evolume/src/lib/alsa_mixer.c,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -3 -r1.1 -r1.2
--- alsa_mixer.c        21 Mar 2006 02:12:19 -0000      1.1
+++ alsa_mixer.c        5 Apr 2006 17:48:48 -0000       1.2
@@ -10,481 +10,477 @@
 #define MODULE
 #include "e_mixer.h"
 
-static int mixer_error(const char *fmt, ...)
+static int
+mixer_error(const char *fmt, ...)
 {
-       va_list va;
-       int r;
+   va_list va;
+   int r;
 
-       va_start(va,fmt);
-       fprintf(stderr,"eVolume: ALSA mixer: ");
-       r = vfprintf(stderr,fmt, va);
-       fprintf(stderr,"\n");
-       va_end(va);
-       return r;
-}
-
-
-Mixer_System_Name* s_get_systems()
-{
-       snd_mixer_t *handle;
-       snd_ctl_t *control;
-       snd_ctl_card_info_t *hw_info;
-       Mixer_Name* name;
-
-       Mixer_System_Name* ret;
-
-       int err;
-       int i;
-       char buf[1024];
-       Evas_List* names_list = NULL;
-
-       ret = calloc(sizeof(Mixer_System_Name), 1);
-       ret->system = strdup("alsa");
-       ret->name = strdup("ALSA");
-       ret->system_id = mixer_system_get_id(ret->name);
-
-       if((err = snd_mixer_open(&handle, 0)) < 0)
-       {
-               mixer_error("Cannot open mixer: %s", snd_strerror(err));
-               return NULL;
-       }
-               
-       snd_ctl_card_info_alloca(&hw_info);
-
-       for(i = 0; i < 32; i ++)
-       {
-               sprintf(buf,"hw:%d", i);
-               if((err = snd_mixer_attach(handle, buf)) < 0)
-                       break;
-
-               if((err = snd_mixer_detach(handle, buf)) < 0)
-               {
-                       snd_mixer_close(handle);
-                       break;
-               }
-
-
-               if ((err = snd_ctl_open(&control, buf, 0)) < 0 )
-               {
-                       mixer_error("Cannot control %s: %s", buf, 
snd_strerror(err));
-                       continue;
-               }
-
-               if ((err = snd_ctl_card_info(control, hw_info)) < 0)
-               {
-                       mixer_error("Cannot get hardware info %s: %s", buf, 
snd_strerror(err));
-                       snd_ctl_close(control);
-                       continue;
-               }
-
-               snd_ctl_close(control);
-
-               name = calloc(1,sizeof(Mixer_Name));
-               name->card = strdup(buf);
-               name->real = strdup(snd_ctl_card_info_get_name(hw_info));
-               name->mixer_id = mixer_get_id(name->real);
-               name->system_name = ret;
+   va_start(va, fmt);
+   fprintf(stderr, "eVolume: ALSA mixer: ");
+   r = vfprintf(stderr, fmt, va);
+   fprintf(stderr, "\n");
+   va_end(va);
+   return r;
+}
+
+Mixer_System_Name *
+s_get_systems()
+{
+   snd_mixer_t *handle;
+   snd_ctl_t *control;
+   snd_ctl_card_info_t *hw_info;
+   Mixer_Name *name;
+
+   Mixer_System_Name *ret;
+
+   int err;
+   int i;
+   char buf[1024];
+   Evas_List *names_list = NULL;
+
+   ret = calloc(sizeof(Mixer_System_Name), 1);
+   ret->system = strdup("alsa");
+   ret->name = strdup("ALSA");
+   ret->system_id = mixer_system_get_id(ret->name);
+
+   if ((err = snd_mixer_open(&handle, 0)) < 0)
+     {
+        mixer_error("Cannot open mixer: %s", snd_strerror(err));
+        return NULL;
+     }
+
+   snd_ctl_card_info_alloca(&hw_info);
+
+   for (i = 0; i < 32; i++)
+     {
+        sprintf(buf, "hw:%d", i);
+        if ((err = snd_mixer_attach(handle, buf)) < 0)
+           break;
+
+        if ((err = snd_mixer_detach(handle, buf)) < 0)
+          {
+             snd_mixer_close(handle);
+             break;
+          }
+
+        if ((err = snd_ctl_open(&control, buf, 0)) < 0)
+          {
+             mixer_error("Cannot control %s: %s", buf, snd_strerror(err));
+             continue;
+          }
+
+        if ((err = snd_ctl_card_info(control, hw_info)) < 0)
+          {
+             mixer_error("Cannot get hardware info %s: %s", buf, 
snd_strerror(err));
+             snd_ctl_close(control);
+             continue;
+          }
+
+        snd_ctl_close(control);
+
+        name = calloc(1, sizeof(Mixer_Name));
+        name->card = strdup(buf);
+        name->real = strdup(snd_ctl_card_info_get_name(hw_info));
+        name->mixer_id = mixer_get_id(name->real);
+        name->system_name = ret;
 
-               names_list = evas_list_append(names_list, name);
-       }
+        names_list = evas_list_append(names_list, name);
+     }
 
-       ret->mixer_names = names_list;
+   ret->mixer_names = names_list;
 
-       return ret;
+   return ret;
 }
 
 #if 0
 static int
-_alsamixer_event(snd_mixer_t * __UNUSED__ m, unsigned int __UNUSED__ sign, 
snd_mixer_elem_t *__UNUSED__ elem)
+_alsamixer_event(snd_mixer_t *__UNUSED__ m, unsigned int __UNUSED__ sign, 
snd_mixer_elem_t *__UNUSED__ elem)
 {
-       //Mixer* mixer;
-
-       /*
-       mixer = (Mixer*) snd_mixer_get_callback_private(m);
+   //Mixer* mixer;
 
-       if(mixer && mixer->callback)
-                mixer->callback(mixer->callback_private);
-                */
-       return 0;
+   /*
+    * mixer = (Mixer*) snd_mixer_get_callback_private(m);
+    * 
+    * if(mixer && mixer->callback)
+    * mixer->callback(mixer->callback_private);
+    */
+   return 0;
 }
 #endif
 
-static int convert_to_percent(int in, int min, int max)
+static int
+convert_to_percent(int in, int min, int max)
 {
-       int ret;
-       int range;
+   int ret;
+   int range;
 
-       range = max - min;
+   range = max - min;
 
-       if (range == 0)
-               return 0;
+   if (range == 0)
+      return 0;
 
-       in -= min;
-       ret = rint(((double) in / (double) range * 100));
-       return ret;
+   in -= min;
+   ret = rint(((double)in / (double)range * 100));
+   return ret;
 }
 
-static int convert_from_percent(int in, int min, int max)
+static int
+convert_from_percent(int in, int min, int max)
 {
-       int ret;
-       int range;
+   int ret;
+   int range;
 
-       range = max - min;
-       if (range == 0)
-               return 0;
+   range = max - min;
+   if (range == 0)
+      return 0;
 
-       ret = rint((double) range * ((double) in * .01)) + min;
-       return ret;
+   ret = rint((double)range * ((double)in * .01)) + min;
+   return ret;
 }
-       
-static int 
-_alsamixer_handler(void* data, Ecore_Fd_Handler* handler)
-{
-       unsigned short revents;
-       Mixer* mixer;
-       Alsa_Mixer *amixer;
-
-       mixer = data;
-
-       handler = handler;
-
-       amixer = ALSAMIXER(mixer->local);
-
-       if (snd_mixer_poll_descriptors_revents(amixer->handle,
-                               amixer->fds, evas_list_count(amixer->handlers), 
&revents) >= 0)
-       {
-               if (!revents)
-                       revents = POLLIN;
-               if (revents & POLLNVAL)
-                       mixer_error("snd_mixer_poll_descriptors (POLLNVAL)", 0);
-               if (revents & POLLERR)
-                       mixer_error("snd_mixer_poll_descriptors (POLLERR)", 0);
-               if (revents & POLLIN)
-                       snd_mixer_handle_events(amixer->handle);
-       }
-       else
-               return 1;
-
 
-                       
-       mixer->is_changed = 1;
-
-//     fprintf(stderr,"revents = %x\n, POLLIN, POLLNVAL, POLLERR = %x, %x, 
%x\n",
-//                     revents, POLLIN, POLLNVAL, POLLERR);
-       if(revents & POLLIN && mixer->callback && !amixer->update)
-               mixer->callback(mixer->callback_private);
+static int
+_alsamixer_handler(void *data, Ecore_Fd_Handler *handler)
+{
+   unsigned short revents;
+   Mixer *mixer;
+   Alsa_Mixer *amixer;
+
+   mixer = data;
+
+   handler = handler;
+
+   amixer = ALSAMIXER(mixer->local);
+
+   if (snd_mixer_poll_descriptors_revents(amixer->handle, amixer->fds, 
evas_list_count(amixer->handlers), &revents) >= 0)
+     {
+        if (!revents)
+           revents = POLLIN;
+        if (revents & POLLNVAL)
+           mixer_error("snd_mixer_poll_descriptors (POLLNVAL)", 0);
+        if (revents & POLLERR)
+           mixer_error("snd_mixer_poll_descriptors (POLLERR)", 0);
+        if (revents & POLLIN)
+           snd_mixer_handle_events(amixer->handle);
+     }
+   else
+      return 1;
+
+   mixer->is_changed = 1;
+
+//      fprintf(stderr,"revents = %x\n, POLLIN, POLLNVAL, POLLERR = %x, %x, 
%x\n",
+//                      revents, POLLIN, POLLNVAL, POLLERR);
+   if (revents & POLLIN && mixer->callback && !amixer->update)
+      mixer->callback(mixer->callback_private);
 
-       return 1;
+   return 1;
 }
 
-static int alsamixer_set_poll_handlers(Mixer *mixer)
+static int
+alsamixer_set_poll_handlers(Mixer *mixer)
 {
-       int count, err, i;
-       Alsa_Mixer *amixer;
+   int count, err, i;
+   Alsa_Mixer *amixer;
+
+   amixer = ALSAMIXER(mixer->local);
 
-       amixer = ALSAMIXER(mixer->local);
+   if ((count = snd_mixer_poll_descriptors_count(amixer->handle)) < 0)
+     {
+        mixer_error("snd_mixer_poll_descriptors_count");
+        return 0;
+     }
 
-       if((count = snd_mixer_poll_descriptors_count(amixer->handle)) < 0)
-       {
-               mixer_error("snd_mixer_poll_descriptors_count");
-               return 0;
-       }
-       
-       amixer->fds = calloc(1, sizeof(struct pollfd) * count);
+   amixer->fds = calloc(1, sizeof(struct pollfd) * count);
 
-       if((err = snd_mixer_poll_descriptors(amixer->handle,
-                                       amixer->fds, count)) < 0)
-       {
-               mixer_error("snd_mixer_poll_descriptors");
-               return 0;
-       }
+   if ((err = snd_mixer_poll_descriptors(amixer->handle, amixer->fds, count)) 
< 0)
+     {
+        mixer_error("snd_mixer_poll_descriptors");
+        return 0;
+     }
 
-       if( err != count )
-       {
-               mixer_error("poll count != polled fds");
-               return 0;
-       }
+   if (err != count)
+     {
+        mixer_error("poll count != polled fds");
+        return 0;
+     }
 
-       amixer->handlers = NULL;
-       for(i = 0; i < count; i++)
-       {
-               Ecore_Fd_Handler* handler;
+   amixer->handlers = NULL;
+   for (i = 0; i < count; i++)
+     {
+        Ecore_Fd_Handler *handler;
 
-               handler = ecore_main_fd_handler_add(amixer->fds[i].fd, 
ECORE_FD_READ,
-                               _alsamixer_handler, mixer, NULL, NULL);
+        handler = ecore_main_fd_handler_add(amixer->fds[i].fd, ECORE_FD_READ, 
_alsamixer_handler, mixer, NULL, NULL);
 
-               if(handler)
-                       amixer->handlers = evas_list_append(amixer->handlers, 
handler);
-       }
+        if (handler)
+           amixer->handlers = evas_list_append(amixer->handlers, handler);
+     }
 
-       return 1;
+   return 1;
 }
 
-Mixer* m_open(Mixer *mixer, Mixer_System* ms, Mixer_Name *mixer_name)
+Mixer *
+m_open(Mixer *mixer, Mixer_System *ms, Mixer_Name *mixer_name)
 {
-       int err;
-       char *card;
-       snd_mixer_t* handle;
-       snd_ctl_t *control;
-       snd_ctl_card_info_t *hw_info;
+   int err;
+   char *card;
+   snd_mixer_t *handle;
+   snd_ctl_t *control;
+   snd_ctl_card_info_t *hw_info;
 
-       snd_mixer_selem_id_t *sid;
-       snd_mixer_elem_t *elem;
-       Alsa_Mixer *amixer;
+   snd_mixer_selem_id_t *sid;
+   snd_mixer_elem_t *elem;
+   Alsa_Mixer *amixer;
 
+   int count, i;
 
-       int count, i;
+   snd_mixer_selem_id_alloca(&sid);
+   snd_ctl_card_info_alloca(&hw_info);
 
-       
-       snd_mixer_selem_id_alloca(&sid);
-       snd_ctl_card_info_alloca(&hw_info);
+   card = mixer_name->card;
+   if ((err = snd_ctl_open(&control, card, 0)) < 0)
+     {
+        mixer_error("Cannot control %s: %s", card, snd_strerror(err));
+        return NULL;
+     }
 
-       card = mixer_name->card;
-       if ((err = snd_ctl_open(&control, card, 0)) < 0 )
-       {
-               mixer_error("Cannot control %s: %s", card, snd_strerror(err));
-               return NULL;
-       }
+   if ((err = snd_ctl_card_info(control, hw_info)) < 0)
+     {
+        mixer_error("Cannot get hardware info %s: %s", card, 
snd_strerror(err));
+        snd_ctl_close(control);
+        return NULL;
+     }
 
-       if ((err = snd_ctl_card_info(control, hw_info)) < 0)
-       {
-               mixer_error("Cannot get hardware info %s: %s", card, 
snd_strerror(err));
-               snd_ctl_close(control);
-               return NULL;
-       }
+   snd_ctl_close(control);
 
-       snd_ctl_close(control);
+   if ((err = snd_mixer_open(&handle, 0)) < 0)
+     {
+        mixer_error("Cannot open mixer: %s", snd_strerror(err));
+        return NULL;
+     }
 
-       if((err = snd_mixer_open(&handle, 0)) < 0)
-       {
-               mixer_error("Cannot open mixer: %s", snd_strerror(err));
-               return NULL;
-       }
+   if ((err = snd_mixer_attach(handle, card)) < 0)
+     {
+        mixer_error("Cannot attach mixer: %s", snd_strerror(err));
+        snd_mixer_close(handle);
+        return NULL;
+     }
 
-       if((err = snd_mixer_attach(handle, card)) < 0)
-       {
-               mixer_error("Cannot attach mixer: %s", snd_strerror(err));
-               snd_mixer_close(handle);
-               return NULL;
-       }
+   if ((err = snd_mixer_selem_register(handle, NULL, NULL)) < 0)
+     {
+        mixer_error("Cannot register: %s", snd_strerror(err));
+        snd_mixer_close(handle);
+        return NULL;
+     }
 
-       if((err = snd_mixer_selem_register(handle, NULL, NULL)) < 0)
-       {
-               mixer_error("Cannot register: %s", snd_strerror(err));
-               snd_mixer_close(handle);
-               return NULL;
-       }
-       
+   err = snd_mixer_load(handle);
+   if (err < 0)
+     {
+        mixer_error("Cannot load mixer: %s", snd_strerror(err));
+        snd_mixer_close(handle);
+        return NULL;
+     }
 
-       err = snd_mixer_load(handle);
-       if(err < 0)
-       {
-               mixer_error("Cannot load mixer: %s", snd_strerror(err));
-               snd_mixer_close(handle);
-               return NULL;
-       }
+   mixer->local = amixer = calloc(1, sizeof(Alsa_Mixer));
+   snd_mixer_set_callback_private(handle, mixer);
 
-       mixer->local = amixer = calloc(1, sizeof(Alsa_Mixer));
-       snd_mixer_set_callback_private(handle, mixer);
+   mixer->name = mixer_name;
 
-       mixer->name = mixer_name;
+   if (mixer->name == NULL)
+     {
+        fprintf(stderr, "Mixer %s was not listed\n", card);
+     }
 
-       if(mixer->name == NULL)
-       {
-               fprintf(stderr, "Mixer %s was not listed\n", card);
-       }
+   amixer->handle = handle;
 
-       amixer->handle = handle;
+   mixer->system = ms;
 
-       mixer->system = ms;
+   mixer->elems = NULL;
 
-       mixer->elems = NULL;
-       
-       for(i = 0, elem = snd_mixer_first_elem(handle);
-                       elem;
-                       elem = snd_mixer_elem_next(elem))
-       {
-               snd_mixer_selem_get_id(elem, sid);
-               if(!snd_mixer_selem_is_active(elem))
-                       continue;
+   for (i = 0, elem = snd_mixer_first_elem(handle); elem; elem = 
snd_mixer_elem_next(elem))
+     {
+        snd_mixer_selem_get_id(elem, sid);
+        if (!snd_mixer_selem_is_active(elem))
+           continue;
 
-               if(snd_mixer_selem_has_playback_volume(elem))
-               {
-                       Mixer_Elem* melem;
+        if (snd_mixer_selem_has_playback_volume(elem))
+          {
+             Mixer_Elem *melem;
 
-                       melem = calloc(1, sizeof(Mixer_Elem));
+             melem = calloc(1, sizeof(Mixer_Elem));
 
+             melem->name = strdup(snd_mixer_selem_id_get_name(sid));
+             melem->elem_id = mixer_elem_get_id(melem->name);
 
-                       melem->name = strdup(snd_mixer_selem_id_get_name(sid));
-                       melem->elem_id = mixer_elem_get_id(melem->name);
-                               
-                       
snd_mixer_selem_id_malloc((snd_mixer_selem_id_t**)&melem->local);
-                       snd_mixer_selem_get_id(elem,melem->local);
+             snd_mixer_selem_id_malloc((snd_mixer_selem_id_t **) & 
melem->local);
+             snd_mixer_selem_get_id(elem, melem->local);
 
-                       melem->mixer = mixer;
+             melem->mixer = mixer;
 
-                       mixer->elems = evas_list_append(mixer->elems, melem);
-               }
+             mixer->elems = evas_list_append(mixer->elems, melem);
+          }
 
-       }
+     }
 
-       alsamixer_set_poll_handlers(mixer);
+   alsamixer_set_poll_handlers(mixer);
 
-       return mixer;
+   return mixer;
 }
 
-
-int m_close(Mixer* mixer)
+int
+m_close(Mixer *mixer)
 {
-       Evas_List *l;
-       Alsa_Mixer *amixer;
+   Evas_List *l;
+   Alsa_Mixer *amixer;
+
+   amixer = ALSAMIXER(mixer->local);
 
-       amixer = ALSAMIXER(mixer->local);
+   /* Wait for thread that polls information */
+   for (l = amixer->handlers; l; l = evas_list_next(l))
+     {
+        Ecore_Fd_Handler *handler;
 
-       /* Wait for thread that polls information */
-       for(l = amixer->handlers; l; l = evas_list_next(l))
-       {
-               Ecore_Fd_Handler* handler;
-               handler = evas_list_data(l);
+        handler = evas_list_data(l);
 
-               /* First free fd */
-               close(ecore_main_fd_handler_fd_get(handler));
+        /* First free fd */
+        close(ecore_main_fd_handler_fd_get(handler));
 
-               ecore_main_fd_handler_del(handler);
-       }
-       evas_list_free(amixer->handlers);
+        ecore_main_fd_handler_del(handler);
+     }
+   evas_list_free(amixer->handlers);
 
-       for(l = mixer->elems; l; l = evas_list_next(l))
-       {
-               Mixer_Elem* melem;
+   for (l = mixer->elems; l; l = evas_list_next(l))
+     {
+        Mixer_Elem *melem;
 
-               melem = evas_list_data(l);
+        melem = evas_list_data(l);
 
-               free(melem->name);
-               free(melem->local);
-               free(melem);
-       }
+        free(melem->name);
+        free(melem->local);
+        free(melem);
+     }
 
-       evas_list_free(mixer->elems);
+   evas_list_free(mixer->elems);
 
-       snd_mixer_close(amixer->handle);
-       free(amixer->fds);
-       free(mixer);
+   snd_mixer_close(amixer->handle);
+   free(amixer->fds);
+   free(mixer);
 
-       return 0;
+   return 0;
 }
 
-       
-int m_get_volume(Mixer_Elem* melem, int* left, int *right)
+int
+m_get_volume(Mixer_Elem *melem, int *left, int *right)
 {
-       long rvol, lvol;
-       long min, max;
-       int err;
-       Mixer   *mixer;
-       Alsa_Mixer *amixer;
-       snd_mixer_elem_t* elem;
+   long rvol, lvol;
+   long min, max;
+   int err;
+   Mixer *mixer;
+   Alsa_Mixer *amixer;
+   snd_mixer_elem_t *elem;
 
-       mixer = melem->mixer;
-       amixer = ALSAMIXER(mixer->local);
-       snd_mixer_handle_events(amixer->handle);
+   mixer = melem->mixer;
+   amixer = ALSAMIXER(mixer->local);
+   snd_mixer_handle_events(amixer->handle);
 
-       //fprintf(stderr,"mixer->is_changed = %d\n", mixer->is_changed);
-       if(mixer->is_changed)
-       {
-               snd_mixer_free(amixer->handle);
-               if((err = snd_mixer_load(amixer->handle)) < 0)
-               {
-                       mixer_error("snd_mixer_load: %s\n", snd_strerror(err));
-                       return 0;
-               }
-               mixer->is_changed = 0;
-       }
-               
-       elem = snd_mixer_find_selem(amixer->handle, melem->local);
+   //fprintf(stderr,"mixer->is_changed = %d\n", mixer->is_changed);
+   if (mixer->is_changed)
+     {
+        snd_mixer_free(amixer->handle);
+        if ((err = snd_mixer_load(amixer->handle)) < 0)
+          {
+             mixer_error("snd_mixer_load: %s\n", snd_strerror(err));
+             return 0;
+          }
+        mixer->is_changed = 0;
+     }
 
-       snd_mixer_selem_get_playback_volume(elem, 0, &lvol);
+   elem = snd_mixer_find_selem(amixer->handle, melem->local);
 
-       snd_mixer_selem_get_playback_volume_range(elem, &min, &max);
+   snd_mixer_selem_get_playback_volume(elem, 0, &lvol);
 
-       if(snd_mixer_selem_is_playback_mono(elem))
-               rvol = lvol;
-       else
-               snd_mixer_selem_get_playback_volume(elem, 1, &rvol);
+   snd_mixer_selem_get_playback_volume_range(elem, &min, &max);
 
-       *left = convert_to_percent(lvol, min, max);
-       *right = convert_to_percent(rvol, min, max);
-       
-       return 1;
-}
+   if (snd_mixer_selem_is_playback_mono(elem))
+      rvol = lvol;
+   else
+      snd_mixer_selem_get_playback_volume(elem, 1, &rvol);
 
+   *left = convert_to_percent(lvol, min, max);
+   *right = convert_to_percent(rvol, min, max);
+
+   return 1;
+}
 
-int m_set_volume(Mixer_Elem* melem, int left, int right)
+int
+m_set_volume(Mixer_Elem *melem, int left, int right)
 {
-       long rvol, lvol;
-       long min, max;
-       snd_mixer_elem_t* elem;
-       Mixer   *mixer;
-       Alsa_Mixer *amixer;
+   long rvol, lvol;
+   long min, max;
+   snd_mixer_elem_t *elem;
+   Mixer *mixer;
+   Alsa_Mixer *amixer;
 
-       mixer = melem->mixer;
-       amixer = ALSAMIXER(mixer->local);
+   mixer = melem->mixer;
+   amixer = ALSAMIXER(mixer->local);
 
-//     fprintf(stderr,"volume = (%d,%d)\n", left, right);
-       amixer->update = 1;
+//      fprintf(stderr,"volume = (%d,%d)\n", left, right);
+   amixer->update = 1;
 
-       elem = snd_mixer_find_selem(amixer->handle, melem->local);
+   elem = snd_mixer_find_selem(amixer->handle, melem->local);
 
-       snd_mixer_selem_get_playback_volume_range(elem, &min, &max);
+   snd_mixer_selem_get_playback_volume_range(elem, &min, &max);
 
-       lvol = convert_from_percent(left, min, max);
-       rvol = convert_from_percent(right, min, max);
-//     fprintf(stderr,"cvolume = (%ld,%ld)\n", lvol, rvol);
+   lvol = convert_from_percent(left, min, max);
+   rvol = convert_from_percent(right, min, max);
+//      fprintf(stderr,"cvolume = (%ld,%ld)\n", lvol, rvol);
 
-       snd_mixer_selem_set_playback_volume(elem, 0, lvol);
+   snd_mixer_selem_set_playback_volume(elem, 0, lvol);
 
-       if(!snd_mixer_selem_is_playback_mono(elem))
-               snd_mixer_selem_set_playback_volume(elem, 1, rvol);
+   if (!snd_mixer_selem_is_playback_mono(elem))
+      snd_mixer_selem_set_playback_volume(elem, 1, rvol);
 
-       amixer->update = 0;
+   amixer->update = 0;
 
-       return 1;
+   return 1;
 }
 
-int m_get_mute(Mixer_Elem* melem)
+int
+m_get_mute(Mixer_Elem *melem)
 {
-       Mixer *mixer;
-       Alsa_Mixer* amixer;
-       int mute;
-       snd_mixer_elem_t* elem;
+   Mixer *mixer;
+   Alsa_Mixer *amixer;
+   int mute;
+   snd_mixer_elem_t *elem;
 
-       mixer = melem->mixer;
-       amixer = ALSAMIXER(mixer->local);
+   mixer = melem->mixer;
+   amixer = ALSAMIXER(mixer->local);
 
-       snd_mixer_handle_events(amixer->handle);
+   snd_mixer_handle_events(amixer->handle);
 
-       elem = snd_mixer_find_selem(amixer->handle, melem->local);
+   elem = snd_mixer_find_selem(amixer->handle, melem->local);
 
-       if (snd_mixer_selem_has_playback_switch_joined(elem))
-               snd_mixer_selem_get_playback_switch(elem, 0, &mute);
+   if (snd_mixer_selem_has_playback_switch_joined(elem))
+      snd_mixer_selem_get_playback_switch(elem, 0, &mute);
 
-       return mute;
+   return mute;
 }
 
-int m_set_mute(Mixer_Elem* melem, int mute)
+int
+m_set_mute(Mixer_Elem *melem, int mute)
 {
-       Mixer *mixer;
-       Alsa_Mixer* amixer;
-       snd_mixer_elem_t* elem;
+   Mixer *mixer;
+   Alsa_Mixer *amixer;
+   snd_mixer_elem_t *elem;
 
-       mixer = melem->mixer;
-       amixer = ALSAMIXER(mixer->local);
+   mixer = melem->mixer;
+   amixer = ALSAMIXER(mixer->local);
 
-       snd_mixer_handle_events(amixer->handle);
+   snd_mixer_handle_events(amixer->handle);
 
-       elem = snd_mixer_find_selem(amixer->handle, melem->local);
+   elem = snd_mixer_find_selem(amixer->handle, melem->local);
 
-       if (snd_mixer_selem_has_playback_switch_joined(elem))
-               snd_mixer_selem_set_playback_switch_all(elem, mute);
+   if (snd_mixer_selem_has_playback_switch_joined(elem))
+      snd_mixer_selem_set_playback_switch_all(elem, mute);
 
-       return 1;
+   return 1;
 }
===================================================================
RCS file: /cvs/e/e_modules/evolume/src/lib/alsa_mixer.h,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -3 -r1.1 -r1.2
--- alsa_mixer.h        21 Mar 2006 02:12:19 -0000      1.1
+++ alsa_mixer.h        5 Apr 2006 17:48:48 -0000       1.2
@@ -6,11 +6,11 @@
 
 struct _Alsa_Mixer
 {
-       snd_mixer_t *handle;
-       Evas_List* handlers;
+   snd_mixer_t *handle;
+   Evas_List *handlers;
 
-       struct pollfd                   *fds;
-       int                     update;
+   struct pollfd *fds;
+   int update;
 };
 
 #define ALSAMIXER(a) ((Alsa_Mixer*)a)
===================================================================
RCS file: /cvs/e/e_modules/evolume/src/lib/e_mixer.c,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -3 -r1.1 -r1.2
--- e_mixer.c   21 Mar 2006 02:12:19 -0000      1.1
+++ e_mixer.c   5 Apr 2006 17:48:48 -0000       1.2
@@ -12,363 +12,370 @@
 #include "e_mixer.h"
 #include "config.h"
 
-extern char* module_root;
+extern char *module_root;
 
 #if 0
-static int mixer_error(const char *fmt, ...)
+static int
+mixer_error(const char *fmt, ...)
 {
-       va_list va;
-       int r;
+   va_list va;
+   int r;
 
-       va_start(va,fmt);
-       fprintf(stderr,"e_vol_module: ");
-       r = vfprintf(stderr,fmt, va);
-       fprintf(stderr,"\n");
-       va_end(va);
-       return r;
+   va_start(va, fmt);
+   fprintf(stderr, "e_vol_module: ");
+   r = vfprintf(stderr, fmt, va);
+   fprintf(stderr, "\n");
+   va_end(va);
+   return r;
 }
 #endif
 
 /* This function returns list with Mixer_System_Name */
-Evas_List* mixer_system_get_list()
+Evas_List *
+mixer_system_get_list()
 {
-       Evas_List* l;
-       DIR* d;
-       struct dirent* de;
-       char buf[1024];
+   Evas_List *l;
+   DIR *d;
+   struct dirent *de;
+   char buf[1024];
 
-       l = NULL;
+   l = NULL;
 
-       snprintf(buf, 1024, "%s/%s/systems/",
-                       module_root, MODULE_ARCH);
+   snprintf(buf, 1024, "%s/%s/systems/", module_root, MODULE_ARCH);
 
-       d = opendir(buf);
-       if(!d)
-               return NULL;
+   d = opendir(buf);
+   if (!d)
+      return NULL;
 
-       while((de = readdir(d)) != NULL)
-       {
-               char *ptr;
-               ptr = de->d_name;
+   while ((de = readdir(d)) != NULL)
+     {
+        char *ptr;
 
-               if(ptr[0] == '.')
-                       continue;
+        ptr = de->d_name;
 
-               if(strncmp(ptr + strlen(ptr) - 3, ".so", 3) != 0)
-                       continue;
+        if (ptr[0] == '.')
+           continue;
 
+        if (strncmp(ptr + strlen(ptr) - 3, ".so", 3) != 0)
+           continue;
 
-               if((ptr = strstr(ptr,"module_")))
-               {
-                       void *handle;
-                       Mixer_System_Name* msn;
-                       Mixer_System_Name* (*s_get_systems)(void);
-                       
-                       snprintf(buf, 1024, "%s/%s/systems/%s",
-                                       module_root, MODULE_ARCH, ptr);
+        if ((ptr = strstr(ptr, "module_")))
+          {
+             void *handle;
+             Mixer_System_Name *msn;
+             Mixer_System_Name *(*s_get_systems) (void);
 
-                       fprintf(stderr,"module_path = %s\n", buf);
-                       handle = dlopen(buf, RTLD_NOW);
-                       if(!handle)
-                               continue;
+             snprintf(buf, 1024, "%s/%s/systems/%s", module_root, MODULE_ARCH, 
ptr);
 
-                       s_get_systems = dlsym(handle, "s_get_systems");
+             fprintf(stderr, "module_path = %s\n", buf);
+             handle = dlopen(buf, RTLD_NOW);
+             if (!handle)
+                continue;
 
-                       if(!s_get_systems)
-                       {
-                               dlclose(handle);
-                               continue;
-                       }
+             s_get_systems = dlsym(handle, "s_get_systems");
 
-                       msn = s_get_systems();
+             if (!s_get_systems)
+               {
+                  dlclose(handle);
+                  continue;
+               }
 
-                       /*
-                       fprintf(stderr,"msn = %p\n", msn);
-                       fprintf(stderr,"msn = { \"%s\", \"%s\", %p }\n",
-                                       msn->system, msn->real, 
msn->mixer_names);
-                       */
+             msn = s_get_systems();
 
-                       dlclose(handle);
+             /*
+              * fprintf(stderr,"msn = %p\n", msn);
+              * fprintf(stderr,"msn = { \"%s\", \"%s\", %p }\n",
+              * msn->system, msn->real, msn->mixer_names);
+              */
 
-                       l = evas_list_append(l, msn);
-                       
-               }
+             dlclose(handle);
 
-               /*
-                  char name[128];
+             l = evas_list_append(l, msn);
 
-                  strncpy(name, ptr + strlen("module_"), 128);
-                  ms = calloc(sizeof(Mixer_System), 1);
-                  ms->name = strdup(name);
-                  mixer_system_load(ms);
+          }
 
+        /*
+         * char name[128];
+         * 
+         * strncpy(name, ptr + strlen("module_"), 128);
+         * ms = calloc(sizeof(Mixer_System), 1);
+         * ms->name = strdup(name);
+         * mixer_system_load(ms);
+         * 
+         * 
+         * mixer_system_unload(ms);
+         * l = evas_list_append(l, ms);
+         */
 
-                  mixer_system_unload(ms);
-                  l = evas_list_append(l, ms);
-                  */
+     }
 
-       }
+   closedir(d);
 
-       closedir(d);
-
-       return l;
+   return l;
 }
 
-int mixer_set_callback(Mixer* mixer, mixer_callback callback, void *data)
+int
+mixer_set_callback(Mixer *mixer, mixer_callback callback, void *data)
 {
-       if (!mixer)
-               return 0;
+   if (!mixer)
+      return 0;
 
-       mixer->callback = callback;
-       mixer->callback_private = data;
+   mixer->callback = callback;
+   mixer->callback_private = data;
 
-       return 1;
+   return 1;
 }
 
-int mixer_system_load(Mixer_System* ms)
+int
+mixer_system_load(Mixer_System *ms)
 {
-       Mixer_System_Name *msn;
-       char buf[1024];
-       msn = ms->name;
+   Mixer_System_Name *msn;
+   char buf[1024];
 
-       if (ms->handle)
-       {
-               ms->ref ++;
-               return 0;
-       }
+   msn = ms->name;
 
-       snprintf(buf, 1024, "%s/%s/systems/module_%s.so",
-                       module_root, MODULE_ARCH, msn->system);
+   if (ms->handle)
+     {
+        ms->ref++;
+        return 0;
+     }
 
-       ms->handle = dlopen(buf, RTLD_NOW);
+   snprintf(buf, 1024, "%s/%s/systems/module_%s.so", module_root, MODULE_ARCH, 
msn->system);
 
+   ms->handle = dlopen(buf, RTLD_NOW);
 
-       if (!ms->handle)
-       {
-               fprintf(stderr,"Cannot load mixer system: %s: %s\n", 
msn->system,
-                               dlerror());
-               return 1;
-       }
+   if (!ms->handle)
+     {
+        fprintf(stderr, "Cannot load mixer system: %s: %s\n", msn->system, 
dlerror());
+        return 1;
+     }
 
-       ms->ref ++;
-       return 0;
+   ms->ref++;
+   return 0;
 }
 
-int mixer_system_unload(Mixer_System* ms)
+int
+mixer_system_unload(Mixer_System *ms)
 {
-       ms->ref --;
+   ms->ref--;
 
-       if (ms->ref)
-               return 0;
+   if (ms->ref)
+      return 0;
 
-       dlclose(ms->handle);
-       return 0;
+   dlclose(ms->handle);
+   return 0;
 }
 
-
-Mixer* mixer_system_getentries( Mixer_System* ms, Mixer_System_Name *msn )
+Mixer *
+mixer_system_getentries(Mixer_System *ms, Mixer_System_Name *msn)
 {
-       Mixer* mixer;
+   Mixer *mixer;
 
-       if(ms->handle == NULL)
-               return NULL;
+   if (ms->handle == NULL)
+      return NULL;
 
-       mixer = calloc(1, sizeof(Mixer));
+   mixer = calloc(1, sizeof(Mixer));
 
-       mixer->system = ms;
+   mixer->system = ms;
 
-       mixer->open = dlsym(ms->handle, "m_open");
-       mixer->close = dlsym(ms->handle, "m_close");
-       mixer->get_volume = dlsym(ms->handle, "m_get_volume");
-       mixer->set_volume = dlsym(ms->handle, "m_set_volume");
+   mixer->open = dlsym(ms->handle, "m_open");
+   mixer->close = dlsym(ms->handle, "m_close");
+   mixer->get_volume = dlsym(ms->handle, "m_get_volume");
+   mixer->set_volume = dlsym(ms->handle, "m_set_volume");
 
-       mixer->get_mute = dlsym(ms->handle, "m_get_mute");
-       mixer->set_mute = dlsym(ms->handle, "m_set_mute");
+   mixer->get_mute = dlsym(ms->handle, "m_get_mute");
+   mixer->set_mute = dlsym(ms->handle, "m_set_mute");
 
-       if (!mixer->open || !mixer->close ||
-               !mixer->get_volume || !mixer->set_volume)
-       {
-               fprintf(stderr,"Cannot get mixer entry points: %s: %s\n",
-                               msn->system, dlerror());
-               mixer_system_unload(ms);
+   if (!mixer->open || !mixer->close || !mixer->get_volume || 
!mixer->set_volume)
+     {
+        fprintf(stderr, "Cannot get mixer entry points: %s: %s\n", 
msn->system, dlerror());
+        mixer_system_unload(ms);
 
-               free(mixer);
-               return NULL;
-       }
+        free(mixer);
+        return NULL;
+     }
 
-       return mixer;
+   return mixer;
 }
 
-Mixer* mixer_open(Mixer_System** ms, Mixer_System_Name* msn,
-               int mixer_id)
+Mixer *
+mixer_open(Mixer_System **ms, Mixer_System_Name *msn, int mixer_id)
 {
-       Mixer* mixer;
-       Mixer_Name *name;
-       Evas_List *l;
+   Mixer *mixer;
+   Mixer_Name *name;
+   Evas_List *l;
 
-       if(!ms || !msn)
-               return NULL;
+   if (!ms || !msn)
+      return NULL;
 
-       if(*ms == NULL)
-       {
-//             fprintf(stderr,"Allocating new Mixer_System\n");
-               *ms = calloc(sizeof(Mixer_System), 1);
-               (*ms)->handle = NULL;
-               (*ms)->name = msn;
-       }
+   if (*ms == NULL)
+     {
+//              fprintf(stderr,"Allocating new Mixer_System\n");
+        *ms = calloc(sizeof(Mixer_System), 1);
+        (*ms)->handle = NULL;
+        (*ms)->name = msn;
+     }
 
+   mixer_system_load(*ms);
 
-       mixer_system_load(*ms);
+   mixer = mixer_system_getentries(*ms, msn);
 
-       mixer = mixer_system_getentries(*ms, msn);
+//      fprintf(stderr,"mixer->system = %p, name = %s\n", mixer->system,
+//                      mixer->system->name->system);
 
-//     fprintf(stderr,"mixer->system = %p, name = %s\n", mixer->system,
-//                     mixer->system->name->system);
+   if (!mixer)
+      return NULL;
 
-       if (!mixer)
-               return NULL;
+   for (l = msn->mixer_names; l; l = evas_list_next(l))
+     {
+        name = evas_list_data(l);
+        if (name->mixer_id == mixer_id)
+           break;
+     }
 
-       for(l = msn->mixer_names; l; l = evas_list_next(l))
-       {
-               name = evas_list_data(l);
-               if(name->mixer_id == mixer_id)
-                       break;
-       }
+   if (!l)
+      return NULL;
 
-       if(!l)
-               return NULL;
-
-       return mixer->open(mixer, *ms, name);
+   return mixer->open(mixer, *ms, name);
 }
 
-int mixer_ref(Mixer* mixer)
+int
+mixer_ref(Mixer *mixer)
 {
-       if(!mixer)
-               return 0;
+   if (!mixer)
+      return 0;
 
-       mixer->ref++;
-       fprintf(stderr,"mixer_ref = %d\n",mixer->ref);
+   mixer->ref++;
+   fprintf(stderr, "mixer_ref = %d\n", mixer->ref);
 
-       return mixer->ref;
+   return mixer->ref;
 }
 
-
-int mixer_unref(Mixer* mixer)
+int
+mixer_unref(Mixer *mixer)
 {
-       if(!mixer)
-               return 0;
+   if (!mixer)
+      return 0;
 
-       mixer->ref--;
-       fprintf(stderr,"mixer_ref = %d\n", mixer->ref);
+   mixer->ref--;
+   fprintf(stderr, "mixer_ref = %d\n", mixer->ref);
 
-       return mixer->ref;
+   return mixer->ref;
 }
 
-int mixer_unref_close(Mixer* mixer)
+int
+mixer_unref_close(Mixer *mixer)
 {
 
-       if(mixer_unref(mixer) <= 0)
-       {
-               mixer_close(mixer);
-               return 0;
-       }
-       else
-               return mixer->ref;
+   if (mixer_unref(mixer) <= 0)
+     {
+        mixer_close(mixer);
+        return 0;
+     }
+   else
+      return mixer->ref;
 }
 
-int mixer_close(Mixer* mixer)
+int
+mixer_close(Mixer *mixer)
 {
 
-       int ret;
+   int ret;
 
-       if (mixer->ref > 0)
-               return 0;
+   if (mixer->ref > 0)
+      return 0;
 
-       if (!mixer || !mixer->close)
-               return 0;
-       
-       fprintf(stderr,"Mixer unloading: %s, %s\n",
-                       mixer->name->real, mixer->name->card);
+   if (!mixer || !mixer->close)
+      return 0;
 
-       ret = mixer->close(mixer, mixer->system);
+   fprintf(stderr, "Mixer unloading: %s, %s\n", mixer->name->real, 
mixer->name->card);
 
-       mixer_system_unload(mixer->system);
-       return ret;
+   ret = mixer->close(mixer, mixer->system);
+
+   mixer_system_unload(mixer->system);
+   return ret;
 }
 
-int mixer_get_volume(Mixer_Elem* melem, int* left, int *right)
+int
+mixer_get_volume(Mixer_Elem *melem, int *left, int *right)
 {
-       Mixer   *mixer;
+   Mixer *mixer;
 
-       mixer = melem->mixer;
+   mixer = melem->mixer;
 
-       return mixer->get_volume(melem, left, right);
+   return mixer->get_volume(melem, left, right);
 }
 
-int mixer_set_volume(Mixer_Elem* melem, int left, int right)
+int
+mixer_set_volume(Mixer_Elem *melem, int left, int right)
 {
-       Mixer   *mixer;
+   Mixer *mixer;
 
-       mixer = melem->mixer;
+   mixer = melem->mixer;
 
-       return mixer->set_volume(melem, left, right);
+   return mixer->set_volume(melem, left, right);
 }
 
-int mixer_get_mute(Mixer_Elem* melem)
+int
+mixer_get_mute(Mixer_Elem *melem)
 {
-       Mixer* mixer;
+   Mixer *mixer;
 
-       mixer = melem->mixer;
-       if(mixer->get_mute)
-               return mixer->get_mute(melem);
-       else
-               return -ENOSYS;
+   mixer = melem->mixer;
+   if (mixer->get_mute)
+      return mixer->get_mute(melem);
+   else
+      return -ENOSYS;
 }
 
-int mixer_set_mute(Mixer_Elem* melem, int mute)
+int
+mixer_set_mute(Mixer_Elem *melem, int mute)
 {
-       Mixer* mixer;
+   Mixer *mixer;
 
-       mixer = melem->mixer;
-       if(mixer->set_mute)
-               return mixer->set_mute(melem, mute);
-       else
-               return -ENOSYS;
+   mixer = melem->mixer;
+   if (mixer->set_mute)
+      return mixer->set_mute(melem, mute);
+   else
+      return -ENOSYS;
 }
 
 #define HASH_DEBUG
 /* Code from evas/src/lib/data/evas_hash.c */
-static int _mixer_hash(const char *key) 
+static int
+_mixer_hash(const char *key)
 {
-       unsigned int hash_num = 0, i;
-       const unsigned char *ptr;
-       if (!key) return 0;
-       for (i = 0, ptr = (unsigned char *)key;
-                       *ptr;
-                       ptr++, i++) hash_num ^= ((int)(*ptr) | ((int)(*ptr) << 
8)) >> (i % 2);
-       hash_num = (hash_num & 0xFF) + (hash_num >> 4 & 0xF0) + (hash_num >> 8 
& 0x4F);
-       hash_num = hash_num & 0xFF;
+   unsigned int hash_num = 0, i;
+   const unsigned char *ptr;
+
+   if (!key)
+      return 0;
+   for (i = 0, ptr = (unsigned char *)key; *ptr; ptr++, i++)
+      hash_num ^= ((int)(*ptr) | ((int)(*ptr) << 8)) >> (i % 2);
+   hash_num = (hash_num & 0xFF) + (hash_num >> 4 & 0xF0) + (hash_num >> 8 & 
0x4F);
+   hash_num = hash_num & 0xFF;
 
 #ifdef HASH_DEBUG
-       fprintf(stderr,"%s: key = %s, hash = %d\n", __FUNCTION__,
-                       key, hash_num);
+   fprintf(stderr, "%s: key = %s, hash = %d\n", __FUNCTION__, key, hash_num);
 #endif
 
-       return (int)hash_num;
+   return (int)hash_num;
 }
 
-int mixer_system_get_id(const char *name)
+int
+mixer_system_get_id(const char *name)
 {
-       return _mixer_hash(name) << 16;
+   return _mixer_hash(name) << 16;
 }
 
-int mixer_get_id(const char *name)
+int
+mixer_get_id(const char *name)
 {
-       return _mixer_hash(name) << 8;
+   return _mixer_hash(name) << 8;
 }
 
-int mixer_elem_get_id(const char *name)
+int
+mixer_elem_get_id(const char *name)
 {
-       return _mixer_hash(name);
+   return _mixer_hash(name);
 }
-
===================================================================
RCS file: /cvs/e/e_modules/evolume/src/lib/e_mixer.h,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -3 -r1.1 -r1.2
--- e_mixer.h   21 Mar 2006 02:12:19 -0000      1.1
+++ e_mixer.h   5 Apr 2006 17:48:48 -0000       1.2
@@ -6,7 +6,6 @@
 
 #include <Ecore.h>
 
-
 #ifndef __UNUSED__
 #define __UNUSED__ __attribute__((unused))
 #endif
@@ -17,156 +16,151 @@
 typedef struct _Mixer_System_Name Mixer_System_Name;
 typedef struct _Mixer_Elem Mixer_Elem;
 
-typedef void (*mixer_callback) (void * pr);
+typedef void (*mixer_callback) (void *pr);
 
 struct _Mixer
 {
-       /** Name of this mixer */
-       Mixer_Name                              *name;
-       /** System for this mixer */
-       Mixer_System                    *system;
-
-       /** Local data - mixer engine definded data */
-       void                                    *local;
-
-       /** Mixer elements */
-       Evas_List                               *elems;
-
-       /** Signals if update necessary */
-       int                                             is_changed;
-
-       /** Callback and callback data */
-       mixer_callback                  callback;
-       void                                    *callback_private;      
-
-       /** Reference counter */
-       int                                             ref;
-
-       /** Pointer to function, that initializes mixer */
-       Mixer*  (*open)(Mixer* mixer, Mixer_System* ms, Mixer_Name* mixer_name);
-       /** Pointer to function, that frees mixer */
-       int (*close)(Mixer* mixer, Mixer_System* ms);
-       /** Standart operations: get and set volume */
-       int (*get_volume)(Mixer_Elem* melem, int *left, int *right);
-       int (*set_volume)(Mixer_Elem* melem, int left, int right);
-
-       /** get and set mute */
-       int (*get_mute)(Mixer_Elem* melem);
-       int (*set_mute)(Mixer_Elem* melem, int mute);
-
-       /*
-       int                     (*get_elem_id)(Mixer_Elem* melem);
-       Mixer_Elem* (*find_elem)(int elem_id);
-       */
+        /** Name of this mixer */
+   Mixer_Name *name;
+        /** System for this mixer */
+   Mixer_System *system;
+
+        /** Local data - mixer engine definded data */
+   void *local;
+
+        /** Mixer elements */
+   Evas_List *elems;
+
+        /** Signals if update necessary */
+   int is_changed;
+
+        /** Callback and callback data */
+   mixer_callback callback;
+   void *callback_private;
+
+        /** Reference counter */
+   int ref;
+
+        /** Pointer to function, that initializes mixer */
+   Mixer *(*open) (Mixer *mixer, Mixer_System *ms, Mixer_Name *mixer_name);
+        /** Pointer to function, that frees mixer */
+   int (*close) (Mixer *mixer, Mixer_System *ms);
+        /** Standart operations: get and set volume */
+   int (*get_volume) (Mixer_Elem *melem, int *left, int *right);
+   int (*set_volume) (Mixer_Elem *melem, int left, int right);
+
+        /** get and set mute */
+   int (*get_mute) (Mixer_Elem *melem);
+   int (*set_mute) (Mixer_Elem *melem, int mute);
+
+   /*
+    * int                  (*get_elem_id)(Mixer_Elem* melem);
+    * Mixer_Elem* (*find_elem)(int elem_id);
+    */
 };
 
-struct _Mixer_Elem 
+struct _Mixer_Elem
 {
-       /** pointer to the parent */
-       Mixer                                   *mixer;
+        /** pointer to the parent */
+   Mixer *mixer;
 
-       /** type of mixer (reserved) */
-       char                                    type;
+        /** type of mixer (reserved) */
+   char type;
 
-       /** mixer name (printable) */
-       char                                    *name;
+        /** mixer name (printable) */
+   char *name;
 
-       /** is this mixer active? */
-       char                                    active;
-       /** local (engine specific) data */
-       void                                    *local;
+        /** is this mixer active? */
+   char active;
+        /** local (engine specific) data */
+   void *local;
 
-       /** Element identifier (hash) */
-       int                                             elem_id;
+        /** Element identifier (hash) */
+   int elem_id;
 
-       /* Previous volume */
-       int                                             pvl, pvr;
+   /* Previous volume */
+   int pvl, pvr;
 
 };
 
 struct _Mixer_Name
 {
-       /** card name (engine specific */
-       char                                    *card;
-       /** real (printable) name */
-       char                                    *real;
-       /** active flag */
-       int                                             active;
+        /** card name (engine specific */
+   char *card;
+        /** real (printable) name */
+   char *real;
+        /** active flag */
+   int active;
 
-       /** ID of mixer, this is typically hash */
-       int                                             mixer_id;
+        /** ID of mixer, this is typically hash */
+   int mixer_id;
 
-       /** name of mixer system (parent)*/
-       Mixer_System_Name               *system_name;
+        /** name of mixer system (parent)*/
+   Mixer_System_Name *system_name;
 };
 
 struct _Mixer_System
 {
-       /** name of mixer system (child)*/
-       Mixer_System_Name *name;
+        /** name of mixer system (child)*/
+   Mixer_System_Name *name;
 
-       /** dl info */
-       void *handle;
-       int ref;
+        /** dl info */
+   void *handle;
+   int ref;
 
-//     Evas_List* (*get_names)(Mixer_System* ms);
+//      Evas_List* (*get_names)(Mixer_System* ms);
 };
 
 struct _Mixer_System_Name
 {
-       /* This is system name: name of module_%s */
-       char *system;
-       /* This is name of system (in nice printable form */
-       char *name;
-
-       /** system id (hash) */
-       int system_id;
-
-       
-       /* List of Mixer_Name structures */
-       Evas_List* mixer_names;
+   /* This is system name: name of module_%s */
+   char *system;
+   /* This is name of system (in nice printable form */
+   char *name;
 
-       /* If it is created */
-       Mixer_System *ms;
-};
+        /** system id (hash) */
+   int system_id;
 
+   /* List of Mixer_Name structures */
+   Evas_List *mixer_names;
+
+   /* If it is created */
+   Mixer_System *ms;
+};
 
 /* Returns Mixer_Name list for that Mixer_System */
-//Evas_List*   mixer_get_names(Mixer_System* );
+//Evas_List*    mixer_get_names(Mixer_System* );
 
 /* Retruns Mixer_System_Name list for all accessible modules */
-Evas_List*     mixer_system_get_list();
+Evas_List *mixer_system_get_list();
 
 /* Loads that mixer_system in memory */
-int                    mixer_system_load(Mixer_System* ms);
+int mixer_system_load(Mixer_System *ms);
 
 /* Retruns Mixer list for that Mixer_System_Name (according to active flag) */
-Evas_List*     mixer_system_open (Mixer_System_Name* msn);
+Evas_List *mixer_system_open(Mixer_System_Name *msn);
 
 /* Closes all mixers for that Mixer_System_Name */
-int                    mixer_system_close(Mixer_System_Name* msn, Evas_List* 
mixers);
+int mixer_system_close(Mixer_System_Name *msn, Evas_List *mixers);
+
+Mixer *mixer_open(Mixer_System **ms, Mixer_System_Name *msn, int mixer_id);
+int mixer_close(Mixer *mixer);
 
-Mixer*         mixer_open (Mixer_System** ms, Mixer_System_Name* msn, 
-                                               int mixer_id);
-int                    mixer_close(Mixer* mixer);
-
-int                    mixer_ref(Mixer* mixer);
-int                    mixer_unref(Mixer* mixer);
-int                    mixer_unref_close(Mixer* mixer);
-
-int                    mixer_get_volume(Mixer_Elem *melem, int *left, int 
*right);
-int                    mixer_set_volume(Mixer_Elem *melem, int left, int 
right);
-int                    mixer_set_callback(Mixer* mixer, mixer_callback 
callback, 
-               void *data);
+int mixer_ref(Mixer *mixer);
+int mixer_unref(Mixer *mixer);
+int mixer_unref_close(Mixer *mixer);
 
-int                    mixer_get_mute(Mixer_Elem *melem);
-int                    mixer_set_mute(Mixer_Elem *melem, int mute);
+int mixer_get_volume(Mixer_Elem *melem, int *left, int *right);
+int mixer_set_volume(Mixer_Elem *melem, int left, int right);
+int mixer_set_callback(Mixer *mixer, mixer_callback callback, void *data);
 
+int mixer_get_mute(Mixer_Elem *melem);
+int mixer_set_mute(Mixer_Elem *melem, int mute);
 
 #ifdef MODULE
-int                    mixer_system_get_id(const char *key);
-int                    mixer_get_id(const char *key);
-int                    mixer_elem_get_id(const char *key);
+int mixer_system_get_id(const char *key);
+int mixer_get_id(const char *key);
+int mixer_elem_get_id(const char *key);
 #endif
 
 #define GET_ELEM_ID(melem) \
@@ -174,4 +168,4 @@
                 melem->mixer->name->mixer_id | \
                 melem->mixer->system->name->system_id)
 
-#endif // _MIXER_H_INCLUDED 
+#endif // _MIXER_H_INCLUDED




-------------------------------------------------------
This SF.Net email is sponsored by xPML, a groundbreaking scripting language
that extends applications into web and mobile media. Attend the live webcast
and join the prime developer group breaking into this new coding territory!
http://sel.as-us.falkag.net/sel?cmd=lnk&kid=110944&bid=241720&dat=121642
_______________________________________________
enlightenment-cvs mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/enlightenment-cvs

Reply via email to