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_is_device_running_by_id(int device_id, bool *is_running)
 330 {
 331         SM_ARG_CHECK(is_running);
 332
 333         LOGI("device_id[%d]", device_id);
 334
 335         return _is_device_running_by_id(device_id, is_running);
 336 }
 337
 338 int sound_manager_get_supported_sample_formats_by_id(int device_id, sound_sample_format_e **formats, unsigned int *num_of_elems)
 339 {
 340         SM_ARG_CHECK(formats);
 341         SM_ARG_CHECK(num_of_elems);
 342
 343         LOGI("device_id[%d]", device_id);
 344
 345         return _get_supported_sample_formats(device_id, formats, num_of_elems);
 346 }
 347
 348 int sound_manager_set_sample_format_by_id(int device_id, sound_sample_format_e format)
 349 {
 350         LOGI("device_id[%d] format[%d]", device_id, format);
 351
 352         return _set_sample_format(device_id, format);
 353 }
 354
 355 int sound_manager_get_sample_format_by_id(int device_id, sound_sample_format_e *format)
 356 {
 357         SM_ARG_CHECK(format);
 358
 359         LOGI("device_id[%d]", device_id);
 360
 361         return _get_sample_format(device_id, format);
 362 }
 363
 364 int sound_manager_get_supported_sample_rates_by_id(int device_id, sound_sample_rate_e **rates, unsigned int *num_of_elems)
 365 {
 366         SM_ARG_CHECK(rates);
 367         SM_ARG_CHECK(num_of_elems);
 368
 369         LOGI("device_id[%d]", device_id);
 370
 371         return _get_supported_sample_rates(device_id, rates, num_of_elems);
 372 }
 373
 374 int sound_manager_set_sample_rate_by_id(int device_id, sound_sample_rate_e rate)
 375 {
 376         LOGI("device_id[%d] rate[%d]", device_id, rate);
 377
 378         return _set_sample_rate(device_id, rate);
 379 }
 380
 381 int sound_manager_get_sample_rate_by_id(int device_id, sound_sample_rate_e *rate)
 382 {
 383         SM_ARG_CHECK(rate);
 384
 385         LOGI("device_id[%d]", device_id);
 386
 387         return _get_sample_rate(device_id, rate);
 388 }
 389
 390 int sound_manager_set_avoid_resampling_by_id(int device_id, bool enable)
 391 {
 392         LOGI("device_id[%d] enable[%d]", device_id, enable);
 393
 394         return _set_avoid_resampling(device_id, enable);
 395 }
 396
 397 int sound_manager_get_avoid_resampling_by_id(int device_id, bool *enabled)
 398 {
 399         SM_ARG_CHECK(enabled);
 400
 401         LOGI("device_id[%d]", device_id);
 402
 403         return _get_avoid_resampling(device_id, enabled);
 404 }
 405
 406 int sound_manager_set_media_stream_only_by_id(int device_id, bool enable)
 407 {
 408         LOGI("device_id[%d] enable[%d]", device_id, enable);
 409
 410         return _set_media_stream_only(device_id, enable);
 411 }
 412
 413 int sound_manager_get_media_stream_only_by_id(int device_id, bool *enabled)
 414 {
 415         SM_ARG_CHECK(enabled);
 416
 417         LOGI("device_id[%d]", device_id);
 418
 419         return _get_media_stream_only(device_id, enabled);
 420 }
 421
 422 int sound_manager_create_virtual_stream(sound_stream_info_h stream_info, virtual_sound_stream_h *virtual_stream)
 423 {
 424         int ret = SOUND_MANAGER_ERROR_NONE;
 425         virtual_sound_stream_info_s *vstream_h = NULL;
 426         sound_stream_info_s *stream_h = (sound_stream_info_s*)stream_info;
 427
 428         SM_ARG_CHECK(stream_h);
 429         SM_ARG_CHECK(virtual_stream);
 430
 431         LOGI("stream_info[%p, type:%s]", stream_info, stream_h->stream_type);
 432
 433         SM_ENTER_CRITICAL_SECTION_WITH_RETURN(&stream_h->vstream_mutex, SOUND_MANAGER_ERROR_INTERNAL);
 434
 435         if (stream_h->vstream) {
 436                 LOGE("virtual stream was already created. vstream(%p)", stream_h->vstream);
 437                 SM_LEAVE_CRITICAL_SECTION(&stream_h->vstream_mutex);
 438                 return SOUND_MANAGER_ERROR_INVALID_OPERATION;
 439         }
 440
 441         ret = _create_virtual_stream(stream_h, &vstream_h);
 442         if (ret == SOUND_MANAGER_ERROR_NONE) {
 443                 *virtual_stream = stream_h->vstream = (virtual_sound_stream_h)vstream_h;
 444                 LOGI("virtual_stream[%p]", *virtual_stream);
 445         }
 446
 447         SM_LEAVE_CRITICAL_SECTION(&stream_h->vstream_mutex);
 448
 449         LOGI("ret[0x%x]", ret);
 450
 451         return ret;
 452 }
 453
 454 int sound_manager_destroy_virtual_stream(virtual_sound_stream_h virtual_stream)
 455 {
 456         int ret = SOUND_MANAGER_ERROR_NONE;
 457         pthread_mutex_t *vstream_mutex;
 458         virtual_sound_stream_info_s *vstream_h = (virtual_sound_stream_info_s*)virtual_stream;
 459
 460         SM_ARG_CHECK(vstream_h);
 461         SM_ARG_CHECK(vstream_h->stream_info);
 462
 463         LOGI("virtual_stream[%p] stream_type[%s]", virtual_stream, vstream_h->stream_info->stream_type);
 464
 465         vstream_mutex = &vstream_h->stream_info->vstream_mutex;
 466
 467         SM_ENTER_CRITICAL_SECTION_WITH_RETURN(vstream_mutex, SOUND_MANAGER_ERROR_INTERNAL);
 468
 469         ret = _destroy_virtual_stream(vstream_h);
 470
 471         SM_LEAVE_CRITICAL_SECTION(vstream_mutex);
 472
 473         LOGI("ret[0x%x]", ret);
 474
 475         return ret;
 476 }
 477
 478 int sound_manager_start_virtual_stream(virtual_sound_stream_h virtual_stream)
 479 {
 480         int ret = SOUND_MANAGER_ERROR_NONE;
 481         pthread_mutex_t *vstream_mutex;
 482         virtual_sound_stream_info_s *vstream_h = (virtual_sound_stream_info_s*)virtual_stream;
 483
 484         SM_ARG_CHECK(vstream_h);
 485         SM_ARG_CHECK(vstream_h->stream_info);
 486
 487         LOGI("virtual_stream[%p] stream_type[%s]", virtual_stream, vstream_h->stream_info->stream_type);
 488
 489         vstream_mutex = &vstream_h->stream_info->vstream_mutex;
 490
 491         SM_ENTER_CRITICAL_SECTION_WITH_RETURN(vstream_mutex, SOUND_MANAGER_ERROR_INTERNAL);
 492
 493         ret = _start_virtual_stream(vstream_h);
 494
 495         SM_LEAVE_CRITICAL_SECTION(vstream_mutex);
 496
 497         LOGI("ret[0x%x]", ret);
 498
 499         return ret;
 500 }
 501
 502 int sound_manager_stop_virtual_stream(virtual_sound_stream_h virtual_stream)
 503 {
 504         int ret = SOUND_MANAGER_ERROR_NONE;
 505         pthread_mutex_t *vstream_mutex;
 506         virtual_sound_stream_info_s *vstream_h = (virtual_sound_stream_info_s*)virtual_stream;
 507
 508         SM_ARG_CHECK(vstream_h);
 509         SM_ARG_CHECK(vstream_h->stream_info);
 510
 511         LOGI("virtual_stream[%p] stream_type[%s]", virtual_stream, vstream_h->stream_info->stream_type);
 512
 513         vstream_mutex = &vstream_h->stream_info->vstream_mutex;
 514
 515         SM_ENTER_CRITICAL_SECTION_WITH_RETURN(vstream_mutex, SOUND_MANAGER_ERROR_INTERNAL);
 516
 517         ret = _stop_virtual_stream(vstream_h);
 518
 519         SM_LEAVE_CRITICAL_SECTION(vstream_mutex);
 520
 521         LOGI("ret[0x%x]", ret);
 522
 523         return ret;
 524 }
 525
 526 int sound_manager_set_virtual_stream_volume(virtual_sound_stream_h virtual_stream, double ratio)
 527 {
 528         int ret = SOUND_MANAGER_ERROR_NONE;
 529         pthread_mutex_t *vstream_mutex;
 530         virtual_sound_stream_info_s *vstream_h = (virtual_sound_stream_info_s*)virtual_stream;
 531
 532         SM_ARG_CHECK(vstream_h);
 533         SM_ARG_CHECK(vstream_h->stream_info);
 534
 535         LOGI("virtual_stream[%p] ratio[%lf]", virtual_stream, ratio);
 536
 537         vstream_mutex = &vstream_h->stream_info->vstream_mutex;
 538
 539         SM_ENTER_CRITICAL_SECTION_WITH_RETURN(vstream_mutex, SOUND_MANAGER_ERROR_INTERNAL);
 540
 541         ret = _set_virtual_stream_volume(vstream_h, ratio);
 542
 543         SM_LEAVE_CRITICAL_SECTION(vstream_mutex);
 544
 545         LOGI("ret[0x%x]", ret);
 546
 547         return ret;
 548 }
 549
 550 static int _convert_filter(sound_filter_e filter, char **filter_str, char **filter_params_str)
 551 {
 552         SM_ARG_CHECK(filter_str);
 553         SM_ARG_CHECK(filter_params_str);
 554
 555         switch (filter) {
 556         case SOUND_FILTER_LOW_PASS:
 557                 *filter_str = "ladspa-sink";
 558                 *filter_params_str = "plugin=filter label=lpf control=22050";
 559                 break;
 560         case SOUND_FILTER_HIGH_PASS:
 561                 *filter_str = "ladspa-sink";
 562                 *filter_params_str = "plugin=filter label=hpf control=2";
 563                 break;
 564         case SOUND_FILTER_DELAY:
 565                 *filter_str = "ladspa-sink";
 566                 *filter_params_str = "plugin=delay label=delay_5s control=0,0";
 567                 break;
 568         //LCOV_EXCL_START
 569         case SOUND_FILTER_SOUNDALIVE:
 570                 *filter_str = "ladspa-sink";
 571                 *filter_params_str = "plugin=audiofilters-sec-ladspa label=audiofiltersec_stereo control=1,0";
 572                 break;
 573         default:
 574                 LOGE("could not find filter[%d]", filter);
 575                 return SOUND_MANAGER_ERROR_INTERNAL;
 576         //LCOV_EXCL_STOP
 577         }
 578         LOGI("filter[%s] param[%s]", *filter_str, *filter_params_str);
 579
 580         return SOUND_MANAGER_ERROR_NONE;
 581 }
 582
 583 static int _convert_filter_preset(sound_filter_preset_e preset, char **control)
 584 {
 585         SM_ARG_CHECK(control);
 586
 587         switch (preset) {
 588         case SOUND_FILTER_PRESET_LOW_PASS_NONE:
 589                 *control = "22050";
 590                 break;
 591         case SOUND_FILTER_PRESET_LOW_PASS_UNDER_240HZ:
 592                 *control = "240";
 593                 break;
 594         case SOUND_FILTER_PRESET_LOW_PASS_UNDER_480HZ:
 595                 *control = "480";
 596                 break;
 597         case SOUND_FILTER_PRESET_HIGH_PASS_NONE:
 598                 *control = "2";
 599                 break;
 600         case SOUND_FILTER_PRESET_HIGH_PASS_OVER_240HZ:
 601                 *control = "240";
 602                 break;
 603         case SOUND_FILTER_PRESET_HIGH_PASS_OVER_480HZ:
 604                 *control = "480";
 605                 break;
 606         case SOUND_FILTER_PRESET_DELAY_NONE:
 607                 *control = "0,0";
 608                 break;
 609         case SOUND_FILTER_PRESET_DELAY_1SEC:
 610                 *control = "1,0.5";
 611                 break;
 612         case SOUND_FILTER_PRESET_DELAY_2SEC:
 613                 *control = "2,0.5";
 614                 break;
 615         //LCOV_EXCL_START
 616         case SOUND_FILTER_PRESET_SOUNDALIVE_NORMAL:
 617                 *control = "1,0";
 618                 break;
 619         case SOUND_FILTER_PRESET_SOUNDALIVE_TUBE:
 620                 *control = "1,1";
 621                 break;
 622         case SOUND_FILTER_PRESET_SOUNDALIVE_VIRT71:
 623                 *control = "1,2";
 624                 break;
 625         case SOUND_FILTER_PRESET_SOUNDALIVE_STUDIO:
 626                 *control = "1,3";
 627                 break;
 628         case SOUND_FILTER_PRESET_SOUNDALIVE_CLUB:
 629                 *control = "1,4";
 630                 break;
 631         case SOUND_FILTER_PRESET_SOUNDALIVE_CONCERT_HALL:
 632                 *control = "1,5";
 633                 break;
 634         //LCOV_EXCL_STOP
 635         default:
 636                 LOGE("could not find the preset[%d]", preset);
 637                 return SOUND_MANAGER_ERROR_INTERNAL;
 638         }
 639         LOGI("preset[%s]", *control);
 640
 641         return SOUND_MANAGER_ERROR_NONE;
 642 }
 643
 644 static int _check_valid_filter_preset(sound_filter_e filter, sound_filter_preset_e preset)
 645 {
 646         switch (filter) {
 647         case SOUND_FILTER_LOW_PASS:
 648                 if (preset > SOUND_FILTER_PRESET_LOW_PASS_UNDER_480HZ) {
 649                         LOGE("invalid preset(%d) for low pass filter", preset);
 650                         goto ERROR_INVALID_ARGS;
 651                 }
 652                 break;
 653         case SOUND_FILTER_HIGH_PASS:
 654                 if (preset < SOUND_FILTER_PRESET_HIGH_PASS_NONE || preset > SOUND_FILTER_PRESET_HIGH_PASS_OVER_480HZ) {
 655                         LOGE("invalid preset(%d) for high pass filter", preset);
 656                         goto ERROR_INVALID_ARGS;
 657                 }
 658                 break;
 659         case SOUND_FILTER_DELAY:
 660                 if (preset < SOUND_FILTER_PRESET_DELAY_NONE || preset > SOUND_FILTER_PRESET_DELAY_2SEC) {
 661                         LOGE("invalid preset(%d) for delay filter", preset);
 662                         goto ERROR_INVALID_ARGS;
 663                 }
 664                 break;
 665         //LCOV_EXCL_START
 666         case SOUND_FILTER_SOUNDALIVE:
 667                 if (preset < SOUND_FILTER_PRESET_SOUNDALIVE_NORMAL || preset > SOUND_FILTER_PRESET_SOUNDALIVE_CONCERT_HALL) {
 668                         LOGE("invalid preset(%d) for soundAlive filter", preset);
 669                         goto ERROR_INVALID_ARGS;
 670                 }
 671                 break;
 672         //LCOV_EXCL_STOP
 673         default:
 674                 LOGE("invalid filter(%d)", filter);
 675                 return SOUND_MANAGER_ERROR_INVALID_PARAMETER;
 676         }
 677
 678         return SOUND_MANAGER_ERROR_NONE;
 679
 680 ERROR_INVALID_ARGS:
 681         LOGE("invalid preset(%d) for filter(%d)", preset, filter);
 682         return SOUND_MANAGER_ERROR_INVALID_PARAMETER;
 683 }
 684
 685 int sound_manager_set_filter(sound_stream_type_e stream_type, sound_filter_e filter)
 686 {
 687         int ret = SOUND_MANAGER_ERROR_NONE;
 688         char *stream_type_str = NULL;
 689         char *filter_str = NULL;
 690         char *filter_params_str = NULL;
 691
 692         LOGI("stream_type[%d] filter[%d]", stream_type, filter);
 693
 694         if (stream_type != SOUND_STREAM_TYPE_MEDIA) {
 695                 LOGE("Not supported stream type(%d)", stream_type);
 696                 return SOUND_MANAGER_ERROR_NOT_SUPPORTED;
 697         }
 698
 699         if ((ret = _convert_stream_type(stream_type, &stream_type_str)) != SOUND_MANAGER_ERROR_NONE)
 700                 return ret;
 701         if ((ret = _convert_filter(filter, &filter_str, &filter_params_str)) != SOUND_MANAGER_ERROR_NONE)
 702                 return ret;
 703
 704         return _convert_sound_manager_error_code(__func__, mm_sound_set_filter(stream_type_str, filter_str, filter_params_str, stream_type_str));
 705 }
 706
 707 int sound_manager_unset_filter(sound_stream_type_e stream_type)
 708 {
 709         int ret = SOUND_MANAGER_ERROR_NONE;
 710         char *stream_type_str = NULL;
 711
 712         LOGI("stream_type[%d]", stream_type);
 713
 714         if ((ret = _convert_stream_type(stream_type, &stream_type_str)) != SOUND_MANAGER_ERROR_NONE)
 715                 return ret;
 716
 717         return _convert_sound_manager_error_code(__func__, mm_sound_unset_filter(stream_type_str));
 718 }
 719
 720 int sound_manager_set_filter_preset(sound_stream_type_e stream_type, sound_filter_e filter, sound_filter_preset_e preset)
 721 {
 722         int ret = SOUND_MANAGER_ERROR_NONE;
 723         char *stream_type_str = NULL;
 724         char *filter_str = NULL;
 725         char *filter_params_str = NULL;
 726         char *control_str = NULL;
 727
 728         if (stream_type != SOUND_STREAM_TYPE_MEDIA) {
 729                 LOGE("Not supported stream type(%d)", stream_type);
 730                 return SOUND_MANAGER_ERROR_NOT_SUPPORTED;
 731         }
 732
 733         LOGI("stream_type[%d] filter[%d] preset[%d]", stream_type, filter, preset);
 734
 735         if ((ret = _check_valid_filter_preset(filter, preset)) != SOUND_MANAGER_ERROR_NONE)
 736                 return ret;
 737         if ((ret = _convert_stream_type(stream_type, &stream_type_str)) != SOUND_MANAGER_ERROR_NONE)
 738                 return ret;
 739         if ((ret = _convert_filter(filter, &filter_str, &filter_params_str)) != SOUND_MANAGER_ERROR_NONE)
 740                 return ret;
 741         if ((ret = _convert_filter_preset(preset, &control_str)) != SOUND_MANAGER_ERROR_NONE)
 742                 return ret;
 743
 744         return _convert_sound_manager_error_code(__func__, mm_sound_control_filter(stream_type_str, filter_str, control_str));
 745 }
 746
 747 int sound_manager_get_device_vendor_id(sound_device_h device, int *vendor_id)
 748 {
 749         int ret = MM_ERROR_NONE;
 750         mm_sound_device_type_e type;
 751
 752         SM_ARG_CHECK(device);
 753         SM_ARG_CHECK(vendor_id);
 754
 755         LOGI("device[%p]", device);
 756
 757         if ((ret = mm_sound_get_device_type(device, &type)) != MM_ERROR_NONE)
 758                 return _convert_sound_manager_error_code(__func__, ret);
 759
 760         if (type != MM_SOUND_DEVICE_TYPE_USB_AUDIO) {
 761                 LOGE("device type is not USB audio device, device_type[%d]", type);
 762                 return SOUND_MANAGER_ERROR_NOT_SUPPORTED;
 763         }
 764
 765         ret = mm_sound_get_device_vendor_id(device, vendor_id);
 766
 767         LOGI("vendor_id[%d]", *vendor_id);
 768
 769         return _convert_sound_manager_error_code(__func__, ret);
 770 }
 771
 772 int sound_manager_get_device_product_id(sound_device_h device, int *product_id)
 773 {
 774         int ret = MM_ERROR_NONE;
 775         mm_sound_device_type_e type;
 776
 777         SM_ARG_CHECK(device);
 778         SM_ARG_CHECK(product_id);
 779
 780         LOGI("device[%p]", device);
 781
 782         if ((ret = mm_sound_get_device_type(device, &type)) != MM_ERROR_NONE)
 783                 return _convert_sound_manager_error_code(__func__, ret);
 784
 785         if (type != MM_SOUND_DEVICE_TYPE_USB_AUDIO) {
 786                 LOGE("device type is not USB audio device, device_type[%d]", type);
 787                 return SOUND_MANAGER_ERROR_NOT_SUPPORTED;
 788         }
 789
 790         ret = mm_sound_get_device_product_id(device, product_id);
 791
 792         LOGI("product_id[%d]", *product_id);
 793
 794         return _convert_sound_manager_error_code(__func__, ret);
 795 }
 796
 797 int sound_manager_get_device_sample_format(sound_device_h device, sound_sample_format_e *format)
 798 {
 799         int ret = MM_ERROR_NONE;
 800         int _format = 0;
 801
 802         SM_ARG_CHECK(device);
 803         SM_ARG_CHECK(format);
 804
 805         LOGI("device[%p]", device);
 806
 807         if ((ret = mm_sound_get_device_sample_format(device, &_format)) != MM_ERROR_NONE)
 808                 return _convert_sound_manager_error_code(__func__, ret);
 809
 810         ret = _convert_sample_format_str_to_enum(pa_sample_format_to_string(_format), format);
 811
 812         LOGI("sample_format [%d]", *format);
 813
 814         return _convert_sound_manager_error_code(__func__, ret);
 815 }
 816
 817 int sound_manager_get_device_sample_rate(sound_device_h device, sound_sample_rate_e *samplerate)
 818 {
 819         int ret = MM_ERROR_NONE;
 820         int _samplerate = 0;
 821
 822         SM_ARG_CHECK(device);
 823         SM_ARG_CHECK(samplerate);
 824
 825         LOGI("device[%p]", device);
 826
 827         if ((ret = mm_sound_get_device_sample_rate(device, &_samplerate)) != MM_ERROR_NONE)
 828                 return _convert_sound_manager_error_code(__func__, ret);
 829
 830         ret = _convert_sample_rate_to_enum(_samplerate, samplerate);
 831
 832         LOGI("sample_rate [%d]", *samplerate);
 833
 834         return _convert_sound_manager_error_code(__func__, ret);
 835 }
 836
 837 int sound_manager_get_device_channels(sound_device_h device, int *channels)
 838 {
 839         int ret = MM_ERROR_NONE;
 840
 841         SM_ARG_CHECK(device);
 842         SM_ARG_CHECK(channels);
 843
 844         LOGI("device[%p]", device);
 845
 846         ret = mm_sound_get_device_channels(device, channels);
 847
 848         LOGI("channels [%d]", *channels);
 849
 850         return _convert_sound_manager_error_code(__func__, ret);
 851 }
 852
 853 int sound_manager_is_stream_on_device_by_id(sound_stream_info_h stream_info, int device_id, bool *is_on)
 854 {
 855         int ret = MM_ERROR_NONE;
 856         sound_stream_info_s *stream_h = (sound_stream_info_s*)stream_info;
 857
 858         SM_ARG_CHECK(stream_h);
 859         SM_ARG_CHECK(is_on);
 860
 861         LOGI("stream_info[%p, type:%s] device_id[%d]", stream_info, stream_h->stream_type, device_id);
 862
 863         ret = mm_sound_is_stream_on_device_by_id(stream_h->pa_info.index, device_id, is_on);
 864
 865         LOGI("is_on[%d]", *is_on);
 866
 867         return _convert_sound_manager_error_code(__func__, ret);
 868 }
 869
 870 int sound_manager_set_acm_master_mode(bool enable)
 871 {
 872         LOGI("enable[%d]", enable);
 873
 874         return _set_acm_master_mode(enable);
 875 }
 876
 877 int sound_manager_get_latest_stream_pid(int stream_type, unsigned int *pid)
 878 {
 879         SM_ARG_CHECK(stream_type >= 0);
 880         SM_ARG_CHECK(pid);
 881
 882         LOGI("stream_type[0x%x]", stream_type);
 883
 884         return _get_latest_stream_pid(stream_type, pid);
 885 }
 886
 887 int sound_manager_set_stream_preemptive_device(sound_stream_type_e stream_type, sound_device_io_direction_e io_direction, int device_id)
 888 {
 889         LOGI("stream_type[%d] io_direction[%d] device_id[%d]", stream_type, io_direction, device_id);
 890
 891         return _set_preemptive_device(stream_type, io_direction, device_id);
 892 }
 893
 894 int sound_manager_get_stream_preemptive_device(sound_stream_type_e stream_type, int *in_device_id, int *out_device_id)
 895 {
 896         SM_ARG_CHECK(in_device_id || out_device_id);
 897
 898         LOGI("stream_type[%d]", stream_type);
 899
 900         return _get_preemptive_device(stream_type, in_device_id, out_device_id);
 901 }
 902
 903 int sound_manager_start_discover_remote_device(void)
 904 {
 905         return _discover_remote_device(true);
 906 }
 907
 908 int sound_manager_stop_discover_remote_device(void)
 909 {
 910         return _discover_remote_device(false);
 911 }
 912
 913 int sound_manager_publish_local_device(sound_manager_remote_client_connected_cb callback, void *user_data)
 914 {
 915         SM_ARG_CHECK(callback);
 916
 917         return _publish_local_device(callback, user_data);
 918 }
 919
 920 int sound_manager_unpublish_local_device(void)
 921 {
 922         return _unpublish_local_device();
 923 }
 924
 925 int sound_manager_set_remote_permission(int id, bool allowed)
 926 {
 927         return _set_remote_permission(id, allowed);
 928 }
 929
 930 int sound_manager_set_rpi_playback_route(sound_rpi_playback_route_type type)
 931 {
 932         return _set_rpi_playback_route(type);
 933 }
 934
 935 int sound_manager_get_rpi_playback_route(sound_rpi_playback_route_type *type)
 936 {
 937         return _get_rpi_playback_route(type);
 938 }
 939
 940 int sound_manager_set_host_volume(sound_type_e type, int volume)
 941 {
 942         int ret = SOUND_MANAGER_ERROR_NONE;
 943         const char *volume_type = NULL;
 944
 945         SM_ARG_CHECK(type < SOUND_TYPE_NUM);
 946
 947         LOGI("type[%d] volume[%d]", type, volume);
 948
 949         ret = _convert_sound_type(type, &volume_type);
 950         if (ret != SOUND_MANAGER_ERROR_NONE)
 951                 return ret;
 952
 953         ret = _set_host_volume_level(DIRECTION_OUT_STR, volume_type, (unsigned int)volume);
 954
 955         return _convert_sound_manager_error_code(__func__, ret);
 956 }
 957
 958 int sound_manager_get_host_volume(sound_type_e type, int *volume)
 959 {
 960         int ret = SOUND_MANAGER_ERROR_NONE;
 961         const char *volume_type = NULL;
 962         unsigned int volume_level = 0;
 963
 964         SM_ARG_CHECK(volume);
 965
 966         LOGI("type[%d]", type);
 967
 968         ret = _convert_sound_type(type, &volume_type);
 969         if (ret != SOUND_MANAGER_ERROR_NONE)
 970                 return ret;
 971
 972         ret = _get_host_volume_level(DIRECTION_OUT_STR, volume_type, &volume_level);
 973         if (ret == SOUND_MANAGER_ERROR_NONE) {
 974                 *volume = (int)volume_level;
 975                 LOGI("host volume[%d]", *volume);
 976         }
 977
 978         return _convert_sound_manager_error_code(__func__, ret);
 979 }
 980
 981 int sound_manager_get_current_media_playback_device_id(int *device_id)
 982 {
 983         sound_device_type_e unused;
 984         SM_ARG_CHECK(device_id);
 985
 986         return _get_current_media_routing_path("out", device_id, &unused);
 987 }