lib/analysis.c

   1 /********************************************************************
   2  *                                                                  *
   3  * THIS FILE IS PART OF THE Ogg Vorbis SOFTWARE CODEC SOURCE CODE.  *
   4  * USE, DISTRIBUTION AND REPRODUCTION OF THIS SOURCE IS GOVERNED BY *
   5  * THE GNU PUBLIC LICENSE 2, WHICH IS INCLUDED WITH THIS SOURCE.    *
   6  * PLEASE READ THESE TERMS DISTRIBUTING.                            *
   7  *                                                                  *
   8  * THE OggSQUISH SOURCE CODE IS (C) COPYRIGHT 1994-1999             *
   9  * by 1999 Monty <monty@xiph.org> and The XIPHOPHORUS Company       *
  10  * http://www.xiph.org/                                             *
  11  *                                                                  *
  12  ********************************************************************
  13
  14  function: single-block PCM analysis
  15  author: Monty <xiphmont@mit.edu>
  16  modifications by: Monty
  17  last modification date: Oct 2 1999
  18
  19  ********************************************************************/
  20
  21 #include <stdio.h>
  22 #include <string.h>
  23 #include <math.h>
  24 #include "lpc.h"
  25 #include "lsp.h"
  26 #include "codec.h"
  27 #include "envelope.h"
  28 #include "mdct.h"
  29 #include "psy.h"
  30
  31 extern void compute_balance(double *A, double *B, double *phi,int n);
  32
  33 int vorbis_analysis(vorbis_block *vb,ogg_packet *op){
  34   int i;
  35   double *window=vb->vd->window[vb->W][vb->lW][vb->nW];
  36   lpc_lookup *vl=&vb->vd->vl[vb->W];
  37   lpc_lookup *vbal=&vb->vd->vbal[vb->W];
  38   int n=vb->pcmend;
  39   static int frameno=0;
  40
  41   double balance_v[vbal->m];
  42   double balance_amp;
  43
  44   _ve_envelope_sparsify(vb);
  45   _ve_envelope_apply(vb,0);
  46
  47   for(i=0;i<vb->pcm_channels;i++)
  48     mdct_forward(&vb->vd->vm[vb->W],vb->pcm[i],vb->pcm[i],window);
  49
  50
  51   /* hardwired to stereo for now */
  52   {
  53     double *C=vb->pcm[0];
  54     double *D=vb->pcm[1];
  55
  56     /* Balance */
  57
  58     balance_amp=_vp_balance_compute(D,C,balance_v,vbal);
  59
  60     /*{
  61       FILE *out;
  62       char buffer[80];
  63
  64       sprintf(buffer,"com%d.m",frameno);
  65       out=fopen(buffer,"w+");
  66       for(i=0;i<n/2;i++){
  67         fprintf(out," 0. 0.\n");
  68         fprintf(out,"%g %g\n",C[i],D[i]);
  69         fprintf(out,"\n");
  70       }
  71       fclose(out);
  72
  73       sprintf(buffer,"L%d.m",frameno);
  74       out=fopen(buffer,"w+");
  75       for(i=0;i<n/2;i++){
  76         fprintf(out,"%g\n",C[i]);
  77       }
  78       fclose(out);
  79       sprintf(buffer,"R%d.m",frameno);
  80       out=fopen(buffer,"w+");
  81       for(i=0;i<n/2;i++){
  82         fprintf(out,"%g\n",D[i]);
  83       }
  84       fclose(out);
  85
  86       }*/
  87
  88     /* apply balance vectors, mix down to the vectors we actually encode */
  89
  90     _vp_balance_apply(D,C,balance_v,balance_amp,vbal,1);
  91
  92     /*{
  93       FILE *out;
  94       char buffer[80];
  95
  96       sprintf(buffer,"bal%d.m",frameno);
  97       out=fopen(buffer,"w+");
  98       for(i=0;i<n/2;i++){
  99         fprintf(out," 0. 0.\n");
 100         fprintf(out,"%g %g\n",C[i],D[i]);
 101         fprintf(out,"\n");
 102       }
 103       fclose(out);
 104       sprintf(buffer,"C%d.m",frameno);
 105       out=fopen(buffer,"w+");
 106       for(i=0;i<n/2;i++){
 107         fprintf(out,"%g\n",C[i]);
 108       }
 109       fclose(out);
 110       sprintf(buffer,"D%d.m",frameno);
 111       out=fopen(buffer,"w+");
 112       for(i=0;i<n/2;i++){
 113         fprintf(out,"%g\n",D[i]);
 114       }
 115       fclose(out);
 116
 117       }*/
 118
 119     /* extract the spectral envelope and residue */
 120
 121     {
 122       double floor1[n/2];
 123       double curve[n/2];
 124       double work[n/2];
 125       double lpc1[80];
 126       double lsp1[80];
 127       double lsp2[80];
 128       double amp1;
 129
 130       memset(floor1,0,sizeof(floor1));
 131       memset(work,0,sizeof(work));
 132
 133       _vp_noise_floor(C,floor1,n/2);
 134       _vp_noise_floor(D,floor1,n/2);
 135       _vp_mask_floor(C,floor1,n/2);
 136       _vp_mask_floor(D,floor1,n/2);
 137
 138       memcpy(curve,floor1,sizeof(double)*n/2);
 139       amp1=sqrt(vorbis_curve_to_lpc(curve,lpc1,vl));
 140
 141       /*vorbis_lpc_to_lsp(lpc1,lsp1,30);
 142
 143       {
 144       int scale=1020;
 145       int last=0;
 146       for(i=0;i<30;i++){
 147       double q=lsp1[i]/M_PI*scale;
 148       int val=rint(q-last);
 149
 150       last+=val;
 151       lsp1[i]=val;
 152
 153       }
 154       }
 155
 156
 157       {
 158       int scale=1020;
 159         double last=0;
 160         for(i=0;i<30;i++){
 161           last+=lsp1[i];
 162           lsp2[i]=last*M_PI/scale;
 163         }
 164       }
 165
 166
 167
 168       vorbis_lsp_to_lpc(lsp2,lpc1,30);*/
 169
 170       vorbis_lpc_to_curve(work,lpc1,amp1,vl);
 171
 172       _vp_psy_quantize(C,work,n/2);
 173       _vp_psy_quantize(D,work,n/2);
 174
 175       _vp_psy_unquantize(C,work,n/2);
 176       _vp_psy_unquantize(D,work,n/2);
 177
 178
 179       {
 180         FILE *out;
 181         char buffer[80];
 182
 183
 184         /*sprintf(buffer,"qC%d.m",frameno);
 185           out=fopen(buffer,"w+");
 186           for(i=0;i<n/2;i++)
 187           fprintf(out,"%g\n",fabs(C[i]));
 188           fclose(out);
 189
 190           sprintf(buffer,"qD%d.m",frameno);
 191           out=fopen(buffer,"w+");
 192           for(i=0;i<n/2;i++)
 193           fprintf(out,"%g\n",fabs(D[i]));
 194           fclose(out);
 195
 196           sprintf(buffer,"floor%d.m",frameno);
 197           out=fopen(buffer,"w+");
 198           for(i=0;i<n/2;i++)
 199           fprintf(out,"%g\n",floor1[i]);
 200           fclose(out);
 201
 202           sprintf(buffer,"lpc%d.m",frameno);
 203           out=fopen(buffer,"w+");
 204           for(i=0;i<n/2;i++)
 205           fprintf(out,"%g\n",work[i]);
 206           fclose(out);
 207
 208           sprintf(buffer,"curve%d.m",frameno);
 209           out=fopen(buffer,"w+");
 210           for(i=0;i<n/2;i++)
 211           fprintf(out,"%g\n",curve[i]);
 212           fclose(out);
 213
 214           sprintf(buffer,"lsp%d.m",frameno);
 215           out=fopen(buffer,"w+");
 216           for(i=0;i<30;i++){
 217           fprintf(out,"%g 0.\n",lsp1[i]);
 218           fprintf(out,"%g .1\n",lsp1[i]);
 219           fprintf(out,"\n");
 220           fprintf(out,"\n");
 221           }
 222           fclose(out);*/
 223
 224         frameno++;
 225       }
 226     }
 227     /* unmix */
 228     _vp_balance_apply(D,C,balance_v,balance_amp,vbal,0);
 229   }
 230
 231   return(0);
 232 }
 233