avsys-audio-ascenario.c

   1 /*
   2  * avsystem
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Jonghyuk Choi <jhchoi.choi@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  */
  21
  22 #if !defined(_MMFW_I386_ALL_SIMULATOR)
  23 #include <alsa/ascenario.h>
  24 #endif
  25 #include <string.h>
  26
  27 #include "avsys-audio-ascenario.h"
  28 #include "avsys-types.h"
  29 #include "avsys-error.h"
  30 #include "avsys-debug.h"
  31 #if defined(TIME_CHECK)
  32 #include <sys/time.h>
  33 #include <time.h>
  34 #endif
  35
  36 #define STR_BUFF_MAX 128
  37 #define P_STR_MAX 42
  38 #define O_STR_MAX 44
  39 #define CARD_NUMBER 0 /* ALSA card number */
  40
  41 static int __avsys_audio_ascn_make_scenario_str(int input, char *buf, int buf_len)
  42 {
  43         char fromStr[P_STR_MAX] = { 0, };
  44         char toStr[P_STR_MAX] = { 0, };
  45         char optStr[O_STR_MAX] = { 0, };
  46
  47         if (buf == NULL) {
  48                 avsys_error(AVAUDIO, "Input Buf is null\n");
  49                 return AVSYS_STATE_ERR_NULL_POINTER;
  50         }
  51
  52         if (input & INPUT_MAIN_MIC) {
  53                 strncpy(fromStr, "mainmic", sizeof(fromStr) - 1);
  54         }
  55         if (input & INPUT_SUB_MIC) {
  56                 strncpy(fromStr, "submic", sizeof(fromStr) - 1);
  57         }
  58         if (input & INPUT_STEREO_MIC) {
  59                 strncpy(fromStr, "stereomic", sizeof(fromStr) - 1);
  60         }
  61         if (input & INPUT_EAR_MIC) {
  62                 strncpy(fromStr, "earmic", sizeof(fromStr) - 1);
  63         }
  64         if (input & INPUT_BT_MIC) {
  65                 strncpy(fromStr, "bt", sizeof(fromStr) - 1);
  66         }
  67         if (input & INPUT_AP) {
  68                 strncpy(fromStr, "ap", sizeof(fromStr) - 1);
  69         }
  70         if (input & INPUT_CP) {
  71                 strncpy(fromStr, "cp", sizeof(fromStr) - 1);
  72         }
  73         if (input & INPUT_FMRADIO) {
  74                 strncpy(fromStr, "fmradio", sizeof(fromStr) - 1);
  75         }
  76
  77         if (input & OUTPUT_HEADSET) {
  78                 strncpy(toStr, "headset", sizeof(toStr) - 1);
  79         }
  80         if (input & OUTPUT_LEFT_SPK) {
  81                 strncpy(toStr, "speaker_left", sizeof(toStr) - 1);
  82         }
  83         if (input & OUTPUT_RIGHT_SPK) {
  84                 strncpy(toStr, "speaker_right", sizeof(toStr) - 1);
  85         }
  86         if (input & OUTPUT_STEREO_SPK) {
  87                 strncpy(toStr, "speaker", sizeof(toStr) - 1);
  88         }
  89         if (input & OUTPUT_RECV) {
  90                 strncpy(toStr, "receiver", sizeof(toStr) - 1);
  91         }
  92         if (input & OUTPUT_BT_HEADSET) {
  93                 strncpy(toStr, "bt", sizeof(toStr) - 1);
  94         }
  95         if (input & OUTPUT_CP) {
  96                 strncpy(toStr, "cp", sizeof(toStr) - 1);
  97         }
  98         if (input & OUTPUT_AP) {
  99                 strncpy(toStr, "ap", sizeof(toStr) - 1);
 100         }
 101         if (input & OUTPUT_HDMI) {
 102                 strncpy(toStr, "hdmi", sizeof(toStr) - 1);
 103         }
 104         if (input & OUTPUT_DOCK) {
 105                 strncpy(toStr, "dock", sizeof(toStr) - 1);
 106         }
 107         if (input & GAIN_MODE) {
 108                 strncpy(optStr, "_gain", sizeof(optStr) - 1);
 109         }
 110         if (input & GAIN_VIDEO_CALL) {
 111                 strncpy(optStr, "_videocall_gain", sizeof(optStr) - 1);
 112         }
 113         if (input & GAIN_VOICE_CALL) {
 114                 strncpy(optStr, "_voicecall_gain", sizeof(optStr) - 1);
 115         }
 116         if (input & GAIN_CALLALERT) {
 117                 strncpy(optStr, "_ringtone_gain", sizeof(optStr) - 1);
 118         }
 119
 120         snprintf(buf, buf_len - 1, "%s_to_%s%s", fromStr, toStr, optStr);
 121         //avsys_info(AVAUDIO, "rslt str : %s\n", buf);
 122         return AVSYS_STATE_SUCCESS;
 123 }
 124
 125 int avsys_audio_ascn_bulk_set(int * bulk, int bulk_cnt, AscnResetType clear)
 126 {
 127         struct snd_scenario *scn = NULL;
 128         int card = CARD_NUMBER;
 129         char *name = NULL;
 130         char str_buf[STR_BUFF_MAX] = { 0, };
 131         char reset_str[STR_BUFF_MAX] = { 0, };
 132         int err = AVSYS_STATE_SUCCESS;
 133         int i = 0;
 134 #if defined(TIME_CHECK)
 135         struct timeval t_start, t_stop;
 136         unsigned long check = 0;
 137 #endif
 138
 139         avsys_info(AVAUDIO, "<< %s, clear = %d\n", __func__, clear);
 140
 141         if (clear < ASCN_RESET_NONE || clear > ASCN_RESET_MODEM) {
 142                 avsys_error_r(AVAUDIO, "invalid clear type %d\n", clear);
 143                 return AVSYS_STATE_ERR_RANGE_OVER;
 144         }
 145
 146         if (bulk == NULL) {
 147                 avsys_error_r(AVAUDIO, "input bulk is null\n");
 148                 return AVSYS_STATE_ERR_NULL_POINTER;
 149         }
 150         if (bulk_cnt < 0) {
 151                 avsys_error_r(AVAUDIO, "bulk_cnt is negative\n");
 152                 return AVSYS_STATE_ERR_RANGE_OVER;
 153         }
 154
 155         /* Try to get card name from CARD_NUMBER. */
 156         snd_card_get_name(card, &name);
 157 #if defined(TIME_CHECK)
 158         gettimeofday(&t_start, NULL);
 159 #endif
 160         if (name == NULL) {
 161                 scn = snd_scenario_open("default");
 162                 if (scn == NULL)
 163                 {
 164                         avsys_error(AVAUDIO, "snd_scenario_open() failed to open with default\n");
 165                         return AVSYS_STATE_ERR_INTERNAL;
 166                 }
 167         } else {
 168                 scn = snd_scenario_open(name);
 169                 free(name);
 170                 if (scn == NULL)
 171                 {
 172                         scn = snd_scenario_open("default");
 173                         if (scn == NULL)
 174                         {
 175                                 avsys_error(AVAUDIO, "snd_scenario_open() failed to open with default\n");
 176                                 return AVSYS_STATE_ERR_INTERNAL;
 177                         }
 178                 }
 179         }
 180 #if defined(TIME_CHECK)
 181         gettimeofday(&t_stop, NULL);
 182         if (t_stop.tv_sec == t_start.tv_sec)
 183                 check = (t_stop.tv_usec - t_start.tv_usec) / 1000;
 184         else
 185                 check = (t_stop.tv_sec - t_start.tv_sec) * 1000 + (t_stop.tv_usec - t_start.tv_usec) / 1000;
 186         avsys_warning(AVAUDIO, "[snd_scenario_open()] takes %u msec\n", check);
 187 #endif
 188         if (clear != ASCN_RESET_NONE) {
 189                 switch (clear) {
 190                 case ASCN_RESET_ALL:
 191                         snprintf(reset_str, sizeof(reset_str) - 1, "%s", ASCN_STR_RESET);
 192                         break;
 193                 case ASCN_RESET_PLAYBACK:
 194                         snprintf(reset_str, sizeof(reset_str) - 1, "%s", ASCN_STR_RESET_PLAYBACK);
 195                         break;
 196                 case ASCN_RESET_CAPTURE:
 197                         snprintf(reset_str, sizeof(reset_str) - 1, "%s", ASCN_STR_RESET_CAPTURE);
 198                         break;
 199                 }
 200 #if defined(TIME_CHECK)
 201                 gettimeofday(&t_start, NULL);
 202 #endif
 203                 err = snd_scenario_set_scn(scn, reset_str);
 204 #if defined(TIME_CHECK)
 205                 gettimeofday(&t_stop, NULL);
 206                 if (t_stop.tv_sec == t_start.tv_sec)
 207                         check = (t_stop.tv_usec - t_start.tv_usec) / 1000;
 208                 else
 209                         check = (t_stop.tv_sec - t_start.tv_sec) * 1000 + (t_stop.tv_usec - t_start.tv_usec) / 1000;
 210                 avsys_warning(AVAUDIO, "[%s] takes %u msec\n", reset_str, check);
 211 #endif
 212                 if (err < 0) {
 213                         avsys_error(AVAUDIO, "Alsa sceanrio [%s] failed\n", reset_str);
 214                 } else {
 215                         avsys_warning(AVAUDIO, "Set [%s] success\n", reset_str);
 216                 }
 217         }
 218
 219         for (i = 0; i < bulk_cnt; i++) {
 220                 if (bulk[i] == 0)
 221                         continue;
 222                 memset(str_buf, '\0', sizeof(str_buf));
 223                 //avsys_info(AVAUDIO, "make string for 0x%X\n", bulk[i]);
 224                 __avsys_audio_ascn_make_scenario_str(bulk[i], str_buf, sizeof(str_buf));
 225                 //avsys_info(AVAUDIO, "result string [%s]\n", str_buf);
 226 #if defined(TIME_CHECK)
 227                 gettimeofday(&t_start, NULL);
 228 #endif
 229                 err = snd_scenario_set_scn(scn, str_buf);
 230 #if defined(TIME_CHECK)
 231                 gettimeofday(&t_stop, NULL);
 232                 if (t_stop.tv_sec == t_start.tv_sec)
 233                         check = (t_stop.tv_usec - t_start.tv_usec) / 1000;
 234                 else
 235                         check = (t_stop.tv_sec - t_start.tv_sec) * 1000 + (t_stop.tv_usec - t_start.tv_usec) / 1000;
 236                 avsys_warning(AVAUDIO, "[%s] takes %u msec\n", str_buf, check);
 237 #endif
 238                 if (err < 0) {
 239                         avsys_error_r(AVAUDIO, "snd_scenario_set_scn(%s) failed with %d\n", str_buf, err);
 240                         goto bulk_error;
 241                 }
 242                 avsys_warning(AVAUDIO, "* [0x%010X] Set [%s] success\n", bulk[i], str_buf);
 243         }
 244
 245 bulk_error:
 246 #if defined(TIME_CHECK)
 247         gettimeofday(&t_start, NULL);
 248 #endif
 249         snd_scenario_close(scn);
 250 #if defined(TIME_CHECK)
 251         gettimeofday(&t_stop, NULL);
 252         if (t_stop.tv_sec == t_start.tv_sec)
 253                 check = (t_stop.tv_usec - t_start.tv_usec) / 1000;
 254         else
 255                 check = (t_stop.tv_sec - t_start.tv_sec) * 1000 + (t_stop.tv_usec - t_start.tv_usec) / 1000;
 256         avsys_warning(AVAUDIO, "[snd_scenario_close()] takes %u msec\n", check);
 257 #endif
 258         return err;
 259 }
 260
 261
 262 int avsys_audio_ascn_single_set(char * str)
 263 {
 264         struct snd_scenario *scn = NULL;
 265         int card = CARD_NUMBER;
 266         char *name = NULL;
 267         char cmd_str[STR_BUFF_MAX] = { 0, };
 268         int err = AVSYS_STATE_SUCCESS;
 269 #if defined(TIME_CHECK)
 270         struct timeval t_start, t_stop;
 271         unsigned long check = 0;
 272 #endif
 273
 274         if (str == NULL) {
 275                 avsys_error_r(AVAUDIO, "input str is null\n");
 276                 return AVSYS_STATE_ERR_NULL_POINTER;
 277         }
 278
 279 #if defined(TIME_CHECK)
 280         gettimeofday(&t_start, NULL);
 281 #endif
 282
 283         /* Try to get card name from CARD_NUMBER. */
 284         snd_card_get_name(card, &name);
 285
 286         if (name == NULL) {
 287                 scn = snd_scenario_open("default");
 288                 if (scn == NULL)
 289                 {
 290                         avsys_error(AVAUDIO, "snd_scenario_open() failed to open with default\n");
 291                         return AVSYS_STATE_ERR_INTERNAL;
 292                 }
 293         } else {
 294                 scn = snd_scenario_open(name);
 295                 free(name);
 296                 if (scn == NULL)
 297                 {
 298                         scn = snd_scenario_open("default");
 299                         if (scn == NULL)
 300                         {
 301                                 avsys_error(AVAUDIO, "snd_scenario_open() failed to open with default\n");
 302                                 return AVSYS_STATE_ERR_INTERNAL;
 303                         }
 304                 }
 305         }
 306
 307         /* Set scenario */
 308         strncpy(cmd_str, str, sizeof(cmd_str) - 1);
 309         err = snd_scenario_set_scn(scn, str);
 310         avsys_info(AVAUDIO, "alsa scenario set [%s]\n", str);
 311
 312         if (err < 0) {
 313                 avsys_error(AVAUDIO, "snd_scenario_set(%s) failed\n", str);
 314         }
 315
 316         /* Close scenario manager core */
 317         snd_scenario_close(scn);
 318
 319 #if defined(TIME_CHECK)
 320         gettimeofday(&t_stop, NULL);
 321         if (t_stop.tv_sec == t_start.tv_sec)
 322                 check = (t_stop.tv_usec - t_start.tv_usec) / 1000;
 323         else
 324                 check = (t_stop.tv_sec - t_start.tv_sec) * 1000 + (t_stop.tv_usec - t_start.tv_usec) / 1000;
 325         avsys_warning(AVAUDIO, "[%s] takes %u msec\n", str, check);
 326 #endif
 327
 328         return err;
 329 }