src/mm_player_audioeffect.c

   1 /*
   2  * libmm-player
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: JongHyuk Choi <jhchoi.choi@samsung.com>,YeJin Cho <cho.yejin@samsung.com>, YoungHwan An <younghwan_.an@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 #include <dlog.h>
  22 #include <mm_error.h>
  23
  24 #include "mm_player_utils.h"
  25 #include "mm_player_audioeffect.h"
  26 #include "mm_player_ini.h"
  27 #include "mm_player_priv.h"
  28 #include <mm_sound.h>
  29
  30
  31 int
  32 mm_player_get_foreach_present_supported_effect_type(MMHandleType hplayer, mm_audio_effect_type_e effect_type, mmplayer_supported_audio_effect_cb foreach_cb, void *user_data)
  33 {
  34         mmplayer_t *player = NULL;
  35         int result = MM_ERROR_NONE;
  36         mm_sound_device_flags_e flags = MM_SOUND_DEVICE_IO_DIRECTION_OUT_FLAG | MM_SOUND_DEVICE_STATE_ACTIVATED_FLAG;
  37         MMSoundDeviceList_t device_list = NULL;
  38         MMSoundDevice_t device_h = NULL;
  39         mm_sound_device_type_e device_type;
  40         int i = 0;
  41
  42         MMPLAYER_FENTER();
  43
  44         MMPLAYER_RETURN_VAL_IF_FAIL(hplayer, MM_ERROR_PLAYER_NOT_INITIALIZED);
  45
  46         player = MM_PLAYER_CAST(hplayer);
  47
  48         /* get status if speaker is activated */
  49         /* (1) get current device list */
  50         result = mm_sound_get_device_list(flags, &device_list);
  51         if (result != MM_ERROR_NONE) {
  52                 LOGE("mm_sound_get_device_list() failed [%x]!!", result);
  53                 MMPLAYER_FLEAVE();
  54                 return result;
  55         }
  56
  57         /* (2) get device handle of device list */
  58         result = mm_sound_get_next_device(device_list, &device_h);
  59         if (result != MM_ERROR_NONE) {
  60                 LOGE("mm_sound_get_next_device() failed [%x]!!", result);
  61                 goto EXIT;
  62         }
  63
  64         /* (3) get device type */
  65         result = mm_sound_get_device_type(device_h, &device_type);
  66         if (result != MM_ERROR_NONE) {
  67                 LOGE("mm_sound_get_device_type() failed [%x]!!", result);
  68                 goto EXIT;
  69         }
  70
  71         if (effect_type == MM_AUDIO_EFFECT_TYPE_PRESET) {
  72                 /* preset */
  73                 for (i = 0; i < MM_AUDIO_EFFECT_PRESET_NUM; i++) {
  74                         if (player->ini.audio_effect_preset_list[i]) {
  75                                 if (device_type == MM_SOUND_DEVICE_TYPE_BUILTIN_SPEAKER &&
  76                                         player->ini.audio_effect_preset_earphone_only_list[i])
  77                                         continue;
  78
  79                                 if (!foreach_cb(effect_type, i, user_data)) {
  80                                         LOGE("foreach callback returned error");
  81                                         result = MM_ERROR_PLAYER_INTERNAL;
  82                                         goto EXIT;
  83                                 }
  84                         }
  85                 }
  86         } else if (effect_type == MM_AUDIO_EFFECT_TYPE_CUSTOM) {
  87                 /* custom */
  88                 for (i = 0; i < MM_AUDIO_EFFECT_CUSTOM_NUM; i++) {
  89                         if (player->ini.audio_effect_custom_list[i]) {
  90                                 if (device_type == MM_SOUND_DEVICE_TYPE_BUILTIN_SPEAKER &&
  91                                         player->ini.audio_effect_custom_earphone_only_list[i]) {
  92                                         continue;
  93                                 }
  94                                 if (!foreach_cb(effect_type, i, user_data)) {
  95                                         LOGE("foreach callback returned error");
  96                                         result = MM_ERROR_PLAYER_INTERNAL;
  97                                         goto EXIT;
  98                                 }
  99                         }
 100                 }
 101         } else {
 102                 LOGE("invalid effect type(%d)", effect_type);
 103                 result = MM_ERROR_INVALID_ARGUMENT;
 104         }
 105
 106 EXIT:
 107         if (device_list)
 108                 mm_sound_free_device_list(device_list);
 109
 110         MMPLAYER_FLEAVE();
 111         return result;
 112 }
 113
 114
 115 static int
 116 __mmplayer_set_harmony_effect(mmplayer_t *player, GstElement *audio_effect_element)
 117 {
 118         gint *ext_effect_level_list = NULL;
 119         int count = 1;          /* start from 1, because of excepting eq index */
 120         int ext_level_index = 0;
 121         int result = MM_ERROR_NONE;
 122
 123         MMPLAYER_FENTER();
 124
 125         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 126         MMPLAYER_RETURN_VAL_IF_FAIL(audio_effect_element, MM_ERROR_INVALID_ARGUMENT);
 127
 128         /* Custom EQ */
 129         if (player->ini.audio_effect_custom_eq_band_num) {
 130                 LOGD("pass custom EQ level list to audio effect plugin");
 131                 /* set custom-equalizer level list */
 132                 g_object_set(audio_effect_element, "custom-eq", player->audio_effect_info.custom_eq_level, NULL);
 133         } else {
 134                 LOGW("no custom EQ");
 135         }
 136
 137         /* Custom Extension effects */
 138         if (player->ini.audio_effect_custom_ext_num) {
 139                 LOGD("pass custom extension level list to audio effect plugin");
 140                 ext_effect_level_list = player->audio_effect_info.custom_ext_level_for_plugin;
 141                 if (!ext_effect_level_list) {
 142                         ext_effect_level_list = (gint *)malloc(sizeof(gint) * player->ini.audio_effect_custom_ext_num);
 143                         if (!ext_effect_level_list) {
 144                                 LOGE("memory allocation for extension effect list failed");
 145                                 return MM_ERROR_OUT_OF_MEMORY;
 146                         } else {
 147                                 memset(ext_effect_level_list, 0, player->ini.audio_effect_custom_ext_num);
 148
 149                                 /* associate it to player handle */
 150                                 player->audio_effect_info.custom_ext_level_for_plugin = ext_effect_level_list;
 151                         }
 152                 }
 153
 154                 while (count < MM_AUDIO_EFFECT_CUSTOM_NUM) {
 155                         if (player->ini.audio_effect_custom_list[count]) {
 156                                 ext_effect_level_list[ext_level_index] = player->audio_effect_info.custom_ext_level[count - 1];
 157                                 ext_level_index++;
 158                                 if (ext_level_index == player->ini.audio_effect_custom_ext_num)
 159                                         break;
 160                         }
 161                         count++;
 162                 }
 163
 164                 /* set custom-extension effects level list */
 165                 g_object_set(audio_effect_element, "custom-ext", ext_effect_level_list, NULL);
 166         } else {
 167                 LOGW("no custom extension effect");
 168         }
 169
 170         /* order action to audio effect plugin */
 171         g_object_set(audio_effect_element, "filter-action", MM_AUDIO_EFFECT_TYPE_CUSTOM, NULL);
 172         LOGD("filter-action = %d", MM_AUDIO_EFFECT_TYPE_CUSTOM);
 173
 174         MMPLAYER_FLEAVE();
 175
 176         return result;
 177 }
 178
 179
 180 static gboolean
 181 __mmplayer_is_earphone_only_effect_type(mmplayer_t *player, mm_audio_effect_type_e effect_type, int effect)
 182 {
 183         gboolean result = FALSE;
 184         int i = 0;
 185
 186         MMPLAYER_FENTER();
 187
 188         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 189
 190         if (effect_type == MM_AUDIO_EFFECT_TYPE_PRESET) {
 191                 /* preset */
 192                 if (player->ini.audio_effect_preset_earphone_only_list[effect]) {
 193                         LOGI("this preset effect(%d) is only available with earphone", effect);
 194                         result = TRUE;
 195                 }
 196         } else if (effect_type == MM_AUDIO_EFFECT_TYPE_CUSTOM) {
 197                 /* custom */
 198                 for (i = 1; i < MM_AUDIO_EFFECT_CUSTOM_NUM; i++) {
 199                         /* it starts from 1(except testing for EQ) */
 200                         if (player->ini.audio_effect_custom_earphone_only_list[i]) {
 201                                 /* check if the earphone only custom effect was set */
 202                                 if (player->audio_effect_info.custom_ext_level[i - 1]) {
 203                                         LOGI("this custom effect(%d) is only available with earphone", i);
 204                                         result = TRUE;
 205                                 }
 206                         }
 207                 }
 208         } else {
 209                 LOGE("invalid effect type(%d)", effect_type);
 210         }
 211
 212         MMPLAYER_FLEAVE();
 213
 214         return result;
 215 }
 216
 217 static int
 218 __mmplayer_audio_set_output_type(mmplayer_t *player, mm_audio_effect_type_e effect_type, int effect)
 219 {
 220         GstElement *audio_effect_element = NULL;
 221         mm_sound_device_flags_e flags = MM_SOUND_DEVICE_ALL_FLAG;
 222         MMSoundDeviceList_t device_list = NULL;
 223         MMSoundDevice_t device_h = NULL;
 224         mm_sound_device_type_e device_type;
 225         int output_type = 0;
 226         int result = MM_ERROR_NONE;
 227
 228         MMPLAYER_FENTER();
 229
 230         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 231
 232         audio_effect_element = player->pipeline->audiobin[MMPLAYER_A_FILTER].gst;
 233
 234         /* (1) get current device list */
 235         result = mm_sound_get_device_list(flags, &device_list);
 236         if (result != MM_ERROR_NONE) {
 237                 LOGE("mm_sound_get_device_list() failed [%x]!!", result);
 238                 MMPLAYER_FLEAVE();
 239                 return result;
 240         }
 241
 242         /* (2) get device handle of device list */
 243         result = mm_sound_get_next_device(device_list, &device_h);
 244         if (result != MM_ERROR_NONE) {
 245                 LOGE("mm_sound_get_next_device() failed [%x]!!", result);
 246                 goto EXIT;
 247         }
 248
 249         /* (3) get device type */
 250         result = mm_sound_get_device_type(device_h, &device_type);
 251         if (result != MM_ERROR_NONE) {
 252                 LOGE("mm_sound_get_device_type() failed [%x]!!", result);
 253                 goto EXIT;
 254         }
 255
 256         /* SPEAKER case */
 257         if (device_type == MM_SOUND_DEVICE_TYPE_BUILTIN_SPEAKER) {
 258                 if (MM_AUDIO_EFFECT_TYPE_SQUARE != effect_type) {
 259                         if (__mmplayer_is_earphone_only_effect_type(player, effect_type, effect)) {
 260                                 LOGE("earphone is not equipped, this filter will not be applied");
 261                                 result = MM_ERROR_PLAYER_SOUND_EFFECT_INVALID_STATUS;
 262                                 goto EXIT;
 263                         }
 264                 }
 265                 output_type = MM_AUDIO_EFFECT_OUTPUT_SPK;
 266         } else if (device_type == MM_SOUND_DEVICE_TYPE_MIRRORING) {
 267                 output_type = MM_AUDIO_EFFECT_OUTPUT_OTHERS;
 268         } else if (device_type == MM_SOUND_DEVICE_TYPE_HDMI) {
 269                 output_type = MM_AUDIO_EFFECT_OUTPUT_HDMI;
 270         } else if (device_type == MM_SOUND_DEVICE_TYPE_BLUETOOTH) {
 271                 output_type = MM_AUDIO_EFFECT_OUTPUT_BT;
 272         } else if (device_type == MM_SOUND_DEVICE_TYPE_USB_AUDIO) {
 273                 output_type = MM_AUDIO_EFFECT_OUTPUT_USB_AUDIO;
 274         } else {
 275                 /* Other case, include WIRED_ACCESSORY */
 276                 output_type = MM_AUDIO_EFFECT_OUTPUT_EAR;
 277         }
 278         LOGW("output_type = %d (0:spk,1:ear,2:others)", output_type);
 279
 280         /* set filter output mode */
 281         g_object_set(audio_effect_element, "filter-output-mode", output_type, NULL);
 282
 283 EXIT:
 284         if (device_list)
 285                 mm_sound_free_device_list(device_list);
 286
 287         MMPLAYER_FLEAVE();
 288         return result;
 289 }
 290
 291 static gboolean
 292 __mmplayer_is_supported_effect_type(mmplayer_t *player, mm_audio_effect_type_e effect_type, int effect)
 293 {
 294         gboolean result = TRUE;
 295         mm_sound_device_flags_e flags = MM_SOUND_DEVICE_ALL_FLAG;
 296         MMSoundDeviceList_t device_list = NULL;
 297         MMSoundDevice_t device_h = NULL;
 298         mm_sound_device_type_e device_type;
 299         int ret = MM_ERROR_NONE;
 300
 301         MMPLAYER_FENTER();
 302
 303         /* get status if speaker is activated */
 304         /* (1) get current device list */
 305         ret = mm_sound_get_device_list(flags, &device_list);
 306         if (ret != MM_ERROR_NONE) {
 307                 MMPLAYER_FLEAVE();
 308                 LOGE("mm_sound_get_device_list() failed [%x]!!", ret);
 309                 return FALSE;
 310         }
 311
 312         /* (2) get device handle of device list */
 313         ret = mm_sound_get_next_device(device_list, &device_h);
 314         if (ret != MM_ERROR_NONE) {
 315                 LOGE("mm_sound_get_next_device() failed [%x]!!", ret);
 316                 goto EXIT;
 317         }
 318
 319         /* (3) get device type */
 320         ret = mm_sound_get_device_type(device_h, &device_type);
 321         if (ret != MM_ERROR_NONE) {
 322                 LOGE("mm_sound_get_device_type() failed [%x]!!", ret);
 323                 goto EXIT;
 324         }
 325
 326         /* preset */
 327         if (effect_type == MM_AUDIO_EFFECT_TYPE_PRESET) {
 328                 if (effect < MM_AUDIO_EFFECT_PRESET_AUTO || effect >= MM_AUDIO_EFFECT_PRESET_NUM) {
 329                         LOGE("out of range, preset effect(%d)", effect);
 330                         result = FALSE;
 331                 } else {
 332                         if (!player->ini.audio_effect_preset_list[effect]) {
 333                                 LOGE("this effect(%d) is not supported", effect);
 334                                 result = FALSE;
 335                         } else {
 336                                 if (device_type == MM_SOUND_DEVICE_TYPE_BUILTIN_SPEAKER &&
 337                                                 player->ini.audio_effect_preset_earphone_only_list[effect]) {
 338                                         result = FALSE;
 339                                 }
 340                         }
 341                 }
 342         } else if (effect_type == MM_AUDIO_EFFECT_TYPE_CUSTOM) {
 343                 /* custom */
 344                 if (effect < MM_AUDIO_EFFECT_CUSTOM_EQ || effect >= MM_AUDIO_EFFECT_CUSTOM_NUM) {
 345                         LOGE("out of range, custom effect(%d)", effect);
 346                         result = FALSE;
 347                 } else {
 348                         if (!player->ini.audio_effect_custom_list[effect]) {
 349                                 LOGE("this custom effect(%d) is not supported", effect);
 350                                 result = FALSE;
 351                         } else {
 352                                 if (device_type == MM_SOUND_DEVICE_TYPE_BUILTIN_SPEAKER &&
 353                                                 player->ini.audio_effect_custom_earphone_only_list[effect])
 354                                         result = FALSE;
 355                         }
 356                 }
 357         } else if (effect_type == MM_AUDIO_EFFECT_TYPE_SQUARE) {
 358                 if (!player->ini.use_audio_effect_custom) {
 359                         LOGE("Square effect is not supported");
 360                         result = FALSE;
 361                 }
 362         } else {
 363                 LOGE("invalid effect type(%d)", effect_type);
 364                 result = FALSE;
 365         }
 366
 367 EXIT:
 368         if (device_list)
 369                 mm_sound_free_device_list(device_list);
 370
 371         MMPLAYER_FLEAVE();
 372         return result;
 373 }
 374
 375 int
 376 _mmplayer_audio_effect_custom_apply(mmplayer_t *player)
 377 {
 378         GstElement *audio_effect_element = NULL;
 379         int result = MM_ERROR_NONE;
 380
 381         MMPLAYER_FENTER();
 382
 383         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 384
 385         /* Music Player can set audio effect value before Audiobin is created. */
 386         if (!player->pipeline || !player->pipeline->audiobin || !player->pipeline->audiobin[MMPLAYER_A_FILTER].gst) {
 387                 LOGW("effect element is not created yet.");
 388                 player->bypass_audio_effect = FALSE;
 389
 390                 /* store audio effect setting in order to apply it when audio effect plugin is created */
 391                 player->audio_effect_info.effect_type = MM_AUDIO_EFFECT_TYPE_CUSTOM;
 392         } else {
 393                 audio_effect_element = player->pipeline->audiobin[MMPLAYER_A_FILTER].gst;
 394
 395                 /* get status if speaker is activated */
 396                 result = __mmplayer_audio_set_output_type(player, MM_AUDIO_EFFECT_TYPE_CUSTOM, 0);
 397                 if (result != MM_ERROR_NONE) {
 398                         LOGE("failed to set output mode");
 399                         MMPLAYER_FLEAVE();
 400                         return result;
 401                 }
 402
 403                 result = __mmplayer_set_harmony_effect(player, audio_effect_element);
 404                 if (result) {
 405                         LOGE("_set_harmony_effect() failed(%x)", result);
 406                         MMPLAYER_FLEAVE();
 407                         return result;
 408                 }
 409         }
 410         player->set_mode.rich_audio = true;
 411
 412         MMPLAYER_FLEAVE();
 413
 414         return result;
 415 }
 416
 417 int
 418 _mmplayer_audio_effect_custom_update_level(mmplayer_t *player)
 419 {
 420         GstElement *audio_effect_element = NULL;
 421         int result = MM_ERROR_NONE;
 422         int ext_level_index = 0;
 423         int count = 1;
 424         int i = 0;
 425         gint *custom_eq = NULL;
 426         gint *custom_ext_effect_level_list = NULL;
 427
 428         MMPLAYER_FENTER();
 429
 430         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 431
 432         audio_effect_element = player->pipeline->audiobin[MMPLAYER_A_FILTER].gst;
 433
 434         /* get custom eq effect */
 435         g_object_get(audio_effect_element, "custom-eq", &custom_eq, NULL);
 436
 437         memcpy(player->audio_effect_info.custom_eq_level, custom_eq, sizeof(gint) * player->ini.audio_effect_custom_eq_band_num);
 438
 439         for (i = 0; i < player->ini.audio_effect_custom_eq_band_num; i++)
 440                 LOGD("updated custom-eq [%d] = %d", i, player->audio_effect_info.custom_eq_level[i]);
 441
 442         /* get custom ext effect */
 443         g_object_get(audio_effect_element, "custom-ext", &custom_ext_effect_level_list, NULL);
 444
 445         while (count < MM_AUDIO_EFFECT_CUSTOM_NUM) {
 446                 if (player->ini.audio_effect_custom_list[count]) {
 447                         player->audio_effect_info.custom_ext_level[count - 1]
 448                                 = custom_ext_effect_level_list[ext_level_index];
 449                         LOGD("updated custom-ext [%d] = %d", count, player->audio_effect_info.custom_ext_level[count - 1]);
 450                         ext_level_index++;
 451                 }
 452                 count++;
 453         }
 454
 455         MMPLAYER_FLEAVE();
 456         return result;
 457 }
 458
 459
 460 int
 461 mm_player_audio_effect_custom_clear_eq_all(MMHandleType hplayer)
 462 {
 463         int result = MM_ERROR_NONE;
 464         mmplayer_t *player = (mmplayer_t *)hplayer;
 465
 466         MMPLAYER_FENTER();
 467
 468         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 469
 470         /* clear EQ custom effect */
 471         memset(player->audio_effect_info.custom_eq_level, MM_AUDIO_EFFECT_CUSTOM_LEVEL_INIT, sizeof(int) * MM_AUDIO_EFFECT_EQ_BAND_NUM_MAX);
 472
 473         LOGI("All the EQ bands clearing success");
 474
 475         MMPLAYER_FLEAVE();
 476
 477         return result;
 478 }
 479
 480
 481 int
 482 mm_player_audio_effect_custom_clear_ext_all(MMHandleType hplayer)
 483 {
 484         int i;
 485         int result = MM_ERROR_NONE;
 486         mmplayer_t *player = (mmplayer_t *)hplayer;
 487
 488         MMPLAYER_FENTER();
 489
 490         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 491
 492         /* clear ALL custom effects, except EQ */
 493         for (i = 0 ; i < MM_AUDIO_EFFECT_CUSTOM_NUM - 1 ; i++)
 494                 player->audio_effect_info.custom_ext_level[i] = MM_AUDIO_EFFECT_CUSTOM_LEVEL_INIT;
 495
 496         LOGI("All the extension effects clearing success");
 497
 498         MMPLAYER_FLEAVE();
 499
 500         return result;
 501 }
 502
 503
 504 int
 505 mm_player_is_supported_preset_effect_type(MMHandleType hplayer, mm_audio_effect_preset_type_e effect)
 506 {
 507         mmplayer_t *player = (mmplayer_t *)hplayer;
 508         int result = MM_ERROR_NONE;
 509
 510         MMPLAYER_FENTER();
 511
 512         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 513
 514         if (!__mmplayer_is_supported_effect_type(player, MM_AUDIO_EFFECT_TYPE_PRESET, effect))
 515                 result = MM_ERROR_PLAYER_SOUND_EFFECT_NOT_SUPPORTED_FILTER;
 516
 517         MMPLAYER_FLEAVE();
 518
 519         return result;
 520 }
 521
 522
 523 int
 524 mm_player_is_supported_custom_effect_type(MMHandleType hplayer, mm_audio_effect_custom_type_e effect)
 525 {
 526         mmplayer_t *player = (mmplayer_t *)hplayer;
 527         int result = MM_ERROR_NONE;
 528
 529         MMPLAYER_FENTER();
 530
 531         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 532
 533         if (!__mmplayer_is_supported_effect_type(player, MM_AUDIO_EFFECT_TYPE_CUSTOM, effect))
 534                 result = MM_ERROR_PLAYER_SOUND_EFFECT_NOT_SUPPORTED_FILTER;
 535
 536         MMPLAYER_FLEAVE();
 537
 538         return result;
 539 }
 540
 541 int
 542 mm_player_audio_effect_custom_apply(MMHandleType hplayer)
 543 {
 544         mmplayer_t *player = (mmplayer_t *)hplayer;
 545         int result = MM_ERROR_NONE;
 546
 547         MMPLAYER_FENTER();
 548
 549         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 550
 551         if (!player->ini.use_audio_effect_custom) {
 552                 LOGE("audio effect(custom) is not supported");
 553                 MMPLAYER_FLEAVE();
 554                 return MM_ERROR_NOT_SUPPORT_API;
 555         }
 556
 557         result = _mmplayer_audio_effect_custom_apply(player);
 558
 559         MMPLAYER_FLEAVE();
 560
 561         return result;
 562 }
 563
 564
 565 int
 566 mm_player_audio_effect_bypass(MMHandleType hplayer)
 567 {
 568         mmplayer_t *player = (mmplayer_t *)hplayer;
 569         int result = MM_ERROR_NONE;
 570         GstElement *audio_effect_element = NULL;
 571
 572         MMPLAYER_FENTER();
 573
 574         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 575
 576         if (!player->ini.use_audio_effect_preset && !player->ini.use_audio_effect_custom) {
 577                 LOGE("audio effect(preset/custom) is not supported");
 578                 MMPLAYER_FLEAVE();
 579                 return MM_ERROR_NOT_SUPPORT_API;
 580         }
 581         if (!player->pipeline || !player->pipeline->audiobin || !player->pipeline->audiobin[MMPLAYER_A_FILTER].gst) {
 582                 LOGW("effect element is not created yet.");
 583         } else {
 584                 audio_effect_element = player->pipeline->audiobin[MMPLAYER_A_FILTER].gst;
 585
 586                 /* order action to audio effect plugin */
 587                 g_object_set(audio_effect_element, "filter-action", MM_AUDIO_EFFECT_TYPE_NONE, NULL);
 588                 LOGD("filter-action = %d", MM_AUDIO_EFFECT_TYPE_NONE);
 589         }
 590
 591         MMPLAYER_FLEAVE();
 592
 593         return result;
 594 }
 595
 596
 597 static int
 598 __mmplayer_audio_effect_custom_set_level_ext(mmplayer_t *player, mm_audio_effect_custom_type_e custom_effect_type, int level)
 599 {
 600         int effect_level_max = 0;
 601         int effect_level_min = 0;
 602         int count = 1;                  /* start from 1, because of excepting eq index */
 603         int ext_level_index = 1;        /* start from 1, because of excepting eq index */
 604         int result = MM_ERROR_NONE;
 605
 606         MMPLAYER_FENTER();
 607
 608         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 609
 610         /* check if EQ is supported */
 611         if (!__mmplayer_is_supported_effect_type(player,  MM_AUDIO_EFFECT_TYPE_CUSTOM, custom_effect_type)) {
 612                 MMPLAYER_FLEAVE();
 613                 return MM_ERROR_PLAYER_SOUND_EFFECT_NOT_SUPPORTED_FILTER;
 614         }
 615
 616         while (count < MM_AUDIO_EFFECT_CUSTOM_NUM) {
 617                 if (player->ini.audio_effect_custom_list[count]) {
 618                         if (count == custom_effect_type) {
 619                                 effect_level_min = player->ini.audio_effect_custom_min_level_list[ext_level_index];
 620                                 effect_level_max = player->ini.audio_effect_custom_max_level_list[ext_level_index];
 621                                 LOGI("level min value(%d), level max value(%d)", effect_level_min, effect_level_max);
 622                                 break;
 623                         }
 624                         ext_level_index++;
 625                         if (ext_level_index == player->ini.audio_effect_custom_ext_num + 1) {
 626                                 LOGE("could not find min, max value. maybe effect information in ini file is not proper for audio effect plugin");
 627                                 break;
 628                         }
 629                 }
 630                 count++;
 631         }
 632
 633         if (level < effect_level_min || level > effect_level_max) {
 634                 LOGE("out of range, level(%d)", level);
 635                 result = MM_ERROR_INVALID_ARGUMENT;
 636         } else {
 637                 player->audio_effect_info.custom_ext_level[custom_effect_type - 1] = level;
 638                 LOGI("set ext[%d] = %d", custom_effect_type-1, level);
 639         }
 640
 641         MMPLAYER_FLEAVE();
 642
 643         return result;
 644 }
 645
 646
 647 static int
 648 __mmplayer_audio_effect_custom_set_level_eq(mmplayer_t *player, int index, int level)
 649 {
 650         gint eq_level_max = 0;
 651         gint eq_level_min = 0;
 652         int result = MM_ERROR_NONE;
 653
 654         MMPLAYER_FENTER();
 655
 656         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 657
 658         /* check if EQ is supported */
 659         if (!__mmplayer_is_supported_effect_type(player, MM_AUDIO_EFFECT_TYPE_CUSTOM, MM_AUDIO_EFFECT_CUSTOM_EQ)) {
 660                 MMPLAYER_FLEAVE();
 661                 return MM_ERROR_PLAYER_SOUND_EFFECT_NOT_SUPPORTED_FILTER;
 662         }
 663
 664         if (index < 0 || index > player->ini.audio_effect_custom_eq_band_num - 1) {
 665                 LOGE("out of range, index(%d)", index);
 666                 result = MM_ERROR_INVALID_ARGUMENT;
 667         } else {
 668                 eq_level_min = player->ini.audio_effect_custom_min_level_list[MM_AUDIO_EFFECT_CUSTOM_EQ];
 669                 eq_level_max = player->ini.audio_effect_custom_max_level_list[MM_AUDIO_EFFECT_CUSTOM_EQ];
 670                 LOGI("EQ level min value(%d), EQ level max value(%d)", eq_level_min, eq_level_max);
 671
 672                 if (level < eq_level_min || level > eq_level_max) {
 673                         LOGE("out of range, EQ level(%d)", level);
 674                         result =  MM_ERROR_INVALID_ARGUMENT;
 675                 } else {
 676                         player->audio_effect_info.custom_eq_level[index] = level;
 677                         LOGI("set EQ[%d] = %d", index, level);
 678                 }
 679         }
 680
 681         MMPLAYER_FLEAVE();
 682
 683         return result;
 684 }
 685
 686
 687 /* NOTE : parameter eq_index is only used for _set_eq_level() */
 688 int
 689 mm_player_audio_effect_custom_set_level(MMHandleType hplayer, mm_audio_effect_custom_type_e effect_custom_type, int eq_index, int level)
 690 {
 691         mmplayer_t *player = (mmplayer_t *)hplayer;
 692         int result = MM_ERROR_NONE;
 693
 694         MMPLAYER_FENTER();
 695
 696         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 697
 698         /* check if this effect type is supported */
 699         if (!__mmplayer_is_supported_effect_type(player, MM_AUDIO_EFFECT_TYPE_CUSTOM, effect_custom_type)) {
 700                 result = MM_ERROR_PLAYER_SOUND_EFFECT_NOT_SUPPORTED_FILTER;
 701         } else {
 702                 if (effect_custom_type == MM_AUDIO_EFFECT_CUSTOM_EQ) {
 703                         result = __mmplayer_audio_effect_custom_set_level_eq(player, eq_index, level);
 704                 } else if (effect_custom_type > MM_AUDIO_EFFECT_CUSTOM_EQ && effect_custom_type < MM_AUDIO_EFFECT_CUSTOM_NUM) {
 705                         result = __mmplayer_audio_effect_custom_set_level_ext(player, effect_custom_type, level);
 706                 } else {
 707                         LOGE("out of range, effect type(%d)", effect_custom_type);
 708                         result = MM_ERROR_INVALID_ARGUMENT;
 709                 }
 710         }
 711
 712         MMPLAYER_FLEAVE();
 713
 714         return result;
 715 }
 716
 717
 718 int
 719 mm_player_audio_effect_custom_get_eq_bands_number(MMHandleType hplayer, int *bands)
 720 {
 721         mmplayer_t *player = (mmplayer_t *)hplayer;
 722         int result = MM_ERROR_NONE;
 723
 724         MMPLAYER_FENTER();
 725
 726         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 727
 728         /* check if EQ is supported */
 729         if (!__mmplayer_is_supported_effect_type(player, MM_AUDIO_EFFECT_TYPE_CUSTOM, MM_AUDIO_EFFECT_CUSTOM_EQ)) {
 730                 MMPLAYER_FLEAVE();
 731                 return MM_ERROR_PLAYER_SOUND_EFFECT_NOT_SUPPORTED_FILTER;
 732         }
 733
 734         *bands = player->ini.audio_effect_custom_eq_band_num;
 735         LOGD("number of custom EQ band = %d", *bands);
 736
 737         MMPLAYER_FLEAVE();
 738
 739         return result;
 740 }
 741
 742
 743 int
 744 mm_player_audio_effect_custom_get_eq_bands_width(MMHandleType hplayer, int band_idx, int *width)
 745 {
 746         mmplayer_t *player = (mmplayer_t *)hplayer;
 747         int result = MM_ERROR_NONE;
 748         unsigned int eq_num = 0;
 749
 750         MMPLAYER_FENTER();
 751
 752         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 753
 754         /* check if EQ is supported */
 755         if (!__mmplayer_is_supported_effect_type(player, MM_AUDIO_EFFECT_TYPE_CUSTOM, MM_AUDIO_EFFECT_CUSTOM_EQ)) {
 756                 MMPLAYER_FLEAVE();
 757                 return MM_ERROR_PLAYER_SOUND_EFFECT_NOT_SUPPORTED_FILTER;
 758         }
 759
 760         eq_num = player->ini.audio_effect_custom_eq_band_num;
 761         if (band_idx < 0 || band_idx > eq_num - 1) {
 762                 LOGE("out of range, invalid band_idx(%d)", band_idx);
 763                 result = MM_ERROR_INVALID_ARGUMENT;
 764         } else {
 765                 /* set the width of EQ band */
 766                 *width = player->ini.audio_effect_custom_eq_band_width[band_idx];
 767                 LOGD("width of band_idx(%d) = %dHz", band_idx, *width);
 768         }
 769
 770         MMPLAYER_FLEAVE();
 771
 772         return result;
 773 }
 774
 775
 776 int
 777 mm_player_audio_effect_custom_get_eq_bands_freq(MMHandleType hplayer, int band_idx, int *freq)
 778 {
 779         mmplayer_t *player = (mmplayer_t *)hplayer;
 780         int result = MM_ERROR_NONE;
 781         unsigned int eq_num = 0;
 782
 783         MMPLAYER_FENTER();
 784
 785         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 786
 787         /* check if EQ is supported */
 788         if (!__mmplayer_is_supported_effect_type(player, MM_AUDIO_EFFECT_TYPE_CUSTOM, MM_AUDIO_EFFECT_CUSTOM_EQ)) {
 789                 MMPLAYER_FLEAVE();
 790                 return MM_ERROR_PLAYER_SOUND_EFFECT_NOT_SUPPORTED_FILTER;
 791         }
 792
 793         eq_num = player->ini.audio_effect_custom_eq_band_num;
 794         if (band_idx < 0 || band_idx > eq_num - 1) {
 795                 LOGE("out of range, invalid band_idx(%d)", band_idx);
 796                 result = MM_ERROR_INVALID_ARGUMENT;
 797         } else {
 798                 /* set the frequency of EQ band */
 799                 *freq = player->ini.audio_effect_custom_eq_band_freq[band_idx];
 800                 LOGD("frequency of band_idx(%d) = %dHz", band_idx, *freq);
 801         }
 802
 803         MMPLAYER_FLEAVE();
 804
 805         return result;
 806 }
 807
 808
 809 int
 810 mm_player_audio_effect_custom_get_level(MMHandleType hplayer, mm_audio_effect_custom_type_e type, int eq_index, int *level)
 811 {
 812         mmplayer_t *player = (mmplayer_t *)hplayer;
 813         int result = MM_ERROR_NONE;
 814
 815         MMPLAYER_FENTER();
 816
 817         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 818         MMPLAYER_RETURN_VAL_IF_FAIL(level, MM_ERROR_PLAYER_NOT_INITIALIZED);
 819
 820         /* check if this effect type is supported */
 821         if (!__mmplayer_is_supported_effect_type(player, MM_AUDIO_EFFECT_TYPE_CUSTOM, type)) {
 822                 MMPLAYER_FLEAVE();
 823                 return MM_ERROR_PLAYER_SOUND_EFFECT_NOT_SUPPORTED_FILTER;
 824         }
 825
 826         if (type == MM_AUDIO_EFFECT_CUSTOM_EQ) {
 827                 if (eq_index < 0 || eq_index > player->ini.audio_effect_custom_eq_band_num - 1) {
 828                         LOGE("out of range, EQ index(%d)", eq_index);
 829                         result = MM_ERROR_INVALID_ARGUMENT;
 830                 } else {
 831                         *level = player->audio_effect_info.custom_eq_level[eq_index];
 832                         LOGD("EQ index = %d, level = %d", eq_index, *level);
 833                 }
 834         } else if (type > MM_AUDIO_EFFECT_CUSTOM_EQ && type < MM_AUDIO_EFFECT_CUSTOM_NUM) {
 835                 *level = player->audio_effect_info.custom_ext_level[type - 1];
 836                 LOGD("extension effect index = %d, level = %d", type, *level);
 837         } else {
 838                 LOGE("out of range, type(%d)", type);
 839                 result = MM_ERROR_INVALID_ARGUMENT;
 840         }
 841
 842         MMPLAYER_FLEAVE();
 843
 844         return result;
 845 }
 846
 847
 848 int
 849 mm_player_audio_effect_custom_get_level_range(MMHandleType hplayer, mm_audio_effect_custom_type_e type, int *min, int *max)
 850 {
 851         mmplayer_t *player = (mmplayer_t *)hplayer;
 852         int result = MM_ERROR_NONE;
 853         int count = 1;                  /* start from 1, because of excepting eq index */
 854         int ext_level_index = 1;        /* start from 1, because of excepting eq index */
 855
 856         MMPLAYER_FENTER();
 857
 858         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 859         MMPLAYER_RETURN_VAL_IF_FAIL(min, MM_ERROR_PLAYER_NOT_INITIALIZED);
 860         MMPLAYER_RETURN_VAL_IF_FAIL(max, MM_ERROR_PLAYER_NOT_INITIALIZED);
 861
 862         /* check if this effect type is supported */
 863         if (!__mmplayer_is_supported_effect_type(player, MM_AUDIO_EFFECT_TYPE_CUSTOM, type)) {
 864                 MMPLAYER_FLEAVE();
 865                 return MM_ERROR_PLAYER_SOUND_EFFECT_NOT_SUPPORTED_FILTER;
 866         }
 867
 868         if (type == MM_AUDIO_EFFECT_CUSTOM_EQ) {
 869                 *min = player->ini.audio_effect_custom_min_level_list[MM_AUDIO_EFFECT_CUSTOM_EQ];
 870                 *max = player->ini.audio_effect_custom_max_level_list[MM_AUDIO_EFFECT_CUSTOM_EQ];
 871                 LOGD("EQ min level = %d, max level = %d", *min, *max);
 872         } else {
 873                 while (count < MM_AUDIO_EFFECT_CUSTOM_NUM) {
 874                         if (player->ini.audio_effect_custom_list[count]) {
 875                                 if (count == type) {
 876                                         *min = player->ini.audio_effect_custom_min_level_list[ext_level_index];
 877                                         *max = player->ini.audio_effect_custom_max_level_list[ext_level_index];
 878                                         LOGI("Extension effect(%d) min level = %d, max level = %d", count, *min, *max);
 879                                         break;
 880                                 }
 881                                 ext_level_index++;
 882                                 if (ext_level_index == player->ini.audio_effect_custom_ext_num + 1) {
 883                                         LOGE("could not find min, max value. maybe effect information in ini file is not proper for audio effect plugin");
 884                                         break;
 885                                 }
 886                         }
 887                         count++;
 888                 }
 889         }
 890
 891         MMPLAYER_FLEAVE();
 892
 893         return result;
 894 }
 895
 896
 897 int
 898 mm_player_audio_effect_custom_set_level_eq_from_list(MMHandleType hplayer, int *level_list, int size)
 899 {
 900         mmplayer_t *player = (mmplayer_t *)hplayer;
 901         gint i = 0;
 902         gint eq_level_min = 0;
 903         gint eq_level_max = 0;
 904         int result = MM_ERROR_NONE;
 905
 906         MMPLAYER_FENTER();
 907
 908         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 909
 910         /* check if EQ is supported */
 911         if (!__mmplayer_is_supported_effect_type(player, MM_AUDIO_EFFECT_TYPE_CUSTOM, MM_AUDIO_EFFECT_CUSTOM_EQ)) {
 912                 MMPLAYER_FLEAVE();
 913                 return MM_ERROR_PLAYER_SOUND_EFFECT_NOT_SUPPORTED_FILTER;
 914         }
 915
 916         if (size != player->ini.audio_effect_custom_eq_band_num) {
 917                 LOGE("input size variable(%d) does not match with number of eq band(%d)", size, player->ini.audio_effect_custom_eq_band_num);
 918                 result = MM_ERROR_INVALID_ARGUMENT;
 919         } else {
 920                 eq_level_min = player->ini.audio_effect_custom_min_level_list[MM_AUDIO_EFFECT_CUSTOM_EQ];
 921                 eq_level_max = player->ini.audio_effect_custom_max_level_list[MM_AUDIO_EFFECT_CUSTOM_EQ];
 922
 923                 for (i = 0 ; i < size ; i++) {
 924                         if (level_list[i] < eq_level_min || level_list[i] > eq_level_max) {
 925                                 LOGE("out of range, level[%d]=%d", i, level_list[i]);
 926                                 result = MM_ERROR_INVALID_ARGUMENT;
 927                                 break;
 928                         }
 929                         player->audio_effect_info.custom_eq_level[i] = level_list[i];
 930                 }
 931         }
 932         MMPLAYER_FLEAVE();
 933
 934         return result;
 935 }