gosu 0.7.16 → 0.7.17

data/dependencies/libvorbis/vq/latticetune.c

@@ -1,164 +0,0 @@
-/********************************************************************
- *                                                                  *
- * 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: utility main for setting entropy encoding parameters
-           for lattice codebooks
- last mod: $Id: latticetune.c 13293 2007-07-24 00:09:47Z xiphmont $
-
- ********************************************************************/
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <math.h>
-#include <string.h>
-#include <errno.h>
-#include "bookutil.h"
-
-static int strrcmp_i(char *s,char *cmp){
-  return(strncmp(s+strlen(s)-strlen(cmp),cmp,strlen(cmp)));
-}
-
-/* This util takes a training-collected file listing codewords used in
-   LSP fitting, then generates new codeword lengths for maximally
-   efficient integer-bits entropy encoding.
-
-   command line:
-   latticetune book.vqh input.vqd [unused_entriesp]
-
-   latticetune produces book.vqh on stdout */
-
-int main(int argc,char *argv[]){
-  codebook *b;
-  static_codebook *c;
-  long *lengths;
-  long *hits;
-
-  int entries=-1,dim=-1,guard=1;
-  FILE *in=NULL;
-  char *line,*name;
-  long j;
-
-  if(argv[1]==NULL){
-    fprintf(stderr,"Need a lattice codebook on the command line.\n");
-    exit(1);
-  }
-  if(argv[2]==NULL){
-    fprintf(stderr,"Need a codeword data file on the command line.\n");
-    exit(1);
-  }
-  if(argv[3]!=NULL)guard=0;
-
-  {
-    char *ptr;
-    char *filename=strdup(argv[1]);
-
-    b=codebook_load(filename);
-    c=(static_codebook *)(b->c);
-    
-    ptr=strrchr(filename,'.');
-    if(ptr){
-      *ptr='\0';
-      name=strdup(filename);
-    }else{
-      name=strdup(filename);
-    }
-  }
-
-  if(c->maptype!=1){
-    fprintf(stderr,"Provided book is not a latticebook.\n");
-    exit(1);
-  }
-
-  entries=b->entries;
-  dim=b->dim;
-
-  hits=_ogg_malloc(entries*sizeof(long));
-  lengths=_ogg_calloc(entries,sizeof(long));
-  for(j=0;j<entries;j++)hits[j]=guard;
-
-  in=fopen(argv[2],"r");
-  if(!in){
-    fprintf(stderr,"Could not open input file %s\n",argv[2]);
-    exit(1);
-  }
-
-  if(!strrcmp_i(argv[0],"latticetune")){
-    long lines=0;
-    line=setup_line(in);
-    while(line){      
-      long code;
-      lines++;
-      if(!(lines&0xfff))spinnit("codewords so far...",lines);
-      
-      if(sscanf(line,"%ld",&code)==1)
-	hits[code]++;
-
-      line=setup_line(in);
-    }
-  }
-
-  /* now we simply count already collated by-entry data */
-  if(!strrcmp_i(argv[0],"res0tune") || !strrcmp_i(argv[0],"res1tune")){
-
-    line=setup_line(in);
-    while(line){
-
-      /* code:hits\n */
-      /* likely to have multiple listing for each code entry; must
-         accumulate */
-
-      char *pos=strchr(line,':');
-      if(pos){
-	long code=atol(line);
-	long val=atol(pos+1); 
-	hits[code]+=val;
-      }
-
-      line=setup_line(in);
-    }
-  }
-
-  fclose(in);
-
-  /* build the codeword lengths */
-  build_tree_from_lengths0(entries,hits,lengths);
-
-  c->lengthlist=lengths;
-  write_codebook(stdout,name,c); 
-
-  {
-    long bins=_book_maptype1_quantvals(c);
-    long i,k,base=c->lengthlist[0];
-    for(i=0;i<entries;i++)
-      if(c->lengthlist[i]>base)base=c->lengthlist[i];
-    
-    for(j=0;j<entries;j++){
-      if(c->lengthlist[j]){
-	int indexdiv=1;
-	fprintf(stderr,"%4ld: ",j);
-	for(k=0;k<c->dim;k++){      
-	  int index= (j/indexdiv)%bins;
-	  fprintf(stderr,"%+3.1f,", c->quantlist[index]*_float32_unpack(c->q_delta)+
-		 _float32_unpack(c->q_min));
-	  indexdiv*=bins;
-	}
-	fprintf(stderr,"\t|");
-	for(k=0;k<base-c->lengthlist[j];k++)fprintf(stderr,"*");
-	fprintf(stderr,"\n");
-      }
-    }
-  }
-  
-  fprintf(stderr,"\r                                                     "
-	  "\nDone.\n");
-  exit(0);
-}

data/dependencies/libvorbis/vq/localcodebook.h

@@ -1,160 +0,0 @@
-/********************************************************************
- *                                                                  *
- * 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-2007             *
- * by the Xiph.Org Foundation http://www.xiph.org/                  *
- *                                                                  *
- ********************************************************************
-
- function: basic shared codebook operations
- last mod: $Id: localcodebook.h 13293 2007-07-24 00:09:47Z xiphmont $
-
- ********************************************************************/
-
-#ifndef _V_CODEBOOK_H_
-#define _V_CODEBOOK_H_
-
-#include <ogg/ogg.h>
-
-/* This structure encapsulates huffman and VQ style encoding books; it
-   doesn't do anything specific to either.
-
-   valuelist/quantlist are nonNULL (and q_* significant) only if
-   there's entry->value mapping to be done.
-
-   If encode-side mapping must be done (and thus the entry needs to be
-   hunted), the auxiliary encode pointer will point to a decision
-   tree.  This is true of both VQ and huffman, but is mostly useful
-   with VQ.
-
-*/
-
-typedef struct static_codebook{
-  long   dim;            /* codebook dimensions (elements per vector) */
-  long   entries;        /* codebook entries */
-  long  *lengthlist;     /* codeword lengths in bits */
-
-  /* mapping ***************************************************************/
-  int    maptype;        /* 0=none
-			    1=implicitly populated values from map column 
-			    2=listed arbitrary values */
-
-  /* The below does a linear, single monotonic sequence mapping. */
-  long     q_min;       /* packed 32 bit float; quant value 0 maps to minval */
-  long     q_delta;     /* packed 32 bit float; val 1 - val 0 == delta */
-  int      q_quant;     /* bits: 0 < quant <= 16 */
-  int      q_sequencep; /* bitflag */
-
-  long     *quantlist;  /* map == 1: (int)(entries^(1/dim)) element column map
-			   map == 2: list of dim*entries quantized entry vals
-			*/
-
-  /* encode helpers ********************************************************/
-  struct encode_aux_nearestmatch *nearest_tree;
-  struct encode_aux_threshmatch  *thresh_tree;
-  struct encode_aux_pigeonhole  *pigeon_tree;
-
-  int allocedp;
-} static_codebook;
-
-/* this structures an arbitrary trained book to quickly find the
-   nearest cell match */
-typedef struct encode_aux_nearestmatch{
-  /* pre-calculated partitioning tree */
-  long   *ptr0;
-  long   *ptr1;
-
-  long   *p;         /* decision points (each is an entry) */
-  long   *q;         /* decision points (each is an entry) */
-  long   aux;        /* number of tree entries */
-  long   alloc;       
-} encode_aux_nearestmatch;
-
-/* assumes a maptype of 1; encode side only, so that's OK */
-typedef struct encode_aux_threshmatch{
-  float *quantthresh;
-  long   *quantmap;
-  int     quantvals; 
-  int     threshvals; 
-} encode_aux_threshmatch;
-
-typedef struct encode_aux_pigeonhole{
-  float min;
-  float del;
-
-  int  mapentries;
-  int  quantvals;
-  long *pigeonmap;
-
-  long fittotal;
-  long *fitlist;
-  long *fitmap;
-  long *fitlength;
-} encode_aux_pigeonhole;
-
-typedef struct codebook{
-  long dim;           /* codebook dimensions (elements per vector) */
-  long entries;       /* codebook entries */
-  long used_entries;  /* populated codebook entries */
-  static_codebook *c;
-
-  /* for encode, the below are entry-ordered, fully populated */
-  /* for decode, the below are ordered by bitreversed codeword and only
-     used entries are populated */
-  float        *valuelist;  /* list of dim*entries actual entry values */  
-  ogg_uint32_t *codelist;   /* list of bitstream codewords for each entry */
-
-  int          *dec_index;  /* only used if sparseness collapsed */
-  char         *dec_codelengths;
-  ogg_uint32_t *dec_firsttable;
-  int           dec_firsttablen;
-  int           dec_maxlength;
-
-} codebook;
-
-extern void vorbis_staticbook_clear(static_codebook *b);
-extern void vorbis_staticbook_destroy(static_codebook *b);
-extern int vorbis_book_init_encode(codebook *dest,const static_codebook *source);
-extern int vorbis_book_init_decode(codebook *dest,const static_codebook *source);
-extern void vorbis_book_clear(codebook *b);
-
-extern float *_book_unquantize(const static_codebook *b,int n,int *map);
-extern float *_book_logdist(const static_codebook *b,float *vals);
-extern float _float32_unpack(long val);
-extern long   _float32_pack(float val);
-extern int  _best(codebook *book, float *a, int step);
-extern int _ilog(unsigned int v);
-extern long _book_maptype1_quantvals(const static_codebook *b);
-
-extern int vorbis_book_besterror(codebook *book,float *a,int step,int addmul);
-extern long vorbis_book_codeword(codebook *book,int entry);
-extern long vorbis_book_codelen(codebook *book,int entry);
-
-
-
-extern int vorbis_staticbook_pack(const static_codebook *c,oggpack_buffer *b);
-extern int vorbis_staticbook_unpack(oggpack_buffer *b,static_codebook *c);
-
-extern int vorbis_book_encode(codebook *book, int a, oggpack_buffer *b);
-extern int vorbis_book_errorv(codebook *book, float *a);
-extern int vorbis_book_encodev(codebook *book, int best,float *a, 
-			       oggpack_buffer *b);
-
-extern long vorbis_book_decode(codebook *book, oggpack_buffer *b);
-extern long vorbis_book_decodevs_add(codebook *book, float *a, 
-				     oggpack_buffer *b,int n);
-extern long vorbis_book_decodev_set(codebook *book, float *a, 
-				    oggpack_buffer *b,int n);
-extern long vorbis_book_decodev_add(codebook *book, float *a, 
-				    oggpack_buffer *b,int n);
-extern long vorbis_book_decodevv_add(codebook *book, float **a,
-				     long off,int ch, 
-				    oggpack_buffer *b,int n);
-
-
-
-#endif

data/dependencies/libvorbis/vq/lspdata.c

@@ -1,157 +0,0 @@
-/********************************************************************
- *                                                                  *
- * 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 13293 2007-07-24 00:09:47Z xiphmont $
-
- ********************************************************************/
-
-#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);
-}
-