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  * This function is to set sound filter and apply to selected stream type.
 506  *
 507  * @param       stream_type                     [in]    stream type to apply
 508  * @param       filter_name                     [in]    name of filter module to apply
 509  * @param       filter_parameters       [in]    extra filter parameters(optional)
 510  * @param       filter_group            [in]    extra filter group(optional)
 511  *
 512  * @return      This function returns MM_ERROR_NONE on success, or negative value
 513  *                      with error code.
 514  * @remark      None
 515  * @pre         None
 516  * @post        None
 517  * @see         None
 518  */
 519 int mm_sound_set_filter(const char *stream_type, const char *filter_name, const char *filter_parameters, const char *filter_group);
 520
 521 /**
 522  * This function is to unset sound filter and remove from selected stream type.
 523  *
 524  * @param       stream_type                     [in]    stream type to remove
 525  *
 526  * @return      This function returns MM_ERROR_NONE on success, or negative value
 527  *                      with error code.
 528  * @remark      None
 529  * @pre         None
 530  * @post        None
 531  * @see         None
 532  */
 533 int mm_sound_unset_filter(const char *stream_type);
 534
 535 /**
 536  * This function is to control filter configurations to selected stream type.
 537  *
 538  * @param       stream_type                     [in]    stream type to apply
 539  * @param       filter_name                     [in]    specify filter module to apply
 540  * @param       filter_controls         [in]    filter control parameters(e.g, "0.0, 0.1, 3.0")
 541  *
 542  * @return      This function returns MM_ERROR_NONE on success, or negative value
 543  *                      with error code.
 544  * @remark      None
 545  * @pre         None
 546  * @post        None
 547  * @see         None
 548  */
 549 int mm_sound_control_filter(const char *stream_type, const char *filter_name, const char *filter_controls);
 550
 551 /**
 552  * Terminate callback function type.
 553  *
 554  * @param       data            [in]    Argument passed when callback was set
 555  * @param       id              [in]    handle which has completed playing
 556  *
 557  * @return      No return value
 558  * @remark      It is not allowed to call MMSound API recursively or do time-consuming
 559  *                      task in this callback because this callback is called synchronously.
 560  * @see         mm_sound_play_sound
 561  */
 562 typedef void (*mm_sound_stop_callback_func) (void *data, int id);
 563
 564 /*
 565  * MMSound Play APIs
 566  */
 567
 568 /**
 569  * This function is to play system sound.
 570  *
 571  * @param       filename                [in] Sound filename to play
 572  * @param       volume config   [in] Volume type & volume gain
 573  * @param       callback                [in] Callback function pointer when playing is terminated.
 574  * @param       data                    [in] Pointer to user data when callback is called.
 575  * @param       handle                  [out] Handle of sound play.
 576  *
 577  * @return      This function returns MM_ERROR_NONE on success, or negative value
 578  *                      with error code.
 579  * @remark      When the stop callback is set, it will be called when system sound is
 580  *                      terminated. If mm_sound_stop_sound() is called apparently before
 581  *                      system sound is terminated, stop_callback will not be called.
 582  * @see         mm_sound_stop_sound mm_sound_stop_callback_func volume_type_t volume_gain_t
 583  * @pre         None.
 584  * @post        Sound will be generated with given filename.
 585  * @par Example
 586  * @code
 587 int g_stop=0;
 588 void _stop_callback(void* data)
 589 {
 590         printf("Stop callback\n");
 591         g_stop = 1;
 592 }
 593
 594 int play_file()
 595 {
 596         char filename[] ="testfile.wav";
 597         volume_type_t volume = VOLUME_TYPE_SYSTEM;
 598         int ret = 0;
 599         int handle = -1;
 600
 601         ret = mm_sound_play_sound(filename, volume, _stop_callback, NULL, &handle);
 602         if(ret < 0)
 603         {
 604                 printf("play file failed\n");
 605         }
 606         else
 607         {
 608                 printf("play file success\n");
 609         }
 610         while(g_stop == 0)
 611         {
 612                 sleep(1);
 613         }
 614         printf("play stopped\n");
 615         return 0;
 616 }
 617  * @endcode
 618  */
 619 int mm_sound_play_sound(const char *filename, int volume_config, mm_sound_stop_callback_func callback, void *data, int *handle);
 620
 621 /**
 622  * This function is to play system sound. And other audio stream will be mute during playing time
 623  *
 624  * @param       filename                [in] Sound filename to play
 625  * @param       volume config   [in] Volume type & volume gain
 626  * @param       callback                [in] Callback function pointer when playing is terminated.
 627  * @param       data                    [in] Pointer to user data when callback is called.
 628  * @param       handle                  [out] Handle of sound play.
 629  *
 630  * @return      This function returns MM_ERROR_NONE on success, or negative value
 631  *                      with error code.
 632  * @remark      This function is almost same with mm_sound_play_sound,
 633  *                      but this make other audio playback stream to mute during playing time.
 634  * @see         mm_sound_stop_sound mm_sound_stop_callback_func volume_type_t volume_gain_t
 635  * @pre         None.
 636  * @post        Sound will be generated with given filename.
 637  * @par Example
 638  * @code
 639 int g_stop=0;
 640 void _stop_callback(void* data)
 641 {
 642         printf("Stop callback\n");
 643         g_stop = 1;
 644 }
 645
 646 int play_file()
 647 {
 648         char filename[] ="testfile.wav";
 649         volume_type_t volume = VOLUME_TYPE_SYSTEM;
 650         int ret = 0;
 651         int handle = -1;
 652
 653         ret = mm_sound_play_loud_solo_sound(filename, volume, _stop_callback, NULL, &handle);
 654         if(ret < 0)
 655         {
 656                 printf("play file failed\n");
 657         }
 658         else
 659         {
 660                 printf("play file success\n");
 661         }
 662         while(g_stop == 0)
 663         {
 664                 sleep(1);
 665         }
 666         printf("play stopped\n");
 667         return 0;
 668 }
 669  * @endcode
 670  */
 671 int mm_sound_play_loud_solo_sound(const char *filename, int volume_config, mm_sound_stop_callback_func callback, void *data, int *handle);
 672
 673 /**
 674  * This function is to stop playing system sound.
 675  *
 676  * @param       handle  [in] Handle of mm_sound_play_sound
 677  *
 678  * @return      This function returns MM_ERROR_NONE on success, or negative value
 679  *                      with error code.
 680  *
 681  * @remark      When system sound is terminated with this function call, it does not
 682  *                      call stop callback which was set when start playing system sound.
 683  * @see         mm_sound_play_sound
 684  * @pre         An sound play handle should be valid.
 685  * @post        Playing sound file will be stopped.
 686  * @par Example
 687  * @code
 688 int g_stop=0;
 689 void _stop_callback(void* data)
 690 {
 691         printf("Stop callback\n");
 692         g_stop = 1;
 693 }
 694
 695 int play_file_one_second()
 696 {
 697         char filename[] ="testfile.wav";
 698         volume_type_t volume = VOLUME_TYPE_SYSTEM;
 699         int ret = 0;
 700         int handle = -1;
 701
 702         ret = mm_sound_play_sound(filename, volume, _stop_callback, NULL, &handle);
 703         if(ret < 0)
 704         {
 705                 printf("play file failed\n");
 706         }
 707         else
 708         {
 709                 printf("play file success\n");
 710         }
 711
 712         sleep(1); //wait 1 second
 713
 714         ret = mm_sound_stop_sound(handle);
 715         if(ret < 0)
 716         {
 717                 printf("stop failed\n");
 718         }
 719         else
 720         {
 721                 printf("play stopped\n");
 722         }
 723         return 0;
 724 }
 725  * @endcode
 726  */
 727 int mm_sound_stop_sound(int handle);
 728
 729
 730 /**
 731  * Enumerations for TONE
 732  */
 733
 734 typedef enum  {
 735         MM_SOUND_TONE_DTMF_0 = 0,                       /**< Predefined DTMF 0 */
 736         MM_SOUND_TONE_DTMF_1,                           /**< Predefined DTMF 1 */
 737         MM_SOUND_TONE_DTMF_2,                           /**< Predefined DTMF 2 */
 738         MM_SOUND_TONE_DTMF_3,                           /**< Predefined DTMF 3 */
 739         MM_SOUND_TONE_DTMF_4,                           /**< Predefined DTMF 4 */
 740         MM_SOUND_TONE_DTMF_5,                           /**< Predefined DTMF 5 */
 741         MM_SOUND_TONE_DTMF_6,                           /**< Predefined DTMF 6 */
 742         MM_SOUND_TONE_DTMF_7,                           /**< Predefined DTMF 7 */
 743         MM_SOUND_TONE_DTMF_8,                           /**< Predefined DTMF 8 */
 744         MM_SOUND_TONE_DTMF_9,                           /**< Predefined DTMF 9 */
 745         MM_SOUND_TONE_DTMF_S,                           /**< Predefined DTMF Star - Asterisk (*) */
 746         MM_SOUND_TONE_DTMF_P,                           /**< Predefined DTMF sharP (#) */
 747         MM_SOUND_TONE_DTMF_A,                           /**< Predefined DTMF A (A) */
 748         MM_SOUND_TONE_DTMF_B,                           /**< Predefined DTMF B (B) */
 749         MM_SOUND_TONE_DTMF_C,                           /**< Predefined DTMF C (C) */
 750         MM_SOUND_TONE_DTMF_D,                           /**< Predefined DTMF D (D) */
 751
 752         /**< Pre-defined TONE */
 753         MM_SOUND_TONE_SUP_DIAL,                                 /**Call supervisory tone, Dial tone: CEPT: 425Hz, continuous */
 754         MM_SOUND_TONE_ANSI_DIAL,                                /**Call supervisory tone, Dial tone: ANSI (IS-95): 350Hz+440Hz, continuous */
 755         MM_SOUND_TONE_JAPAN_DIAL,                               /**Call supervisory tone, Dial tone: JAPAN: 400Hz, continuous*/
 756         MM_SOUND_TONE_SUP_BUSY,                         /**Call supervisory tone, Busy: CEPT: 425Hz, 500ms ON, 500ms OFF... */
 757         MM_SOUND_TONE_ANSI_BUSY,                                /**Call supervisory tone, Busy: ANSI (IS-95): 480Hz+620Hz, 500ms ON, 500ms OFF... */
 758         MM_SOUND_TONE_JAPAN_BUSY,                               /**Call supervisory tone, Busy: JAPAN: 400Hz, 500ms ON, 500ms OFF...*/
 759         MM_SOUND_TONE_SUP_CONGESTION,           /**Call supervisory tone, Congestion: CEPT, JAPAN: 425Hz, 200ms ON, 200ms OFF */
 760         MM_SOUND_TONE_ANSI_CONGESTION,          /**Call supervisory tone, Congestion: ANSI (IS-95): 480Hz+620Hz, 250ms ON, 250ms OFF... */
 761         MM_SOUND_TONE_SUP_RADIO_ACK,                    /**Call supervisory tone, Radio path acknowlegment : CEPT, ANSI: 425Hz, 200ms ON  */
 762         MM_SOUND_TONE_JAPAN_RADIO_ACK,          /**Call supervisory tone, Radio path acknowlegment : JAPAN: 400Hz, 1s ON, 2s OFF...*/
 763         MM_SOUND_TONE_SUP_RADIO_NOTAVAIL,               /**Call supervisory tone, Radio path not available: 425Hz, 200ms ON, 200 OFF 3 bursts */
 764         MM_SOUND_TONE_SUP_ERROR,                                /**Call supervisory tone, Error/Special info: 950Hz+1400Hz+1800Hz, 330ms ON, 1s OFF... */
 765         MM_SOUND_TONE_SUP_CALL_WAITING,         /**Call supervisory tone, Call Waiting: CEPT, JAPAN: 425Hz, 200ms ON, 600ms OFF, 200ms ON, 3s OFF...  */
 766         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 ...) */
 767         MM_SOUND_TONE_SUP_RINGTONE,                     /**Call supervisory tone, Ring Tone: CEPT, JAPAN: 425Hz, 1s ON, 4s OFF... */
 768         MM_SOUND_TONE_ANSI_RINGTONE,                    /**Call supervisory tone, Ring Tone: ANSI (IS-95): 440Hz + 480Hz, 2s ON, 4s OFF... */
 769         MM_SOUND_TONE_PROP_BEEP,                                /**General beep: 400Hz+1200Hz, 35ms ON */
 770         MM_SOUND_TONE_PROP_ACK,                                 /**Proprietary tone, positive acknowlegement: 1200Hz, 100ms ON, 100ms OFF 2 bursts */
 771         MM_SOUND_TONE_PROP_NACK,                                /**Proprietary tone, negative acknowlegement: 300Hz+400Hz+500Hz, 400ms ON */
 772         MM_SOUND_TONE_PROP_PROMPT,                      /**Proprietary tone, prompt tone: 400Hz+1200Hz, 200ms ON         */
 773         MM_SOUND_TONE_PROP_BEEP2,                               /**Proprietary tone, general double beep: twice 400Hz+1200Hz, 35ms ON, 200ms OFF, 35ms ON */
 774         MM_SOUND_TONE_SUP_INTERCEPT,                                            /**Call supervisory tone (IS-95), intercept tone: alternating 440 Hz and 620 Hz tones, each on for 250 ms */
 775         MM_SOUND_TONE_SUP_INTERCEPT_ABBREV,                             /**Call supervisory tone (IS-95), abbreviated intercept: intercept tone limited to 4 seconds */
 776         MM_SOUND_TONE_SUP_CONGESTION_ABBREV,                            /**Call supervisory tone (IS-95), abbreviated congestion: congestion tone limited to 4 seconds */
 777         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 */
 778         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). */
 779         MM_SOUND_TONE_CDMA_DIAL_TONE_LITE,                              /**425Hz continuous */
 780         MM_SOUND_TONE_CDMA_NETWORK_USA_RINGBACK,                /**CDMA USA Ringback: 440Hz+480Hz 2s ON, 4000 OFF ...*/
 781         MM_SOUND_TONE_CDMA_INTERCEPT,                                   /**CDMA Intercept tone: 440Hz 250ms ON, 620Hz 250ms ON ...*/
 782         MM_SOUND_TONE_CDMA_ABBR_INTERCEPT,                              /**CDMA Abbr Intercept tone: 440Hz 250ms ON, 620Hz 250ms ON */
 783         MM_SOUND_TONE_CDMA_REORDER,                                             /**CDMA Reorder tone: 480Hz+620Hz 250ms ON, 250ms OFF... */
 784         MM_SOUND_TONE_CDMA_ABBR_REORDER,                                /**CDMA Abbr Reorder tone: 480Hz+620Hz 250ms ON, 250ms OFF repeated for 8 times */
 785         MM_SOUND_TONE_CDMA_NETWORK_BUSY,                                /**CDMA Network Busy tone: 480Hz+620Hz 500ms ON, 500ms OFF continuous */
 786         MM_SOUND_TONE_CDMA_CONFIRM,                                             /**CDMA Confirm tone: 350Hz+440Hz 100ms ON, 100ms OFF repeated for 3 times */
 787         MM_SOUND_TONE_CDMA_ANSWER,                                              /**CDMA answer tone: silent tone - defintion Frequency 0, 0ms ON, 0ms OFF */
 788         MM_SOUND_TONE_CDMA_NETWORK_CALLWAITING,                         /**CDMA Network Callwaiting tone: 440Hz 300ms ON */
 789         MM_SOUND_TONE_CDMA_PIP,                                                         /**CDMA PIP tone: 480Hz 100ms ON, 100ms OFF repeated for 4 times */
 790         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 */
 791         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.*/
 792         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 */
 793         MM_SOUND_TONE_CDMA_CALL_SIGNAL_ISDN_PAT3,               /**SDN Call sign PAT3 tone: silent tone */
 794         MM_SOUND_TONE_CDMA_CALL_SIGNAL_ISDN_PING_RING,  /**ISDN Ping Ring tone: {2091Hz 32ms ON, 2556Hz 64ms ON} 5 times 2091Hz 20ms ON */
 795         MM_SOUND_TONE_CDMA_CALL_SIGNAL_ISDN_PAT5,               /**ISDN Pat5 tone: silent tone */
 796         MM_SOUND_TONE_CDMA_CALL_SIGNAL_ISDN_PAT6,               /**ISDN Pat6 tone: silent tone */
 797         MM_SOUND_TONE_CDMA_CALL_SIGNAL_ISDN_PAT7,               /**ISDN Pat7 tone: silent tone */
 798         MM_SOUND_TONE_CDMA_HIGH_L,                                              /**TONE_CDMA_HIGH_L tone: {3700Hz 25ms, 4000Hz 25ms} 40 times 4000ms OFF, Repeat .... */
 799         MM_SOUND_TONE_CDMA_MED_L,                                               /**TONE_CDMA_MED_L tone: {2600Hz 25ms, 2900Hz 25ms} 40 times 4000ms OFF, Repeat .... */
 800         MM_SOUND_TONE_CDMA_LOW_L,                                               /**TONE_CDMA_LOW_L tone: {1300Hz 25ms, 1450Hz 25ms} 40 times, 4000ms OFF, Repeat .... */
 801         MM_SOUND_TONE_CDMA_HIGH_SS,                                             /**CDMA HIGH SS tone: {3700Hz 25ms, 4000Hz 25ms} repeat 16 times, 400ms OFF, repeat .... */
 802         MM_SOUND_TONE_CDMA_MED_SS,                                              /**CDMA MED SS tone: {2600Hz 25ms, 2900Hz 25ms} repeat 16 times, 400ms OFF, repeat .... */
 803         MM_SOUND_TONE_CDMA_LOW_SS,                                              /**CDMA LOW SS tone: {1300z 25ms, 1450Hz 25ms} repeat 16 times, 400ms OFF, repeat .... */
 804         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 ... */
 805         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 ... */
 806         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 ... */
 807         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 .... */
 808         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 .... */
 809         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 .... */
 810         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 */
 811         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 */
 812         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 */
 813         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.... */
 814         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.... */
 815         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....*/
 816         MM_SOUND_TONE_CDMA_HIGH_PBX_L,                                  /**CDMA HIGH PBX L: {3700Hz 25ms, 4000Hz 25ms}20 times, 2000ms OFF, REPEAT.... */
 817         MM_SOUND_TONE_CDMA_MED_PBX_L,                                   /**CDMA MED PBX L: {2600Hz 25ms, 2900Hz 25ms}20 times, 2000ms OFF, REPEAT.... */
 818         MM_SOUND_TONE_CDMA_LOW_PBX_L,                                   /**CDMA LOW PBX L: {1300Hz 25ms,1450Hz 25ms}20 times, 2000ms OFF, REPEAT.... */
 819         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.... */
 820         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.... */
 821         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.... */
 822         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.... */
 823         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.... */
 824         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.... */
 825         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....  */
 826         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.... */
 827         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.... */
 828         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... */
 829         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... */
 830         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... */
 831         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 */
 832         MM_SOUND_TONE_CDMA_ALERT_AUTOREDIAL_LITE,               /**CDMA Alert Auto Redial tone: {1245Hz 62ms ON, 659Hz 62ms ON} 3 times, 1245 62ms ON */
 833         MM_SOUND_TONE_CDMA_ONE_MIN_BEEP,                                        /**CDMA One Min Beep tone: 1150Hz+770Hz 400ms ON */
 834         MM_SOUND_TONE_CDMA_KEYPAD_VOLUME_KEY_LITE,              /**CDMA KEYPAD Volume key lite tone: 941Hz+1477Hz 120ms ON */
 835         MM_SOUND_TONE_CDMA_PRESSHOLDKEY_LITE,                   /**CDMA PRESSHOLDKEY LITE tone: 587Hz 375ms ON, 1175Hz 125ms ON */
 836         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*/
 837         MM_SOUND_TONE_CDMA_EMERGENCY_RINGBACK,                  /**CDMA EMERGENCY RINGBACK tone: {941Hz 125ms ON, 10ms OFF} 3times 4990ms OFF, REPEAT... */
 838         MM_SOUND_TONE_CDMA_ALERT_CALL_GUARD,                    /**CDMA ALERT CALL GUARD tone: {1319Hz 125ms ON, 125ms OFF} 3 times */
 839         MM_SOUND_TONE_CDMA_SOFT_ERROR_LITE,                             /**CDMA SOFT ERROR LITE tone: 1047Hz 125ms ON, 370Hz 125ms */
 840         MM_SOUND_TONE_CDMA_CALLDROP_LITE,                               /**CDMA CALLDROP LITE tone: 1480Hz 125ms, 1397Hz 125ms, 784Hz 125ms */
 841         MM_SOUND_TONE_CDMA_NETWORK_BUSY_ONE_SHOT,               /**CDMA_NETWORK_BUSY_ONE_SHOT tone: 425Hz 500ms ON, 500ms OFF. */
 842         MM_SOUND_TONE_CDMA_ABBR_ALERT,                                  /**CDMA_ABBR_ALERT tone: 1150Hz+770Hz 400ms ON */
 843         MM_SOUND_TONE_CDMA_SIGNAL_OFF,                                  /**CDMA_SIGNAL_OFF - silent tone */
 844         MM_SOUND_TONE_LOW_FRE,                                  /**100Hz continuous */
 845         MM_SOUND_TONE_MED_FRE,                                  /**200Hz continuous */
 846         MM_SOUND_TONE_HIGH_FRE,                                 /**300Hz continuous */
 847         MM_SOUND_TONE_NUM,
 848 }MMSoundTone_t;
 849
 850 typedef unsigned long sound_time_msec_t;                /**< millisecond unit */
 851
 852 /**
 853  * This function is to play tone sound.
 854  *
 855  * @param       num                             [in] predefined tone type (MMSoundTone_t)
 856  *                      volume config   [in] volume type & volume gain
 857  *                      volume                  [in] volume ratio (0.0 ~1.0)
 858  *                      duration                [in] millisecond (-1 for infinite)
 859  *                      handle                  [in] Handle of mm_sound_play_tone
 860  *                      enable_session  [in] set enable/unable session
 861  *
 862  * @return      This function returns MM_ERROR_NONE on success, or negative value
 863  *                      with error code.
 864  *
 865  * @remark      It doesn't provide stop
 866  * @see volume_type_t volume_gain_t MMSoundTone_t
 867  * @pre         None.
 868  * @post        TONE sound will be played.
 869  * @par Example
 870  * @code
 871 int ret = 0;
 872
 873 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
 874 if(ret < 0)
 875 {
 876         printf("play tone failed\n");
 877 }
 878 else
 879 {
 880         printf("play tone success\n");
 881 }
 882  * @endcode
 883  */
 884 int mm_sound_play_tone_ex (MMSoundTone_t num, int volume_config, const double volume, const int duration, int *handle, bool enable_session);
 885
 886 /**
 887  * This function is to play tone sound.
 888  *
 889  * @param       num                             [in] predefined tone type (MMSoundTone_t)
 890  *                      volume config   [in] volume type & volume gain
 891  *                      volume                  [in] volume ratio (0.0 ~1.0)
 892  *                      duration                [in] millisecond (-1 for infinite)
 893  *                      handle                  [in] Handle of mm_sound_play_tone
 894  *
 895  * @return      This function returns MM_ERROR_NONE on success, or negative value
 896  *                      with error code.
 897  *
 898  * @remark      It doesn't provide stop
 899  * @see volume_type_t volume_gain_t MMSoundTone_t
 900  * @pre         None.
 901  * @post        TONE sound will be played.
 902  * @par Example
 903  * @code
 904 int ret = 0;
 905
 906 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
 907 if(ret < 0)
 908 {
 909         printf("play tone failed\n");
 910 }
 911 else
 912 {
 913         printf("play tone success\n");
 914 }
 915  * @endcode
 916  */
 917 int mm_sound_play_tone (MMSoundTone_t num, int volume_config, const double volume, const int duration, int *handle);
 918
 919 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);
 920
 921 /*
 922  * Enumerations of device & route
 923  */
 924
 925 typedef enum{
 926         MM_SOUND_DIRECTION_NONE,
 927         MM_SOUND_DIRECTION_IN,                                                  /**< Capture */
 928         MM_SOUND_DIRECTION_OUT,                                                 /**< Playback */
 929 } mm_sound_direction;
 930
 931 typedef enum{
 932         MM_SOUND_DEVICE_IN_NONE                         = 0x00,
 933         MM_SOUND_DEVICE_IN_MIC                          = 0x01,         /**< Device builtin mic. */
 934         MM_SOUND_DEVICE_IN_WIRED_ACCESSORY      = 0x02,         /**< Wired input devices */
 935         MM_SOUND_DEVICE_IN_BT_SCO       = 0x08,         /**< Bluetooth SCO device */
 936 } mm_sound_device_in;
 937
 938 typedef enum{
 939         MM_SOUND_DEVICE_OUT_NONE                        = 0x000,
 940         MM_SOUND_DEVICE_OUT_SPEAKER             = 0x001<<8,     /**< Device builtin speaker */
 941         MM_SOUND_DEVICE_OUT_RECEIVER            = 0x002<<8,     /**< Device builtin receiver */
 942         MM_SOUND_DEVICE_OUT_WIRED_ACCESSORY     = 0x004<<8,     /**< Wired output devices such as headphone, headset, and so on. */
 943         MM_SOUND_DEVICE_OUT_BT_SCO                      = 0x008<<8,     /**< Bluetooth SCO device */
 944         MM_SOUND_DEVICE_OUT_BT_A2DP             = 0x010<<8,     /**< Bluetooth A2DP device */
 945         MM_SOUND_DEVICE_OUT_DOCK                        = 0x020<<8,     /**< DOCK device */
 946         MM_SOUND_DEVICE_OUT_HDMI                        = 0x040<<8,     /**< HDMI device */
 947         MM_SOUND_DEVICE_OUT_MIRRORING           = 0x080<<8, /**< MIRRORING device */
 948         MM_SOUND_DEVICE_OUT_USB_AUDIO           = 0x100<<8,     /**< USB Audio device */
 949         MM_SOUND_DEVICE_OUT_MULTIMEDIA_DOCK     = 0x200<<8,     /**< Multimedia DOCK device */
 950 } mm_sound_device_out;
 951
 952 typedef enum {
 953         MM_SOUND_VOLUME_DEVICE_OUT_SPEAKER,                             /**< Device builtin speaker */
 954         MM_SOUND_VOLUME_DEVICE_OUT_RECEIVER,                    /**< Device builtin receiver */
 955         MM_SOUND_VOLUME_DEVICE_OUT_WIRED_ACCESSORY,             /**< Wired output devices such as headphone, headset, and so on. */
 956         MM_SOUND_VOLUME_DEVICE_OUT_BT_SCO,                              /**< Bluetooth SCO device */
 957         MM_SOUND_VOLUME_DEVICE_OUT_BT_A2DP,                             /**< Bluetooth A2DP device */
 958         MM_SOUND_VOLUME_DEVICE_OUT_DOCK,                                /**< DOCK device */
 959         MM_SOUND_VOLUME_DEVICE_OUT_HDMI,                                /**< HDMI device */
 960         MM_SOUND_VOLUME_DEVICE_OUT_MIRRORING,                   /**< MIRRORING device */
 961         MM_SOUND_VOLUME_DEVICE_OUT_USB_AUDIO,                   /**< USB Audio device */
 962         MM_SOUND_VOLUME_DEVICE_OUT_MULTIMEDIA_DOCK,             /**< Multimedia DOCK device */
 963 } mm_sound_volume_device_out_t;
 964
 965 #define MM_SOUND_ROUTE_NUM 16
 966 #define MM_SOUND_NAME_NUM 32
 967
 968 /*
 969  * MMSound Device APIs
 970  */
 971
 972 typedef enum {
 973         MM_SOUND_DEVICE_IO_DIRECTION_IN_FLAG      = 0x0001,  /**< Flag for input devices */
 974         MM_SOUND_DEVICE_IO_DIRECTION_OUT_FLAG     = 0x0002,  /**< Flag for output devices */
 975         MM_SOUND_DEVICE_IO_DIRECTION_BOTH_FLAG    = 0x0004,  /**< Flag for input/output devices (both directions are available) */
 976         MM_SOUND_DEVICE_TYPE_INTERNAL_FLAG        = 0x0010,  /**< Flag for built-in devices */
 977         MM_SOUND_DEVICE_TYPE_EXTERNAL_FLAG        = 0x0020,  /**< Flag for external devices */
 978         MM_SOUND_DEVICE_STATE_DEACTIVATED_FLAG    = 0x1000,  /**< Flag for deactivated devices */
 979         MM_SOUND_DEVICE_STATE_ACTIVATED_FLAG      = 0x2000,  /**< Flag for activated devices */
 980         MM_SOUND_DEVICE_ALL_FLAG                  = 0xFFFF,  /**< Flag for all devices */
 981 } mm_sound_device_flags_e;
 982
 983 typedef enum {
 984         MM_SOUND_DEVICE_IO_DIRECTION_IN           = 0x1,
 985         MM_SOUND_DEVICE_IO_DIRECTION_OUT          = 0x2,
 986         MM_SOUND_DEVICE_IO_DIRECTION_BOTH         = MM_SOUND_DEVICE_IO_DIRECTION_IN | MM_SOUND_DEVICE_IO_DIRECTION_OUT,
 987 } mm_sound_device_io_direction_e;
 988
 989 typedef enum {
 990         MM_SOUND_DEVICE_STATE_DEACTIVATED,
 991         MM_SOUND_DEVICE_STATE_ACTIVATED,
 992 } mm_sound_device_state_e;
 993
 994 typedef enum
 995 {
 996         MM_SOUND_DEVICE_TYPE_BUILTIN_SPEAKER,   /**< Built-in speaker. */
 997         MM_SOUND_DEVICE_TYPE_BUILTIN_RECEIVER,  /**< Built-in receiver. */
 998         MM_SOUND_DEVICE_TYPE_BUILTIN_MIC,       /**< Built-in mic. */
 999         MM_SOUND_DEVICE_TYPE_AUDIOJACK,         /**< Audio jack such as headphone, headset, and so on. */
1000         MM_SOUND_DEVICE_TYPE_BLUETOOTH,         /**< Bluetooth */
1001         MM_SOUND_DEVICE_TYPE_BLUETOOTH_A2DP = MM_SOUND_DEVICE_TYPE_BLUETOOTH,    /**< Bluetooth A2DP */
1002         MM_SOUND_DEVICE_TYPE_HDMI,              /**< HDMI. */
1003         MM_SOUND_DEVICE_TYPE_MIRRORING,         /**< MIRRORING. */
1004         MM_SOUND_DEVICE_TYPE_USB_AUDIO,         /**< USB Audio. */
1005         MM_SOUND_DEVICE_TYPE_BLUETOOTH_SCO,     /**< Bluetooth SCO */
1006 } mm_sound_device_type_e;
1007
1008 typedef void *MMSoundDevice_t;          /**< MMsound Device handle */
1009 typedef void *MMSoundDeviceList_t;      /**< MMsound Device list handle */
1010 typedef void (*mm_sound_device_connected_cb) (MMSoundDevice_t device_h, bool is_connected, void *user_data);
1011 typedef void (*mm_sound_device_info_changed_cb) (MMSoundDevice_t device_h, int changed_info_type, void *user_data);
1012 typedef void (*mm_sound_device_state_changed_cb) (MMSoundDevice_t device_h, mm_sound_device_state_e state, void *user_data);
1013
1014 int mm_sound_add_device_connected_callback(int flags, mm_sound_device_connected_cb func, void *user_data, unsigned int *id);
1015 int mm_sound_remove_device_connected_callback(unsigned int id);
1016 int mm_sound_add_device_information_changed_callback(int flags, mm_sound_device_info_changed_cb func, void *user_data, unsigned int *id);
1017 int mm_sound_remove_device_information_changed_callback(unsigned int id);
1018 int mm_sound_add_device_state_changed_callback(int flags, mm_sound_device_state_changed_cb func, void *user_data, unsigned int *id);
1019 int mm_sound_remove_device_state_changed_callback(unsigned int id);
1020
1021 int mm_sound_get_current_device_list(mm_sound_device_flags_e device_mask, MMSoundDeviceList_t *device_list);
1022 int mm_sound_get_device_list(int device_mask, MMSoundDeviceList_t *device_list);
1023 int mm_sound_free_device_list(MMSoundDeviceList_t device_list);
1024 int mm_sound_get_next_device (MMSoundDeviceList_t device_list, MMSoundDevice_t *device);
1025 int mm_sound_get_prev_device (MMSoundDeviceList_t device_list, MMSoundDevice_t *device);
1026 int mm_sound_get_device_type(MMSoundDevice_t device_h, mm_sound_device_type_e *type);
1027 int mm_sound_get_device_io_direction(MMSoundDevice_t device_h, mm_sound_device_io_direction_e *io_direction);
1028 int mm_sound_get_device_id(MMSoundDevice_t device_h, int *id);
1029 int mm_sound_get_device_state(MMSoundDevice_t device_h, mm_sound_device_state_e *state);
1030 int mm_sound_get_device_name(MMSoundDevice_t device_h, char **name);
1031
1032 /**
1033  * Active device changed callback function type.
1034  *
1035  * @param       user_data               [in]    Argument passed when callback has called
1036  *
1037  * @return      No return value
1038  * @remark      None.
1039  * @see         mm_sound_add_active_device_changed_callback mm_sound_remove_active_device_changed_callback
1040  */
1041 typedef void (*mm_sound_active_device_changed_cb) (mm_sound_device_in device_in, mm_sound_device_out device_out, void *user_data);
1042
1043 typedef void (*mm_sound_test_cb) (int a, void *user_data);
1044 int mm_sound_test(int a, int b, int* get);
1045 int mm_sound_add_test_callback(mm_sound_test_cb func, void *user_data, unsigned int *id);
1046 int mm_sound_remove_test_callback(unsigned int sub_id);
1047
1048 void mm_sound_convert_volume_type_to_stream_type(int volume_type, char *stream_type);
1049
1050 typedef enum {
1051         MM_SOUND_SIGNAL_RELEASE_INTERNAL_FOCUS,
1052         MM_SOUND_SIGNAL_MAX,
1053 } mm_sound_signal_name_t;
1054
1055 typedef void (*mm_sound_signal_callback) (mm_sound_signal_name_t signal_type, int value, void *user_data);
1056 int mm_sound_subscribe_signal(mm_sound_signal_name_t signal_type, unsigned int *subscribe_id, mm_sound_signal_callback callback, void *user_data);
1057 int mm_sound_subscribe_signal_for_daemon(mm_sound_signal_name_t signal_type, int client_pid, unsigned int *subscribe_id, mm_sound_signal_callback callback, void *user_data);
1058 void mm_sound_unsubscribe_signal(unsigned int subscribe_id);
1059 int mm_sound_send_signal(mm_sound_signal_name_t signal_type, int value);
1060 int mm_sound_get_signal_value(mm_sound_signal_name_t signal_type, int *value);
1061 int mm_sound_is_stream_on_device(int stream_id, MMSoundDevice_t device_h, bool *is_on);
1062
1063 /**
1064         @}
1065  */
1066
1067 #ifdef __cplusplus
1068 }
1069 #endif
1070
1071 #endif  /* __MM_SOUND_H__ */
1072