sconceal.h
上传用户:zhongxx05
上传日期:2007-06-06
资源大小:33641k
文件大小:5k
源码类别:

Symbian

开发平台:

C/C++

  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  35. #ifndef __CONCEALMENT_H__
  36. #define __CONCEALMENT_H__
  37. #include "hlxclib/assert.h"
  38. /*
  39.  * class CConcealment keeps a history of spectral lines and tries
  40.  * to conceal missing spectra.
  41.  * Instantiate one per channel.
  42.  */
  43. class CConcealment
  44. {
  45. public:
  46.   // instantiate a spectrum concealer. nLinesMax is the maximum number
  47.   // of lines that we'll ever take or hand out.
  48.   CConcealment(int nLinesMax) ;
  49.   ~CConcealment() ;
  50.   // insert spectrum into our delay line. Currently, blocktype is of
  51.   // Layer-3 flavor (2 == short block); this will be generalized.
  52.   // nLines is the highest active spectral line in this block
  53.   // (i.e. the audio bandwidth)
  54.   void insert(const float *spec, int blocktype, int nLines = -1) ;
  55.   // no spectrum present, schedule this spectrum to be concealed.
  56.   // call this if you have a defect, or missing, spectrum.
  57.   void insert() ;
  58.   // retrieve a valid spectrum, concealed if necessary
  59.   // returns index+1 of highest spectral line containing energy
  60.   // and Layer-3 type blocktype.
  61.   int retrieve(float *s, int &blocktype) ;
  62. private:
  63.   enum
  64.   {
  65.     CONCEAL_REPETITION    = 0,
  66.     CONCEAL_INTERPOLATION = 1,
  67.     CONCEAL_PREDICTION    = 2
  68.   };
  69.   //
  70.   // the most likely candidates for concealment. See source code
  71.   // for documentation
  72.   //
  73.   void conceal(int method) ;
  74.   void concealByPrediction() ;
  75.   void adaptEnergy() ;
  76.   void prediction() ;
  77.   void predict(int          nLines,
  78.                const float *spec0,
  79.                const float *spec1,
  80.                const float *a0,
  81.                const float *a1,
  82.                const float *ma,
  83.                float       *current);
  84.   void calculateCoefficients(/* input */
  85.                              int          nLines,
  86.                              const float *g0,
  87.                              const float *g0p,
  88.                              const float *g1,
  89.                              const float *g1p,
  90.                              const float *g2,
  91.                              /* output */
  92.                              float       *a0,
  93.                              float       *a1);
  94.   void poleLimitMagnitude(float mag, float *a0, float *a1) ;
  95.   void rotateHistory() ;
  96.   void zeroFloat(float *f, int n) ;
  97.   //
  98.   // inline helper functions to make access to history buffer
  99.   // transparent
  100.   //
  101.   unsigned char& spectrumPresent(int time)
  102.   {
  103.     return m_historyPtr[time + sizeofHistory]->spectrumPresent;
  104.   }
  105.   int& blockType(int time)
  106.   {
  107.     return m_historyPtr[time + sizeofHistory]->blockType;
  108.   }
  109.   int& nLinesActive(int time)
  110.   {
  111.     return m_historyPtr[time + sizeofHistory]->nLinesActive;
  112.   }
  113.   float* spectrum(int time)
  114.   {
  115.     assert(sizeofHistory+time >= 0);
  116.     assert(sizeofHistory+time < sizeofBuffer);
  117.     return m_historyPtr[time + sizeofHistory]->spectrum;
  118.   }
  119.   //
  120.   // member variables ...
  121.   //
  122.   enum
  123.   {
  124.     sizeofBuffer = 8,
  125.     sizeofFuture = 2,
  126.     sizeofHistory= sizeofBuffer-sizeofFuture-1,
  127.     CONCEALLIMIT = 576 // can handle at most 576 lines.
  128.   };
  129.   int m_offset ;
  130.   int m_nLinesMax ;
  131.   struct
  132.   {
  133.     float * spectrum ;
  134.     int     nLinesActive ;
  135.     unsigned char    spectrumPresent ;
  136.     int     blockType ;
  137.   } m_history[sizeofBuffer], *m_historyPtr[sizeofBuffer] ;
  138.   unsigned char lastConcealed ;
  139.   // last frame's predictor coefficients
  140.   float a0[CONCEALLIMIT] ;
  141.   float a1[CONCEALLIMIT] ;
  142.   float ma[CONCEALLIMIT] ;
  143.   float g0[CONCEALLIMIT], g0p[CONCEALLIMIT];
  144.   float g1[CONCEALLIMIT], g1p[CONCEALLIMIT];
  145.   float g2[CONCEALLIMIT];
  146. };
  147. #endif /* ifdef __CONCEALMENT_H__ */