src/lib/doslib/ext/vorbis/floor0.c

   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: floor backend 0 implementation
  14  last mod: $Id: floor0.c 17558 2010-10-22 00:24:41Z tterribe $
  15
  16  ********************************************************************/
  17
  18 #include <stdlib.h>
  19 #include <string.h>
  20 #include <math.h>
  21 #include <ext/libogg/ogg.h>
  22 #include "codec.h"
  23 #include "codec_internal.h"
  24 #include "registry.h"
  25 #include "lpc.h"
  26 #include "lsp.h"
  27 #include "codebook.h"
  28 #include "scales.h"
  29 #include "misc.h"
  30 #include "os.h"
  31
  32 #include "misc.h"
  33 #include <stdio.h>
  34
  35 typedef struct {
  36   int ln;
  37   int  m;
  38   int **linearmap;
  39   int  n[2];
  40
  41   vorbis_info_floor0 *vi;
  42
  43   long bits;
  44   long frames;
  45 } vorbis_look_floor0;
  46
  47
  48 /***********************************************/
  49
  50 static void floor0_free_info(vorbis_info_floor *i){
  51   vorbis_info_floor0 *info=(vorbis_info_floor0 *)i;
  52   if(info){
  53     memset(info,0,sizeof(*info));
  54     _ogg_free(info);
  55   }
  56 }
  57
  58 static void floor0_free_look(vorbis_look_floor *i){
  59   vorbis_look_floor0 *look=(vorbis_look_floor0 *)i;
  60   if(look){
  61
  62     if(look->linearmap){
  63
  64       if(look->linearmap[0])_ogg_free(look->linearmap[0]);
  65       if(look->linearmap[1])_ogg_free(look->linearmap[1]);
  66
  67       _ogg_free(look->linearmap);
  68     }
  69     memset(look,0,sizeof(*look));
  70     _ogg_free(look);
  71   }
  72 }
  73
  74 static vorbis_info_floor *floor0_unpack (vorbis_info *vi,oggpack_buffer *opb){
  75   codec_setup_info     *ci=vi->codec_setup;
  76   int j;
  77
  78   vorbis_info_floor0 *info=_ogg_malloc(sizeof(*info));
  79   info->order=oggpack_read(opb,8);
  80   info->rate=oggpack_read(opb,16);
  81   info->barkmap=oggpack_read(opb,16);
  82   info->ampbits=oggpack_read(opb,6);
  83   info->ampdB=oggpack_read(opb,8);
  84   info->numbooks=oggpack_read(opb,4)+1;
  85
  86   if(info->order<1)goto err_out;
  87   if(info->rate<1)goto err_out;
  88   if(info->barkmap<1)goto err_out;
  89   if(info->numbooks<1)goto err_out;
  90
  91   for(j=0;j<info->numbooks;j++){
  92     info->books[j]=oggpack_read(opb,8);
  93     if(info->books[j]<0 || info->books[j]>=ci->books)goto err_out;
  94     if(ci->book_param[info->books[j]]->maptype==0)goto err_out;
  95     if(ci->book_param[info->books[j]]->dim<1)goto err_out;
  96   }
  97   return(info);
  98
  99  err_out:
 100   floor0_free_info(info);
 101   return(NULL);
 102 }
 103
 104 /* initialize Bark scale and normalization lookups.  We could do this
 105    with static tables, but Vorbis allows a number of possible
 106    combinations, so it's best to do it computationally.
 107
 108    The below is authoritative in terms of defining scale mapping.
 109    Note that the scale depends on the sampling rate as well as the
 110    linear block and mapping sizes */
 111
 112 static void floor0_map_lazy_init(vorbis_block      *vb,
 113                                  vorbis_info_floor *infoX,
 114                                  vorbis_look_floor0 *look){
 115   if(!look->linearmap[vb->W]){
 116     vorbis_dsp_state   *vd=vb->vd;
 117     vorbis_info        *vi=vd->vi;
 118     codec_setup_info   *ci=vi->codec_setup;
 119     vorbis_info_floor0 *info=(vorbis_info_floor0 *)infoX;
 120     int W=vb->W;
 121     int n=ci->blocksizes[W]/2,j;
 122
 123     /* we choose a scaling constant so that:
 124        floor(bark(rate/2-1)*C)=mapped-1
 125      floor(bark(rate/2)*C)=mapped */
 126     float scale=look->ln/toBARK(info->rate/2.f);
 127
 128     /* the mapping from a linear scale to a smaller bark scale is
 129        straightforward.  We do *not* make sure that the linear mapping
 130        does not skip bark-scale bins; the decoder simply skips them and
 131        the encoder may do what it wishes in filling them.  They're
 132        necessary in some mapping combinations to keep the scale spacing
 133        accurate */
 134     look->linearmap[W]=_ogg_malloc((n+1)*sizeof(**look->linearmap));
 135     for(j=0;j<n;j++){
 136       int val=floor( toBARK((info->rate/2.f)/n*j)
 137                      *scale); /* bark numbers represent band edges */
 138       if(val>=look->ln)val=look->ln-1; /* guard against the approximation */
 139       look->linearmap[W][j]=val;
 140     }
 141     look->linearmap[W][j]=-1;
 142     look->n[W]=n;
 143   }
 144 }
 145
 146 static vorbis_look_floor *floor0_look(vorbis_dsp_state *vd,
 147                                       vorbis_info_floor *i){
 148   vorbis_info_floor0 *info=(vorbis_info_floor0 *)i;
 149   vorbis_look_floor0 *look=_ogg_calloc(1,sizeof(*look));
 150   look->m=info->order;
 151   look->ln=info->barkmap;
 152   look->vi=info;
 153
 154   look->linearmap=_ogg_calloc(2,sizeof(*look->linearmap));
 155
 156   return look;
 157 }
 158
 159 static void *floor0_inverse1(vorbis_block *vb,vorbis_look_floor *i){
 160   vorbis_look_floor0 *look=(vorbis_look_floor0 *)i;
 161   vorbis_info_floor0 *info=look->vi;
 162   int j,k;
 163
 164   int ampraw=oggpack_read(&vb->opb,info->ampbits);
 165   if(ampraw>0){ /* also handles the -1 out of data case */
 166     long maxval=(1<<info->ampbits)-1;
 167     float amp=(float)ampraw/maxval*info->ampdB;
 168     int booknum=oggpack_read(&vb->opb,_ilog(info->numbooks));
 169
 170     if(booknum!=-1 && booknum<info->numbooks){ /* be paranoid */
 171       codec_setup_info  *ci=vb->vd->vi->codec_setup;
 172       codebook *b=ci->fullbooks+info->books[booknum];
 173       float last=0.f;
 174
 175       /* the additional b->dim is a guard against any possible stack
 176          smash; b->dim is provably more than we can overflow the
 177          vector */
 178       float *lsp=_vorbis_block_alloc(vb,sizeof(*lsp)*(look->m+b->dim+1));
 179
 180       for(j=0;j<look->m;j+=b->dim)
 181         if(vorbis_book_decodev_set(b,lsp+j,&vb->opb,b->dim)==-1)goto eop;
 182       for(j=0;j<look->m;){
 183         for(k=0;k<b->dim;k++,j++)lsp[j]+=last;
 184         last=lsp[j-1];
 185       }
 186
 187       lsp[look->m]=amp;
 188       return(lsp);
 189     }
 190   }
 191  eop:
 192   return(NULL);
 193 }
 194
 195 static int floor0_inverse2(vorbis_block *vb,vorbis_look_floor *i,
 196                            void *memo,float *out){
 197   vorbis_look_floor0 *look=(vorbis_look_floor0 *)i;
 198   vorbis_info_floor0 *info=look->vi;
 199
 200   floor0_map_lazy_init(vb,info,look);
 201
 202   if(memo){
 203     float *lsp=(float *)memo;
 204     float amp=lsp[look->m];
 205
 206     /* take the coefficients back to a spectral envelope curve */
 207     vorbis_lsp_to_curve(out,
 208                         look->linearmap[vb->W],
 209                         look->n[vb->W],
 210                         look->ln,
 211                         lsp,look->m,amp,(float)info->ampdB);
 212     return(1);
 213   }
 214   memset(out,0,sizeof(*out)*look->n[vb->W]);
 215   return(0);
 216 }
 217
 218 /* export hooks */
 219 const vorbis_func_floor floor0_exportbundle={
 220   NULL,&floor0_unpack,&floor0_look,&floor0_free_info,
 221   &floor0_free_look,&floor0_inverse1,&floor0_inverse2
 222 };