MTK

开发平台：
C++ Builder

melody_coef_cal32.cpp：源码内容
							/*****************************************************************************
*  Copyright Statement:
*  --------------------
*  This software is protected by Copyright and the information contained
*  herein is confidential. The software may not be copied and the information
*  contained herein may not be used or disclosed except with the written
*  permission of MediaTek Inc. (C) 2005
*
*  BY OPENING THIS FILE, BUYER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
*  THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
*  RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO BUYER ON
*  AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
*  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
*  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
*  NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
*  SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
*  SUPPLIED WITH THE MEDIATEK SOFTWARE, AND BUYER AGREES TO LOOK ONLY TO SUCH
*  THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. MEDIATEK SHALL ALSO
*  NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE RELEASES MADE TO BUYER'S
*  SPECIFICATION OR TO CONFORM TO A PARTICULAR STANDARD OR OPEN FORUM.
*
*  BUYER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND CUMULATIVE
*  LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
*  AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
*  OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY BUYER TO
*  MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
*
*  THE TRANSACTION CONTEMPLATED HEREUNDER SHALL BE CONSTRUED IN ACCORDANCE
*  WITH THE LAWS OF THE STATE OF CALIFORNIA, USA, EXCLUDING ITS CONFLICT OF
*  LAWS PRINCIPLES.  ANY DISPUTES, CONTROVERSIES OR CLAIMS ARISING THEREOF AND
*  RELATED THERETO SHALL BE SETTLED BY ARBITRATION IN SAN FRANCISCO, CA, UNDER
*  THE RULES OF THE INTERNATIONAL CHAMBER OF COMMERCE (ICC).
*
*****************************************************************************/
/*****************************************************************************
 *
 * Filename:
 * ---------
 *   sp_coef_cal32.cpp
 *
 * Project:
 * --------
 *   Maui META APP
 *
 * Description:
 * ------------
 *  Melody FIR coefficient calibration source
 *
 * Author:
 * -------
 *  Andy Ueng (mtk00490)
 *
 *============================================================================
 *             HISTORY
 * Below this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
 *------------------------------------------------------------------------------
 * $Revision$
 * $Modtime$
 * $Log$
 * 
 *------------------------------------------------------------------------------
 * Upper this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
 *============================================================================
 ****************************************************************************/
#include <IniFiles.hpp>
#include <stdio.h>
#include <math.h>
#pragma hdrstop
#include "misc.h"
#include "meta_utils.h"
#include "man_active.h"
#include "sp_coef.h"
#include "melody_coef_cal32.h"
#include "math_utils.h"
//===========================================================================
static CMELODYCOEFCAL32*  melody_coef_cal32_ptr;
static bool g_bIsRunning;
//===========================================================================
//===========================================================================
CMELODYCOEFCAL32::CMELODYCOEFCAL32(void)
{
   g_bIsRunning = false;
   m_iConfirmState = 0;
   CoefCalBufSize = 0;
   CoefCalBuf = NULL;
}
//---------------------------------------------------------------------------
CMELODYCOEFCAL32::~CMELODYCOEFCAL32()
{
   g_bIsRunning = false;
   m_iConfirmState = 0;
   if(CoefCalBuf)
   {
      delete [] CoefCalBuf;
      CoefCalBuf = NULL;
   }
   AFT_close();
}
//---------------------------------------------------------------------------
void CMELODYCOEFCAL32::REQ_Finish(void)
{
    if (!g_bIsRunning)
    {
        return;
    }
    Confirm(STATE_COEF_CAL32_OK);
    g_bIsRunning = false;
}
//---------------------------------------------------------------------------
void CMELODYCOEFCAL32::REQ_Stop(void)
{
    if (!g_bIsRunning)
    {
        return;
    }
    META_Cancel_r(m_META_HANDLE_Obj.Get_MainHandle(), MELODYID_COEF_CAL);
    Confirm( STATE_COEF_CAL32_STOP );
}
//---------------------------------------------------------------------------
void CMELODYCOEFCAL32::REQ_TimeOut(void)
{
    if (!g_bIsRunning)
    {
        return;
    }
    META_Cancel_r(m_META_HANDLE_Obj.Get_MainHandle(), MELODYID_COEF_CAL);
    Confirm(STATE_COEF_CAL32_TIMEOUT);
}
//---------------------------------------------------------------------------
void CMELODYCOEFCAL32::Confirm(int confirm_state)
{
    if (!g_bIsRunning)
    {
        return;
    }
    g_bIsRunning = false;
    if (NULL == ConfirmCallback)
    {
        return;
    }
    m_iConfirmState = confirm_state;
    ActiveMan->SetActiveFunction(ConfirmCallback);
}
//---------------------------------------------------------------------------
bool CMELODYCOEFCAL32::getInterpolateFreq( double start_freq, double step_freq, double end_freq, sMelodyInterpolate *p_interpolate )
{
    if( start_freq < 0 || step_freq < 0 || end_freq < 0 || start_freq > end_freq )
    {
        return false;
    }
    for(int i=0; i<TOTAL_MELODY_SAMPLE_NUM; i++)
    {
        p_interpolate->Hz[i] = start_freq + i*step_freq;
    }
    return true;
}
//==============================================================================
bool  CMELODYCOEFCAL32::REQ_Write_FIR_File( char *filename, sMelodyFir *p_MelodyFirCoef )
{
    FILE *fp;
    char str[512];
    AnsiString as_Str;
    if( strcmp(filename, "") == 0 )
        return false;
        
    fp = fopen(filename, "w");
    if(fp == NULL)
        return false;
    fprintf( fp, "%dn", (int) MELODY_FIR_TAPS);
    for( int i=0; i<MELODY_FIR_TAPS; i++ )
    {
        fprintf( fp, "%dn", (int) p_MelodyFirCoef->Mag[i]);
    }
    fclose(fp);
    return  true;
}
//------------------------------------------------------------------------------
bool  CMELODYCOEFCAL32::CheckLicenseDat( void )
{
    FILE *fp;
    AnsiString asPath, asFileName;
    if ( getPathFromStr(Application->ExeName, asPath) &&
         withPath( asPath) &&
         !withPath( asFileName)
       )
    {
       asFileName = asPath + "license.dat";
    }
    fp = fopen(asFileName.c_str(), "r");
    if( fp == NULL )
    {
        fclose(fp);
        return false;
    }
    fclose(fp);    
    return true;
}
//==============================================================================
#if 0
void CMELODYCOEFCAL32::ReorderFirCoef(  sFirCoefParameters *p_FirCoef )
{
    // re-ordering
    int i;
    double temp_old_fir_coeffs[MAX_AUDIO_COEFF_LEN];
    for( i=0; i<p_FirCoef->taps; i++ )
    {
        temp_old_fir_coeffs[i] = p_FirCoef->FirCoef[i];
    }
    for( i=0; i<p_FirCoef->taps; i++ )
    {
        p_FirCoef->FirCoef[i] = temp_old_fir_coeffs[p_FirCoef->taps-1-i];
    }
}
#endif
#if 0
//==============================================================================
void  CMELODYCOEFCAL32::getSelHzIndex(int *p_TplHz, int *p_SelHz, int* p_SelHzIndex)
{
    int k=0;
    for( int i=0; i<TOTAL_TRC_FREQ_NUM; i++ )
    {
        for( int j=0; j<TOTAL_SEL_FREQ_NUM; j++)
        {
            if( *(p_TplHz+i) == *(p_SelHz+j) )
            {
                p_SelHzIndex[k]=i;
                k++;
                break;
            }
        }
    }
}
//-----------------------------------------------------------------------------
void  CMELODYCOEFCAL32::getSeldB( double *p_TpldB, double *p_SeldB, int* p_SelHzIndex)
{
    for(int i=0; i<TOTAL_SEL_FREQ_NUM; i++)
    {
        *(p_SeldB+i) =  *(p_TpldB+*(p_SelHzIndex+i));
    }
}
//==============================================================================
bool  CMELODYCOEFCAL32::CheckEngineExist( void )
{
    // engine test code
    Engine  *mat;
    mat = engOpen( "" );
    if( mat == NULL )
    {
        return  false;
    }
}
#endif
//--------------------------------------------------------------------------
AFT_RESULT  CMELODYCOEFCAL32::freqz( sMelodyFir *p_MelodyFir, int A, int N, double Fs, sMelodyInterpolate *p_MelodyInterpolate)
{
    AFT_RESULT    ret;
    double  Process_Hz[TOTAL_MELODY_SAMPLE_NUM];
    double  d_A[1];
    double  pi = 3.1416;
    int  i;
   // output
    int    nResp;
    double *daRespReal = NULL;
    double *daRespImag = NULL;
    sMelodyInterpolate r_MelodyInterpolate, i_MelodyInterpolate;
    Process_Hz[0] = 0;
    for(i=0; i<TOTAL_MELODY_SAMPLE_NUM-1; i++)
    {
        Process_Hz[i+1] =  p_MelodyInterpolate->Hz[i]/Fs*(2*pi);
    }
    ret = AFT_freqz(
	&nResp,
	&daRespReal,
	&daRespImag,
	p_MelodyFir->Mag,
	sizeof(p_MelodyFir->Mag)/sizeof(p_MelodyFir->Mag[0]),
	p_MelodyInterpolate->Hz,
	sizeof(p_MelodyInterpolate->Hz)/sizeof(p_MelodyInterpolate->Hz[0]),
	Fs
	);
    if( ret )
        return ret;
    for( i=0; i<TOTAL_MELODY_SAMPLE_NUM; i++ )
    {
        r_MelodyInterpolate.Mag[i] = *(daRespReal + i);
        i_MelodyInterpolate.Mag[i] = *(daRespImag + i);
        p_MelodyInterpolate->Mag[i] = sqrt(pow(r_MelodyInterpolate.Mag[i], 2.0) + pow(i_MelodyInterpolate.Mag[i],2.0));
        p_MelodyInterpolate->MagdB[i] = 20.0*log10( Abs_double(p_MelodyInterpolate->Mag[i]) );
    }
    return ret;
}
//------------------------------------------------------------------------------
AFT_RESULT  CMELODYCOEFCAL32::firls( int N, double Fs, sMelodyInterpolate *p_MelodyInterpolate, sMelodyFir *p_MelodyFir)
{
    AFT_RESULT ret;
    double  Fa[TOTAL_MELODY_SAMPLE_NUM], A[TOTAL_MELODY_SAMPLE_NUM];
    double  d_N[1];
    double  *p_mx_N, *p_mx_Fa, *p_mx_A;
    double  *p_mx_MelodyFir;
    int  i;
    int  taps;
    double  *p_weight;
    int  size = sizeof(p_MelodyInterpolate->Mag)/sizeof(p_MelodyInterpolate->Mag[0])/2;
    p_weight = new double[size];
    for( i=0; i<size; i++ )
    {
        *(p_weight + i) = 1.0;
    }
    for( i=0; i<TOTAL_MELODY_SAMPLE_NUM; i++ )
    {
        Fa[i] = p_MelodyInterpolate->Hz[i] / (Fs/2) ;
        A[i] = Abs_double( p_MelodyInterpolate->Mag[i] );
    }
  ret = AFT_firls(
	&taps,
	&p_mx_MelodyFir,
	N,
	Fa,
	sizeof(Fa)/sizeof(Fa[0]),
	p_MelodyInterpolate->Mag,
	sizeof(p_MelodyInterpolate->Mag)/sizeof(p_MelodyInterpolate->Mag[0]),
	p_weight,
	size);
    if( ret )
        return ret;
    for(int i=0; i<MELODY_FIR_TAPS; i++)
    {
        p_MelodyFir->Mag[i] = *(p_mx_MelodyFir + i);
    }
    return ret;
}
//--------------------------------------------------------------------------
const char*  CMELODYCOEFCAL32::Get_ErrorString(AFT_RESULT code)
{
    return AFT_getErrorString(code);
}
#if 0
//------------------------------------------------------------------------------
void  CSPCOEFCAL::firls4input( int wanted_ord, sSpCoefCalParameters  *p_ProcessOddSpCoef, sSpCoefCalParameters *p_NewFirOddSpCoef, sWeightParameters *p_Weight, double Fs, sFirCoefParameters *p_NewFirCoeffF1)
{
//    double  Fs = 8000.0;
    double  d_wanted_ord[1], ProcessOddHz[TOTAL_TRC_FREQ_NUM+2];
    double  *p_mx_wanted_ord, *p_mx_new_fir_mag_odd, *p_mx_process_Hz_odd, *p_mx_weight;
    double  *p_mx_new_fir_coeff_F1;  // output
    sSpCoefCalParameters  process_Hz_odd, new_fir_mag_odd;
    int  i, nlhs, nrhs;
    mxArray  *mx_wanted_ord = NULL, *mx_process_Hz_odd = NULL, *mx_new_fir_mag_odd = NULL, *mx_weight=NULL;
    mxArray  *mx_new_fir_coeff_F1 = NULL; //output
    mxArray *plhs[1], *prhs[4];
    for( i=0; i<p_ProcessOddSpCoef->num; i++ )
    {
        ProcessOddHz[i] = p_ProcessOddSpCoef->Hz[i]/(Fs/2.0);
    }
    for( i=p_ProcessOddSpCoef->num; i<TOTAL_TRC_FREQ_NUM+2; i++ )
    {
        ProcessOddHz[i] = p_ProcessOddSpCoef->Hz[p_ProcessOddSpCoef->num-1]/(Fs/2.0);
    }
    d_wanted_ord[0]=wanted_ord;
    mx_wanted_ord = mxCreateDoubleMatrix(1, 1, mxREAL);
    mx_process_Hz_odd = mxCreateDoubleMatrix( p_ProcessOddSpCoef->num, 1, mxREAL );
    mx_new_fir_mag_odd = mxCreateDoubleMatrix( p_NewFirOddSpCoef->num, 1, mxREAL );
    mx_weight = mxCreateDoubleMatrix( p_Weight->num, 1, mxREAL );
    mx_new_fir_coeff_F1 = mxCreateDoubleMatrix( 1, MAX_AUDIO_COEFF_LEN, mxREAL ); // output
    p_mx_wanted_ord = mxGetPr( mx_wanted_ord );
    p_mx_process_Hz_odd = mxGetPr( mx_process_Hz_odd );
    p_mx_new_fir_mag_odd = mxGetPr( mx_new_fir_mag_odd );
    p_mx_weight = mxGetPr( mx_weight );
    memcpy( (void *) p_mx_wanted_ord, d_wanted_ord, sizeof(d_wanted_ord) );
    memcpy( (void *) p_mx_process_Hz_odd, ProcessOddHz, (p_ProcessOddSpCoef->num)*sizeof(double) );
    memcpy( (void *) p_mx_new_fir_mag_odd, p_NewFirOddSpCoef->Mag, (p_NewFirOddSpCoef->num)*sizeof(double) );
    memcpy( (void *) p_mx_weight, p_Weight->weight, (p_Weight->num)*sizeof(double) );
    nlhs=1, nrhs = 4;
    prhs[0] = mx_wanted_ord;
    prhs[1] = mx_process_Hz_odd;
    prhs[2] = mx_new_fir_mag_odd;
    prhs[3] = mx_weight;
    plhs[0] = mx_new_fir_coeff_F1;
    InitializeModule_firls();
    InitializeModule_signal_private_firchk();
    InitializeModule_sinc();
    mlxFirls(nlhs, plhs, nrhs, prhs);
    p_mx_new_fir_coeff_F1 =  mxGetPr( plhs[0] );
    p_NewFirCoeffF1->taps = wanted_ord + 1;
    for(int i=0; i<p_NewFirCoeffF1->taps; i++)
    {
        p_NewFirCoeffF1->FirCoef[i] = *(p_mx_new_fir_coeff_F1 + i);
    }
    TerminateModule_sinc();
    TerminateModule_signal_private_firchk();
    TerminateModule_firls();
    // free mxArray memory
    mxDestroyArray( mx_wanted_ord );
    mxDestroyArray( mx_process_Hz_odd );
    mxDestroyArray( mx_new_fir_mag_odd );
    mxDestroyArray( mx_weight );
    mxDestroyArray( mx_new_fir_coeff_F1 );
}
#endif
#if 0
//------------------------------------------------------------------------------
void  CMELODYCOEFCAL32::interp1(sMelodySelected *p_mSel, sMelodyInterpolate *p_xi_Coeff )
{
    double  d_mx_X[TOTAL_MELODY_SAMPLE_NUM], d_mx_Y[TOTAL_MELODY_SAMPLE_NUM], d_mx_xi[TOTAL_MELODY_SAMPLE_NUM];
    double  *p_mx_X, *p_mx_Y, *p_mx_xi, *p_mx_method;
    double  *p_mx_a;  // output
    int  i, nlhs, nrhs;
    mxArray  *mx_X = NULL, *mx_Y = NULL, *mx_xi = NULL, *mx_method = NULL;
    mxArray  *mx_a = NULL; //output
    mxArray *plhs[1], *prhs[4];
    char *str_method;
    str_method = "linear";
    mx_X = mxCreateDoubleMatrix(TOTAL_SEL_MELODY_FREQ_NUM, 1, mxREAL);
    mx_Y = mxCreateDoubleMatrix( TOTAL_SEL_MELODY_FREQ_NUM, 1, mxREAL );
    mx_xi = mxCreateDoubleMatrix( TOTAL_MELODY_SAMPLE_NUM, 1, mxREAL );
    mx_method = mxCreateString("linear");
    mx_a = mxCreateDoubleMatrix( TOTAL_MELODY_SAMPLE_NUM, 1, mxREAL );  // output
    p_mx_X = mxGetPr( mx_X );
    p_mx_Y = mxGetPr( mx_Y );
    p_mx_xi = mxGetPr( mx_xi );
    p_mx_method = mxGetPr( mx_method );
    p_mx_a = mxGetPr( mx_a );
    memcpy( (void *) p_mx_X, p_mSel->Hz, sizeof(p_mSel->Hz) );
    memcpy( (void *) p_mx_Y, p_mSel->MagdB, sizeof(p_mSel->MagdB) );
    memcpy( (void *) p_mx_xi, p_xi_Coeff->Hz, sizeof(p_xi_Coeff->Hz) );
    //memcpy( (void *) p_mx_method, p_xi_Coeff->Hz, sizeof(p_xi_Coeff->Hz) );
    nlhs=1, nrhs = 3;
    prhs[0] = mx_X;
    prhs[1] = mx_Y;
    prhs[2] = mx_xi;
   // prhs[3] = mx_method;
    plhs[0] = mx_a;
    libmmfileInitialize();
    //InitializeModule_libmmfile();
    InitializeModule_interp1q_b();
    InitializeModule_interp1b();
    libmatlbmxInitialize();
    libmmfile_defsInitialize();
    //mlxInterp1(nlhs, plhs, nrhs, prhs);
    //mlxInterp1b(nlhs, plhs, nrhs, prhs);
    mlxInterp1q_b(nlhs, plhs, nrhs, prhs);
    //TerminateModule_libmmfile();
     //plhs[0] = mlfInterp1q(mx_X, mx_Y, mx_xi);
    p_mx_a =  mxGetPr( plhs[0] );
    for( i=0; i<TOTAL_MELODY_SAMPLE_NUM; i++)
    {
        p_xi_Coeff->MagdB[i] = *(p_mx_a + i);
    }
   // TerminateModule_libmmfile();
   libmmfile_defsTerminate();
   libmmfileTerminate();
   TerminateModule_interp1b();
   TerminateModule_interp1q_b();
    // free mxArray memory
    mxDestroyArray( mx_X );
    mxDestroyArray( mx_Y );
    mxDestroyArray( mx_xi );
    mxDestroyArray( mx_a );
}
#endif
//------------------------------------------------------------------------------
bool  CMELODYCOEFCAL32::interp1(sMelodySelected *p_mSel, sMelodyInterpolate *p_xi_Coeff )
{
    double interpolate_value[TOTAL_MELODY_SAMPLE_NUM];
    int idx1, idx2;
    for(int i=0; i<TOTAL_MELODY_SAMPLE_NUM; i++)
    {
        if( ! getIndexRange(p_xi_Coeff->Hz[i], p_mSel->Hz, idx1, idx2) )
        {
            return false;
        }
        if( ! getInterpolateValue(p_mSel, idx1, idx2, p_xi_Coeff->Hz[i], interpolate_value[i]) )
        {
            return false;
        }
        p_xi_Coeff->Mag[i] =  interpolate_value[i];
        p_xi_Coeff->MagdB[i] = 20.0*log10(Abs_double(p_xi_Coeff->Mag[i]));
    }
    return true;
}
//------------------------------------------------------------------------------
bool  CMELODYCOEFCAL32::getIndexRange( double source_Hz, double *p_dest_Hz, int &idx1, int &idx2)
{
    for(int j=0; j<TOTAL_SEL_MELODY_FREQ_NUM; j++)
    {
        if(  source_Hz >= *(p_dest_Hz +j) && source_Hz <= *(p_dest_Hz +j+1) )
        {
            idx1 = j;
            idx2 = j+1;
            return true;
        }
    }
    return false;
}
//------------------------------------------------------------------------------
bool CMELODYCOEFCAL32::getInterpolateValue(sMelodySelected *p_mSel, int idx1, int idx2, double source_Hz, double &interpolate_value)
{
    double slope;
    slope = ( p_mSel->Mag[idx2] - p_mSel->Mag[idx1] ) / ( p_mSel->Hz[idx2] - p_mSel->Hz[idx1] );
    interpolate_value = p_mSel->Mag[idx1] + slope * ( source_Hz - p_mSel->Hz[idx1] );
    return true;
}
//===========================================================================
////////////////////////////  Global information  ///////////////////////////
//===========================================================================
int  CMELODYCOEFCAL32::Get_ConfirmState( void )
{
    return  m_iConfirmState;
}

						