LCOV - app.info - media/libvorbis/lib/vorbis_lsp.c

LCOV - code coverage report
| Current view: | directory - media/libvorbis/lib - vorbis_lsp.c (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 112 | 0 | 0.0 %
| Date: | 2012-07-07 | Functions: | 6 | 0 | 0.0 %

           1                 : /********************************************************************
           2                 :  *                                                                  *
           3                 :  * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE.   *
           4                 :  * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS     *
           5                 :  * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
           6                 :  * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING.       *
           7                 :  *                                                                  *
           8                 :  * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009             *
           9                 :  * by the Xiph.Org Foundation http://www.xiph.org/                  *
          10                 :  *                                                                  *
          11                 :  ********************************************************************
          12                 :
          13                 :   function: LSP (also called LSF) conversion routines
          14                 :   last mod: $Id: lsp.c 17538 2010-10-15 02:52:29Z tterribe $
          15                 :
          16                 :   The LSP generation code is taken (with minimal modification and a
          17                 :   few bugfixes) from "On the Computation of the LSP Frequencies" by
          18                 :   Joseph Rothweiler (see http://www.rothweiler.us for contact info).
          19                 :   The paper is available at:
          20                 :
          21                 :   http://www.myown1.com/joe/lsf
          22                 :
          23                 :  ********************************************************************/
          24                 :
          25                 : /* Note that the lpc-lsp conversion finds the roots of polynomial with
          26                 :    an iterative root polisher (CACM algorithm 283).  It *is* possible
          27                 :    to confuse this algorithm into not converging; that should only
          28                 :    happen with absurdly closely spaced roots (very sharp peaks in the
          29                 :    LPC f response) which in turn should be impossible in our use of
          30                 :    the code.  If this *does* happen anyway, it's a bug in the floor
          31                 :    finder; find the cause of the confusion (probably a single bin
          32                 :    spike or accidental near-float-limit resolution problems) and
          33                 :    correct it. */
          34                 :
          35                 : #include <math.h>
          36                 : #include <string.h>
          37                 : #include <stdlib.h>
          38                 : #include "lsp.h"
          39                 : #include "os.h"
          40                 : #include "misc.h"
          41                 : #include "lookup.h"
          42                 : #include "scales.h"
          43                 :
          44                 : /* three possible LSP to f curve functions; the exact computation
          45                 :    (float), a lookup based float implementation, and an integer
          46                 :    implementation.  The float lookup is likely the optimal choice on
          47                 :    any machine with an FPU.  The integer implementation is *not* fixed
          48                 :    point (due to the need for a large dynamic range and thus a
          49                 :    separately tracked exponent) and thus much more complex than the
          50                 :    relatively simple float implementations. It's mostly for future
          51                 :    work on a fully fixed point implementation for processors like the
          52                 :    ARM family. */
          53                 :
          54                 : /* define either of these (preferably FLOAT_LOOKUP) to have faster
          55                 :    but less precise implementation. */
          56                 : #undef FLOAT_LOOKUP
          57                 : #undef INT_LOOKUP
          58                 :
          59                 : #ifdef FLOAT_LOOKUP
          60                 : #include "vorbis_lookup.c" /* catch this in the build system; we #include for
          61                 :                        compilers (like gcc) that can't inline across
          62                 :                        modules */
          63                 :
          64                 : /* side effect: changes *lsp to cosines of lsp */
          65                 : void vorbis_lsp_to_curve(float *curve,int *map,int n,int ln,float *lsp,int m,
          66                 :                             float amp,float ampoffset){
          67                 :   int i;
          68                 :   float wdel=M_PI/ln;
          69                 :   vorbis_fpu_control fpu;
          70                 :
          71                 :   vorbis_fpu_setround(&fpu);
          72                 :   for(i=0;i<m;i++)lsp[i]=vorbis_coslook(lsp[i]);
          73                 :
          74                 :   i=0;
          75                 :   while(i<n){
          76                 :     int k=map[i];
          77                 :     int qexp;
          78                 :     float p=.7071067812f;
          79                 :     float q=.7071067812f;
          80                 :     float w=vorbis_coslook(wdel*k);
          81                 :     float *ftmp=lsp;
          82                 :     int c=m>>1;
          83                 :
          84                 :     while(c--){
          85                 :       q*=ftmp[0]-w;
          86                 :       p*=ftmp[1]-w;
          87                 :       ftmp+=2;
          88                 :     }
          89                 :
          90                 :     if(m&1){
          91                 :       /* odd order filter; slightly assymetric */
          92                 :       /* the last coefficient */
          93                 :       q*=ftmp[0]-w;
          94                 :       q*=q;
          95                 :       p*=p*(1.f-w*w);
          96                 :     }else{
          97                 :       /* even order filter; still symmetric */
          98                 :       q*=q*(1.f+w);
          99                 :       p*=p*(1.f-w);
         100                 :     }
         101                 :
         102                 :     q=frexp(p+q,&qexp);
         103                 :     q=vorbis_fromdBlook(amp*
         104                 :                         vorbis_invsqlook(q)*
         105                 :                         vorbis_invsq2explook(qexp+m)-
         106                 :                         ampoffset);
         107                 :
         108                 :     do{
         109                 :       curve[i++]*=q;
         110                 :     }while(map[i]==k);
         111                 :   }
         112                 :   vorbis_fpu_restore(fpu);
         113                 : }
         114                 :
         115                 : #else
         116                 :
         117                 : #ifdef INT_LOOKUP
         118                 : #include "vorbis_lookup.c" /* catch this in the build system; we #include for
         119                 :                        compilers (like gcc) that can't inline across
         120                 :                        modules */
         121                 :
         122                 : static const int MLOOP_1[64]={
         123                 :    0,10,11,11, 12,12,12,12, 13,13,13,13, 13,13,13,13,
         124                 :   14,14,14,14, 14,14,14,14, 14,14,14,14, 14,14,14,14,
         125                 :   15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15,
         126                 :   15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15,
         127                 : };
         128                 :
         129                 : static const int MLOOP_2[64]={
         130                 :   0,4,5,5, 6,6,6,6, 7,7,7,7, 7,7,7,7,
         131                 :   8,8,8,8, 8,8,8,8, 8,8,8,8, 8,8,8,8,
         132                 :   9,9,9,9, 9,9,9,9, 9,9,9,9, 9,9,9,9,
         133                 :   9,9,9,9, 9,9,9,9, 9,9,9,9, 9,9,9,9,
         134                 : };
         135                 :
         136                 : static const int MLOOP_3[8]={0,1,2,2,3,3,3,3};
         137                 :
         138                 :
         139                 : /* side effect: changes *lsp to cosines of lsp */
         140                 : void vorbis_lsp_to_curve(float *curve,int *map,int n,int ln,float *lsp,int m,
         141                 :                             float amp,float ampoffset){
         142                 :
         143                 :   /* 0 <= m < 256 */
         144                 :
         145                 :   /* set up for using all int later */
         146                 :   int i;
         147                 :   int ampoffseti=rint(ampoffset*4096.f);
         148                 :   int ampi=rint(amp*16.f);
         149                 :   long *ilsp=alloca(m*sizeof(*ilsp));
         150                 :   for(i=0;i<m;i++)ilsp[i]=vorbis_coslook_i(lsp[i]/M_PI*65536.f+.5f);
         151                 :
         152                 :   i=0;
         153                 :   while(i<n){
         154                 :     int j,k=map[i];
         155                 :     unsigned long pi=46341; /* 2**-.5 in 0.16 */
         156                 :     unsigned long qi=46341;
         157                 :     int qexp=0,shift;
         158                 :     long wi=vorbis_coslook_i(k*65536/ln);
         159                 :
         160                 :     qi*=labs(ilsp[0]-wi);
         161                 :     pi*=labs(ilsp[1]-wi);
         162                 :
         163                 :     for(j=3;j<m;j+=2){
         164                 :       if(!(shift=MLOOP_1[(pi|qi)>>25]))
         165                 :         if(!(shift=MLOOP_2[(pi|qi)>>19]))
         166                 :           shift=MLOOP_3[(pi|qi)>>16];
         167                 :       qi=(qi>>shift)*labs(ilsp[j-1]-wi);
         168                 :       pi=(pi>>shift)*labs(ilsp[j]-wi);
         169                 :       qexp+=shift;
         170                 :     }
         171                 :     if(!(shift=MLOOP_1[(pi|qi)>>25]))
         172                 :       if(!(shift=MLOOP_2[(pi|qi)>>19]))
         173                 :         shift=MLOOP_3[(pi|qi)>>16];
         174                 :
         175                 :     /* pi,qi normalized collectively, both tracked using qexp */
         176                 :
         177                 :     if(m&1){
         178                 :       /* odd order filter; slightly assymetric */
         179                 :       /* the last coefficient */
         180                 :       qi=(qi>>shift)*labs(ilsp[j-1]-wi);
         181                 :       pi=(pi>>shift)<<14;
         182                 :       qexp+=shift;
         183                 :
         184                 :       if(!(shift=MLOOP_1[(pi|qi)>>25]))
         185                 :         if(!(shift=MLOOP_2[(pi|qi)>>19]))
         186                 :           shift=MLOOP_3[(pi|qi)>>16];
         187                 :
         188                 :       pi>>=shift;
         189                 :       qi>>=shift;
         190                 :       qexp+=shift-14*((m+1)>>1);
         191                 :
         192                 :       pi=((pi*pi)>>16);
         193                 :       qi=((qi*qi)>>16);
         194                 :       qexp=qexp*2+m;
         195                 :
         196                 :       pi*=(1<<14)-((wi*wi)>>14);
         197                 :       qi+=pi>>14;
         198                 :
         199                 :     }else{
         200                 :       /* even order filter; still symmetric */
         201                 :
         202                 :       /* p*=p(1-w), q*=q(1+w), let normalization drift because it isn't
         203                 :          worth tracking step by step */
         204                 :
         205                 :       pi>>=shift;
         206                 :       qi>>=shift;
         207                 :       qexp+=shift-7*m;
         208                 :
         209                 :       pi=((pi*pi)>>16);
         210                 :       qi=((qi*qi)>>16);
         211                 :       qexp=qexp*2+m;
         212                 :
         213                 :       pi*=(1<<14)-wi;
         214                 :       qi*=(1<<14)+wi;
         215                 :       qi=(qi+pi)>>14;
         216                 :
         217                 :     }
         218                 :
         219                 :
         220                 :     /* we've let the normalization drift because it wasn't important;
         221                 :        however, for the lookup, things must be normalized again.  We
         222                 :        need at most one right shift or a number of left shifts */
         223                 :
         224                 :     if(qi&0xffff0000){ /* checks for 1.xxxxxxxxxxxxxxxx */
         225                 :       qi>>=1; qexp++;
         226                 :     }else
         227                 :       while(qi && !(qi&0x8000)){ /* checks for 0.0xxxxxxxxxxxxxxx or less*/
         228                 :         qi<<=1; qexp--;
         229                 :       }
         230                 :
         231                 :     amp=vorbis_fromdBlook_i(ampi*                     /*  n.4         */
         232                 :                             vorbis_invsqlook_i(qi,qexp)-
         233                 :                                                       /*  m.8, m+n<=8 */
         234                 :                             ampoffseti);              /*  8.12[0]     */
         235                 :
         236                 :     curve[i]*=amp;
         237                 :     while(map[++i]==k)curve[i]*=amp;
         238                 :   }
         239                 : }
         240                 :
         241                 : #else
         242                 :
         243                 : /* old, nonoptimized but simple version for any poor sap who needs to
         244                 :    figure out what the hell this code does, or wants the other
         245                 :    fraction of a dB precision */
         246                 :
         247                 : /* side effect: changes *lsp to cosines of lsp */
         248               0 : void vorbis_lsp_to_curve(float *curve,int *map,int n,int ln,float *lsp,int m,
         249                 :                             float amp,float ampoffset){
         250                 :   int i;
         251               0 :   float wdel=M_PI/ln;
         252               0 :   for(i=0;i<m;i++)lsp[i]=2.f*cos(lsp[i]);
         253                 :
         254               0 :   i=0;
         255               0 :   while(i<n){
         256               0 :     int j,k=map[i];
         257               0 :     float p=.5f;
         258               0 :     float q=.5f;
         259               0 :     float w=2.f*cos(wdel*k);
         260               0 :     for(j=1;j<m;j+=2){
         261               0 :       q *= w-lsp[j-1];
         262               0 :       p *= w-lsp[j];
         263                 :     }
         264               0 :     if(j==m){
         265                 :       /* odd order filter; slightly assymetric */
         266                 :       /* the last coefficient */
         267               0 :       q*=w-lsp[j-1];
         268               0 :       p*=p*(4.f-w*w);
         269               0 :       q*=q;
         270                 :     }else{
         271                 :       /* even order filter; still symmetric */
         272               0 :       p*=p*(2.f-w);
         273               0 :       q*=q*(2.f+w);
         274                 :     }
         275                 :
         276               0 :     q=fromdB(amp/sqrt(p+q)-ampoffset);
         277                 :
         278               0 :     curve[i]*=q;
         279               0 :     while(map[++i]==k)curve[i]*=q;
         280                 :   }
         281               0 : }
         282                 :
         283                 : #endif
         284                 : #endif
         285                 :
         286               0 : static void cheby(float *g, int ord) {
         287                 :   int i, j;
         288                 :
         289               0 :   g[0] *= .5f;
         290               0 :   for(i=2; i<= ord; i++) {
         291               0 :     for(j=ord; j >= i; j--) {
         292               0 :       g[j-2] -= g[j];
         293               0 :       g[j] += g[j];
         294                 :     }
         295                 :   }
         296               0 : }
         297                 :
         298               0 : static int comp(const void *a,const void *b){
         299               0 :   return (*(float *)a<*(float *)b)-(*(float *)a>*(float *)b);
         300                 : }
         301                 :
         302                 : /* Newton-Raphson-Maehly actually functioned as a decent root finder,
         303                 :    but there are root sets for which it gets into limit cycles
         304                 :    (exacerbated by zero suppression) and fails.  We can't afford to
         305                 :    fail, even if the failure is 1 in 100,000,000, so we now use
         306                 :    Laguerre and later polish with Newton-Raphson (which can then
         307                 :    afford to fail) */
         308                 :
         309                 : #define EPSILON 10e-7
         310               0 : static int Laguerre_With_Deflation(float *a,int ord,float *r){
         311                 :   int i,m;
         312               0 :   double lastdelta=0.f;
         313               0 :   double *defl=alloca(sizeof(*defl)*(ord+1));
         314               0 :   for(i=0;i<=ord;i++)defl[i]=a[i];
         315                 :
         316               0 :   for(m=ord;m>0;m--){
         317               0 :     double new=0.f,delta;
         318                 :
         319                 :     /* iterate a root */
         320                 :     while(1){
         321               0 :       double p=defl[m],pp=0.f,ppp=0.f,denom;
         322                 :
         323                 :       /* eval the polynomial and its first two derivatives */
         324               0 :       for(i=m;i>0;i--){
         325               0 :         ppp = new*ppp + pp;
         326               0 :         pp  = new*pp  + p;
         327               0 :         p   = new*p   + defl[i-1];
         328                 :       }
         329                 :
         330                 :       /* Laguerre's method */
         331               0 :       denom=(m-1) * ((m-1)*pp*pp - m*p*ppp);
         332               0 :       if(denom<0)
         333               0 :         return(-1);  /* complex root!  The LPC generator handed us a bad filter */
         334                 :
         335               0 :       if(pp>0){
         336               0 :         denom = pp + sqrt(denom);
         337               0 :         if(denom<EPSILON)denom=EPSILON;
         338                 :       }else{
         339               0 :         denom = pp - sqrt(denom);
         340               0 :         if(denom>-(EPSILON))denom=-(EPSILON);
         341                 :       }
         342                 :
         343               0 :       delta  = m*p/denom;
         344               0 :       new   -= delta;
         345                 :
         346               0 :       if(delta<0.f)delta*=-1;
         347                 :
         348               0 :       if(fabs(delta/new)<10e-12)break;
         349               0 :       lastdelta=delta;
         350               0 :     }
         351                 :
         352               0 :     r[m-1]=new;
         353                 :
         354                 :     /* forward deflation */
         355                 :
         356               0 :     for(i=m;i>0;i--)
         357               0 :       defl[i-1]+=new*defl[i];
         358               0 :     defl++;
         359                 :
         360                 :   }
         361               0 :   return(0);
         362                 : }
         363                 :
         364                 :
         365                 : /* for spit-and-polish only */
         366               0 : static int Newton_Raphson(float *a,int ord,float *r){
         367               0 :   int i, k, count=0;
         368               0 :   double error=1.f;
         369               0 :   double *root=alloca(ord*sizeof(*root));
         370                 :
         371               0 :   for(i=0; i<ord;i++) root[i] = r[i];
         372                 :
         373               0 :   while(error>1e-20){
         374               0 :     error=0;
         375                 :
         376               0 :     for(i=0; i<ord; i++) { /* Update each point. */
         377               0 :       double pp=0.,delta;
         378               0 :       double rooti=root[i];
         379               0 :       double p=a[ord];
         380               0 :       for(k=ord-1; k>= 0; k--) {
         381                 :
         382               0 :         pp= pp* rooti + p;
         383               0 :         p = p * rooti + a[k];
         384                 :       }
         385                 :
         386               0 :       delta = p/pp;
         387               0 :       root[i] -= delta;
         388               0 :       error+= delta*delta;
         389                 :     }
         390                 :
         391               0 :     if(count>40)return(-1);
         392                 :
         393               0 :     count++;
         394                 :   }
         395                 :
         396                 :   /* Replaced the original bubble sort with a real sort.  With your
         397                 :      help, we can eliminate the bubble sort in our lifetime. --Monty */
         398                 :
         399               0 :   for(i=0; i<ord;i++) r[i] = root[i];
         400               0 :   return(0);
         401                 : }
         402                 :
         403                 :
         404                 : /* Convert lpc coefficients to lsp coefficients */
         405               0 : int vorbis_lpc_to_lsp(float *lpc,float *lsp,int m){
         406               0 :   int order2=(m+1)>>1;
         407                 :   int g1_order,g2_order;
         408               0 :   float *g1=alloca(sizeof(*g1)*(order2+1));
         409               0 :   float *g2=alloca(sizeof(*g2)*(order2+1));
         410               0 :   float *g1r=alloca(sizeof(*g1r)*(order2+1));
         411               0 :   float *g2r=alloca(sizeof(*g2r)*(order2+1));
         412                 :   int i;
         413                 :
         414                 :   /* even and odd are slightly different base cases */
         415               0 :   g1_order=(m+1)>>1;
         416               0 :   g2_order=(m)  >>1;
         417                 :
         418                 :   /* Compute the lengths of the x polynomials. */
         419                 :   /* Compute the first half of K & R F1 & F2 polynomials. */
         420                 :   /* Compute half of the symmetric and antisymmetric polynomials. */
         421                 :   /* Remove the roots at +1 and -1. */
         422                 :
         423               0 :   g1[g1_order] = 1.f;
         424               0 :   for(i=1;i<=g1_order;i++) g1[g1_order-i] = lpc[i-1]+lpc[m-i];
         425               0 :   g2[g2_order] = 1.f;
         426               0 :   for(i=1;i<=g2_order;i++) g2[g2_order-i] = lpc[i-1]-lpc[m-i];
         427                 :
         428               0 :   if(g1_order>g2_order){
         429               0 :     for(i=2; i<=g2_order;i++) g2[g2_order-i] += g2[g2_order-i+2];
         430                 :   }else{
         431               0 :     for(i=1; i<=g1_order;i++) g1[g1_order-i] -= g1[g1_order-i+1];
         432               0 :     for(i=1; i<=g2_order;i++) g2[g2_order-i] += g2[g2_order-i+1];
         433                 :   }
         434                 :
         435                 :   /* Convert into polynomials in cos(alpha) */
         436               0 :   cheby(g1,g1_order);
         437               0 :   cheby(g2,g2_order);
         438                 :
         439                 :   /* Find the roots of the 2 even polynomials.*/
         440               0 :   if(Laguerre_With_Deflation(g1,g1_order,g1r) ||
         441               0 :      Laguerre_With_Deflation(g2,g2_order,g2r))
         442               0 :     return(-1);
         443                 :
         444               0 :   Newton_Raphson(g1,g1_order,g1r); /* if it fails, it leaves g1r alone */
         445               0 :   Newton_Raphson(g2,g2_order,g2r); /* if it fails, it leaves g2r alone */
         446                 :
         447               0 :   qsort(g1r,g1_order,sizeof(*g1r),comp);
         448               0 :   qsort(g2r,g2_order,sizeof(*g2r),comp);
         449                 :
         450               0 :   for(i=0;i<g1_order;i++)
         451               0 :     lsp[i*2] = acos(g1r[i]);
         452                 :
         453               0 :   for(i=0;i<g2_order;i++)
         454               0 :     lsp[i*2+1] = acos(g2r[i]);
         455               0 :   return(0);
         456                 : }

Generated by: LCOV version 1.7