include/mm_sound.h

   1 /*
   2  * libmm-sound
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Seungbae Shin <seungbae.shin@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  */
  21
  22 /**
  23  * @file                mm_sound.h
  24  * @brief               Application interface library for sound module.
  25  * @date
  26  * @version             Release
  27  *
  28  * Application interface library for sound module.
  29  */
  30
  31 #ifndef __MM_SOUND_H__
  32 #define __MM_SOUND_H__
  33
  34 #include <mm_types.h>
  35 #include <mm_error.h>
  36 #include <mm_message.h>
  37
  38 #ifdef __cplusplus
  39         extern "C" {
  40 #endif
  41
  42 /**
  43         @addtogroup SOUND
  44         @{
  45         @par
  46         This part is describes the sound module of multimedia framework. Sound
  47         module provides APIs to implement play wav file with simple api, to handle volume information,
  48         to handle audio route policy.
  49
  50         @par
  51         There is six different volume type for normal usage. application should set proper volume type to multimedia playback APIs.
  52         <div> <table>
  53         <tr>
  54         <td><B>Type</B></td>
  55         <td><B>Description</B></td>
  56         </tr>
  57         <tr>
  58         <td>VOLUME_TYPE_SYSTEM</td>
  59         <td>volume for normal system sound (e.g. keysound, camera shutter)</td>
  60         </tr>
  61         <tr>
  62         <td>VOLUME_TYPE_NOTIFICATION</td>
  63         <td>volume for notification (e.g. message, email notification)</td>
  64         </tr>
  65         <tr>
  66         <td>VOLUME_TYPE_RINGTONE</td>
  67         <td>volume for incoming call ring</td>
  68         </tr>
  69         <tr>
  70         <td>VOLUME_TYPE_MEDIA</td>
  71         <td>volume for media playback (e.g. music, video playback)</td>
  72         </tr>
  73         <tr>
  74         <td>VOLUME_TYPE_CALL</td>
  75         <td>volume for call</td>
  76         </tr>
  77         </table> </div>
  78
  79         @par
  80         application can change audio route policy with mm-sound API.
  81         Audio route is input and output of audio stream.
  82
  83         @par
  84         @image html             audio_device.png        "Figure1. Audio Devices of mobile phone"        width=12cm
  85         @image latex    audio_device.png        "Figure1. Audio Devices of mobile phone"        width=12cm
  86
  87         @par
  88         Default audio route policy is like follows
  89         @par
  90         for playback
  91         <div><table>
  92         <tr>
  93         <td><B>Bluetooth headset</B></td>
  94         <td><B>Wired headset</B></td>
  95         <td><B>Playback Device</B></td>
  96         </tr>
  97         <tr>
  98         <td>connected</td>
  99         <td>plugged</td>
 100         <td>Bluetooth headset</td>
 101         </tr>
 102         <tr>
 103         <td>connected</td>
 104         <td>unplugged</td>
 105         <td>Bluetooth headset</td>
 106         </tr>
 107         <tr>
 108         <td>disconnected</td>
 109         <td>plugged</td>
 110         <td>Wired headset</td>
 111         </tr>
 112         <tr>
 113         <td>disconnected</td>
 114         <td>unplugged</td>
 115         <td>Loud speaker</td>
 116         </tr>
 117         </table></div>
 118
 119         @par
 120         for capture (bluetooth headset mic used only in call mode)
 121         <div><table>
 122         <tr>
 123         <td><B>Bluetooth headset mic</B></td>
 124         <td><B>Wired headset mic</B></td>
 125         <td><B>Capture Device</B></td>
 126         </tr>
 127         <tr>
 128         <td>connected</td>
 129         <td>plugged</td>
 130         <td>Wired headset mic</td>
 131         </tr>
 132         <tr>
 133         <td>connected</td>
 134         <td>unplugged</td>
 135         <td>microphone</td>
 136         </tr>
 137         <tr>
 138         <td>disconnected</td>
 139         <td>plugged</td>
 140         <td>Wired headset mic</td>
 141         </tr>
 142         <tr>
 143         <td>disconnected</td>
 144         <td>unplugged</td>
 145         <td>Wired headset mic</td>
 146         </tr>
 147         </table></div>
 148
 149         @par
 150         If application changes routing policy to SYSTEM_AUDIO_ROUTE_POLICY_IGNORE_A2DP with mm_sound_route_set_system_policy
 151         audio routing policy has changed to ignore bluetooth headset connection.
 152         @par
 153         for playback
 154         <div><table>
 155         <tr>
 156         <td><B>Bluetooth headset</B></td>
 157         <td><B>Wired headset</B></td>
 158         <td><B>Playback Device</B></td>
 159         </tr>
 160         <tr>
 161         <td>connected</td>
 162         <td>plugged</td>
 163         <td>Wired headset</td>
 164         </tr>
 165         <tr>
 166         <td>connected</td>
 167         <td>unplugged</td>
 168         <td>Loud speaker</td>
 169         </tr>
 170         <tr>
 171         <td>disconnected</td>
 172         <td>plugged</td>
 173         <td>Wired headset</td>
 174         </tr>
 175         <tr>
 176         <td>disconnected</td>
 177         <td>unplugged</td>
 178         <td>Loud speaker</td>
 179         </tr>
 180         </table></div>
 181
 182         @par
 183         for capture (bluetooth headset mic used only in call mode)
 184         <div><table>
 185         <tr>
 186         <td><B>Bluetooth headset mic</B></td>
 187         <td><B>Wired headset mic</B></td>
 188         <td><B>Capture Device</B></td>
 189         </tr>
 190         <tr>
 191         <td>connected</td>
 192         <td>plugged</td>
 193         <td>Wired headset mic</td>
 194         </tr>
 195         <tr>
 196         <td>connected</td>
 197         <td>unplugged</td>
 198         <td>microphone</td>
 199         </tr>
 200         <tr>
 201         <td>disconnected</td>
 202         <td>plugged</td>
 203         <td>Wired headset mic</td>
 204         </tr>
 205         <tr>
 206         <td>disconnected</td>
 207         <td>unplugged</td>
 208         <td>Wired headset mic</td>
 209         </tr>
 210         </table></div>
 211
 212         @par
 213         If application changes routing policy to SYSTEM_AUDIO_ROUTE_POLICY_HANDSET_ONLY with mm_sound_route_set_system_policy
 214         audio routing policy has changed to use only loud speaker and microphone.
 215         @par
 216         for playback
 217         <div><table>
 218         <tr>
 219         <td><B>Bluetooth headset</B></td>
 220         <td><B>Wired headset</B></td>
 221         <td><B>Playback Device</B></td>
 222         </tr>
 223         <tr>
 224         <td>connected</td>
 225         <td>plugged</td>
 226         <td>Loud speaker</td>
 227         </tr>
 228         <tr>
 229         <td>connected</td>
 230         <td>unplugged</td>
 231         <td>Loud speaker</td>
 232         </tr>
 233         <tr>
 234         <td>disconnected</td>
 235         <td>plugged</td>
 236         <td>Loud speaker</td>
 237         </tr>
 238         <tr>
 239         <td>disconnected</td>
 240         <td>unplugged</td>
 241         <td>Loud speaker</td>
 242         </tr>
 243         </table></div>
 244
 245         @par
 246         for capture (bluetooth headset mic used only in call mode)
 247         <div><table>
 248         <tr>
 249         <td><B>Bluetooth headset mic</B></td>
 250         <td><B>Wired headset mic</B></td>
 251         <td><B>Capture Device</B></td>
 252         </tr>
 253         <tr>
 254         <td>connected</td>
 255         <td>plugged</td>
 256         <td>microphone</td>
 257         </tr>
 258         <tr>
 259         <td>connected</td>
 260         <td>unplugged</td>
 261         <td>microphone</td>
 262         </tr>
 263         <tr>
 264         <td>disconnected</td>
 265         <td>plugged</td>
 266         <td>microphone</td>
 267         </tr>
 268         <tr>
 269         <td>disconnected</td>
 270         <td>unplugged</td>
 271         <td>microphone</td>
 272         </tr>
 273         </table></div>
 274
 275  */
 276 #define MM_SOUND_STREAM_TYPE_LEN 64
 277
 278 /*
 279  * MMSound Volume APIs
 280  */
 281
 282 /**
 283  * Enumerations of Volume type.
 284  */
 285
 286 typedef enum {
 287         VOLUME_TYPE_SYSTEM,                             /**< System volume type */
 288         VOLUME_TYPE_NOTIFICATION,               /**< Notification volume type */
 289         VOLUME_TYPE_ALARM,                              /**< Alarm volume type */
 290         VOLUME_TYPE_RINGTONE,                   /**< Ringtone volume type */
 291         VOLUME_TYPE_MEDIA,                              /**< Media volume type */
 292         VOLUME_TYPE_CALL,                               /**< Call volume type */
 293         VOLUME_TYPE_VOIP,                               /**< VOIP volume type */
 294         VOLUME_TYPE_VOICE,                              /**< VOICE volume type */
 295         VOLUME_TYPE_FIXED,                              /**< Volume type for fixed acoustic level */
 296         VOLUME_TYPE_MAX,                                /**< Volume type count */
 297         VOLUME_TYPE_UNKNOWN = -1,       /**< volume type is not determined */
 298 } volume_type_t;
 299
 300 typedef enum {
 301         VOLUME_GAIN_DEFAULT             = 0,
 302         VOLUME_GAIN_DIALER              = 1<<8,
 303         VOLUME_GAIN_TOUCH               = 2<<8,
 304         VOLUME_GAIN_AF                  = 3<<8,
 305         VOLUME_GAIN_SHUTTER1    = 4<<8,
 306         VOLUME_GAIN_SHUTTER2    = 5<<8,
 307         VOLUME_GAIN_CAMCORDING  = 6<<8,
 308         VOLUME_GAIN_MIDI                = 7<<8,
 309         VOLUME_GAIN_BOOTING             = 8<<8,
 310         VOLUME_GAIN_VIDEO               = 9<<8,
 311         VOLUME_GAIN_TTS                 = 10<<8,
 312 } volume_gain_t;
 313
 314 /**
 315  * @brief Enumerations of supporting source_type
 316  */
 317 typedef enum {
 318     SUPPORT_SOURCE_TYPE_DEFAULT,
 319     SUPPORT_SOURCE_TYPE_MIRRORING,
 320     SUPPORT_SOURCE_TYPE_VOICECONTROL,
 321     SUPPORT_SOURCE_TYPE_SVR,
 322     SUPPORT_SOURCE_TYPE_VIDEOCALL,
 323     SUPPORT_SOURCE_TYPE_VOICERECORDING,
 324     SUPPORT_SOURCE_TYPE_VOIP, /* Supporting VoIP source*/
 325     SUPPORT_SOURCE_TYPE_CALL_FORWARDING,
 326     SUPPORT_SOURCE_TYPE_FMRADIO,
 327     SUPPORT_SOURCE_TYPE_LOOPBACK,
 328 } mm_sound_source_type_e;
 329
 330 /**
 331  * Active volume change callback function type.
 332  *
 333  * @param       type                    [in]    The sound type of changed volume
 334  * @param       volume                  [in]    The new volume value
 335  * @param       user_data               [in]    Argument passed when callback has called
 336  *
 337  * @return      No return value
 338  * @remark      None.
 339  * @see         mm_sound_add_volume_changed_callback mm_sound_remove_volume_changed_callback
 340  */
 341 typedef void (*mm_sound_volume_changed_cb) (volume_type_t type, unsigned int volume, void *user_data);
 342
 343
 344
 345
 346 int mm_sound_add_volume_changed_callback(mm_sound_volume_changed_cb func, void* user_data, unsigned int *id);
 347
 348
 349 /**
 350  * This function is to remove volume changed callback.
 351  *
 352  * @param       type                    [in]    volume type to set change callback function
 353  *
 354  * @return      This function returns MM_ERROR_NONE on success, or negative value
 355  *                      with error code.
 356  * @remark      None.
 357  * @pre         Callback function should be registered previously for given volume type.
 358  * @post        Callback function will not be called anymore.
 359  * @see         volume_type_t
 360  * @par Example
 361  * @code
 362 void _volume_callback(void *data)
 363 {
 364         printf("Callback function\n");
 365 }
 366
 367 int volume_callback()
 368 {
 369         int ret = 0;
 370         int vol_type = VOLUME_TYPE_MEDIA;
 371
 372         mm_sound_volume_add_callback(vol_type, _volume_callback, NULL);
 373
 374         ret = mm_sound_volume_remove_callback(vol_type);
 375         if ( MM_ERROR_NONE == ret)
 376         {
 377                 printf("Remove callback success\n");
 378         }
 379         else
 380         {
 381                 printf("Remove callback failed\n");
 382         }
 383
 384         return ret;
 385 }
 386
 387  * @endcode
 388  */
 389 int mm_sound_volume_remove_callback(volume_type_t type);
 390
 391 /**
 392  * This function is to remove volume change callback.
 393  *
 394  * @return      This function returns MM_ERROR_NONE on success, or negative value
 395  *                      with error code.
 396  **/
 397 int mm_sound_remove_volume_changed_callback(unsigned int id);
 398
 399 /**
 400  * This function is to set volume level of certain volume type.
 401  *
 402  * @param       type                    [in]    volume type to set value.
 403  * @param       value                   [in]    volume value.
 404  *
 405  * @return      This function returns MM_ERROR_NONE on success, or negative value
 406  *                      with error code.
 407  * @remark      value should be 0 ~ MAX
 408  * @see         mm_sound_volume_get_value volume_type_t
 409  * @pre         None.
 410  * @post        Volume value will be changed to given value for given volume type.
 411  * @par Example
 412  */
 413 int mm_sound_volume_set_value(volume_type_t type, const unsigned int volume_level);
 414
 415
 416 /**
 417  * This function is to get volume level of certain volume type.
 418  *
 419  * @param       type                    [in]    volume type to get value.
 420  * @param       value                   [out]   volume value.
 421  *
 422  * @return      This function returns MM_ERROR_NONE on success, or negative value
 423  *                      with error code.
 424  * @remark      None.
 425  * @pre         None.
 426  * @post        None.
 427  * @see         volume_type_t mm_sound_volume_set_value
 428  * @par Example
 429  * @code
 430 int value = 0;
 431 int ret = 0;
 432
 433 ret = mm_sound_volume_get_value(VOLUME_TYPE_SYSTEM, &value);
 434 if(ret < 0)
 435 {
 436         printf("Can not get volume\n");
 437 }
 438 else
 439 {
 440         printf("System type volume is %d\n", value);
 441 }
 442  * @endcode
 443  * @see         mm_sound_volume_set_value
 444  */
 445 int mm_sound_volume_get_value(volume_type_t type, unsigned int *value);
 446
 447
 448
 449 /**
 450  * This function is to set primary volume type.
 451  *
 452  * @param       type                    [in]    volume type to set as primary volume type.
 453  *
 454  * @return      This function returns MM_ERROR_NONE on success, or negative value
 455  *                      with error code.
 456  * @remark      Application should use this function during foreground.
 457  * @pre         None.
 458  * @post        Volume app. will be update given volume type when H/W volume control key pressed.
 459  * @see         volume_type_t
 460  * @par Example
 461  * @code
 462 static int _resume(void *data)
 463 {
 464         int ret = 0;
 465
 466         ret = mm_sound_volume_primary_type_set(VOLUME_TYPE_MEDIA);
 467         if(ret < 0)
 468         {
 469                 printf("Can not set primary volume type\n");
 470         }
 471         ...
 472 }
 473
 474 static int _pause(void* data)
 475 {
 476         int ret = 0;
 477
 478         ret = mm_sound_volume_primary_type_set(VOLUME_TYPE_UNKNOWN);
 479         if(ret < 0)
 480         {
 481                 printf("Can not clear primary volume type\n");
 482         }
 483         ...
 484 }
 485
 486 int main()
 487 {
 488         ...
 489         struct appcore_ops ops = {
 490                 .create = _create,
 491                 .terminate = _terminate,
 492                 .pause = _pause,
 493                 .resume = _resume,
 494                 .reset = _reset,
 495         };
 496         ...
 497         return appcore_efl_main(PACKAGE, ..., &ops);
 498 }
 499  * @endcode
 500  */
 501 int mm_sound_volume_primary_type_set(volume_type_t type);
 502 int mm_sound_volume_primary_type_get(volume_type_t *type);
 503
 504 /**
 505  * Terminate callback function type.
 506  *
 507  * @param       data            [in]    Argument passed when callback was set
 508  * @param       id              [in]    handle which has completed playing
 509  *
 510  * @return      No return value
 511  * @remark      It is not allowed to call MMSound API recursively or do time-consuming
 512  *                      task in this callback because this callback is called synchronously.
 513  * @see         mm_sound_play_sound
 514  */
 515 typedef void (*mm_sound_stop_callback_func) (void *data, int id);
 516
 517 /*
 518  * MMSound Play APIs
 519  */
 520
 521 /**
 522  * This function is to play system sound.
 523  *
 524  * @param       filename                [in] Sound filename to play
 525  * @param       volume config   [in] Volume type & volume gain
 526  * @param       callback                [in] Callback function pointer when playing is terminated.
 527  * @param       data                    [in] Pointer to user data when callback is called.
 528  * @param       handle                  [out] Handle of sound play.
 529  *
 530  * @return      This function returns MM_ERROR_NONE on success, or negative value
 531  *                      with error code.
 532  * @remark      When the stop callback is set, it will be called when system sound is
 533  *                      terminated. If mm_sound_stop_sound() is called apparently before
 534  *                      system sound is terminated, stop_callback will not be called.
 535  * @see         mm_sound_stop_sound mm_sound_stop_callback_func volume_type_t volume_gain_t
 536  * @pre         None.
 537  * @post        Sound will be generated with given filename.
 538  * @par Example
 539  * @code
 540 int g_stop=0;
 541 void _stop_callback(void* data)
 542 {
 543         printf("Stop callback\n");
 544         g_stop = 1;
 545 }
 546
 547 int play_file()
 548 {
 549         char filename[] ="testfile.wav";
 550         volume_type_t volume = VOLUME_TYPE_SYSTEM;
 551         int ret = 0;
 552         int handle = -1;
 553
 554         ret = mm_sound_play_sound(filename, volume, _stop_callback, NULL, &handle);
 555         if(ret < 0)
 556         {
 557                 printf("play file failed\n");
 558         }
 559         else
 560         {
 561                 printf("play file success\n");
 562         }
 563         while(g_stop == 0)
 564         {
 565                 sleep(1);
 566         }
 567         printf("play stopped\n");
 568         return 0;
 569 }
 570  * @endcode
 571  */
 572 int mm_sound_play_sound(const char *filename, int volume_config, mm_sound_stop_callback_func callback, void *data, int *handle);
 573
 574 /**
 575  * This function is to play system sound. And other audio stream will be mute during playing time
 576  *
 577  * @param       filename                [in] Sound filename to play
 578  * @param       volume config   [in] Volume type & volume gain
 579  * @param       callback                [in] Callback function pointer when playing is terminated.
 580  * @param       data                    [in] Pointer to user data when callback is called.
 581  * @param       handle                  [out] Handle of sound play.
 582  *
 583  * @return      This function returns MM_ERROR_NONE on success, or negative value
 584  *                      with error code.
 585  * @remark      This function is almost same with mm_sound_play_sound,
 586  *                      but this make other audio playback stream to mute during playing time.
 587  * @see         mm_sound_stop_sound mm_sound_stop_callback_func volume_type_t volume_gain_t
 588  * @pre         None.
 589  * @post        Sound will be generated with given filename.
 590  * @par Example
 591  * @code
 592 int g_stop=0;
 593 void _stop_callback(void* data)
 594 {
 595         printf("Stop callback\n");
 596         g_stop = 1;
 597 }
 598
 599 int play_file()
 600 {
 601         char filename[] ="testfile.wav";
 602         volume_type_t volume = VOLUME_TYPE_SYSTEM;
 603         int ret = 0;
 604         int handle = -1;
 605
 606         ret = mm_sound_play_loud_solo_sound(filename, volume, _stop_callback, NULL, &handle);
 607         if(ret < 0)
 608         {
 609                 printf("play file failed\n");
 610         }
 611         else
 612         {
 613                 printf("play file success\n");
 614         }
 615         while(g_stop == 0)
 616         {
 617                 sleep(1);
 618         }
 619         printf("play stopped\n");
 620         return 0;
 621 }
 622  * @endcode
 623  */
 624 int mm_sound_play_loud_solo_sound(const char *filename, int volume_config, mm_sound_stop_callback_func callback, void *data, int *handle);
 625
 626 /**
 627  * This function is to stop playing system sound.
 628  *
 629  * @param       handle  [in] Handle of mm_sound_play_sound
 630  *
 631  * @return      This function returns MM_ERROR_NONE on success, or negative value
 632  *                      with error code.
 633  *
 634  * @remark      When system sound is terminated with this function call, it does not
 635  *                      call stop callback which was set when start playing system sound.
 636  * @see         mm_sound_play_sound
 637  * @pre         An sound play handle should be valid.
 638  * @post        Playing sound file will be stopped.
 639  * @par Example
 640  * @code
 641 int g_stop=0;
 642 void _stop_callback(void* data)
 643 {
 644         printf("Stop callback\n");
 645         g_stop = 1;
 646 }
 647
 648 int play_file_one_second()
 649 {
 650         char filename[] ="testfile.wav";
 651         volume_type_t volume = VOLUME_TYPE_SYSTEM;
 652         int ret = 0;
 653         int handle = -1;
 654
 655         ret = mm_sound_play_sound(filename, volume, _stop_callback, NULL, &handle);
 656         if(ret < 0)
 657         {
 658                 printf("play file failed\n");
 659         }
 660         else
 661         {
 662                 printf("play file success\n");
 663         }
 664
 665         sleep(1); //wait 1 second
 666
 667         ret = mm_sound_stop_sound(handle);
 668         if(ret < 0)
 669         {
 670                 printf("stop failed\n");
 671         }
 672         else
 673         {
 674                 printf("play stopped\n");
 675         }
 676         return 0;
 677 }
 678  * @endcode
 679  */
 680 int mm_sound_stop_sound(int handle);
 681
 682
 683 /**
 684  * Enumerations for TONE
 685  */
 686
 687 typedef enum  {
 688         MM_SOUND_TONE_DTMF_0 = 0,                       /**< Predefined DTMF 0 */
 689         MM_SOUND_TONE_DTMF_1,                           /**< Predefined DTMF 1 */
 690         MM_SOUND_TONE_DTMF_2,                           /**< Predefined DTMF 2 */
 691         MM_SOUND_TONE_DTMF_3,                           /**< Predefined DTMF 3 */
 692         MM_SOUND_TONE_DTMF_4,                           /**< Predefined DTMF 4 */
 693         MM_SOUND_TONE_DTMF_5,                           /**< Predefined DTMF 5 */
 694         MM_SOUND_TONE_DTMF_6,                           /**< Predefined DTMF 6 */
 695         MM_SOUND_TONE_DTMF_7,                           /**< Predefined DTMF 7 */
 696         MM_SOUND_TONE_DTMF_8,                           /**< Predefined DTMF 8 */
 697         MM_SOUND_TONE_DTMF_9,                           /**< Predefined DTMF 9 */
 698         MM_SOUND_TONE_DTMF_S,                           /**< Predefined DTMF Star - Asterisk (*) */
 699         MM_SOUND_TONE_DTMF_P,                           /**< Predefined DTMF sharP (#) */
 700         MM_SOUND_TONE_DTMF_A,                           /**< Predefined DTMF A (A) */
 701         MM_SOUND_TONE_DTMF_B,                           /**< Predefined DTMF B (B) */
 702         MM_SOUND_TONE_DTMF_C,                           /**< Predefined DTMF C (C) */
 703         MM_SOUND_TONE_DTMF_D,                           /**< Predefined DTMF D (D) */
 704
 705         /**< Pre-defined TONE */
 706         MM_SOUND_TONE_SUP_DIAL,                                 /**Call supervisory tone, Dial tone: CEPT: 425Hz, continuous */
 707         MM_SOUND_TONE_ANSI_DIAL,                                /**Call supervisory tone, Dial tone: ANSI (IS-95): 350Hz+440Hz, continuous */
 708         MM_SOUND_TONE_JAPAN_DIAL,                               /**Call supervisory tone, Dial tone: JAPAN: 400Hz, continuous*/
 709         MM_SOUND_TONE_SUP_BUSY,                         /**Call supervisory tone, Busy: CEPT: 425Hz, 500ms ON, 500ms OFF... */
 710         MM_SOUND_TONE_ANSI_BUSY,                                /**Call supervisory tone, Busy: ANSI (IS-95): 480Hz+620Hz, 500ms ON, 500ms OFF... */
 711         MM_SOUND_TONE_JAPAN_BUSY,                               /**Call supervisory tone, Busy: JAPAN: 400Hz, 500ms ON, 500ms OFF...*/
 712         MM_SOUND_TONE_SUP_CONGESTION,           /**Call supervisory tone, Congestion: CEPT, JAPAN: 425Hz, 200ms ON, 200ms OFF */
 713         MM_SOUND_TONE_ANSI_CONGESTION,          /**Call supervisory tone, Congestion: ANSI (IS-95): 480Hz+620Hz, 250ms ON, 250ms OFF... */
 714         MM_SOUND_TONE_SUP_RADIO_ACK,                    /**Call supervisory tone, Radio path acknowlegment : CEPT, ANSI: 425Hz, 200ms ON  */
 715         MM_SOUND_TONE_JAPAN_RADIO_ACK,          /**Call supervisory tone, Radio path acknowlegment : JAPAN: 400Hz, 1s ON, 2s OFF...*/
 716         MM_SOUND_TONE_SUP_RADIO_NOTAVAIL,               /**Call supervisory tone, Radio path not available: 425Hz, 200ms ON, 200 OFF 3 bursts */
 717         MM_SOUND_TONE_SUP_ERROR,                                /**Call supervisory tone, Error/Special info: 950Hz+1400Hz+1800Hz, 330ms ON, 1s OFF... */
 718         MM_SOUND_TONE_SUP_CALL_WAITING,         /**Call supervisory tone, Call Waiting: CEPT, JAPAN: 425Hz, 200ms ON, 600ms OFF, 200ms ON, 3s OFF...  */
 719         MM_SOUND_TONE_ANSI_CALL_WAITING,                /**Call supervisory tone, Call Waiting: ANSI (IS-95): 440 Hz, 300 ms ON, 9.7 s OFF, (100 ms ON, 100 ms OFF, 100 ms ON, 9.7s OFF ...) */
 720         MM_SOUND_TONE_SUP_RINGTONE,                     /**Call supervisory tone, Ring Tone: CEPT, JAPAN: 425Hz, 1s ON, 4s OFF... */
 721         MM_SOUND_TONE_ANSI_RINGTONE,                    /**Call supervisory tone, Ring Tone: ANSI (IS-95): 440Hz + 480Hz, 2s ON, 4s OFF... */
 722         MM_SOUND_TONE_PROP_BEEP,                                /**General beep: 400Hz+1200Hz, 35ms ON */
 723         MM_SOUND_TONE_PROP_ACK,                                 /**Proprietary tone, positive acknowlegement: 1200Hz, 100ms ON, 100ms OFF 2 bursts */
 724         MM_SOUND_TONE_PROP_NACK,                                /**Proprietary tone, negative acknowlegement: 300Hz+400Hz+500Hz, 400ms ON */
 725         MM_SOUND_TONE_PROP_PROMPT,                      /**Proprietary tone, prompt tone: 400Hz+1200Hz, 200ms ON         */
 726         MM_SOUND_TONE_PROP_BEEP2,                               /**Proprietary tone, general double beep: twice 400Hz+1200Hz, 35ms ON, 200ms OFF, 35ms ON */
 727         MM_SOUND_TONE_SUP_INTERCEPT,                                            /**Call supervisory tone (IS-95), intercept tone: alternating 440 Hz and 620 Hz tones, each on for 250 ms */
 728         MM_SOUND_TONE_SUP_INTERCEPT_ABBREV,                             /**Call supervisory tone (IS-95), abbreviated intercept: intercept tone limited to 4 seconds */
 729         MM_SOUND_TONE_SUP_CONGESTION_ABBREV,                            /**Call supervisory tone (IS-95), abbreviated congestion: congestion tone limited to 4 seconds */
 730         MM_SOUND_TONE_SUP_CONFIRM,                                              /**Call supervisory tone (IS-95), confirm tone: a 350 Hz tone added to a 440 Hz tone repeated 3 times in a 100 ms on, 100 ms off cycle */
 731         MM_SOUND_TONE_SUP_PIP,                                                  /**Call supervisory tone (IS-95), pip tone: four bursts of 480 Hz tone (0.1 s on, 0.1 s off). */
 732         MM_SOUND_TONE_CDMA_DIAL_TONE_LITE,                              /**425Hz continuous */
 733         MM_SOUND_TONE_CDMA_NETWORK_USA_RINGBACK,                /**CDMA USA Ringback: 440Hz+480Hz 2s ON, 4000 OFF ...*/
 734         MM_SOUND_TONE_CDMA_INTERCEPT,                                   /**CDMA Intercept tone: 440Hz 250ms ON, 620Hz 250ms ON ...*/
 735         MM_SOUND_TONE_CDMA_ABBR_INTERCEPT,                              /**CDMA Abbr Intercept tone: 440Hz 250ms ON, 620Hz 250ms ON */
 736         MM_SOUND_TONE_CDMA_REORDER,                                             /**CDMA Reorder tone: 480Hz+620Hz 250ms ON, 250ms OFF... */
 737         MM_SOUND_TONE_CDMA_ABBR_REORDER,                                /**CDMA Abbr Reorder tone: 480Hz+620Hz 250ms ON, 250ms OFF repeated for 8 times */
 738         MM_SOUND_TONE_CDMA_NETWORK_BUSY,                                /**CDMA Network Busy tone: 480Hz+620Hz 500ms ON, 500ms OFF continuous */
 739         MM_SOUND_TONE_CDMA_CONFIRM,                                             /**CDMA Confirm tone: 350Hz+440Hz 100ms ON, 100ms OFF repeated for 3 times */
 740         MM_SOUND_TONE_CDMA_ANSWER,                                              /**CDMA answer tone: silent tone - defintion Frequency 0, 0ms ON, 0ms OFF */
 741         MM_SOUND_TONE_CDMA_NETWORK_CALLWAITING,                         /**CDMA Network Callwaiting tone: 440Hz 300ms ON */
 742         MM_SOUND_TONE_CDMA_PIP,                                                         /**CDMA PIP tone: 480Hz 100ms ON, 100ms OFF repeated for 4 times */
 743         MM_SOUND_TONE_CDMA_CALL_SIGNAL_ISDN_NORMAL,             /**ISDN Call Signal Normal tone: {2091Hz 32ms ON, 2556 64ms ON} 20 times, 2091 32ms ON, 2556 48ms ON, 4s OFF */
 744         MM_SOUND_TONE_CDMA_CALL_SIGNAL_ISDN_INTERGROUP,         /**ISDN Call Signal Intergroup tone: {2091Hz 32ms ON, 2556 64ms ON} 8 times, 2091Hz 32ms ON, 400ms OFF, {2091Hz 32ms ON, 2556Hz 64ms ON} 8times, 2091Hz 32ms ON, 4s OFF.*/
 745         MM_SOUND_TONE_CDMA_CALL_SIGNAL_ISDN_SP_PRI,             /**ISDN Call Signal SP PRI tone:{2091Hz 32ms ON, 2556 64ms ON} 4 times 2091Hz 16ms ON, 200ms OFF, {2091Hz 32ms ON, 2556Hz 64ms ON} 4 times, 2091Hz 16ms ON, 200ms OFF */
 746         MM_SOUND_TONE_CDMA_CALL_SIGNAL_ISDN_PAT3,               /**SDN Call sign PAT3 tone: silent tone */
 747         MM_SOUND_TONE_CDMA_CALL_SIGNAL_ISDN_PING_RING,  /**ISDN Ping Ring tone: {2091Hz 32ms ON, 2556Hz 64ms ON} 5 times 2091Hz 20ms ON */
 748         MM_SOUND_TONE_CDMA_CALL_SIGNAL_ISDN_PAT5,               /**ISDN Pat5 tone: silent tone */
 749         MM_SOUND_TONE_CDMA_CALL_SIGNAL_ISDN_PAT6,               /**ISDN Pat6 tone: silent tone */
 750         MM_SOUND_TONE_CDMA_CALL_SIGNAL_ISDN_PAT7,               /**ISDN Pat7 tone: silent tone */
 751         MM_SOUND_TONE_CDMA_HIGH_L,                                              /**TONE_CDMA_HIGH_L tone: {3700Hz 25ms, 4000Hz 25ms} 40 times 4000ms OFF, Repeat .... */
 752         MM_SOUND_TONE_CDMA_MED_L,                                               /**TONE_CDMA_MED_L tone: {2600Hz 25ms, 2900Hz 25ms} 40 times 4000ms OFF, Repeat .... */
 753         MM_SOUND_TONE_CDMA_LOW_L,                                               /**TONE_CDMA_LOW_L tone: {1300Hz 25ms, 1450Hz 25ms} 40 times, 4000ms OFF, Repeat .... */
 754         MM_SOUND_TONE_CDMA_HIGH_SS,                                             /**CDMA HIGH SS tone: {3700Hz 25ms, 4000Hz 25ms} repeat 16 times, 400ms OFF, repeat .... */
 755         MM_SOUND_TONE_CDMA_MED_SS,                                              /**CDMA MED SS tone: {2600Hz 25ms, 2900Hz 25ms} repeat 16 times, 400ms OFF, repeat .... */
 756         MM_SOUND_TONE_CDMA_LOW_SS,                                              /**CDMA LOW SS tone: {1300z 25ms, 1450Hz 25ms} repeat 16 times, 400ms OFF, repeat .... */
 757         MM_SOUND_TONE_CDMA_HIGH_SSL,                                            /**CDMA HIGH SSL tone: {3700Hz 25ms, 4000Hz 25ms} 8 times, 200ms OFF, {3700Hz 25ms, 4000Hz 25ms} repeat 8 times, 200ms OFF, {3700Hz 25ms, 4000Hz 25ms} repeat 16 times, 4000ms OFF, repeat ... */
 758         MM_SOUND_TONE_CDMA_MED_SSL,                                             /**CDMA MED SSL tone: {2600Hz 25ms, 2900Hz 25ms} 8 times, 200ms OFF, {2600Hz 25ms, 2900Hz 25ms} repeat 8 times, 200ms OFF, {2600Hz 25ms, 2900Hz 25ms} repeat 16 times, 4000ms OFF, repeat ... */
 759         MM_SOUND_TONE_CDMA_LOW_SSL,                                             /**CDMA LOW SSL tone: {1300Hz 25ms, 1450Hz 25ms} 8 times, 200ms OFF, {1300Hz 25ms, 1450Hz 25ms} repeat 8 times, 200ms OFF, {1300Hz 25ms, 1450Hz 25ms} repeat 16 times, 4000ms OFF, repeat ... */
 760         MM_SOUND_TONE_CDMA_HIGH_SS_2,                                   /**CDMA HIGH SS2 tone: {3700Hz 25ms, 4000Hz 25ms} 20 times, 1000ms OFF, {3700Hz 25ms, 4000Hz 25ms} 20 times, 3000ms OFF, repeat .... */
 761         MM_SOUND_TONE_CDMA_MED_SS_2,                                            /**CDMA MED SS2 tone: {2600Hz 25ms, 2900Hz 25ms} 20 times, 1000ms OFF, {2600Hz 25ms, 2900Hz 25ms} 20 times, 3000ms OFF, repeat .... */
 762         MM_SOUND_TONE_CDMA_LOW_SS_2,                                            /**CDMA LOW SS2 tone: {1300Hz 25ms, 1450Hz 25ms} 20 times, 1000ms OFF, {1300Hz 25ms, 1450Hz 25ms} 20 times, 3000ms OFF, repeat .... */
 763         MM_SOUND_TONE_CDMA_HIGH_SLS,                                            /**CDMA HIGH SLS tone: {3700Hz 25ms, 4000Hz 25ms} 10 times, 500ms OFF, {3700Hz 25ms, 4000Hz 25ms} 20 times, 500ms OFF, {3700Hz 25ms, 4000Hz 25ms} 10 times, 3000ms OFF, REPEAT */
 764         MM_SOUND_TONE_CDMA_MED_SLS,                                             /**CDMA MED SLS tone: {2600Hz 25ms, 2900Hz 25ms} 10 times, 500ms OFF, {2600Hz 25ms, 2900Hz 25ms} 20 times, 500ms OFF, {2600Hz 25ms, 2900Hz 25ms} 10 times, 3000ms OFF, REPEAT */
 765         MM_SOUND_TONE_CDMA_LOW_SLS,                                             /**CDMA LOW SLS tone: {1300Hz 25ms, 1450Hz 25ms} 10 times, 500ms OFF, {1300Hz 25ms, 1450Hz 25ms} 20 times, 500ms OFF, {1300Hz 25ms, 1450Hz 25ms} 10 times, 3000ms OFF, REPEAT */
 766         MM_SOUND_TONE_CDMA_HIGH_S_X4,                                   /**CDMA HIGH S X4 tone: {3700Hz 25ms, 4000Hz 25ms} 10 times, 500ms OFF, {3700Hz 25ms, 4000Hz 25ms} 10 times, 500ms OFF, {3700Hz 25ms, 4000Hz 25ms} 10 times, 500ms OFF, {3700Hz 25ms, 4000Hz 25ms} 10 times, 2500ms OFF, REPEAT.... */
 767         MM_SOUND_TONE_CDMA_MED_S_X4,                                            /**CDMA MED S X4 tone: {2600Hz 25ms, 2900Hz 25ms} 10 times, 500ms OFF, {2600Hz 25ms, 2900Hz 25ms} 10 times, 500ms OFF, {2600Hz 25ms, 2900Hz 25ms} 10 times, 500ms OFF, {2600Hz 25ms, 2900Hz 25ms} 10 times, 2500ms OFF, REPEAT.... */
 768         MM_SOUND_TONE_CDMA_LOW_S_X4,                                            /**CDMA LOW S X4 tone: {2600Hz 25ms, 2900Hz 25ms} 10 times, 500ms OFF, {2600Hz 25ms, 2900Hz 25ms} 10 times, 500ms OFF, {2600Hz 25ms, 2900Hz 25ms} 10 times, 500ms OFF, {2600Hz 25ms, 2900Hz 25ms} 10 times, 2500ms OFF, REPEAT....*/
 769         MM_SOUND_TONE_CDMA_HIGH_PBX_L,                                  /**CDMA HIGH PBX L: {3700Hz 25ms, 4000Hz 25ms}20 times, 2000ms OFF, REPEAT.... */
 770         MM_SOUND_TONE_CDMA_MED_PBX_L,                                   /**CDMA MED PBX L: {2600Hz 25ms, 2900Hz 25ms}20 times, 2000ms OFF, REPEAT.... */
 771         MM_SOUND_TONE_CDMA_LOW_PBX_L,                                   /**CDMA LOW PBX L: {1300Hz 25ms,1450Hz 25ms}20 times, 2000ms OFF, REPEAT.... */
 772         MM_SOUND_TONE_CDMA_HIGH_PBX_SS,                                         /**CDMA HIGH PBX SS tone: {3700Hz 25ms, 4000Hz 25ms} 8 times 200 ms OFF, {3700Hz 25ms 4000Hz 25ms}8 times, 2000ms OFF, REPEAT.... */
 773         MM_SOUND_TONE_CDMA_MED_PBX_SS,                                  /**CDMA MED PBX SS tone: {2600Hz 25ms, 2900Hz 25ms} 8 times 200 ms OFF, {2600Hz 25ms 2900Hz 25ms}8 times, 2000ms OFF, REPEAT.... */
 774         MM_SOUND_TONE_CDMA_LOW_PBX_SS,                                  /**CDMA LOW PBX SS tone: {1300Hz 25ms, 1450Hz 25ms} 8 times 200 ms OFF, {1300Hz 25ms 1450Hz 25ms}8 times, 2000ms OFF, REPEAT.... */
 775         MM_SOUND_TONE_CDMA_HIGH_PBX_SSL,                                        /**CDMA HIGH PBX SSL tone:{3700Hz 25ms, 4000Hz 25ms} 8 times 200ms OFF, {3700Hz 25ms, 4000Hz 25ms} 8 times, 200ms OFF, {3700Hz 25ms, 4000Hz 25ms} 16 times, 1000ms OFF, REPEAT.... */
 776         MM_SOUND_TONE_CDMA_MED_PBX_SSL,                                         /**CDMA MED PBX SSL tone:{2600Hz 25ms, 2900Hz 25ms} 8 times 200ms OFF, {2600Hz 25ms, 2900Hz 25ms} 8 times, 200ms OFF, {2600Hz 25ms, 2900Hz 25ms} 16 times, 1000ms OFF, REPEAT.... */
 777         MM_SOUND_TONE_CDMA_LOW_PBX_SSL,                                         /**CDMA LOW PBX SSL tone:{1300Hz 25ms, 1450Hz 25ms} 8 times 200ms OFF, {1300Hz 25ms, 1450Hz 25ms} 8 times, 200ms OFF, {1300Hz 25ms, 1450Hz 25ms} 16 times, 1000ms OFF, REPEAT.... */
 778         MM_SOUND_TONE_CDMA_HIGH_PBX_SLS,                                        /**CDMA HIGH PBX SLS tone:{3700Hz 25ms, 4000Hz 25ms} 8 times 200ms OFF, {3700Hz 25ms, 4000Hz 25ms} 16 times, 200ms OFF, {3700Hz 25ms, 4000Hz 25ms} 8 times, 1000ms OFF, REPEAT....  */
 779         MM_SOUND_TONE_CDMA_MED_PBX_SLS,                                         /**CDMA MED PBX SLS tone:{2600Hz 25ms, 2900Hz 25ms} 8 times 200ms OFF, {2600Hz 25ms, 2900Hz 25ms} 16 times, 200ms OFF, {2600Hz 25ms, 2900Hz 25ms} 8 times, 1000ms OFF, REPEAT.... */
 780         MM_SOUND_TONE_CDMA_LOW_PBX_SLS,                                         /**CDMA LOW PBX SLS tone:{1300Hz 25ms, 1450Hz 25ms} 8 times 200ms OFF, {1300Hz 25ms, 1450Hz 25ms} 16 times, 200ms OFF, {1300Hz 25ms, 1450Hz 25ms} 8 times, 1000ms OFF, REPEAT.... */
 781         MM_SOUND_TONE_CDMA_HIGH_PBX_S_X4,                               /**CDMA HIGH PBX X S4 tone: {3700Hz 25ms 4000Hz 25ms} 8 times, 200ms OFF, {3700Hz 25ms 4000Hz 25ms} 8 times, 200ms OFF, {3700Hz 25ms 4000Hz 25ms} 8 times, 200ms OFF, {3700Hz 25ms 4000Hz 25ms} 8 times, 800ms OFF, REPEAT... */
 782         MM_SOUND_TONE_CDMA_MED_PBX_S_X4,                                        /**CDMA MED PBX X S4 tone: {2600Hz 25ms 2900Hz 25ms} 8 times, 200ms OFF, {2600Hz 25ms 2900Hz 25ms} 8 times, 200ms OFF, {2600Hz 25ms 2900Hz 25ms} 8 times, 200ms OFF, {2600Hz 25ms 2900Hz 25ms} 8 times, 800ms OFF, REPEAT... */
 783         MM_SOUND_TONE_CDMA_LOW_PBX_S_X4,                                        /**CDMA LOW PBX X S4 tone: {1300Hz 25ms 1450Hz 25ms} 8 times, 200ms OFF, {1300Hz 25ms 1450Hz 25ms} 8 times, 200ms OFF, {1300Hz 25ms 1450Hz 25ms} 8 times, 200ms OFF, {1300Hz 25ms 1450Hz 25ms} 8 times, 800ms OFF, REPEAT... */
 784         MM_SOUND_TONE_CDMA_ALERT_NETWORK_LITE,                  /**CDMA Alert Network Lite tone: 1109Hz 62ms ON, 784Hz 62ms ON, 740Hz 62ms ON 622Hz 62ms ON, 1109Hz 62ms ON */
 785         MM_SOUND_TONE_CDMA_ALERT_AUTOREDIAL_LITE,               /**CDMA Alert Auto Redial tone: {1245Hz 62ms ON, 659Hz 62ms ON} 3 times, 1245 62ms ON */
 786         MM_SOUND_TONE_CDMA_ONE_MIN_BEEP,                                        /**CDMA One Min Beep tone: 1150Hz+770Hz 400ms ON */
 787         MM_SOUND_TONE_CDMA_KEYPAD_VOLUME_KEY_LITE,              /**CDMA KEYPAD Volume key lite tone: 941Hz+1477Hz 120ms ON */
 788         MM_SOUND_TONE_CDMA_PRESSHOLDKEY_LITE,                   /**CDMA PRESSHOLDKEY LITE tone: 587Hz 375ms ON, 1175Hz 125ms ON */
 789         MM_SOUND_TONE_CDMA_ALERT_INCALL_LITE,                           /**CDMA ALERT INCALL LITE tone: 587Hz 62ms, 784 62ms, 831Hz 62ms, 784Hz 62ms, 1109 62ms, 784Hz 62ms, 831Hz 62ms, 784Hz 62ms*/
 790         MM_SOUND_TONE_CDMA_EMERGENCY_RINGBACK,                  /**CDMA EMERGENCY RINGBACK tone: {941Hz 125ms ON, 10ms OFF} 3times 4990ms OFF, REPEAT... */
 791         MM_SOUND_TONE_CDMA_ALERT_CALL_GUARD,                    /**CDMA ALERT CALL GUARD tone: {1319Hz 125ms ON, 125ms OFF} 3 times */
 792         MM_SOUND_TONE_CDMA_SOFT_ERROR_LITE,                             /**CDMA SOFT ERROR LITE tone: 1047Hz 125ms ON, 370Hz 125ms */
 793         MM_SOUND_TONE_CDMA_CALLDROP_LITE,                               /**CDMA CALLDROP LITE tone: 1480Hz 125ms, 1397Hz 125ms, 784Hz 125ms */
 794         MM_SOUND_TONE_CDMA_NETWORK_BUSY_ONE_SHOT,               /**CDMA_NETWORK_BUSY_ONE_SHOT tone: 425Hz 500ms ON, 500ms OFF. */
 795         MM_SOUND_TONE_CDMA_ABBR_ALERT,                                  /**CDMA_ABBR_ALERT tone: 1150Hz+770Hz 400ms ON */
 796         MM_SOUND_TONE_CDMA_SIGNAL_OFF,                                  /**CDMA_SIGNAL_OFF - silent tone */
 797         MM_SOUND_TONE_LOW_FRE,                                  /**100Hz continuous */
 798         MM_SOUND_TONE_MED_FRE,                                  /**200Hz continuous */
 799         MM_SOUND_TONE_HIGH_FRE,                                 /**300Hz continuous */
 800         MM_SOUND_TONE_NUM,
 801 }MMSoundTone_t;
 802
 803 typedef unsigned long sound_time_msec_t;                /**< millisecond unit */
 804
 805 /**
 806  * This function is to play tone sound.
 807  *
 808  * @param       num                             [in] predefined tone type (MMSoundTone_t)
 809  *                      volume config   [in] volume type & volume gain
 810  *                      volume                  [in] volume ratio (0.0 ~1.0)
 811  *                      duration                [in] millisecond (-1 for infinite)
 812  *                      handle                  [in] Handle of mm_sound_play_tone
 813  *                      enable_session  [in] set enable/unable session
 814  *
 815  * @return      This function returns MM_ERROR_NONE on success, or negative value
 816  *                      with error code.
 817  *
 818  * @remark      It doesn't provide stop
 819  * @see volume_type_t volume_gain_t MMSoundTone_t
 820  * @pre         None.
 821  * @post        TONE sound will be played.
 822  * @par Example
 823  * @code
 824 int ret = 0;
 825
 826 ret = mm_sound_play_tone_ex(MM_SOUND_TONE_DTMF_9, VOLUME_TYPE_SYSTEM, 1.0, 1000, &handle, TRUE); //play 1 second with volume ratio 1.0
 827 if(ret < 0)
 828 {
 829         printf("play tone failed\n");
 830 }
 831 else
 832 {
 833         printf("play tone success\n");
 834 }
 835  * @endcode
 836  */
 837 int mm_sound_play_tone_ex (MMSoundTone_t num, int volume_config, const double volume, const int duration, int *handle, bool enable_session);
 838
 839 /**
 840  * This function is to play tone sound.
 841  *
 842  * @param       num                             [in] predefined tone type (MMSoundTone_t)
 843  *                      volume config   [in] volume type & volume gain
 844  *                      volume                  [in] volume ratio (0.0 ~1.0)
 845  *                      duration                [in] millisecond (-1 for infinite)
 846  *                      handle                  [in] Handle of mm_sound_play_tone
 847  *
 848  * @return      This function returns MM_ERROR_NONE on success, or negative value
 849  *                      with error code.
 850  *
 851  * @remark      It doesn't provide stop
 852  * @see volume_type_t volume_gain_t MMSoundTone_t
 853  * @pre         None.
 854  * @post        TONE sound will be played.
 855  * @par Example
 856  * @code
 857 int ret = 0;
 858
 859 ret = mm_sound_play_tone(MM_SOUND_TONE_DTMF_9, VOLUME_TYPE_SYSTEM, 1.0, 1000, &handle); //play 1 second with volume ratio 1.0
 860 if(ret < 0)
 861 {
 862         printf("play tone failed\n");
 863 }
 864 else
 865 {
 866         printf("play tone success\n");
 867 }
 868  * @endcode
 869  */
 870 int mm_sound_play_tone (MMSoundTone_t num, int volume_config, const double volume, const int duration, int *handle);
 871
 872 int mm_sound_play_tone_with_stream_info(MMSoundTone_t tone, char *stream_type, int stream_id, const double volume, const int duration, int *handle);
 873
 874 /*
 875  * Enumerations of System audio route policy
 876  */
 877
 878
 879 /*
 880  * Enumerations of device & route
 881  */
 882
 883 typedef enum{
 884         MM_SOUND_DIRECTION_NONE,
 885         MM_SOUND_DIRECTION_IN,                                                  /**< Capture */
 886         MM_SOUND_DIRECTION_OUT,                                                 /**< Playback */
 887 } mm_sound_direction;
 888
 889 typedef enum{
 890         MM_SOUND_DEVICE_IN_NONE                         = 0x00,
 891         MM_SOUND_DEVICE_IN_MIC                          = 0x01,         /**< Device builtin mic. */
 892         MM_SOUND_DEVICE_IN_WIRED_ACCESSORY      = 0x02,         /**< Wired input devices */
 893         MM_SOUND_DEVICE_IN_BT_SCO       = 0x08,         /**< Bluetooth SCO device */
 894 } mm_sound_device_in;
 895
 896 typedef enum{
 897         MM_SOUND_DEVICE_OUT_NONE                        = 0x000,
 898         MM_SOUND_DEVICE_OUT_SPEAKER             = 0x001<<8,     /**< Device builtin speaker */
 899         MM_SOUND_DEVICE_OUT_RECEIVER            = 0x002<<8,     /**< Device builtin receiver */
 900         MM_SOUND_DEVICE_OUT_WIRED_ACCESSORY     = 0x004<<8,     /**< Wired output devices such as headphone, headset, and so on. */
 901         MM_SOUND_DEVICE_OUT_BT_SCO                      = 0x008<<8,     /**< Bluetooth SCO device */
 902         MM_SOUND_DEVICE_OUT_BT_A2DP             = 0x010<<8,     /**< Bluetooth A2DP device */
 903         MM_SOUND_DEVICE_OUT_DOCK                        = 0x020<<8,     /**< DOCK device */
 904         MM_SOUND_DEVICE_OUT_HDMI                        = 0x040<<8,     /**< HDMI device */
 905         MM_SOUND_DEVICE_OUT_MIRRORING           = 0x080<<8, /**< MIRRORING device */
 906         MM_SOUND_DEVICE_OUT_USB_AUDIO           = 0x100<<8,     /**< USB Audio device */
 907         MM_SOUND_DEVICE_OUT_MULTIMEDIA_DOCK     = 0x200<<8,     /**< Multimedia DOCK device */
 908 } mm_sound_device_out;
 909
 910 typedef enum {
 911         MM_SOUND_VOLUME_DEVICE_OUT_SPEAKER,                             /**< Device builtin speaker */
 912         MM_SOUND_VOLUME_DEVICE_OUT_RECEIVER,                    /**< Device builtin receiver */
 913         MM_SOUND_VOLUME_DEVICE_OUT_WIRED_ACCESSORY,             /**< Wired output devices such as headphone, headset, and so on. */
 914         MM_SOUND_VOLUME_DEVICE_OUT_BT_SCO,                              /**< Bluetooth SCO device */
 915         MM_SOUND_VOLUME_DEVICE_OUT_BT_A2DP,                             /**< Bluetooth A2DP device */
 916         MM_SOUND_VOLUME_DEVICE_OUT_DOCK,                                /**< DOCK device */
 917         MM_SOUND_VOLUME_DEVICE_OUT_HDMI,                                /**< HDMI device */
 918         MM_SOUND_VOLUME_DEVICE_OUT_MIRRORING,                   /**< MIRRORING device */
 919         MM_SOUND_VOLUME_DEVICE_OUT_USB_AUDIO,                   /**< USB Audio device */
 920         MM_SOUND_VOLUME_DEVICE_OUT_MULTIMEDIA_DOCK,             /**< Multimedia DOCK device */
 921 } mm_sound_volume_device_out_t;
 922
 923 #define MM_SOUND_ROUTE_NUM 16
 924 #define MM_SOUND_NAME_NUM 32
 925
 926 typedef enum{
 927         MM_SOUND_ROUTE_OUT_SPEAKER = MM_SOUND_DEVICE_OUT_SPEAKER, /**< Routing audio output to builtin device such as internal speaker. */
 928         MM_SOUND_ROUTE_OUT_RECEIVER = MM_SOUND_DEVICE_OUT_RECEIVER, /**< Routing audio output to builtin device such as internal receiver. */
 929         MM_SOUND_ROUTE_OUT_WIRED_ACCESSORY = MM_SOUND_DEVICE_OUT_WIRED_ACCESSORY,/**< Routing audio output to wired accessory such as headphone, headset, and so on. */
 930         MM_SOUND_ROUTE_OUT_BLUETOOTH_SCO = MM_SOUND_DEVICE_OUT_BT_SCO, /**< Routing audio output to bluetooth SCO. */
 931         MM_SOUND_ROUTE_OUT_BLUETOOTH_A2DP = MM_SOUND_DEVICE_OUT_BT_A2DP, /**< Routing audio output to bluetooth A2DP. */
 932         MM_SOUND_ROUTE_OUT_DOCK = MM_SOUND_DEVICE_OUT_DOCK, /**< Routing audio output to DOCK */
 933         MM_SOUND_ROUTE_OUT_HDMI = MM_SOUND_DEVICE_OUT_HDMI, /**< Routing audio output to HDMI */
 934         MM_SOUND_ROUTE_OUT_MIRRORING = MM_SOUND_DEVICE_OUT_MIRRORING, /**< Routing audio output to MIRRORING */
 935         MM_SOUND_ROUTE_OUT_USB_AUDIO = MM_SOUND_DEVICE_OUT_USB_AUDIO, /**< Routing audio output to USB Audio */
 936         MM_SOUND_ROUTE_OUT_MULTIMEDIA_DOCK = MM_SOUND_DEVICE_OUT_MULTIMEDIA_DOCK, /**< Routing audio output to Multimedia DOCK */
 937         MM_SOUND_ROUTE_IN_MIC = MM_SOUND_DEVICE_IN_MIC, /**< Routing audio input to device builtin mic. */
 938         MM_SOUND_ROUTE_IN_WIRED_ACCESSORY = MM_SOUND_DEVICE_IN_WIRED_ACCESSORY, /**< Routing audio input to wired accessory. */
 939         MM_SOUND_ROUTE_IN_MIC_OUT_RECEIVER = MM_SOUND_DEVICE_IN_MIC | MM_SOUND_DEVICE_OUT_RECEIVER, /**< Routing audio input to device builtin mic and routing audio output to builtin receiver*/
 940         MM_SOUND_ROUTE_IN_MIC_OUT_SPEAKER = MM_SOUND_DEVICE_IN_MIC | MM_SOUND_DEVICE_OUT_SPEAKER , /**< Routing audio input to device builtin mic and routing audio output to builtin speaker */
 941         MM_SOUND_ROUTE_IN_MIC_OUT_HEADPHONE = MM_SOUND_DEVICE_IN_MIC | MM_SOUND_DEVICE_OUT_WIRED_ACCESSORY,/**< Routing audio input to device builtin mic and routing audio output to headphone */
 942         MM_SOUND_ROUTE_INOUT_HEADSET = MM_SOUND_DEVICE_IN_WIRED_ACCESSORY | MM_SOUND_DEVICE_OUT_WIRED_ACCESSORY,        /**< Routing audio input and output to headset*/
 943         MM_SOUND_ROUTE_INOUT_BLUETOOTH = MM_SOUND_DEVICE_IN_BT_SCO | MM_SOUND_DEVICE_OUT_BT_SCO /**< Routing audio input and output to bluetooth SCO */
 944 } mm_sound_route;
 945
 946 /*
 947  * MMSound Device APIs
 948  */
 949
 950 typedef enum {
 951         MM_SOUND_DEVICE_IO_DIRECTION_IN_FLAG      = 0x0001,  /**< Flag for input devices */
 952         MM_SOUND_DEVICE_IO_DIRECTION_OUT_FLAG     = 0x0002,  /**< Flag for output devices */
 953         MM_SOUND_DEVICE_IO_DIRECTION_BOTH_FLAG    = 0x0004,  /**< Flag for input/output devices (both directions are available) */
 954         MM_SOUND_DEVICE_TYPE_INTERNAL_FLAG        = 0x0010,  /**< Flag for built-in devices */
 955         MM_SOUND_DEVICE_TYPE_EXTERNAL_FLAG        = 0x0020,  /**< Flag for external devices */
 956         MM_SOUND_DEVICE_STATE_DEACTIVATED_FLAG    = 0x1000,  /**< Flag for deactivated devices */
 957         MM_SOUND_DEVICE_STATE_ACTIVATED_FLAG      = 0x2000,  /**< Flag for activated devices */
 958         MM_SOUND_DEVICE_ALL_FLAG                  = 0xFFFF,  /**< Flag for all devices */
 959 } mm_sound_device_flags_e;
 960
 961 typedef enum {
 962         MM_SOUND_DEVICE_IO_DIRECTION_IN           = 0x1,
 963         MM_SOUND_DEVICE_IO_DIRECTION_OUT          = 0x2,
 964         MM_SOUND_DEVICE_IO_DIRECTION_BOTH         = MM_SOUND_DEVICE_IO_DIRECTION_IN | MM_SOUND_DEVICE_IO_DIRECTION_OUT,
 965 } mm_sound_device_io_direction_e;
 966
 967 typedef enum {
 968         MM_SOUND_DEVICE_STATE_DEACTIVATED,
 969         MM_SOUND_DEVICE_STATE_ACTIVATED,
 970 } mm_sound_device_state_e;
 971
 972 typedef enum
 973 {
 974         MM_SOUND_DEVICE_TYPE_BUILTIN_SPEAKER,   /**< Built-in speaker. */
 975         MM_SOUND_DEVICE_TYPE_BUILTIN_RECEIVER,  /**< Built-in receiver. */
 976         MM_SOUND_DEVICE_TYPE_BUILTIN_MIC,       /**< Built-in mic. */
 977         MM_SOUND_DEVICE_TYPE_AUDIOJACK,         /**< Audio jack such as headphone, headset, and so on. */
 978         MM_SOUND_DEVICE_TYPE_BLUETOOTH,         /**< Bluetooth */
 979         MM_SOUND_DEVICE_TYPE_BLUETOOTH_A2DP = MM_SOUND_DEVICE_TYPE_BLUETOOTH,    /**< Bluetooth A2DP */
 980         MM_SOUND_DEVICE_TYPE_HDMI,              /**< HDMI. */
 981         MM_SOUND_DEVICE_TYPE_MIRRORING,         /**< MIRRORING. */
 982         MM_SOUND_DEVICE_TYPE_USB_AUDIO,         /**< USB Audio. */
 983         MM_SOUND_DEVICE_TYPE_BLUETOOTH_SCO,     /**< Bluetooth SCO */
 984 } mm_sound_device_type_e;
 985
 986 typedef void *MMSoundDevice_t;          /**< MMsound Device handle */
 987 typedef void *MMSoundDeviceList_t;      /**< MMsound Device list handle */
 988 typedef void (*mm_sound_device_connected_cb) (MMSoundDevice_t device_h, bool is_connected, void *user_data);
 989 typedef void (*mm_sound_device_info_changed_cb) (MMSoundDevice_t device_h, int changed_info_type, void *user_data);
 990 typedef void (*mm_sound_device_state_changed_cb) (MMSoundDevice_t device_h, mm_sound_device_state_e state, void *user_data);
 991
 992 int mm_sound_add_device_connected_callback(int flags, mm_sound_device_connected_cb func, void *user_data, unsigned int *id);
 993 int mm_sound_remove_device_connected_callback(unsigned int id);
 994 int mm_sound_add_device_information_changed_callback(int flags, mm_sound_device_info_changed_cb func, void *user_data, unsigned int *id);
 995 int mm_sound_remove_device_information_changed_callback(unsigned int id);
 996 int mm_sound_add_device_state_changed_callback(int flags, mm_sound_device_state_changed_cb func, void *user_data, unsigned int *id);
 997 int mm_sound_remove_device_state_changed_callback(unsigned int id);
 998
 999 int mm_sound_get_current_device_list(mm_sound_device_flags_e device_mask, MMSoundDeviceList_t *device_list);
1000 int mm_sound_get_device_list(int device_mask, MMSoundDeviceList_t *device_list);
1001 int mm_sound_free_device_list(MMSoundDeviceList_t device_list);
1002 int mm_sound_get_next_device (MMSoundDeviceList_t device_list, MMSoundDevice_t *device);
1003 int mm_sound_get_prev_device (MMSoundDeviceList_t device_list, MMSoundDevice_t *device);
1004 int mm_sound_get_device_type(MMSoundDevice_t device_h, mm_sound_device_type_e *type);
1005 int mm_sound_get_device_io_direction(MMSoundDevice_t device_h, mm_sound_device_io_direction_e *io_direction);
1006 int mm_sound_get_device_id(MMSoundDevice_t device_h, int *id);
1007 int mm_sound_get_device_state(MMSoundDevice_t device_h, mm_sound_device_state_e *state);
1008 int mm_sound_get_device_name(MMSoundDevice_t device_h, char **name);
1009
1010 /**
1011  * Active device changed callback function type.
1012  *
1013  * @param       user_data               [in]    Argument passed when callback has called
1014  *
1015  * @return      No return value
1016  * @remark      None.
1017  * @see         mm_sound_add_active_device_changed_callback mm_sound_remove_active_device_changed_callback
1018  */
1019 typedef void (*mm_sound_active_device_changed_cb) (mm_sound_device_in device_in, mm_sound_device_out device_out, void *user_data);
1020
1021 typedef void (*mm_sound_test_cb) (int a, void *user_data);
1022 int mm_sound_test(int a, int b, int* get);
1023 int mm_sound_add_test_callback(mm_sound_test_cb func, void *user_data, unsigned int *id);
1024 int mm_sound_remove_test_callback(unsigned int sub_id);
1025
1026 void mm_sound_convert_volume_type_to_stream_type(int volume_type, char *stream_type);
1027
1028 typedef enum {
1029         MM_SOUND_SIGNAL_RELEASE_INTERNAL_FOCUS,
1030         MM_SOUND_SIGNAL_MAX,
1031 } mm_sound_signal_name_t;
1032
1033 typedef void (*mm_sound_signal_callback) (mm_sound_signal_name_t signal, int value, void *user_data);
1034 int mm_sound_subscribe_signal(mm_sound_signal_name_t signal, unsigned int *subscribe_id, mm_sound_signal_callback callback, void *user_data);
1035 int mm_sound_subscribe_signal_for_daemon(mm_sound_signal_name_t signal, int client_pid, unsigned int *subscribe_id, mm_sound_signal_callback callback, void *user_data);
1036 void mm_sound_unsubscribe_signal(unsigned int subscribe_id);
1037 int mm_sound_send_signal(mm_sound_signal_name_t signal, int value);
1038 int mm_sound_get_signal_value(mm_sound_signal_name_t signal, int *value);
1039 int mm_sound_is_stream_on_device(int stream_id, MMSoundDevice_t device_h, bool *is_on);
1040
1041 /**
1042         @}
1043  */
1044
1045 #ifdef __cplusplus
1046 }
1047 #endif
1048
1049 #endif  /* __MM_SOUND_H__ */
1050