misc/libtremor/tremor/floor0.c
branchhedgeroid
changeset 6045 9a7cc0f29430
parent 6043 9bd2d6b1ba52
child 7697 767d3c4153a1
equal deleted inserted replaced
6043:9bd2d6b1ba52 6045:9a7cc0f29430
       
     1 /********************************************************************
       
     2  *                                                                  *
       
     3  * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE.   *
       
     4  *                                                                  *
       
     5  * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS     *
       
     6  * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
       
     7  * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING.       *
       
     8  *                                                                  *
       
     9  * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002    *
       
    10  * BY THE Xiph.Org FOUNDATION http://www.xiph.org/                  *
       
    11  *                                                                  *
       
    12  ********************************************************************
       
    13 
       
    14  function: floor backend 0 implementation
       
    15 
       
    16  ********************************************************************/
       
    17 
       
    18 #include <stdlib.h>
       
    19 #include <string.h>
       
    20 #include <math.h>
       
    21 #include "ogg.h"
       
    22 #include "ivorbiscodec.h"
       
    23 #include "codec_internal.h"
       
    24 #include "registry.h"
       
    25 #include "codebook.h"
       
    26 #include "misc.h"
       
    27 #include "block.h"
       
    28 
       
    29 #define LSP_FRACBITS 14
       
    30 
       
    31 typedef struct {
       
    32   long n;
       
    33   int ln;
       
    34   int  m;
       
    35   int *linearmap;
       
    36 
       
    37   vorbis_info_floor0 *vi;
       
    38   ogg_int32_t *lsp_look;
       
    39 
       
    40 } vorbis_look_floor0;
       
    41 
       
    42 /*************** LSP decode ********************/
       
    43 
       
    44 #include "lsp_lookup.h"
       
    45 
       
    46 /* interpolated 1./sqrt(p) where .5 <= a < 1. (.100000... to .111111...) in
       
    47    16.16 format 
       
    48    returns in m.8 format */
       
    49 
       
    50 static long ADJUST_SQRT2[2]={8192,5792};
       
    51 STIN ogg_int32_t vorbis_invsqlook_i(long a,long e){
       
    52   long i=(a&0x7fff)>>(INVSQ_LOOKUP_I_SHIFT-1); 
       
    53   long d=a&INVSQ_LOOKUP_I_MASK;                              /*  0.10 */
       
    54   long val=INVSQ_LOOKUP_I[i]-                                /*  1.16 */
       
    55     ((INVSQ_LOOKUP_IDel[i]*d)>>INVSQ_LOOKUP_I_SHIFT);        /* result 1.16 */
       
    56   val*=ADJUST_SQRT2[e&1];
       
    57   e=(e>>1)+21;
       
    58   return(val>>e);
       
    59 }
       
    60 
       
    61 /* interpolated lookup based fromdB function, domain -140dB to 0dB only */
       
    62 /* a is in n.12 format */
       
    63 STIN ogg_int32_t vorbis_fromdBlook_i(long a){
       
    64   int i=(-a)>>(12-FROMdB2_SHIFT);
       
    65   if(i<0) return 0x7fffffff;
       
    66   if(i>=(FROMdB_LOOKUP_SZ<<FROMdB_SHIFT))return 0;
       
    67   
       
    68   return FROMdB_LOOKUP[i>>FROMdB_SHIFT] * FROMdB2_LOOKUP[i&FROMdB2_MASK];
       
    69 }
       
    70 
       
    71 /* interpolated lookup based cos function, domain 0 to PI only */
       
    72 /* a is in 0.16 format, where 0==0, 2^^16-1==PI, return 0.14 */
       
    73 STIN ogg_int32_t vorbis_coslook_i(long a){
       
    74   int i=a>>COS_LOOKUP_I_SHIFT;
       
    75   int d=a&COS_LOOKUP_I_MASK;
       
    76   return COS_LOOKUP_I[i]- ((d*(COS_LOOKUP_I[i]-COS_LOOKUP_I[i+1]))>>
       
    77 			   COS_LOOKUP_I_SHIFT);
       
    78 }
       
    79 
       
    80 /* interpolated lookup based cos function */
       
    81 /* a is in 0.16 format, where 0==0, 2^^16==PI, return .LSP_FRACBITS */
       
    82 STIN ogg_int32_t vorbis_coslook2_i(long a){
       
    83   a=a&0x1ffff;
       
    84 
       
    85   if(a>0x10000)a=0x20000-a;
       
    86   {               
       
    87     int i=a>>COS_LOOKUP_I_SHIFT;
       
    88     int d=a&COS_LOOKUP_I_MASK;
       
    89     a=((COS_LOOKUP_I[i]<<COS_LOOKUP_I_SHIFT)-
       
    90        d*(COS_LOOKUP_I[i]-COS_LOOKUP_I[i+1]))>>
       
    91       (COS_LOOKUP_I_SHIFT-LSP_FRACBITS+14);
       
    92   }
       
    93   
       
    94   return(a);
       
    95 }
       
    96 
       
    97 static const int barklook[28]={
       
    98   0,100,200,301,          405,516,635,766,
       
    99   912,1077,1263,1476,     1720,2003,2333,2721,
       
   100   3184,3742,4428,5285,    6376,7791,9662,12181,
       
   101   15624,20397,27087,36554
       
   102 };
       
   103 
       
   104 /* used in init only; interpolate the long way */
       
   105 STIN ogg_int32_t toBARK(int n){
       
   106   int i;
       
   107   for(i=0;i<27;i++) 
       
   108     if(n>=barklook[i] && n<barklook[i+1])break;
       
   109   
       
   110   if(i==27){
       
   111     return 27<<15;
       
   112   }else{
       
   113     int gap=barklook[i+1]-barklook[i];
       
   114     int del=n-barklook[i];
       
   115 
       
   116     return((i<<15)+((del<<15)/gap));
       
   117   }
       
   118 }
       
   119 
       
   120 static const unsigned char MLOOP_1[64]={
       
   121    0,10,11,11, 12,12,12,12, 13,13,13,13, 13,13,13,13,
       
   122   14,14,14,14, 14,14,14,14, 14,14,14,14, 14,14,14,14,
       
   123   15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15,
       
   124   15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15,
       
   125 };
       
   126 
       
   127 static const unsigned char MLOOP_2[64]={
       
   128   0,4,5,5, 6,6,6,6, 7,7,7,7, 7,7,7,7,
       
   129   8,8,8,8, 8,8,8,8, 8,8,8,8, 8,8,8,8,
       
   130   9,9,9,9, 9,9,9,9, 9,9,9,9, 9,9,9,9,
       
   131   9,9,9,9, 9,9,9,9, 9,9,9,9, 9,9,9,9,
       
   132 };
       
   133 
       
   134 static const unsigned char MLOOP_3[8]={0,1,2,2,3,3,3,3};
       
   135 
       
   136 void vorbis_lsp_to_curve(ogg_int32_t *curve,int *map,int n,int ln,
       
   137 			 ogg_int32_t *lsp,int m,
       
   138 			 ogg_int32_t amp,
       
   139 			 ogg_int32_t ampoffset,
       
   140 			 ogg_int32_t *icos){
       
   141 
       
   142   /* 0 <= m < 256 */
       
   143 
       
   144   /* set up for using all int later */
       
   145   int i;
       
   146   int ampoffseti=ampoffset*4096;
       
   147   int ampi=amp;
       
   148   ogg_int32_t *ilsp=(ogg_int32_t *)alloca(m*sizeof(*ilsp));
       
   149   /* lsp is in 8.24, range 0 to PI; coslook wants it in .16 0 to 1*/
       
   150   for(i=0;i<m;i++){
       
   151 #ifndef _LOW_ACCURACY_
       
   152     ogg_int32_t val=MULT32(lsp[i],0x517cc2);
       
   153 #else
       
   154     ogg_int32_t val=((lsp[i]>>10)*0x517d)>>14;
       
   155 #endif
       
   156 
       
   157     /* safeguard against a malicious stream */
       
   158     if(val<0 || (val>>COS_LOOKUP_I_SHIFT)>=COS_LOOKUP_I_SZ){
       
   159       memset(curve,0,sizeof(*curve)*n);
       
   160       return;
       
   161     }
       
   162 
       
   163     ilsp[i]=vorbis_coslook_i(val);
       
   164   }
       
   165 
       
   166   i=0;
       
   167   while(i<n){
       
   168     int j,k=map[i];
       
   169     ogg_uint32_t pi=46341; /* 2**-.5 in 0.16 */
       
   170     ogg_uint32_t qi=46341;
       
   171     ogg_int32_t qexp=0,shift;
       
   172     ogg_int32_t wi=icos[k];
       
   173 
       
   174 #ifdef _V_LSP_MATH_ASM
       
   175     lsp_loop_asm(&qi,&pi,&qexp,ilsp,wi,m);
       
   176 
       
   177     pi=((pi*pi)>>16);
       
   178     qi=((qi*qi)>>16);
       
   179     
       
   180     if(m&1){
       
   181       qexp= qexp*2-28*((m+1)>>1)+m;	     
       
   182       pi*=(1<<14)-((wi*wi)>>14);
       
   183       qi+=pi>>14;     
       
   184     }else{
       
   185       qexp= qexp*2-13*m;
       
   186       
       
   187       pi*=(1<<14)-wi;
       
   188       qi*=(1<<14)+wi;
       
   189       
       
   190       qi=(qi+pi)>>14;
       
   191     }
       
   192     
       
   193     if(qi&0xffff0000){ /* checks for 1.xxxxxxxxxxxxxxxx */
       
   194       qi>>=1; qexp++; 
       
   195     }else
       
   196       lsp_norm_asm(&qi,&qexp);
       
   197 
       
   198 #else
       
   199 
       
   200     qi*=labs(ilsp[0]-wi);
       
   201     pi*=labs(ilsp[1]-wi);
       
   202 
       
   203     for(j=3;j<m;j+=2){
       
   204       if(!(shift=MLOOP_1[(pi|qi)>>25]))
       
   205 	if(!(shift=MLOOP_2[(pi|qi)>>19]))
       
   206 	  shift=MLOOP_3[(pi|qi)>>16];
       
   207       qi=(qi>>shift)*labs(ilsp[j-1]-wi);
       
   208       pi=(pi>>shift)*labs(ilsp[j]-wi);
       
   209       qexp+=shift;
       
   210     }
       
   211     if(!(shift=MLOOP_1[(pi|qi)>>25]))
       
   212       if(!(shift=MLOOP_2[(pi|qi)>>19]))
       
   213 	shift=MLOOP_3[(pi|qi)>>16];
       
   214 
       
   215     /* pi,qi normalized collectively, both tracked using qexp */
       
   216 
       
   217     if(m&1){
       
   218       /* odd order filter; slightly assymetric */
       
   219       /* the last coefficient */
       
   220       qi=(qi>>shift)*labs(ilsp[j-1]-wi);
       
   221       pi=(pi>>shift)<<14;
       
   222       qexp+=shift;
       
   223 
       
   224       if(!(shift=MLOOP_1[(pi|qi)>>25]))
       
   225 	if(!(shift=MLOOP_2[(pi|qi)>>19]))
       
   226 	  shift=MLOOP_3[(pi|qi)>>16];
       
   227       
       
   228       pi>>=shift;
       
   229       qi>>=shift;
       
   230       qexp+=shift-14*((m+1)>>1);
       
   231 
       
   232       pi=((pi*pi)>>16);
       
   233       qi=((qi*qi)>>16);
       
   234       qexp=qexp*2+m;
       
   235 
       
   236       pi*=(1<<14)-((wi*wi)>>14);
       
   237       qi+=pi>>14;
       
   238 
       
   239     }else{
       
   240       /* even order filter; still symmetric */
       
   241 
       
   242       /* p*=p(1-w), q*=q(1+w), let normalization drift because it isn't
       
   243 	 worth tracking step by step */
       
   244       
       
   245       pi>>=shift;
       
   246       qi>>=shift;
       
   247       qexp+=shift-7*m;
       
   248 
       
   249       pi=((pi*pi)>>16);
       
   250       qi=((qi*qi)>>16);
       
   251       qexp=qexp*2+m;
       
   252       
       
   253       pi*=(1<<14)-wi;
       
   254       qi*=(1<<14)+wi;
       
   255       qi=(qi+pi)>>14;
       
   256       
       
   257     }
       
   258     
       
   259 
       
   260     /* we've let the normalization drift because it wasn't important;
       
   261        however, for the lookup, things must be normalized again.  We
       
   262        need at most one right shift or a number of left shifts */
       
   263 
       
   264     if(qi&0xffff0000){ /* checks for 1.xxxxxxxxxxxxxxxx */
       
   265       qi>>=1; qexp++; 
       
   266     }else
       
   267       while(qi && !(qi&0x8000)){ /* checks for 0.0xxxxxxxxxxxxxxx or less*/
       
   268 	qi<<=1; qexp--; 
       
   269       }
       
   270 
       
   271 #endif
       
   272 
       
   273     amp=vorbis_fromdBlook_i(ampi*                     /*  n.4         */
       
   274 			    vorbis_invsqlook_i(qi,qexp)- 
       
   275 			                              /*  m.8, m+n<=8 */
       
   276 			    ampoffseti);              /*  8.12[0]     */
       
   277     
       
   278 #ifdef _LOW_ACCURACY_
       
   279     amp>>=9;
       
   280 #endif
       
   281     curve[i]= MULT31_SHIFT15(curve[i],amp);
       
   282     while(map[++i]==k) curve[i]= MULT31_SHIFT15(curve[i],amp);
       
   283   }
       
   284 }
       
   285 
       
   286 /*************** vorbis decode glue ************/
       
   287 
       
   288 static void floor0_free_info(vorbis_info_floor *i){
       
   289   vorbis_info_floor0 *info=(vorbis_info_floor0 *)i;
       
   290   if(info){
       
   291     memset(info,0,sizeof(*info));
       
   292     _ogg_free(info);
       
   293   }
       
   294 }
       
   295 
       
   296 static void floor0_free_look(vorbis_look_floor *i){
       
   297   vorbis_look_floor0 *look=(vorbis_look_floor0 *)i;
       
   298   if(look){
       
   299 
       
   300     if(look->linearmap)_ogg_free(look->linearmap);
       
   301     if(look->lsp_look)_ogg_free(look->lsp_look);
       
   302     memset(look,0,sizeof(*look));
       
   303     _ogg_free(look);
       
   304   }
       
   305 }
       
   306 
       
   307 static vorbis_info_floor *floor0_unpack (vorbis_info *vi,oggpack_buffer *opb){
       
   308   codec_setup_info     *ci=(codec_setup_info *)vi->codec_setup;
       
   309   int j;
       
   310 
       
   311   vorbis_info_floor0 *info=(vorbis_info_floor0 *)_ogg_malloc(sizeof(*info));
       
   312   info->order=oggpack_read(opb,8);
       
   313   info->rate=oggpack_read(opb,16);
       
   314   info->barkmap=oggpack_read(opb,16);
       
   315   info->ampbits=oggpack_read(opb,6);
       
   316   info->ampdB=oggpack_read(opb,8);
       
   317   info->numbooks=oggpack_read(opb,4)+1;
       
   318   
       
   319   if(info->order<1)goto err_out;
       
   320   if(info->rate<1)goto err_out;
       
   321   if(info->barkmap<1)goto err_out;
       
   322   if(info->numbooks<1)goto err_out;
       
   323     
       
   324   for(j=0;j<info->numbooks;j++){
       
   325     info->books[j]=oggpack_read(opb,8);
       
   326     if(info->books[j]<0 || info->books[j]>=ci->books)goto err_out;
       
   327   }
       
   328   return(info);
       
   329 
       
   330  err_out:
       
   331   floor0_free_info(info);
       
   332   return(NULL);
       
   333 }
       
   334 
       
   335 /* initialize Bark scale and normalization lookups.  We could do this
       
   336    with static tables, but Vorbis allows a number of possible
       
   337    combinations, so it's best to do it computationally.
       
   338 
       
   339    The below is authoritative in terms of defining scale mapping.
       
   340    Note that the scale depends on the sampling rate as well as the
       
   341    linear block and mapping sizes */
       
   342 
       
   343 static vorbis_look_floor *floor0_look (vorbis_dsp_state *vd,vorbis_info_mode *mi,
       
   344                               vorbis_info_floor *i){
       
   345   int j;
       
   346   vorbis_info        *vi=vd->vi;
       
   347   codec_setup_info   *ci=(codec_setup_info *)vi->codec_setup;
       
   348   vorbis_info_floor0 *info=(vorbis_info_floor0 *)i;
       
   349   vorbis_look_floor0 *look=(vorbis_look_floor0 *)_ogg_calloc(1,sizeof(*look));
       
   350   look->m=info->order;
       
   351   look->n=ci->blocksizes[mi->blockflag]/2;
       
   352   look->ln=info->barkmap;
       
   353   look->vi=info;
       
   354 
       
   355   /* the mapping from a linear scale to a smaller bark scale is
       
   356      straightforward.  We do *not* make sure that the linear mapping
       
   357      does not skip bark-scale bins; the decoder simply skips them and
       
   358      the encoder may do what it wishes in filling them.  They're
       
   359      necessary in some mapping combinations to keep the scale spacing
       
   360      accurate */
       
   361   look->linearmap=(int *)_ogg_malloc((look->n+1)*sizeof(*look->linearmap));
       
   362   for(j=0;j<look->n;j++){
       
   363 
       
   364     int val=(look->ln*
       
   365 	     ((toBARK(info->rate/2*j/look->n)<<11)/toBARK(info->rate/2)))>>11;
       
   366 
       
   367     if(val>=look->ln)val=look->ln-1; /* guard against the approximation */
       
   368     look->linearmap[j]=val;
       
   369   }
       
   370   look->linearmap[j]=-1;
       
   371 
       
   372   look->lsp_look=(ogg_int32_t *)_ogg_malloc(look->ln*sizeof(*look->lsp_look));
       
   373   for(j=0;j<look->ln;j++)
       
   374     look->lsp_look[j]=vorbis_coslook2_i(0x10000*j/look->ln);
       
   375 
       
   376   return look;
       
   377 }
       
   378 
       
   379 static void *floor0_inverse1(vorbis_block *vb,vorbis_look_floor *i){
       
   380   vorbis_look_floor0 *look=(vorbis_look_floor0 *)i;
       
   381   vorbis_info_floor0 *info=look->vi;
       
   382   int j,k;
       
   383   
       
   384   int ampraw=oggpack_read(&vb->opb,info->ampbits);
       
   385   if(ampraw>0){ /* also handles the -1 out of data case */
       
   386     long maxval=(1<<info->ampbits)-1;
       
   387     int amp=((ampraw*info->ampdB)<<4)/maxval;
       
   388     int booknum=oggpack_read(&vb->opb,_ilog(info->numbooks));
       
   389     
       
   390     if(booknum!=-1 && booknum<info->numbooks){ /* be paranoid */
       
   391       codec_setup_info  *ci=(codec_setup_info *)vb->vd->vi->codec_setup;
       
   392       codebook *b=ci->fullbooks+info->books[booknum];
       
   393       ogg_int32_t last=0;
       
   394       ogg_int32_t *lsp=(ogg_int32_t *)_vorbis_block_alloc(vb,sizeof(*lsp)*(look->m+1));
       
   395             
       
   396       for(j=0;j<look->m;j+=b->dim)
       
   397 	if(vorbis_book_decodev_set(b,lsp+j,&vb->opb,b->dim,-24)==-1)goto eop;
       
   398       for(j=0;j<look->m;){
       
   399 	for(k=0;k<b->dim;k++,j++)lsp[j]+=last;
       
   400 	last=lsp[j-1];
       
   401       }
       
   402       
       
   403       lsp[look->m]=amp;
       
   404       return(lsp);
       
   405     }
       
   406   }
       
   407  eop:
       
   408   return(NULL);
       
   409 }
       
   410 
       
   411 static int floor0_inverse2(vorbis_block *vb,vorbis_look_floor *i,
       
   412 			   void *memo,ogg_int32_t *out){
       
   413   vorbis_look_floor0 *look=(vorbis_look_floor0 *)i;
       
   414   vorbis_info_floor0 *info=look->vi;
       
   415   
       
   416   if(memo){
       
   417     ogg_int32_t *lsp=(ogg_int32_t *)memo;
       
   418     ogg_int32_t amp=lsp[look->m];
       
   419 
       
   420     /* take the coefficients back to a spectral envelope curve */
       
   421     vorbis_lsp_to_curve(out,look->linearmap,look->n,look->ln,
       
   422 			lsp,look->m,amp,info->ampdB,look->lsp_look);
       
   423     return(1);
       
   424   }
       
   425   memset(out,0,sizeof(*out)*look->n);
       
   426   return(0);
       
   427 }
       
   428 
       
   429 /* export hooks */
       
   430 vorbis_func_floor floor0_exportbundle={
       
   431   &floor0_unpack,&floor0_look,&floor0_free_info,
       
   432   &floor0_free_look,&floor0_inverse1,&floor0_inverse2
       
   433 };
       
   434 
       
   435