src/sound_manager_internal.c

   1 /*
   2 * Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
   3 *
   4 * Licensed under the Apache License, Version 2.0 (the "License");
   5 * you may not use this file except in compliance with the License.
   6 * You may obtain a copy of the License at
   7 *
   8 * http://www.apache.org/licenses/LICENSE-2.0
   9 *
  10 * Unless required by applicable law or agreed to in writing, software
  11 * distributed under the License is distributed on an "AS IS" BASIS,
  12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 * See the License for the specific language governing permissions and
  14 * limitations under the License.
  15 */
  16
  17 #include <sound_manager.h>
  18 #include <sound_manager_private.h>
  19 #include <sound_manager_internal.h>
  20 #include <mm_sound.h>
  21
  22 #ifndef TIZEN_FEATURE_TV_PROD
  23 int sound_manager_get_max_master_volume(int *max_level)
  24 {
  25         int ret = SOUND_MANAGER_ERROR_NONE;
  26         unsigned int volume_level = 0;
  27
  28         SM_ARG_CHECK(max_level);
  29
  30         ret = _get_volume_max_level(DIRECTION_OUT_STR, SOUND_TYPE_MASTER_STR, &volume_level);
  31         if (ret == SOUND_MANAGER_ERROR_NONE) {
  32                 *max_level = (int)volume_level;
  33                 LOGI("max_level[%d]", *max_level);
  34         }
  35
  36         return ret;
  37 }
  38
  39 int sound_manager_set_master_volume(int level)
  40 {
  41         int ret = SOUND_MANAGER_ERROR_NONE;
  42
  43         LOGI("level[%d]", level);
  44
  45         ret = _set_volume_level(DIRECTION_OUT_STR, SOUND_TYPE_MASTER_STR, (unsigned int)level);
  46
  47         LOGI("ret[0x%x]", ret);
  48
  49         return ret;
  50 }
  51
  52 int sound_manager_get_master_volume(int *level)
  53 {
  54         int ret = SOUND_MANAGER_ERROR_NONE;
  55         unsigned int volume_level = 0;
  56
  57         SM_ARG_CHECK(level);
  58
  59         ret = _get_volume_level(DIRECTION_OUT_STR, SOUND_TYPE_MASTER_STR, &volume_level);
  60         if (ret == SOUND_MANAGER_ERROR_NONE) {
  61                 *level = (int)volume_level;
  62                 LOGI("level[%d]", *level);
  63         }
  64
  65         LOGI("ret[0x%x]", ret);
  66
  67         return ret;
  68 }
  69 #endif
  70
  71 int sound_manager_set_mute(sound_type_e type, bool mute)
  72 {
  73         int ret = MM_ERROR_NONE;
  74
  75         SM_ARG_CHECK(type < SOUND_TYPE_NUM);
  76
  77         LOGI("type[%d] mute[%d]", type, mute);
  78
  79         ret = mm_sound_set_mute(type, mute);
  80
  81         return _convert_sound_manager_error_code(__func__, ret);
  82 }
  83
  84 int sound_manager_get_mute(sound_type_e type, bool *muted)
  85 {
  86         int ret = MM_ERROR_NONE;
  87
  88         SM_ARG_CHECK(type < SOUND_TYPE_NUM);
  89         SM_ARG_CHECK(muted);
  90
  91         LOGI("type[%d]", type);
  92
  93         ret = mm_sound_get_mute(type, muted);
  94
  95         LOGI("muted[%d]", *muted);
  96
  97         return _convert_sound_manager_error_code(__func__, ret);
  98 }
  99
 100 int sound_manager_get_max_volume_internal(sound_type_internal_e type, int *max)
 101 {
 102         const char *volume_type = NULL;
 103         unsigned int max_level = 0;
 104         int ret = SOUND_MANAGER_ERROR_NONE;
 105
 106         SM_ARG_CHECK(max);
 107         SM_ARG_CHECK(type < SOUND_TYPE_INTERNAL_NUM);
 108
 109         LOGI("type[%d]", type);
 110
 111         ret = _convert_sound_type_for_internal(type, &volume_type);
 112         if (ret == SOUND_MANAGER_ERROR_NONE) {
 113                 ret = _get_volume_max_level(DIRECTION_OUT_STR, volume_type, &max_level);
 114                 if (ret == SOUND_MANAGER_ERROR_NONE) {
 115                         *max = (int)max_level -1;       /* actual volume step can be max step - 1 */
 116                         LOGI("volume_type[%s] max_level[%d]", volume_type, *max);
 117                 }
 118         }
 119
 120         LOGI("ret[0x%x]", ret);
 121
 122         return ret;
 123 }
 124
 125 int sound_manager_set_volume_internal(sound_type_internal_e type, int level)
 126 {
 127         int ret = MM_ERROR_NONE;
 128
 129         SM_ARG_CHECK(type < SOUND_TYPE_INTERNAL_NUM);
 130         SM_ARG_CHECK(level >= 0);
 131
 132         LOGI("type[%d] level[%d]", type, level);
 133
 134         ret = mm_sound_volume_set_value_internal(type, level);
 135
 136         return _convert_sound_manager_error_code(__func__, ret);
 137 }
 138
 139 int sound_manager_get_volume_internal(sound_type_internal_e type, int *level)
 140 {
 141         int ret = MM_ERROR_NONE;
 142         unsigned int uvolume;
 143
 144         SM_ARG_CHECK(type < SOUND_TYPE_INTERNAL_NUM);
 145         SM_ARG_CHECK(level);
 146
 147         LOGI("type[%d]", type);
 148
 149         ret = mm_sound_volume_get_value_internal(type, &uvolume);
 150         if (ret == MM_ERROR_NONE) {
 151                 *level = uvolume;
 152                 LOGI("level[%d]", *level);
 153         }
 154
 155         return _convert_sound_manager_error_code(__func__, ret);
 156 }
 157
 158 int sound_manager_get_current_sound_type_internal(sound_type_internal_e *type)
 159 {
 160         int ret = SOUND_MANAGER_ERROR_NONE;
 161         char *volume_type = NULL;
 162
 163         SM_ARG_CHECK(type);
 164
 165         /* get the volume type of the current playing stream */
 166         ret = _get_current_volume_type(DIRECTION_OUT_STR, &volume_type);
 167         if (ret == SOUND_MANAGER_ERROR_NONE) {
 168                 ret = _convert_sound_type_to_enum_for_internal((const char*)volume_type, type);
 169                 if (ret == SOUND_MANAGER_ERROR_NONE)
 170                         LOGI("volume_type[%s] type[%d]", volume_type, *type);
 171         }
 172
 173         LOGI("ret[0x%x]", ret);
 174
 175         return ret;
 176 }
 177
 178 int sound_manager_add_volume_changed_cb_internal(sound_manager_volume_changed_cb_internal callback, void *user_data, int *id)
 179 {
 180         int ret = MM_ERROR_NONE;
 181
 182         SM_ARG_CHECK(callback);
 183         SM_ARG_CHECK(id);
 184
 185         LOGI("callback[%p] user_data[%p]", callback, user_data);
 186
 187         ret = mm_sound_add_volume_changed_callback_internal((mm_sound_volume_changed_cb_internal)callback, user_data, (unsigned int*)id);
 188
 189         LOGI("id[%d]", *id);
 190
 191         return _convert_sound_manager_error_code(__func__, ret);
 192 }
 193
 194 int sound_manager_remove_volume_changed_cb_internal(int id)
 195 {
 196         int ret = MM_ERROR_NONE;
 197
 198         SM_ARG_CHECK(id >= 0);
 199
 200         LOGI("id[%d]", id);
 201
 202         ret = mm_sound_remove_volume_changed_callback_internal(id);
 203
 204         return _convert_sound_manager_error_code(__func__, ret);
 205 }
 206
 207 int sound_manager_create_stream_information_internal(sound_stream_type_internal_e stream_type, sound_stream_focus_state_changed_cb callback, void *user_data, sound_stream_info_h *stream_info)
 208 {
 209         int ret = SOUND_MANAGER_ERROR_NONE;
 210
 211         SM_ARG_CHECK(stream_info);
 212
 213         LOGI("stream_type[%d] callback[%p] user_data[%p]", stream_type, callback, user_data);
 214
 215         sound_stream_info_s *stream_h = malloc(sizeof(sound_stream_info_s));
 216         if (!stream_h) {
 217                 ret = SOUND_MANAGER_ERROR_INTERNAL;
 218                 goto LEAVE;
 219         }
 220
 221         memset(stream_h, 0, sizeof(sound_stream_info_s));
 222         ret = _convert_stream_type_for_internal(stream_type, &stream_h->stream_type);
 223         if (ret == SOUND_MANAGER_ERROR_NONE) {
 224                 _set_focus_availability(stream_h);
 225                 ret = _make_pa_connection_and_register_focus(stream_h, callback, user_data);
 226                 if (ret == SOUND_MANAGER_ERROR_NONE) {
 227                         *stream_info = (sound_stream_info_h)stream_h;
 228                         LOGI("stream_info[%p, type:%s] pa_index[%u] focus_id[%d]",
 229                                 stream_info, stream_h->stream_type, stream_h->pa_info.index, stream_h->focus_id);
 230                 }
 231         }
 232
 233 LEAVE:
 234         if (ret)
 235                 SM_SAFE_FREE(stream_h);
 236
 237         LOGI("ret[0x%x]", ret);
 238
 239         return ret;
 240 }
 241
 242 int sound_manager_set_stream_routing_option(sound_stream_info_h stream_info, const char *name, int value)
 243 {
 244         sound_stream_info_s *stream_h = (sound_stream_info_s*)stream_info;
 245
 246         SM_ARG_CHECK(stream_h);
 247         SM_ARG_CHECK(name);
 248
 249         LOGI("stream_info[%p] name[%s] value[%d]", stream_info, name, value);
 250
 251         return _set_route_option(stream_h->pa_info.index, name, value);
 252 }
 253
 254 int sound_manager_is_available_stream_information(sound_stream_info_h stream_info, native_api_e api_name, bool *is_available)
 255 {
 256         int i = 0;
 257         const char *name = NULL;
 258         sound_stream_info_s* stream_h = (sound_stream_info_s*)stream_info;
 259
 260         SM_ARG_CHECK(stream_h);
 261         SM_ARG_CHECK(is_available);
 262
 263         *is_available = false;
 264
 265         name = _convert_api_name(api_name);
 266         for (i = 0; i < AVAIL_FRAMEWORKS_MAX; i++) {
 267                 if (stream_h->stream_conf_info.avail_frameworks[i] && !strncmp(stream_h->stream_conf_info.avail_frameworks[i], name, strlen(name))) {
 268                         *is_available = true;
 269                         break;
 270                 }
 271         }
 272         LOGI("stream_type[%s] native api[%s] is_available[%d]", stream_h->stream_type, name, *is_available);
 273
 274         return SOUND_MANAGER_ERROR_NONE;
 275 }
 276
 277 int sound_manager_get_type_from_stream_information(sound_stream_info_h stream_info, char **type)
 278 {
 279         sound_stream_info_s* stream_h = (sound_stream_info_s*)stream_info;
 280
 281         SM_ARG_CHECK(stream_h);
 282         SM_ARG_CHECK(type);
 283
 284         *type = stream_h->stream_type;
 285         LOGI("stream_type[%s]", *type);
 286
 287         return SOUND_MANAGER_ERROR_NONE;
 288 }
 289 int sound_manager_get_index_from_stream_information(sound_stream_info_h stream_info, int *index)
 290 {
 291         sound_stream_info_s* stream_h = (sound_stream_info_s*)stream_info;
 292
 293         SM_ARG_CHECK(stream_h);
 294         SM_ARG_CHECK(index);
 295
 296         *index = stream_h->pa_info.index;
 297         LOGI("stream_index[%u]", stream_h->pa_info.index);
 298
 299         return SOUND_MANAGER_ERROR_NONE;
 300 }
 301
 302 int sound_manager_add_device_id_for_stream_routing(sound_stream_info_h stream_info, int device_id)
 303 {
 304         SM_ARG_CHECK(stream_info);
 305
 306         LOGI("stream_info[%p] device_id[%d]", stream_info, device_id);
 307
 308         return _add_device_id_for_stream_routing((sound_stream_info_s*)stream_info, device_id);
 309 }
 310
 311 int sound_manager_remove_device_id_for_stream_routing(sound_stream_info_h stream_info, int device_id)
 312 {
 313         SM_ARG_CHECK(stream_info);
 314
 315         LOGI("stream_info[%p] device_id[%d]", stream_info, device_id);
 316
 317         return _remove_device_id_for_stream_routing((sound_stream_info_s*)stream_info, device_id);
 318 }
 319
 320 int sound_manager_set_stream_preferred_device_id(sound_stream_info_h stream_info, sound_device_io_direction_e io_direction, int device_id)
 321 {
 322         SM_ARG_CHECK(stream_info);
 323
 324         LOGI("stream_info[%p] io_direction[%d] device_id[%d]", stream_info, io_direction, device_id);
 325
 326         return _set_preferred_device_id((sound_stream_info_s*)stream_info, io_direction, device_id);
 327 }
 328
 329 int sound_manager_get_device_state_by_id(int device_id, sound_device_state_e *state)
 330 {
 331         int ret = MM_ERROR_NONE;
 332         MMSoundDevice_t device = NULL;
 333
 334         SM_ARG_CHECK(state);
 335
 336         LOGI("device_id[%d]", device_id);
 337
 338         if ((ret = mm_sound_get_device_by_id(device_id, &device)) != MM_ERROR_NONE) {
 339                 LOGE("failed to mm_sound_get_device_by_id()");
 340                 goto LEAVE;
 341         }
 342
 343         ret = mm_sound_get_device_state(device, (mm_sound_device_state_e*)state);
 344
 345         LOGI("state[%d]", *state);
 346
 347         mm_sound_free_device(device);
 348 LEAVE:
 349         return _convert_sound_manager_error_code(__func__, ret);
 350 }
 351
 352 int sound_manager_is_device_running_by_id(int device_id, bool *is_running)
 353 {
 354         SM_ARG_CHECK(is_running);
 355
 356         LOGI("device_id[%d]", device_id);
 357
 358         return _is_device_running_by_id(device_id, is_running);
 359 }
 360
 361 int sound_manager_get_supported_sample_formats_by_id(int device_id, sound_sample_format_e **formats, unsigned int *num_of_elems)
 362 {
 363         SM_ARG_CHECK(formats);
 364         SM_ARG_CHECK(num_of_elems);
 365
 366         LOGI("device_id[%d]", device_id);
 367
 368         return _get_supported_sample_formats(device_id, formats, num_of_elems);
 369 }
 370
 371 int sound_manager_set_sample_format_by_id(int device_id, sound_sample_format_e format)
 372 {
 373         LOGI("device_id[%d] format[%d]", device_id, format);
 374
 375         return _set_sample_format(device_id, format);
 376 }
 377
 378 int sound_manager_get_sample_format_by_id(int device_id, sound_sample_format_e *format)
 379 {
 380         SM_ARG_CHECK(format);
 381
 382         LOGI("device_id[%d]", device_id);
 383
 384         return _get_sample_format(device_id, format);
 385 }
 386
 387 int sound_manager_get_supported_sample_rates_by_id(int device_id, sound_sample_rate_e **rates, unsigned int *num_of_elems)
 388 {
 389         SM_ARG_CHECK(rates);
 390         SM_ARG_CHECK(num_of_elems);
 391
 392         LOGI("device_id[%d]", device_id);
 393
 394         return _get_supported_sample_rates(device_id, rates, num_of_elems);
 395 }
 396
 397 int sound_manager_set_sample_rate_by_id(int device_id, sound_sample_rate_e rate)
 398 {
 399         LOGI("device_id[%d] rate[%d]", device_id, rate);
 400
 401         return _set_sample_rate(device_id, rate);
 402 }
 403
 404 int sound_manager_get_sample_rate_by_id(int device_id, sound_sample_rate_e *rate)
 405 {
 406         SM_ARG_CHECK(rate);
 407
 408         LOGI("device_id[%d]", device_id);
 409
 410         return _get_sample_rate(device_id, rate);
 411 }
 412
 413 int sound_manager_set_avoid_resampling_by_id(int device_id, bool enable)
 414 {
 415         LOGI("device_id[%d] enable[%d]", device_id, enable);
 416
 417         return _set_avoid_resampling(device_id, enable);
 418 }
 419
 420 int sound_manager_get_avoid_resampling_by_id(int device_id, bool *enabled)
 421 {
 422         SM_ARG_CHECK(enabled);
 423
 424         LOGI("device_id[%d]", device_id);
 425
 426         return _get_avoid_resampling(device_id, enabled);
 427 }
 428
 429 int sound_manager_set_media_stream_only_by_id(int device_id, bool enable)
 430 {
 431         LOGI("device_id[%d] enable[%d]", device_id, enable);
 432
 433         return _set_media_stream_only(device_id, enable);
 434 }
 435
 436 int sound_manager_get_media_stream_only_by_id(int device_id, bool *enabled)
 437 {
 438         SM_ARG_CHECK(enabled);
 439
 440         LOGI("device_id[%d]", device_id);
 441
 442         return _get_media_stream_only(device_id, enabled);
 443 }
 444
 445 int sound_manager_create_virtual_stream(sound_stream_info_h stream_info, virtual_sound_stream_h *virtual_stream)
 446 {
 447         int ret = SOUND_MANAGER_ERROR_NONE;
 448         virtual_sound_stream_info_s *vstream_h = NULL;
 449         sound_stream_info_s *stream_h = (sound_stream_info_s*)stream_info;
 450
 451         SM_ARG_CHECK(stream_h);
 452         SM_ARG_CHECK(virtual_stream);
 453
 454         LOGI("stream_info[%p, type:%s]", stream_info, stream_h->stream_type);
 455
 456         SM_ENTER_CRITICAL_SECTION_WITH_RETURN(&stream_h->vstream_mutex, SOUND_MANAGER_ERROR_INTERNAL);
 457
 458         if (stream_h->vstream) {
 459                 LOGE("virtual stream was already created. vstream(%p)", stream_h->vstream);
 460                 SM_LEAVE_CRITICAL_SECTION(&stream_h->vstream_mutex);
 461                 return SOUND_MANAGER_ERROR_INVALID_OPERATION;
 462         }
 463
 464         ret = _create_virtual_stream(stream_h, &vstream_h);
 465         if (ret == SOUND_MANAGER_ERROR_NONE) {
 466                 *virtual_stream = stream_h->vstream = (virtual_sound_stream_h)vstream_h;
 467                 LOGI("virtual_stream[%p]", *virtual_stream);
 468         }
 469
 470         SM_LEAVE_CRITICAL_SECTION(&stream_h->vstream_mutex);
 471
 472         LOGI("ret[0x%x]", ret);
 473
 474         return ret;
 475 }
 476
 477 int sound_manager_destroy_virtual_stream(virtual_sound_stream_h virtual_stream)
 478 {
 479         int ret = SOUND_MANAGER_ERROR_NONE;
 480         pthread_mutex_t *vstream_mutex;
 481         virtual_sound_stream_info_s *vstream_h = (virtual_sound_stream_info_s*)virtual_stream;
 482
 483         SM_ARG_CHECK(vstream_h);
 484         SM_ARG_CHECK(vstream_h->stream_info);
 485
 486         LOGI("virtual_stream[%p] stream_type[%s]", virtual_stream, vstream_h->stream_info->stream_type);
 487
 488         vstream_mutex = &vstream_h->stream_info->vstream_mutex;
 489
 490         SM_ENTER_CRITICAL_SECTION_WITH_RETURN(vstream_mutex, SOUND_MANAGER_ERROR_INTERNAL);
 491
 492         ret = _destroy_virtual_stream(vstream_h);
 493
 494         SM_LEAVE_CRITICAL_SECTION(vstream_mutex);
 495
 496         LOGI("ret[0x%x]", ret);
 497
 498         return ret;
 499 }
 500
 501 int sound_manager_start_virtual_stream(virtual_sound_stream_h virtual_stream)
 502 {
 503         int ret = SOUND_MANAGER_ERROR_NONE;
 504         pthread_mutex_t *vstream_mutex;
 505         virtual_sound_stream_info_s *vstream_h = (virtual_sound_stream_info_s*)virtual_stream;
 506
 507         SM_ARG_CHECK(vstream_h);
 508         SM_ARG_CHECK(vstream_h->stream_info);
 509
 510         LOGI("virtual_stream[%p] stream_type[%s]", virtual_stream, vstream_h->stream_info->stream_type);
 511
 512         vstream_mutex = &vstream_h->stream_info->vstream_mutex;
 513
 514         SM_ENTER_CRITICAL_SECTION_WITH_RETURN(vstream_mutex, SOUND_MANAGER_ERROR_INTERNAL);
 515
 516         ret = _start_virtual_stream(vstream_h);
 517
 518         SM_LEAVE_CRITICAL_SECTION(vstream_mutex);
 519
 520         LOGI("ret[0x%x]", ret);
 521
 522         return ret;
 523 }
 524
 525 int sound_manager_stop_virtual_stream(virtual_sound_stream_h virtual_stream)
 526 {
 527         int ret = SOUND_MANAGER_ERROR_NONE;
 528         pthread_mutex_t *vstream_mutex;
 529         virtual_sound_stream_info_s *vstream_h = (virtual_sound_stream_info_s*)virtual_stream;
 530
 531         SM_ARG_CHECK(vstream_h);
 532         SM_ARG_CHECK(vstream_h->stream_info);
 533
 534         LOGI("virtual_stream[%p] stream_type[%s]", virtual_stream, vstream_h->stream_info->stream_type);
 535
 536         vstream_mutex = &vstream_h->stream_info->vstream_mutex;
 537
 538         SM_ENTER_CRITICAL_SECTION_WITH_RETURN(vstream_mutex, SOUND_MANAGER_ERROR_INTERNAL);
 539
 540         ret = _stop_virtual_stream(vstream_h);
 541
 542         SM_LEAVE_CRITICAL_SECTION(vstream_mutex);
 543
 544         LOGI("ret[0x%x]", ret);
 545
 546         return ret;
 547 }
 548
 549 int sound_manager_set_virtual_stream_volume(virtual_sound_stream_h virtual_stream, double ratio)
 550 {
 551         int ret = SOUND_MANAGER_ERROR_NONE;
 552         pthread_mutex_t *vstream_mutex;
 553         virtual_sound_stream_info_s *vstream_h = (virtual_sound_stream_info_s*)virtual_stream;
 554
 555         SM_ARG_CHECK(vstream_h);
 556         SM_ARG_CHECK(vstream_h->stream_info);
 557
 558         LOGI("virtual_stream[%p] ratio[%lf]", virtual_stream, ratio);
 559
 560         vstream_mutex = &vstream_h->stream_info->vstream_mutex;
 561
 562         SM_ENTER_CRITICAL_SECTION_WITH_RETURN(vstream_mutex, SOUND_MANAGER_ERROR_INTERNAL);
 563
 564         ret = _set_virtual_stream_volume(vstream_h, ratio);
 565
 566         SM_LEAVE_CRITICAL_SECTION(vstream_mutex);
 567
 568         LOGI("ret[0x%x]", ret);
 569
 570         return ret;
 571 }
 572
 573 static int _convert_filter(sound_filter_e filter, char **filter_str, char **filter_params_str)
 574 {
 575         SM_ARG_CHECK(filter_str);
 576         SM_ARG_CHECK(filter_params_str);
 577
 578         switch (filter) {
 579         case SOUND_FILTER_LOW_PASS:
 580                 *filter_str = "ladspa-sink";
 581                 *filter_params_str = "plugin=filter label=lpf control=22050";
 582                 break;
 583         case SOUND_FILTER_HIGH_PASS:
 584                 *filter_str = "ladspa-sink";
 585                 *filter_params_str = "plugin=filter label=hpf control=2";
 586                 break;
 587         case SOUND_FILTER_DELAY:
 588                 *filter_str = "ladspa-sink";
 589                 *filter_params_str = "plugin=delay label=delay_5s control=0,0";
 590                 break;
 591         //LCOV_EXCL_START
 592         case SOUND_FILTER_SOUNDALIVE:
 593                 *filter_str = "ladspa-sink";
 594                 *filter_params_str = "plugin=audiofilters-sec-ladspa label=audiofiltersec_stereo control=1,0";
 595                 break;
 596         default:
 597                 LOGE("could not find filter[%d]", filter);
 598                 return SOUND_MANAGER_ERROR_INTERNAL;
 599         //LCOV_EXCL_STOP
 600         }
 601         LOGI("filter[%s] param[%s]", *filter_str, *filter_params_str);
 602
 603         return SOUND_MANAGER_ERROR_NONE;
 604 }
 605
 606 static int _convert_filter_preset(sound_filter_preset_e preset, char **control)
 607 {
 608         SM_ARG_CHECK(control);
 609
 610         switch (preset) {
 611         case SOUND_FILTER_PRESET_LOW_PASS_NONE:
 612                 *control = "22050";
 613                 break;
 614         case SOUND_FILTER_PRESET_LOW_PASS_UNDER_240HZ:
 615                 *control = "240";
 616                 break;
 617         case SOUND_FILTER_PRESET_LOW_PASS_UNDER_480HZ:
 618                 *control = "480";
 619                 break;
 620         case SOUND_FILTER_PRESET_HIGH_PASS_NONE:
 621                 *control = "2";
 622                 break;
 623         case SOUND_FILTER_PRESET_HIGH_PASS_OVER_240HZ:
 624                 *control = "240";
 625                 break;
 626         case SOUND_FILTER_PRESET_HIGH_PASS_OVER_480HZ:
 627                 *control = "480";
 628                 break;
 629         case SOUND_FILTER_PRESET_DELAY_NONE:
 630                 *control = "0,0";
 631                 break;
 632         case SOUND_FILTER_PRESET_DELAY_1SEC:
 633                 *control = "1,0.5";
 634                 break;
 635         case SOUND_FILTER_PRESET_DELAY_2SEC:
 636                 *control = "2,0.5";
 637                 break;
 638         //LCOV_EXCL_START
 639         case SOUND_FILTER_PRESET_SOUNDALIVE_NORMAL:
 640                 *control = "1,0";
 641                 break;
 642         case SOUND_FILTER_PRESET_SOUNDALIVE_TUBE:
 643                 *control = "1,1";
 644                 break;
 645         case SOUND_FILTER_PRESET_SOUNDALIVE_VIRT71:
 646                 *control = "1,2";
 647                 break;
 648         case SOUND_FILTER_PRESET_SOUNDALIVE_STUDIO:
 649                 *control = "1,3";
 650                 break;
 651         case SOUND_FILTER_PRESET_SOUNDALIVE_CLUB:
 652                 *control = "1,4";
 653                 break;
 654         case SOUND_FILTER_PRESET_SOUNDALIVE_CONCERT_HALL:
 655                 *control = "1,5";
 656                 break;
 657         //LCOV_EXCL_STOP
 658         default:
 659                 LOGE("could not find the preset[%d]", preset);
 660                 return SOUND_MANAGER_ERROR_INTERNAL;
 661         }
 662         LOGI("preset[%s]", *control);
 663
 664         return SOUND_MANAGER_ERROR_NONE;
 665 }
 666
 667 static int _check_valid_filter_preset(sound_filter_e filter, sound_filter_preset_e preset)
 668 {
 669         switch (filter) {
 670         case SOUND_FILTER_LOW_PASS:
 671                 if (preset > SOUND_FILTER_PRESET_LOW_PASS_UNDER_480HZ) {
 672                         LOGE("invalid preset(%d) for low pass filter", preset);
 673                         goto ERROR_INVALID_ARGS;
 674                 }
 675                 break;
 676         case SOUND_FILTER_HIGH_PASS:
 677                 if (preset < SOUND_FILTER_PRESET_HIGH_PASS_NONE || preset > SOUND_FILTER_PRESET_HIGH_PASS_OVER_480HZ) {
 678                         LOGE("invalid preset(%d) for high pass filter", preset);
 679                         goto ERROR_INVALID_ARGS;
 680                 }
 681                 break;
 682         case SOUND_FILTER_DELAY:
 683                 if (preset < SOUND_FILTER_PRESET_DELAY_NONE || preset > SOUND_FILTER_PRESET_DELAY_2SEC) {
 684                         LOGE("invalid preset(%d) for delay filter", preset);
 685                         goto ERROR_INVALID_ARGS;
 686                 }
 687                 break;
 688         //LCOV_EXCL_START
 689         case SOUND_FILTER_SOUNDALIVE:
 690                 if (preset < SOUND_FILTER_PRESET_SOUNDALIVE_NORMAL || preset > SOUND_FILTER_PRESET_SOUNDALIVE_CONCERT_HALL) {
 691                         LOGE("invalid preset(%d) for soundAlive filter", preset);
 692                         goto ERROR_INVALID_ARGS;
 693                 }
 694                 break;
 695         //LCOV_EXCL_STOP
 696         default:
 697                 LOGE("invalid filter(%d)", filter);
 698                 return SOUND_MANAGER_ERROR_INVALID_PARAMETER;
 699         }
 700
 701         return SOUND_MANAGER_ERROR_NONE;
 702
 703 ERROR_INVALID_ARGS:
 704         LOGE("invalid preset(%d) for filter(%d)", preset, filter);
 705         return SOUND_MANAGER_ERROR_INVALID_PARAMETER;
 706 }
 707
 708 int sound_manager_set_filter(sound_stream_type_e stream_type, sound_filter_e filter)
 709 {
 710         int ret = SOUND_MANAGER_ERROR_NONE;
 711         char *stream_type_str = NULL;
 712         char *filter_str = NULL;
 713         char *filter_params_str = NULL;
 714
 715         LOGI("stream_type[%d] filter[%d]", stream_type, filter);
 716
 717         if (stream_type != SOUND_STREAM_TYPE_MEDIA) {
 718                 LOGE("Not supported stream type(%d)", stream_type);
 719                 return SOUND_MANAGER_ERROR_NOT_SUPPORTED;
 720         }
 721
 722         if ((ret = _convert_stream_type(stream_type, &stream_type_str)) != SOUND_MANAGER_ERROR_NONE)
 723                 return ret;
 724         if ((ret = _convert_filter(filter, &filter_str, &filter_params_str)) != SOUND_MANAGER_ERROR_NONE)
 725                 return ret;
 726
 727         return _convert_sound_manager_error_code(__func__, mm_sound_set_filter(stream_type_str, filter_str, filter_params_str, stream_type_str));
 728 }
 729
 730 int sound_manager_unset_filter(sound_stream_type_e stream_type)
 731 {
 732         int ret = SOUND_MANAGER_ERROR_NONE;
 733         char *stream_type_str = NULL;
 734
 735         LOGI("stream_type[%d]", stream_type);
 736
 737         if ((ret = _convert_stream_type(stream_type, &stream_type_str)) != SOUND_MANAGER_ERROR_NONE)
 738                 return ret;
 739
 740         return _convert_sound_manager_error_code(__func__, mm_sound_unset_filter(stream_type_str));
 741 }
 742
 743 int sound_manager_set_filter_preset(sound_stream_type_e stream_type, sound_filter_e filter, sound_filter_preset_e preset)
 744 {
 745         int ret = SOUND_MANAGER_ERROR_NONE;
 746         char *stream_type_str = NULL;
 747         char *filter_str = NULL;
 748         char *filter_params_str = NULL;
 749         char *control_str = NULL;
 750
 751         if (stream_type != SOUND_STREAM_TYPE_MEDIA) {
 752                 LOGE("Not supported stream type(%d)", stream_type);
 753                 return SOUND_MANAGER_ERROR_NOT_SUPPORTED;
 754         }
 755
 756         LOGI("stream_type[%d] filter[%d] preset[%d]", stream_type, filter, preset);
 757
 758         if ((ret = _check_valid_filter_preset(filter, preset)) != SOUND_MANAGER_ERROR_NONE)
 759                 return ret;
 760         if ((ret = _convert_stream_type(stream_type, &stream_type_str)) != SOUND_MANAGER_ERROR_NONE)
 761                 return ret;
 762         if ((ret = _convert_filter(filter, &filter_str, &filter_params_str)) != SOUND_MANAGER_ERROR_NONE)
 763                 return ret;
 764         if ((ret = _convert_filter_preset(preset, &control_str)) != SOUND_MANAGER_ERROR_NONE)
 765                 return ret;
 766
 767         return _convert_sound_manager_error_code(__func__, mm_sound_control_filter(stream_type_str, filter_str, control_str));
 768 }
 769
 770 int sound_manager_get_device_vendor_id(sound_device_h device, int *vendor_id)
 771 {
 772         int ret = MM_ERROR_NONE;
 773         mm_sound_device_type_e type;
 774
 775         SM_ARG_CHECK(device);
 776         SM_ARG_CHECK(vendor_id);
 777
 778         LOGI("device[%p]", device);
 779
 780         if ((ret = mm_sound_get_device_type(device, &type)) != MM_ERROR_NONE)
 781                 return _convert_sound_manager_error_code(__func__, ret);
 782
 783         if (type != MM_SOUND_DEVICE_TYPE_USB_AUDIO) {
 784                 LOGE("device type is not USB audio device, device_type[%d]", type);
 785                 return SOUND_MANAGER_ERROR_NOT_SUPPORTED;
 786         }
 787
 788         ret = mm_sound_get_device_vendor_id(device, vendor_id);
 789
 790         LOGI("vendor_id[%d]", *vendor_id);
 791
 792         return _convert_sound_manager_error_code(__func__, ret);
 793 }
 794
 795 int sound_manager_get_device_product_id(sound_device_h device, int *product_id)
 796 {
 797         int ret = MM_ERROR_NONE;
 798         mm_sound_device_type_e type;
 799
 800         SM_ARG_CHECK(device);
 801         SM_ARG_CHECK(product_id);
 802
 803         LOGI("device[%p]", device);
 804
 805         if ((ret = mm_sound_get_device_type(device, &type)) != MM_ERROR_NONE)
 806                 return _convert_sound_manager_error_code(__func__, ret);
 807
 808         if (type != MM_SOUND_DEVICE_TYPE_USB_AUDIO) {
 809                 LOGE("device type is not USB audio device, device_type[%d]", type);
 810                 return SOUND_MANAGER_ERROR_NOT_SUPPORTED;
 811         }
 812
 813         ret = mm_sound_get_device_product_id(device, product_id);
 814
 815         LOGI("product_id[%d]", *product_id);
 816
 817         return _convert_sound_manager_error_code(__func__, ret);
 818 }
 819
 820 int sound_manager_is_stream_on_device_by_id(sound_stream_info_h stream_info, int device_id, bool *is_on)
 821 {
 822         int ret = MM_ERROR_NONE;
 823         sound_stream_info_s *stream_h = (sound_stream_info_s*)stream_info;
 824
 825         SM_ARG_CHECK(stream_h);
 826         SM_ARG_CHECK(is_on);
 827
 828         LOGI("stream_info[%p, type:%s] device_id[%d]", stream_info, stream_h->stream_type, device_id);
 829
 830         ret = mm_sound_is_stream_on_device_by_id(stream_h->pa_info.index, device_id, is_on);
 831
 832         LOGI("is_on[%d]", *is_on);
 833
 834         return _convert_sound_manager_error_code(__func__, ret);
 835 }
 836
 837 int sound_manager_set_acm_master_mode(bool enable)
 838 {
 839         LOGI("enable[%d]", enable);
 840
 841         return _set_acm_master_mode(enable);
 842 }
 843
 844 int sound_manager_get_latest_stream_pid(int stream_type, unsigned int *pid)
 845 {
 846         SM_ARG_CHECK(stream_type >= 0);
 847         SM_ARG_CHECK(pid);
 848
 849         LOGI("stream_type[0x%x]", stream_type);
 850
 851         return _get_latest_stream_pid(stream_type, pid);
 852 }
 853
 854 int sound_manager_set_stream_preemptive_device(sound_stream_type_e stream_type, sound_device_io_direction_e io_direction, int device_id)
 855 {
 856         LOGI("stream_type[%d] io_direction[%d] device_id[%d]", stream_type, io_direction, device_id);
 857
 858         return _set_preemptive_device(stream_type, io_direction, device_id);
 859 }
 860
 861 int sound_manager_get_stream_preemptive_device(sound_stream_type_e stream_type, int *in_device_id, int *out_device_id)
 862 {
 863         SM_ARG_CHECK(in_device_id || out_device_id);
 864
 865         LOGI("stream_type[%d]", stream_type);
 866
 867         return _get_preemptive_device(stream_type, in_device_id, out_device_id);
 868 }
 869
 870 int sound_manager_start_discover_remote_device(void)
 871 {
 872         return _discover_remote_device(true);
 873 }
 874
 875 int sound_manager_stop_discover_remote_device(void)
 876 {
 877         return _discover_remote_device(false);
 878 }
 879
 880 int sound_manager_publish_local_device(sound_manager_remote_client_connected_cb callback, void *user_data)
 881 {
 882         SM_ARG_CHECK(callback);
 883
 884         return _publish_local_device(callback, user_data);
 885 }
 886
 887 int sound_manager_unpublish_local_device(void)
 888 {
 889         return _unpublish_local_device();
 890 }
 891
 892 int sound_manager_set_remote_permission(int id, bool allowed)
 893 {
 894         return _set_remote_permission(id, allowed);
 895 }
 896
 897 int sound_manager_set_echo_cancel_reference_device(sound_stream_info_h stream_info, sound_device_h device)
 898 {
 899         return _set_echo_cancel_reference_device((sound_stream_info_s*)stream_info, device);
 900 }
 901
 902 int sound_manager_get_echo_cancel_reference_device(sound_stream_info_h stream_info, int *device_id)
 903 {
 904         return _get_echo_cancel_reference_device((sound_stream_info_s*)stream_info, device_id);
 905 }
 906
 907 int sound_manager_set_rpi_playback_route(sound_rpi_playback_route_type type)
 908 {
 909         return _set_rpi_playback_route(type);
 910 }
 911
 912 int sound_manager_get_rpi_playback_route(sound_rpi_playback_route_type *type)
 913 {
 914         return _get_rpi_playback_route(type);
 915 }
 916
 917 int sound_manager_set_host_volume(sound_type_e type, int volume)
 918 {
 919         int ret = SOUND_MANAGER_ERROR_NONE;
 920         const char *volume_type = NULL;
 921
 922         SM_ARG_CHECK(type < SOUND_TYPE_NUM);
 923
 924         LOGI("type[%d] volume[%d]", type, volume);
 925
 926         ret = _convert_sound_type(type, &volume_type);
 927         if (ret != SOUND_MANAGER_ERROR_NONE)
 928                 return ret;
 929
 930         ret = _set_host_volume_level(DIRECTION_OUT_STR, volume_type, (unsigned int)volume);
 931
 932         return _convert_sound_manager_error_code(__func__, ret);
 933 }
 934
 935 int sound_manager_get_host_volume(sound_type_e type, int *volume)
 936 {
 937         int ret = SOUND_MANAGER_ERROR_NONE;
 938         const char *volume_type = NULL;
 939         unsigned int volume_level = 0;
 940
 941         SM_ARG_CHECK(volume);
 942
 943         LOGI("type[%d]", type);
 944
 945         ret = _convert_sound_type(type, &volume_type);
 946         if (ret != SOUND_MANAGER_ERROR_NONE)
 947                 return ret;
 948
 949         ret = _get_host_volume_level(DIRECTION_OUT_STR, volume_type, &volume_level);
 950         if (ret == SOUND_MANAGER_ERROR_NONE) {
 951                 *volume = (int)volume_level;
 952                 LOGI("host volume[%d]", *volume);
 953         }
 954
 955         return _convert_sound_manager_error_code(__func__, ret);
 956 }