Move library tree where it belongs

lib-src/libvorbis/vq/lspdata.c

@@ -0,0 +1,157 @@
+/********************************************************************
+ *                                                                  *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE.   *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS     *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING.       *
+ *                                                                  *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2001             *
+ * by the Xiph.Org Foundation http://www.xiph.org/                  *
+ *                                                                  *
+ ********************************************************************
+
+ function: metrics and quantization code for LSP VQ codebooks
+ last mod: $Id: lspdata.c,v 1.4 2008-02-02 15:54:08 richardash1981 Exp $
+
+ ********************************************************************/
+
+#include <stdlib.h>
+#include <math.h>
+#include <stdio.h>
+#include "vqgen.h"
+#include "vqext.h"
+#include "codebook.h"
+
+char *vqext_booktype="LSPdata";  
+quant_meta q={0,0,0,1};          /* set sequence data */
+int vqext_aux=1;
+
+float global_maxdel=M_PI;
+float global_mindel=M_PI;
+#if 0
+void vqext_quantize(vqgen *v,quant_meta *q){
+  float delta,mindel;
+  float maxquant=((1<<q->quant)-1);
+  int j,k;
+
+  /* first find the basic delta amount from the maximum span to be
+     encoded.  Loosen the delta slightly to allow for additional error
+     during sequence quantization */
+
+  delta=(global_maxdel-global_mindel)/((1<<q->quant)-1.5f);
+  
+  q->min=_float32_pack(global_mindel);
+  q->delta=_float32_pack(delta);
+
+  mindel=_float32_unpack(q->min);
+  delta=_float32_unpack(q->delta);
+
+  for(j=0;j<v->entries;j++){
+    float last=0;
+    for(k=0;k<v->elements;k++){
+      float val=_now(v,j)[k];
+      float now=rint((val-last-mindel)/delta);
+      
+      _now(v,j)[k]=now;
+      if(now<0){
+	/* be paranoid; this should be impossible */
+	fprintf(stderr,"fault; quantized value<0\n");
+	exit(1);
+      }
+
+      if(now>maxquant){
+	/* be paranoid; this should be impossible */
+	fprintf(stderr,"fault; quantized value>max\n");
+	exit(1);
+      }
+      last=(now*delta)+mindel+last;
+    }
+  }
+
+}
+#else
+void vqext_quantize(vqgen *v,quant_meta *q){
+  vqgen_quantize(v,q);
+}
+#endif
+
+float *weight=NULL;
+#if 0
+/* LSP training metric.  We weight error proportional to distance
+   *between* LSP vector values.  The idea of this metric is not to set
+   final cells, but get the midpoint spacing into a form conducive to
+   what we want, which is weighting toward preserving narrower
+   features. */
+
+#define FUDGE (global_maxdel-weight[i])
+
+float *vqext_weight(vqgen *v,float *p){
+  int i;
+  int el=v->elements;
+  float lastp=0.f;
+  for(i=0;i<el;i++){
+    float predist=(p[i]-lastp);
+    float postdist=(p[i+1]-p[i]);
+    weight[i]=(predist<postdist?predist:postdist);
+    lastp=p[i];
+  }
+  return p;
+}
+#else
+#define FUDGE 1.f
+float *vqext_weight(vqgen *v,float *p){
+  return p;
+}
+#endif
+
+                            /* candidate,actual */
+float vqext_metric(vqgen *v,float *e, float *p){
+  int i;
+  int el=v->elements;
+  float acc=0.f;
+  for(i=0;i<el;i++){
+    float val=(p[i]-e[i])*FUDGE;
+    acc+=val*val;
+  }
+  return sqrt(acc/v->elements);
+}
+
+/* Data files are line-vectors, now just deltas.  The codebook entries
+   want to be monotonically increasing, so we adjust */
+
+/* assume vqext_aux==1 */
+void vqext_addpoint_adj(vqgen *v,float *b,int start,int dim,int cols,int num){
+  float *a=alloca(sizeof(float)*(dim+1)); /* +aux */
+  float base=0;
+  int i;
+
+  for(i=0;i<dim;i++)
+    base=a[i]=b[i+start]+base;
+
+  if(start+dim+1>cols) /* +aux */
+    a[i]=M_PI;
+  else
+    a[i]=b[i+start]+base;
+  
+  vqgen_addpoint(v,a,a+dim);
+}
+
+/* we just need to calc the global_maxdel from the training set */
+void vqext_preprocess(vqgen *v){
+  long j,k;
+
+  global_maxdel=0.f;
+  global_mindel=M_PI;
+  for(j=0;j<v->points;j++){
+    float last=0.;
+    for(k=0;k<v->elements+v->aux;k++){
+      float p=_point(v,j)[k];
+      if(p-last>global_maxdel)global_maxdel=p-last;
+      if(p-last<global_mindel)global_mindel=p-last;
+      last=p;
+    }
+  }
+
+  weight=_ogg_malloc(sizeof(float)*v->elements);
+}
+