开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > MTK > 查看源码
volume_setting.cpp
资源名称：Maui_META_src_v5.0808.0.zip　[点击查看]
上传用户：gelin96
上传日期：2017-01-08
资源大小：20993k
文件大小：36k
源码类别：

MTK

开发平台：

C++ Builder

volume_setting.cpp：源码内容
  1. /*****************************************************************************
  2. *  Copyright Statement:
  3. *  --------------------
  4. *  This software is protected by Copyright and the information contained
  5. *  herein is confidential. The software may not be copied and the information
  6. *  contained herein may not be used or disclosed except with the written
  7. *  permission of MediaTek Inc. (C) 2005
  8. *
  9. *  BY OPENING THIS FILE, BUYER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
  10. *  THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
  11. *  RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO BUYER ON
  12. *  AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
  13. *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
  14. *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
  15. *  NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
  16. *  SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
  17. *  SUPPLIED WITH THE MEDIATEK SOFTWARE, AND BUYER AGREES TO LOOK ONLY TO SUCH
  18. *  THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. MEDIATEK SHALL ALSO
  19. *  NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE RELEASES MADE TO BUYER'S
  20. *  SPECIFICATION OR TO CONFORM TO A PARTICULAR STANDARD OR OPEN FORUM.
  21. *
  22. *  BUYER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND CUMULATIVE
  23. *  LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
  24. *  AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
  25. *  OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY BUYER TO
  26. *  MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
  27. *
  28. *  THE TRANSACTION CONTEMPLATED HEREUNDER SHALL BE CONSTRUED IN ACCORDANCE
  29. *  WITH THE LAWS OF THE STATE OF CALIFORNIA, USA, EXCLUDING ITS CONFLICT OF
  30. *  LAWS PRINCIPLES.  ANY DISPUTES, CONTROVERSIES OR CLAIMS ARISING THEREOF AND
  31. *  RELATED THERETO SHALL BE SETTLED BY ARBITRATION IN SAN FRANCISCO, CA, UNDER
  32. *  THE RULES OF THE INTERNATIONAL CHAMBER OF COMMERCE (ICC).
  33. *
  34. *****************************************************************************/
  35. /*****************************************************************************
  36.  *
  37.  * Filename:
  38.  * ---------
  39.  *   volume_setting.cpp
  40.  *
  41.  * Project:
  42.  * --------
  43.  *   Maui META APP
  44.  *
  45.  * Description:
  46.  * ------------
  47.  *  Acoustic volume setting source
  48.  *
  49.  * Author:
  50.  * -------
  51.  *  Andy Ueng (mtk00490)
  52.  *
  53.  *============================================================================
  54.  *             HISTORY
  55.  * Below this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  56.  *------------------------------------------------------------------------------
  57.  * $Revision$
  58.  * $Modtime$
  59.  * $Log$
  60.  * 
  61.  *------------------------------------------------------------------------------
  62.  * Upper this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  63.  *============================================================================
  64.  ****************************************************************************/
  65. //---------------------------------------------------------------------------
  66. #include <IniFiles.hpp>
  68. #pragma hdrstop
  70. #ifndef _VOLUME_SETTING_H_
  71. #include "volume_setting.h"
  72. #endif
  74. #ifndef  _MAN_ACTIVE_H_
  75. #include "man_active.h"
  76. #endif
  78. #ifndef  _MAN_FDM_H_
  79. #include "man_fdm.h"
  80. #endif
  83. //===========================================================================
  84. static CVOLSET*  volume_setting_ptr;
  85. static bool g_bIsRunning = false;
  87. //===========================================================================
  88. static void CNF_ReadFromNVRAM(void)
  89. {
  90.     volume_setting_ptr->CNF_ReadFromNVRAM();
  91. }
  93. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  94. static void CNF_WriteToNVRAM(void)
  95. {
  96.     volume_setting_ptr->CNF_WriteToNVRAM();
  97. }
  99. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  100. static void REQ_Get_Runtime_CustVol(void)
  101. {
  102.     volume_setting_ptr->REQ_Get_Runtime_CustVol();
  103. }
  105. //---------------------------------------------------------------------------
  106. static void REQ_Set_Runtime_CustVol(void)
  107. {
  108.     volume_setting_ptr->REQ_Set_Runtime_CustVol();
  109. }
  111. //===========================================================================
  112. CVOLSET::CVOLSET(void)
  113. {
  114.     g_bIsRunning = false;
  115.     ConfirmCallback = NULL;
  116.     m_pcVolSetBuf = NULL;
  117. }
  119. //---------------------------------------------------------------------------
  120. CVOLSET::~CVOLSET()
  121. {
  122.     g_bIsRunning = false;
  123.     ConfirmCallback = NULL;
  124.     ReleaseDynMemory();
  125. }
  127. //---------------------------------------------------------------------------
  128. void CVOLSET::Init(void)
  129. {
  130.     ReleaseDynMemory();
  131. }
  133. //---------------------------------------------------------------------------
  134. void CVOLSET::ReleaseDynMemory(void)
  135. {
  136.     if (NULL == m_pcVolSetBuf)
  137.     {
  138.         delete [] m_pcVolSetBuf;
  139.         m_pcVolSetBuf = NULL;
  140.         m_iVolSetBufSize = 0;
  141.     }
  142. }
  144. //---------------------------------------------------------------------------
  145. void CVOLSET::REQ_Stop(void)
  146. {
  147.     if (!g_bIsRunning)
  148.     {
  149.         return;
  150.     }
  151.     Confirm(METAAPP_STOP);
  152. }
  154. //---------------------------------------------------------------------------
  155. void CVOLSET::Confirm(E_METAAPP_RESULT_T confirm_state)
  156. {
  157.     if (!g_bIsRunning)
  158.     {
  159.         return;
  160.     }
  162.     g_bIsRunning = false;
  163.     if (NULL == ConfirmCallback)
  164.     {
  165.         return;
  166.     }
  167.     m_eConfirmState = confirm_state;
  168.     ActiveMan->SetActiveFunction(ConfirmCallback);
  169. }
  171. //===========================================================================
  172. ///////////////////////////  NVRAM read/write   /////////////////////////////
  173. //===========================================================================
  174. void CVOLSET::REQ_Read_From_NVRAM(bool CustVolExSupport)
  175. {
  176.     volume_setting_ptr = this;
  177.     g_bIsRunning = true;
  178.     m_bCustVolExSupport = CustVolExSupport;
  179.     if (NULL == m_pcVolSetBuf)
  180.     {
  181.         META_RESULT MetaResult = META_NVRAM_GetRecLen("NVRAM_EF_CUST_ACOUSTIC_DATA_LID",
  182.                                                       &m_iVolSetBufSize
  183.                                                       );
  184.         if (MetaResult != META_SUCCESS)
  185.         {
  186.             Confirm(METAAPP_FAIL);
  187.             return;
  188.         }
  189.         m_pcVolSetBuf = new  char[m_iVolSetBufSize];
  190.    }
  191.    NVRAMMan->ConfirmCallback = ::CNF_ReadFromNVRAM;
  192.    NVRAMMan->REQ_ReadNVRAM_Start("NVRAM_EF_CUST_ACOUSTIC_DATA_LID",
  193.                                  1,
  194.                                   m_iVolSetBufSize,
  195.                                   m_pcVolSetBuf );
  196. }
  198. //-------------------------------------
  199. void CVOLSET::CNF_ReadFromNVRAM(void)
  200. {
  201.     if (!g_bIsRunning)
  202.     {
  203.         return;
  204.     }
  206.     E_METAAPP_RESULT_T state = NVRAMMan->Get_ConfirmState();
  207.     switch (state)
  208.     {
  209.         case METAAPP_SUCCESS:
  210.         {
  211.             if (!Decompose_CustAcousticVol())
  212.             {
  213.                 Confirm(METAAPP_FAIL);
  214.                 return;
  215.             }
  216.             Confirm(METAAPP_SUCCESS);
  217.        }
  218.        break;
  220.        default:
  221.        {
  222.            Confirm(state);
  223.        }
  224.        break;
  225.    }
  226. }
  228. //---------------------------------------------------------------------------
  229. bool  CVOLSET::Compose_CustAcousticVol(void)
  230. {
  231.     META_RESULT MetaResult;
  232.     if( ! m_bCustVolExSupport )
  233.     {
  234.         MetaResult = META_NVRAM_Compose_CustAcousticVol(&m_sCustVol, m_pcVolSetBuf, m_iVolSetBufSize);
  235.     }
  236.     else
  237.     {   MetaResult = META_NVRAM_Compose_16lvlCustAcousticVol(&m_sCustVolEx, m_pcVolSetBuf, m_iVolSetBufSize);
  238.     }
  239.     if(MetaResult!=META_SUCCESS)     return false;
  241.     return true;
  242. }
  244. //-------------------------------------
  245. bool  CVOLSET::Decompose_CustAcousticVol(void)
  246. {
  247.     META_RESULT MetaResult;
  248.     if (!m_bCustVolExSupport)
  249.     {
  250.         MetaResult = META_NVRAM_Decompose_CustAcousticVol(&m_sCustVol, m_pcVolSetBuf,  m_iVolSetBufSize);
  251.     }
  252.     else
  253.     {   MetaResult = META_NVRAM_Decompose_16lvlCustAcousticVol(&m_sCustVolEx, m_pcVolSetBuf,  m_iVolSetBufSize);
  254.     }
  255.     if (MetaResult != META_SUCCESS)
  256.     {
  257.         return false;
  258.     }
  259.     return true;
  260. }
  262. //===========================================================================
  263. void  CVOLSET::REQ_Write_To_NVRAM(bool CustVolExSupport, bool b_runtime_support)
  264. {
  265.     volume_setting_ptr = this;
  266.     g_bIsRunning = true;
  267.     m_bCustVolExSupport = CustVolExSupport;
  268.     m_bRuntimeSupport   = b_runtime_support;
  270.     if (NULL == m_pcVolSetBuf)
  271.     {
  272.         META_RESULT MetaResult = META_NVRAM_GetRecLen("NVRAM_EF_CUST_ACOUSTIC_DATA_LID", &m_iVolSetBufSize);
  273.         if (MetaResult != META_SUCCESS)
  274.         {
  275.             Confirm(METAAPP_FAIL);
  276.             return;
  277.         }
  278.         m_pcVolSetBuf = new  char[m_iVolSetBufSize];
  279.     }
  281.     if (!Compose_CustAcousticVol())
  282.     {
  283.         Confirm(METAAPP_FAIL);
  284.         return;
  285.     }
  286.     NVRAMMan->ConfirmCallback = ::CNF_WriteToNVRAM;
  287.     NVRAMMan->REQ_WriteNVRAM_Start("NVRAM_EF_CUST_ACOUSTIC_DATA_LID",
  288.                                   1,
  289.                                    m_iVolSetBufSize,
  290.                                    m_pcVolSetBuf);
  291. }
  293. //-------------------------------------
  294. void  CVOLSET::CNF_WriteToNVRAM(void)
  295. {
  296.     if (!g_bIsRunning)
  297.     {
  298.         return;
  299.     }
  301.     E_METAAPP_RESULT_T state = NVRAMMan->Get_ConfirmState();
  302.     if (METAAPP_SUCCESS == state)
  303.     {
  304.         if (m_bRuntimeSupport)
  305.         {
  306.             ActiveMan->SetActiveFunction(::REQ_Set_Runtime_CustVol);
  307.             return;
  308.         }    
  309.     }
  311.     Confirm(state);
  312. }
  314. //===========================================================================
  315. ///////////////////////////// runtime setting ///////////////////////////////
  316. //===========================================================================
  317. void CVOLSET::REQ_Get_Runtime_CustVol_Start(void)
  318. {
  319.     volume_setting_ptr = this;
  320.     g_bIsRunning = true;
  321.     ActiveMan->SetActiveFunction(::REQ_Get_Runtime_CustVol);
  322. }
  324. //---------------------------------------------------------------------------
  325. void CVOLSET::REQ_Get_Runtime_CustVol(void)
  326. {
  327.     if (!g_bIsRunning)
  328.     {
  329.         return;
  330.     }
  332.     Audio_Get_Profile_Settings_By_Mode_Req_T req;
  333.     Audio_Get_Profile_Settings_By_Mode_Cnf_T cnf;
  334.     unsigned char ucTotalModeNum = 3;
  335.     for (unsigned char ucMode = 0; ucMode < ucTotalModeNum; ucMode++)
  336.     {
  337.         req.m_ucMode = ucMode;
  338.         META_RESULT MetaResult = META_Audio_Get_Audio_Profile_Settings_r(m_META_HANDLE_Obj.Get_MainHandle(), 5000, &req, &cnf);
  339.         if (MetaResult != META_SUCCESS)
  340.         {
  341.             if (MetaResult != META_TIMEOUT)
  342.             {
  343.                 Confirm(METAAPP_FAIL);
  344.                 return;
  345.             }
  346.             else
  347.             {
  348.                 Confirm(METAAPP_TIMEOUT);
  349.                 return;
  350.             }
  351.         }
  352.     }
  353.     Confirm(METAAPP_SUCCESS);
  354. }
  356. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  357. void CVOLSET::REQ_Set_Runtime_CustVol_Start(void)
  358. {
  359.     volume_setting_ptr = this;
  360.     g_bIsRunning = true;
  361.     ActiveMan->SetActiveFunction(::REQ_Set_Runtime_CustVol);
  362. }
  364. //---------------------------------------------------------------------------
  365. void CVOLSET::REQ_Set_Runtime_CustVol(void)
  366. {
  367.     if (!g_bIsRunning)
  368.     {
  369.         return;
  370.     }
  372.     Audio_Set_Profile_Settings_By_Mode_Req_T req;
  373.     Audio_Set_Profile_Settings_By_Mode_Cnf_T cnf;
  374.     unsigned char ucTotalModeNum = 3;
  375.     for (unsigned char ucMode = 0; ucMode < ucTotalModeNum; ucMode++)
  376.     {
  377.         req.mode = ucMode;
  378.         ComposeCustAcousticVol16Lvl(m_sCustVolEx, req);
  379.        // req.m_ucMode = ucMode;
  380.         META_RESULT MetaResult = META_Audio_Set_Audio_Profile_Settings_r(m_META_HANDLE_Obj.Get_MainHandle(), 5000, &req, &cnf);
  381.         if (MetaResult != META_SUCCESS)
  382.         {
  383.             if (MetaResult != META_TIMEOUT)
  384.             {
  385.                 Confirm(METAAPP_FAIL);
  386.                 return;
  387.             }
  388.             else
  389.             {
  390.                 Confirm(METAAPP_TIMEOUT);
  391.                 return;
  392.             }
  393.         }
  394.     }
  395.     Confirm(METAAPP_SUCCESS);
  396. }
  398. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  399. void CVOLSET::ComposeCustAcousticVol(CustAcousticVol_T s_cust_vol, Audio_Get_Profile_Settings_By_Mode_Cnf_T& s_runtime)
  400. {
  401.     s_runtime.sidetone = s_cust_vol.volume_gain[s_runtime.mode][SIDE_TONE_TYPE][0];
  402.     for (int i = 0; i < CUST_VOL_LEVEL_NUM; i++)
  403.     {
  404.         s_runtime.keytone[i] = s_cust_vol.volume_gain[s_runtime.mode][KEYPAD_TONE_TYPE][i];
  405.         s_runtime.mic[i]     = s_cust_vol.volume_gain[s_runtime.mode][MICROPHONE_TYPE][i];
  406.         s_runtime.sound[i]   = s_cust_vol.volume_gain[s_runtime.mode][GMI_TONE_TYPE][i];
  407.         s_runtime.speech[i]  = s_cust_vol.volume_gain[s_runtime.mode][SPEECH_TONE_TYPE][i];
  408.         s_runtime.melody[i]  = s_cust_vol.volume_gain[s_runtime.mode][MELODY_TYPE][i];
  409.     }
  410. }
  412. //---------------------------------------------------------------------------
  413. void CVOLSET::DeComposeCustAcousticVol(Audio_Get_Profile_Settings_By_Mode_Cnf_T s_runtime, CustAcousticVol_T& s_cust_vol)
  414. {
  415.     for (int i = 0; i < CUST_VOL_LEVEL_NUM; i++)
  416.     {
  417.         s_cust_vol.volume_gain[s_runtime.mode][KEYPAD_TONE_TYPE][i] = s_runtime.keytone[i];
  418.         s_cust_vol.volume_gain[s_runtime.mode][MICROPHONE_TYPE][i]  = s_runtime.mic[i];
  419.         s_cust_vol.volume_gain[s_runtime.mode][GMI_TONE_TYPE][i]    = s_runtime.sound[i];
  420.         s_cust_vol.volume_gain[s_runtime.mode][SPEECH_TONE_TYPE][i] = s_runtime.speech[i];
  421.         s_cust_vol.volume_gain[s_runtime.mode][SIDE_TONE_TYPE][i]   = s_runtime.sidetone;
  422.         s_cust_vol.volume_gain[s_runtime.mode][MELODY_TYPE][i]      = s_runtime.melody[i];
  423.     }
  424. }
  426. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  427. void CVOLSET::ComposeCustAcousticVol16Lvl(CustAcousticVol16lvl_T s_cust_vol, Audio_Set_Profile_Settings_By_Mode_Req_T& s_runtime)
  428. {
  429.     for (int i = 0; i < CUST_VOL_LEVEL_NUM; i++)
  430.     {
  431.         //s_runtime. = s_cust_vol.volume_gain[s_runtime.mode][CALL_TONE_TYPE][i];
  432.         s_runtime.keytone[i]            = s_cust_vol.volume_gain[s_runtime.mode][KEYPAD_TONE_TYPE][i];
  433.         s_runtime.mic[i]                = s_cust_vol.volume_gain[s_runtime.mode][MICROPHONE_TYPE][i];
  434.         s_runtime.sound[i]              = s_cust_vol.volume_gain[s_runtime.mode][GMI_TONE_TYPE][i];
  435.         s_runtime.speech[i]             = s_cust_vol.volume_gain[s_runtime.mode][SPEECH_TONE_TYPE][i];
  436.         s_runtime.sidetone              = s_cust_vol.volume_gain[s_runtime.mode][SIDE_TONE_TYPE][i];
  437.         s_runtime.melody[i]             = s_cust_vol.volume_gain[s_runtime.mode][MELODY_TYPE][i];
  438.         s_runtime.tv_out_volume_gain[i] = s_cust_vol.tv_out_volume_gain[i];
  439.     }
  440.     s_runtime.max_melody_volume_gain  = s_cust_vol.max_melody_volume_gain[s_runtime.mode];
  441.     s_runtime.melody_volume_gain_step = s_cust_vol.melody_volume_gain_step[s_runtime.mode];
  442. }
  444. //---------------------------------------------------------------------------
  445. void CVOLSET::DeComposeCustAcousticVol16Lvl(Audio_Get_Profile_Settings_By_Mode_Cnf_T s_runtime, CustAcousticVol16lvl_T& s_cust_vol)
  446. {
  447.     for (int i = 0; i < CUST_VOL_LEVEL_NUM; i++)
  448.     {
  449.         //s_cust_vol.volume_gain[s_runtime.mode][CALL_TONE_TYPE][i]   = s_runtime.
  450.         s_cust_vol.volume_gain[s_runtime.mode][KEYPAD_TONE_TYPE][i] = s_runtime.keytone[i];
  451.         s_cust_vol.volume_gain[s_runtime.mode][MICROPHONE_TYPE][i]  = s_runtime.mic[i];
  452.         s_cust_vol.volume_gain[s_runtime.mode][GMI_TONE_TYPE][i]    = s_runtime.sound[i];
  453.         s_cust_vol.volume_gain[s_runtime.mode][SPEECH_TONE_TYPE][i] = s_runtime.speech[i];
  454.         s_cust_vol.volume_gain[s_runtime.mode][SIDE_TONE_TYPE][i]   = s_runtime.sidetone;
  455.         s_cust_vol.volume_gain[s_runtime.mode][MELODY_TYPE][i]      = s_runtime.melody[i];
  457.     }
  458.     s_cust_vol.max_melody_volume_gain[s_runtime.mode]  = s_runtime.max_melody_volume_gain;
  459.     s_cust_vol.melody_volume_gain_step[s_runtime.mode] = s_runtime.melody_volume_gain_step;
  460. }
  462. //===========================================================================
  463. ///////////////////////////// file read/write ///////////////////////////////
  464. //===========================================================================
  465. bool CVOLSET::REQ_Read_From_File( char *filename, bool CustVolExSupport )
  466. {
  467.     TIniFile   *ini_file;
  468.     AnsiString  data;
  469.     AnsiString  CategoryStr;
  470.     AnsiString  ItemStr;
  471.     int         i, j, k;
  472.     AnsiString VolumeMode[] = { "Normal", "Headset", "Handfree", "TV Out" };
  473.     AnsiString ToneType[] = {"Call Tone", "Keypad Tone", "Microphone", "GMI Tone", "Speech Tone", "Side Tone", "Melody"};
  474.     AnsiString VolumeLevel[] = { "Level 0", "Level 1", "Level 2", "Level 3", "Level 4", "Level 5", "Level 6"};
  476.     ini_file = new TIniFile( filename );
  477.     if( ini_file == NULL )  return false;
  479.     // Volume level
  480.     for (i=0; i<TOTAL_AUDIO_MODE_NUM-1; i++)
  481.     {
  482.         for (j=0; j<TOTAL_TONE_NUM; j++)
  483.         {
  484.             if( j!= MICROPHONE_INDEX && j!= SIDE_TONE_INDEX && j!=CALL_TONE_INDEX && j!=GMI_TONE_INDEX )
  485.             {
  486.                 CategoryStr = VolumeMode[i] + " Volume Level";
  487.                 ItemStr = ToneType[j];
  488.                 if( ! CustVolExSupport )
  489.                 {
  490.                     m_sCustVol.volume[i][j] = ini_file->ReadInteger(CategoryStr, ItemStr, 3);
  491.                 }
  492.                 else
  493.                 {   m_sCustVolEx.volume[i][j] = ini_file->ReadInteger(CategoryStr, ItemStr, 3);
  494.                 }
  495.             }
  496.         }
  497.    }
  499.    // Volume gain
  500.    for (i=0; i<TOTAL_AUDIO_MODE_NUM-1; i++)
  501.    {
  502.         for (j=0; j<TOTAL_TONE_NUM; j++)
  503.         {
  504.             if( j != MICROPHONE_INDEX && j != SIDE_TONE_INDEX && j!=CALL_TONE_INDEX && j!=GMI_TONE_INDEX )
  505.             {
  506.                 for (k=0; k<TOTAL_VOLUME_LEVEL_NUM; k++)
  507.                 {
  508.                     CategoryStr = VolumeMode[i] + " Volume Gain";
  509.                     ItemStr = ToneType[j] + " " + VolumeLevel[k];
  510.                     if( ! CustVolExSupport )
  511.                     {
  512.                         m_sCustVol.volume_gain[i][j][k] = ini_file->ReadInteger(CategoryStr, ItemStr, 0);
  513.                     }
  514.                     else
  515.                     {   m_sCustVolEx.volume_gain[i][j][k] = ini_file->ReadInteger(CategoryStr, ItemStr, 0);
  516.                     }
  517.                 }
  518.             }
  519.             else if( j == MICROPHONE_INDEX || j == SIDE_TONE_INDEX )
  520.             {
  521.                 CategoryStr = VolumeMode[i] + " Volume Gain";
  522.                 ItemStr = ToneType[j] + " " + VolumeLevel[0];
  523.                 if( ! CustVolExSupport )
  524.                 {
  525.                     m_sCustVol.volume_gain[i][j][0] = ini_file->ReadInteger(CategoryStr, ItemStr, 0);
  526.                 }
  527.                 else
  528.                 {   m_sCustVolEx.volume_gain[i][j][0] = ini_file->ReadInteger(CategoryStr, ItemStr, 0);
  529.                 }
  530.             }
  531.         }
  532.    }
  534.    if( CustVolExSupport )
  535.    {
  536.        for(i=0; i<TOTAL_AUDIO_MODE_NUM; i++)
  537.        {
  538.            CategoryStr = "16 Level Max Melody Volume Gain";
  539.            ItemStr = VolumeMode[i] + " Max Melody Volume Gain";
  540.            m_sCustVolEx.max_melody_volume_gain[i] = ini_file->ReadInteger( CategoryStr, ItemStr, 0 );
  541.        }
  543.        for(i=0; i<TOTAL_AUDIO_MODE_NUM; i++)
  544.        {
  545.            CategoryStr = "16 Level Melody Volume Gain Step";
  546.            ItemStr = VolumeMode[i] + " Melody Volume Gain Step";
  547.            m_sCustVolEx.melody_volume_gain_step[i] = ini_file->ReadInteger( CategoryStr, ItemStr, 0 );
  548.        }
  550.        for( i=0; i<TOTAL_VOLUME_LEVEL_NUM; i++ )
  551.        {
  552.            CategoryStr = "TV Out Volume Gain";
  553.            ItemStr = "TV Out Volume Gain " + IntToStr(i);
  554.            m_sCustVolEx.tv_out_volume_gain[i] = ini_file->ReadInteger( CategoryStr, ItemStr, 0 );
  555.        }
  556.    }
  558.    delete  ini_file;
  559.    return  true;
  560. }
  562. //-----------------------------------------------------------------------------------------------
  563. bool  CVOLSET::REQ_Write_To_File( char *filename, bool hideEnable, bool CustVolExSupport )
  564. {
  565.    TIniFile   *ini_file;
  566.    AnsiString  data;
  567.    AnsiString  CategoryStr;
  568.    AnsiString  ItemStr;
  569.    int         i, j, k;
  570.    AnsiString VolumeMode[] = { "Normal", "Headset", "Handfree", "TV Out" };
  571.    AnsiString ToneType[] = {"Call Tone", "Keypad Tone", "Microphone", "GMI Tone", "Speech Tone", "Side Tone", "Melody"};
  572.    AnsiString VolumeLevel[] = { "Level 0", "Level 1", "Level 2", "Level 3", "Level 4", "Level 5", "Level 6"};
  574.    ini_file = new TIniFile( filename );
  575.    if( ini_file == NULL )  return  false;
  577.    if (ini_file != NULL)
  578.    {
  579.       // Volume level
  580.       for (i=0; i<TOTAL_AUDIO_MODE_NUM-1; i++)
  581.       {
  582.           for (j=0; j<TOTAL_TONE_NUM; j++)
  583.           {
  584.               if( j!= MICROPHONE_INDEX && j!= SIDE_TONE_INDEX && j!=CALL_TONE_INDEX && j!=GMI_TONE_INDEX )
  585.               {
  586.                     CategoryStr = VolumeMode[i] + " Volume Level";
  587.                     ItemStr = ToneType[j];
  588.                     if( ! CustVolExSupport )
  589.                     {
  590.                         ini_file->WriteInteger( CategoryStr, ItemStr, m_sCustVol.volume[i][j]  );
  591.                     }
  592.                     else
  593.                     {
  594.                         ini_file->WriteInteger( CategoryStr, ItemStr, m_sCustVolEx.volume[i][j]  );
  595.                     }
  596.                }
  597.           }
  598.       }
  600.       for (i=0; i<TOTAL_AUDIO_MODE_NUM-1; i++)
  601.       {
  602.           for (j=0; j<TOTAL_TONE_NUM; j++)
  603.           {
  604.               for (k=0; k<TOTAL_VOLUME_LEVEL_NUM; k++)
  605.               {
  606.                   if( j != MICROPHONE_INDEX && j != SIDE_TONE_INDEX && j!=CALL_TONE_INDEX && j!=GMI_TONE_INDEX )
  607.                   {
  608.                       CategoryStr = VolumeMode[i] + " Volume Gain";
  609.                       ItemStr = ToneType[j] + " " + VolumeLevel[k];
  610.                       if( ! CustVolExSupport )
  611.                       {
  612.                           ini_file->WriteInteger( CategoryStr, ItemStr, m_sCustVol.volume_gain[i][j][k] );
  613.                       }
  614.                       else
  615.                       {
  616.                           ini_file->WriteInteger( CategoryStr, ItemStr, m_sCustVolEx.volume_gain[i][j][k] );
  617.                       }
  618.                   }
  619.                   else if( j == MICROPHONE_INDEX || j == SIDE_TONE_INDEX )
  620.                   {
  621.                         CategoryStr = VolumeMode[i] + " Volume Gain";
  622.                         ItemStr = ToneType[j] + " " + VolumeLevel[0];
  623.                         if( ! CustVolExSupport )
  624.                         {
  625.                             ini_file->WriteInteger( CategoryStr, ItemStr, m_sCustVol.volume_gain[i][j][0] );
  626.                         }
  627.                         else
  628.                         {   ini_file->WriteInteger( CategoryStr, ItemStr, m_sCustVolEx.volume_gain[i][j][0] );
  629.                         }
  630.                   }
  631.               }
  632.           }
  633.       }
  635.       if( CustVolExSupport )
  636.       {
  637.           for(i=0; i<TOTAL_AUDIO_MODE_NUM; i++)
  638.           {
  639.               CategoryStr = "16 Level Max Melody Volume Gain";
  640.               ItemStr = VolumeMode[i] + " Max Melody Volume Gain";
  641.               ini_file->WriteInteger( CategoryStr, ItemStr, m_sCustVolEx.max_melody_volume_gain[i] );
  642.           }
  644.           for(i=0; i<TOTAL_AUDIO_MODE_NUM; i++)
  645.           {
  646.               CategoryStr = "16 Level Melody Volume Gain Step";
  647.               ItemStr = VolumeMode[i] + " Melody Volume Gain Step";
  648.               ini_file->WriteInteger( CategoryStr, ItemStr, m_sCustVolEx.melody_volume_gain_step[i] );
  649.           }
  651.           for( i=0; i<TOTAL_VOLUME_LEVEL_NUM; i++ )
  652.           {
  653.               CategoryStr = "TV Out Volume Gain";
  654.               ItemStr = "TV Out Volume Gain " + IntToStr(i);
  655.               ini_file->WriteInteger( CategoryStr, ItemStr, m_sCustVolEx.tv_out_volume_gain[i] );
  656.           }
  657.       }
  658.       delete  ini_file;
  659.     }
  661.    return  true;
  662. }
  664. //===========================================================================
  665. bool  CVOLSET::REQ_Write_To_nvram_default_audio( char *filename, S_TONE_SUPPORT tone_support, bool CustVolExSupport )
  666. {
  667.     FILE *fs;
  668.     int  i, j, k;
  669.     AnsiString  as_str;
  670.     AnsiString  as_mode[MAX_VOL_CATE+1] = { (AnsiString) "NOR",
  671.                                           (AnsiString) "HED",
  672.                                           (AnsiString) "HND",
  673.                                           (AnsiString) "TVO"
  674.                                         };
  676.     AnsiString  as_type[MAX_VOL_TYPE] = { (AnsiString) "CTN",
  677.                                           (AnsiString) "KEY",
  678.                                           (AnsiString) "MIC",
  679.                                           (AnsiString) "GMI",
  680.                                           (AnsiString) "SPH",
  681.                                           (AnsiString) "SID",
  682.                                           (AnsiString) "MED"
  683.                                         };
  684.     AnsiString  as_comment[MAX_VOL_CATE] = { (AnsiString) "Normal",
  685.                                              (AnsiString) "Headset",
  686.                                              (AnsiString) "Handfree"
  687.                                            };
  688.     fs = fopen( filename, "w" );
  689.     if(fs==0)  return(false);
  691.     fprintf( fs, "#include "kal_release.h"nn");
  693.     if( CustVolExSupport )
  694.     {
  695.         for( i=0; i<MAX_VOL_CATE+1; i++ )
  696.         {
  697.             if( i != TVOUT_MODE )
  698.             {
  699.                 as_str = "#define GAIN_" + as_mode[i] + "_MED_VOL_MAX      " + m_sCustVolEx.max_melody_volume_gain[i] + "n";
  700.             }
  701.             else
  702.             {   as_str = "#define GAIN_" + as_mode[i] + "_VOL_MAX      " + m_sCustVolEx.max_melody_volume_gain[i] + "n";
  703.             }
  704.             fprintf( fs, as_str.c_str() );
  705.         }
  707.         for( i=0; i<MAX_VOL_CATE+1; i++ )
  708.         {
  709.             if( i != TVOUT_MODE )
  710.             {
  711.                 as_str = "#define GAIN_" + as_mode[i] + "_MED_VOL_STEP      " + m_sCustVolEx.melody_volume_gain_step[i] + "n";
  712.             }
  713.             else
  714.             {   as_str = "#define GAIN_" + as_mode[i] + "_VOL_STEP      " + m_sCustVolEx.melody_volume_gain_step[i] + "n";
  715.             }
  716.             fprintf( fs, as_str.c_str() );
  717.         }
  718.         fprintf( fs, "n" );
  719.         for( i=0; i<MAX_VOL_LEVEL; i++ )
  720.         {   as_str = "#define GAIN_TVO_VOL" + IntToStr(i) + "      " + m_sCustVolEx.tv_out_volume_gain[i] + "n";
  721.             fprintf( fs, as_str.c_str() );
  722.         }
  724.     }
  726.     for( i=0; i<MAX_VOL_CATE; i++ )
  727.     {
  728.         as_str = "/* define Gain For " + as_comment[i] + " */n";
  729.         fprintf( fs, as_str.c_str() );
  730.         fprintf( fs, "/* speaker, microphone, loudspeaker, buzzer */n" );
  731.         for( j=0; j<MAX_VOL_TYPE; j++ )
  732.         {
  733.             if( j!=MICROPHONE_INDEX && j!=SIDE_TONE_INDEX && j!=CALL_TONE_INDEX && j!=GMI_TONE_INDEX )
  734.             {
  735.                // if( frmAudio->m_cbTone[j]->Visible )
  736.                 if( tone_support.b_ToneSupport[j] )
  737.                 {
  738.                     if( ! CustVolExSupport )
  739.                     {
  740.                         as_str = "#define GAIN_" + as_mode[i] + "_" + as_type[j] + "_VOL"  + "      " + m_sCustVol.volume[i][j] + "n";
  741.                     }
  742.                     else
  743.                     {
  744.                         as_str = "#define GAIN_" + as_mode[i] + "_" + as_type[j] + "_VOL"  + "      " + m_sCustVolEx.volume[i][j] + "n";
  745.                     }
  746.                     fprintf( fs, as_str.c_str() );
  747.                 }
  750.                 for( k=0; k<MAX_VOL_LEVEL; k++ )
  751.                 {
  752.                     if( ! CustVolExSupport )
  753.                     {
  754.                         as_str = "#define GAIN_" + as_mode[i] + "_" + as_type[j] + "_VOL" + IntToStr(k) + "     " + m_sCustVol.volume_gain[i][j][k] + "n";
  755.                     }
  756.                     else
  757.                     {
  758.                         as_str = "#define GAIN_" + as_mode[i] + "_" + as_type[j] + "_VOL" + IntToStr(k) + "     " + m_sCustVolEx.volume_gain[i][j][k] + "n";
  759.                     }
  760.                     fprintf( fs, as_str.c_str() );
  761.                 }
  762.                 fprintf( fs, "n" );
  764.             }
  765.             else if( j==MICROPHONE_INDEX || j==SIDE_TONE_INDEX )  // microphone & sidetone only contain one volume level
  766.             {
  767.                 if( ! CustVolExSupport )
  768.                 {
  769.                     as_str = "#define GAIN_" + as_mode[i] + "_" + as_type[j] + "_VOL"  + "      " + m_sCustVol.volume[i][j] + "n";
  770.                 }
  771.                 else
  772.                 {   as_str = "#define GAIN_" + as_mode[i] + "_" + as_type[j] + "_VOL"  + "      " + m_sCustVolEx.volume[i][j] + "n";
  773.                 }
  774.                 fprintf( fs, as_str.c_str() );
  775.                 if( ! CustVolExSupport )
  776.                 {
  777.                     as_str = "#define GAIN_" + as_mode[i] + "_" + as_type[j] + "_VOL" + IntToStr(0) + "     " + m_sCustVol.volume_gain[i][j][0] + "n";
  778.                 }
  779.                 else
  780.                 {   as_str = "#define GAIN_" + as_mode[i] + "_" + as_type[j] + "_VOL" + IntToStr(0) + "     " + m_sCustVolEx.volume_gain[i][j][0] + "n";
  781.                 }
  782.                 fprintf( fs, as_str.c_str() );
  783.                 fprintf( fs, "n" );
  784.             }
  785.         }
  786.     }
  788.     // array
  789.     fprintf( fs, "kal_uint8 const NVRAM_EF_CUST_ACOUSTIC_DATA_DEFAULT[] = {" );
  790.     for( i=0; i<MAX_VOL_CATE; i++ )
  791.     {
  792.         fprintf( fs, "n      " );
  793.         as_str = "/* " + as_comment[i] + ": Call Tone, Keypad Tone, Microphone, GMI Tone, Speech Tone, Side Tone */n";
  794.         fprintf( fs, as_str.c_str() );
  795.         for( j=0; j<MAX_VOL_TYPE; j++ )
  796.         {
  797.             fprintf( fs, "      " );
  798.             for( k=0; k<MAX_VOL_LEVEL; k++ )
  799.             {
  800.                 as_str = "GAIN_" + as_mode[i] + "_" + as_type[j] + "_VOL" + IntToStr(k) + ", ";
  801.                 fprintf( fs, as_str.c_str() );
  802.             }
  803.             fprintf( fs, "n" );
  804.         }
  805.     }
  807.     for( i=0; i<MAX_VOL_CATE; i++ )
  808.     {
  809.         fprintf( fs, "n      " );
  810.         as_str = "/* " + as_comment[i] + " volume: CTN, SPK, MIC, BUZ, SPH, SID, MED */n";
  811.         fprintf( fs, as_str.c_str() );
  812.         fprintf( fs, "      " );
  813.         for( j=0; j<MAX_VOL_TYPE; j++ )
  814.         {
  815.             as_str = "GAIN_" + as_mode[i] + "_" + as_type[j] + "_VOL";
  816.             fprintf( fs, as_str.c_str() );
  817.             if( i == MAX_VOL_CATE-1 && j == MAX_VOL_TYPE-1 )
  818.             {
  819.                 break;
  820.             }
  821.             fprintf( fs, ", " );
  822.         }
  823.     }
  824.     fprintf( fs, "nn     " );
  826.     as_str = "/* Normal, Headset, Handfree mode melody volume gains */";
  827.     fprintf( fs, as_str.c_str() );
  828.     fprintf( fs, "n      " );
  829.     for( i=0; i<MAX_VOL_CATE; i++ )
  830.     {
  831.         as_str = ", GAIN_" + as_mode[i] + "_MED_VOL_MAX";
  832.         fprintf( fs, as_str.c_str() );
  833.     }
  834.     as_str = ", GAIN_TVO_VOL_MAX,";
  835.     fprintf( fs, as_str.c_str() );
  837.     fprintf( fs, "n      " );
  838.     as_str = "/* Normal, Headset, Handfree mode melody volume gain steps */";
  839.     fprintf( fs, as_str.c_str() );
  840.     fprintf( fs, "n      " );
  841.     for( i=0; i<MAX_VOL_CATE; i++ )
  842.     {
  843.         as_str = " GAIN_" + as_mode[i] + "_MED_VOL_STEP,";
  844.         fprintf( fs, as_str.c_str() );
  845.     }
  846.     as_str = " GAIN_TVO_VOL_STEP,";
  847.     fprintf( fs, as_str.c_str() );
  850.     fprintf( fs, "n      " );
  851.     as_str = "/* TV out volume gains*/";
  852.     fprintf( fs, as_str.c_str() );
  853.     fprintf( fs, "n      " );
  854.     for( i=0; i<MAX_VOL_LEVEL-1; i++ )
  855.     {
  856.         as_str = " GAIN_TVO_VOL" + IntToStr(i) + ",";
  857.         fprintf( fs, as_str.c_str() );
  858.     }
  859.     as_str = " GAIN_TVO_VOL6";
  860.     fprintf( fs, as_str.c_str() );
  862.     fprintf( fs, "n};nn");
  864.     fclose(fs);
  866.     return(true);
  868. }
  870. //===========================================================================
  871. ////////////////////////////        Query         ///////////////////////////
  872. //===========================================================================
  873. bool CVOLSET::Query_CustVolExSupport_Start(void)
  874. {
  875.     META_RESULT  MetaResult = META_QueryIfTargetSupportAcoustic16level_r(m_META_HANDLE_Obj.Get_MainHandle(), 300);
  876.     if (MetaResult != META_SUCCESS)
  877.     {
  878.         return false;
  879.     }
  880.     return true;
  881. }
  883. //--------------------------------------------------------------------------
  884. bool CVOLSET::Query_CustVolRuntime_Support_Start(void)
  885. {
  886.     META_RESULT MetaResult = META_QueryIfFunctionSupportedByTarget_r(m_META_HANDLE_Obj.Get_MainHandle(), 300, "META_Audio_Set_Audio_Profile_Settings_r");
  887.     if(MetaResult!=META_SUCCESS)
  888.     {
  889.         return false;
  890.     }
  891.     return true;
  892. }
  894. //===========================================================================
  895. ////////////////////////////  Export information  ///////////////////////////
  896. //===========================================================================
  897. E_METAAPP_RESULT_T CVOLSET::Get_ConfirmState(void)
  898. {
  899.     return  m_eConfirmState;
  900. }
  902. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  903. CustAcousticVol_T* CVOLSET::Get_CustVol(void)
  904. {
  905.     return &m_sCustVol;
  906. }
  908. //---------------------------------------------------------------------------
  909. void CVOLSET::Set_CustVol(CustAcousticVol_T cust_vol)
  910. {
  911.     m_sCustVol = cust_vol;
  912. }
  914. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  915. CustAcousticVol16lvl_T* CVOLSET::Get_CustVol16(void)
  916. {
  917.     return &m_sCustVolEx;
  918. }
  920. //---------------------------------------------------------------------------
  921. void CVOLSET::Set_CustVol16(CustAcousticVol16lvl_T cust_vol)
  922. {
  923.     m_sCustVolEx = cust_vol;
  924. }
  926. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  927. unsigned char CVOLSET::Get_CustVol(  int cate, int type, bool CustVolExSupport )
  928. {
  929.     if( CustVolExSupport )
  930.     {
  931.         return m_sCustVolEx.volume[cate][type];
  932.     }
  933.     else
  934.     {
  935.         return m_sCustVol.volume[cate][type];
  936.     }
  937. }
  939. //---------------------------------------------------------------------------
  940. void CVOLSET::Set_CustVol( int cate, int type, unsigned char vol, bool CustVolExSupport )
  941. {
  942.     if( CustVolExSupport )
  943.     {
  944.         m_sCustVolEx.volume[cate][type] = vol;
  945.     }
  946.     else
  947.     {
  948.         m_sCustVol.volume[cate][type] = vol;
  949.     }
  950. }
  952. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  953. unsigned char CVOLSET::Get_CustVolGain( int cate, int type, int level, bool CustVolExSupport )
  954. {
  955.     if( CustVolExSupport )
  956.     {
  957.         return m_sCustVolEx.volume_gain[cate][type][level];
  958.     }
  959.     else
  960.     {
  961.         return m_sCustVol.volume_gain[cate][type][level];
  962.     }
  963. }
  965. //---------------------------------------------------------------------------
  966. void CVOLSET::Set_CustVolGain( int cate, int type, int level, unsigned char vol_gain, bool CustVolExSupport )
  967. {
  968.     if( CustVolExSupport )
  969.     {
  970.         m_sCustVolEx.volume_gain[cate][type][level] = vol_gain;
  971.     }
  972.     else
  973.     {
  974.         m_sCustVol.volume_gain[cate][type][level] = vol_gain;
  975.     }
  976. }
  978. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  979. unsigned char CVOLSET::Get_MaxMelodyVolGain( int cate )
  980. {
  981.     return m_sCustVolEx.max_melody_volume_gain[cate];
  982. }
  984. //--------------------------------------------------------------------------
  985. void CVOLSET::Set_MaxMelodyVolGain( int cate, unsigned char vol_gain )
  986. {   m_sCustVolEx.max_melody_volume_gain[cate] = vol_gain;
  987. }
  989. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  990. unsigned char CVOLSET::Get_MelodyVolGainStep( int cate )
  991. {   return m_sCustVolEx.melody_volume_gain_step[cate];
  992. }
  994. //---------------------------------------------------------------------------
  995. void  CVOLSET::Set_MelodyVolGainStep( int cate, unsigned char gain_step )
  996. {   m_sCustVolEx.melody_volume_gain_step[cate] = gain_step;
  997. }
  999. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  1000. unsigned char CVOLSET::Get_TvOutVolGain( int level )
  1001. {   return m_sCustVolEx.tv_out_volume_gain[level];
  1002. }
  1004. //---------------------------------------------------------------------------
  1005. void CVOLSET::Set_TvOutVolGain( int level, unsigned char vol_gain)
  1006. {   m_sCustVolEx.tv_out_volume_gain[level] = vol_gain;
  1007. }