# HG changeset patch
# User ods15
# Date 1229058771 0
# Node ID ddecbc18fe942af144e92e22f7ecde440d2870e7
# Parent  1408a8907da98898b665191d6f43466fb5b2d2f3
Rename all vorbis encoder related typedefs to not use _t for POSIX compatibility

diff -r 1408a8907da9 -r ddecbc18fe94 vorbis.c
--- a/vorbis.c	Fri Dec 12 01:40:00 2008 +0000
+++ b/vorbis.c	Fri Dec 12 05:12:51 2008 +0000
@@ -111,7 +111,7 @@
     return 0;
 }
 
-void ff_vorbis_ready_floor1_list(floor1_entry_t * list, int values) {
+void ff_vorbis_ready_floor1_list(vorbis_floor1_entry * list, int values) {
     int i;
     list[0].sort = 0;
     list[1].sort = 1;
@@ -162,7 +162,7 @@
     }
 }
 
-void ff_vorbis_floor1_render_list(floor1_entry_t * list, int values, uint_fast16_t * y_list, int * flag, int multiplier, float * out, int samples) {
+void ff_vorbis_floor1_render_list(vorbis_floor1_entry * list, int values, uint_fast16_t * y_list, int * flag, int multiplier, float * out, int samples) {
     int lx, ly, i;
     lx = 0;
     ly = y_list[0] * multiplier;
diff -r 1408a8907da9 -r ddecbc18fe94 vorbis.h
--- a/vorbis.h	Fri Dec 12 01:40:00 2008 +0000
+++ b/vorbis.h	Fri Dec 12 05:12:51 2008 +0000
@@ -31,12 +31,12 @@
     uint_fast16_t sort;
     uint_fast16_t low;
     uint_fast16_t high;
-} floor1_entry_t;
+} vorbis_floor1_entry;
 
-void ff_vorbis_ready_floor1_list(floor1_entry_t * list, int values);
+void ff_vorbis_ready_floor1_list(vorbis_floor1_entry * list, int values);
 unsigned int ff_vorbis_nth_root(unsigned int x, unsigned int n); // x^(1/n)
 int ff_vorbis_len2vlc(uint8_t *bits, uint32_t *codes, uint_fast32_t num);
-void ff_vorbis_floor1_render_list(floor1_entry_t * list, int values, uint_fast16_t * y_list, int * flag, int multiplier, float * out, int samples);
+void ff_vorbis_floor1_render_list(vorbis_floor1_entry * list, int values, uint_fast16_t * y_list, int * flag, int multiplier, float * out, int samples);
 
 #define ilog(i) av_log2(2*(i))
 
diff -r 1408a8907da9 -r ddecbc18fe94 vorbis_dec.c
--- a/vorbis_dec.c	Fri Dec 12 01:40:00 2008 +0000
+++ b/vorbis_dec.c	Fri Dec 12 05:12:51 2008 +0000
@@ -90,7 +90,7 @@
             int_fast16_t subclass_books[16][8];
             uint_fast8_t multiplier;
             uint_fast16_t x_list_dim;
-            floor1_entry_t * list;
+            vorbis_floor1_entry * list;
         } t1;
     } data;
 } vorbis_floor;
@@ -511,7 +511,7 @@
                 floor_setup->data.t1.x_list_dim+=floor_setup->data.t1.class_dimensions[floor_setup->data.t1.partition_class[j]];
             }
 
-            floor_setup->data.t1.list=av_mallocz(floor_setup->data.t1.x_list_dim * sizeof(floor1_entry_t));
+            floor_setup->data.t1.list=av_mallocz(floor_setup->data.t1.x_list_dim * sizeof(vorbis_floor1_entry));
 
 
             rangebits=get_bits(gb, 4);
diff -r 1408a8907da9 -r ddecbc18fe94 vorbis_enc.c
--- a/vorbis_enc.c	Fri Dec 12 01:40:00 2008 +0000
+++ b/vorbis_enc.c	Fri Dec 12 05:12:51 2008 +0000
@@ -48,25 +48,25 @@
     int * quantlist;
     float * dimentions;
     float * pow2;
-} codebook_t;
+} vorbis_enc_codebook;
 
 typedef struct {
     int dim;
     int subclass;
     int masterbook;
     int * books;
-} floor_class_t;
+} vorbis_enc_floor_class;
 
 typedef struct {
     int partitions;
     int * partition_to_class;
     int nclasses;
-    floor_class_t * classes;
+    vorbis_enc_floor_class * classes;
     int multiplier;
     int rangebits;
     int values;
-    floor1_entry_t * list;
-} floor_t;
+    vorbis_floor1_entry * list;
+} vorbis_enc_floor;
 
 typedef struct {
     int type;
@@ -77,7 +77,7 @@
     int classbook;
     int8_t (*books)[8];
     float (*maxes)[2];
-} residue_t;
+} vorbis_enc_residue;
 
 typedef struct {
     int submaps;
@@ -87,12 +87,12 @@
     int coupling_steps;
     int * magnitude;
     int * angle;
-} mapping_t;
+} vorbis_enc_mapping;
 
 typedef struct {
     int blockflag;
     int mapping;
-} vorbis_mode_t;
+} vorbis_enc_mode;
 
 typedef struct {
     int channels;
@@ -108,24 +108,24 @@
     float quality;
 
     int ncodebooks;
-    codebook_t * codebooks;
+    vorbis_enc_codebook * codebooks;
 
     int nfloors;
-    floor_t * floors;
+    vorbis_enc_floor * floors;
 
     int nresidues;
-    residue_t * residues;
+    vorbis_enc_residue * residues;
 
     int nmappings;
-    mapping_t * mappings;
+    vorbis_enc_mapping * mappings;
 
     int nmodes;
-    vorbis_mode_t * modes;
+    vorbis_enc_mode * modes;
 
     int64_t sample_count;
-} venc_context_t;
+} vorbis_enc_context;
 
-static inline void put_codeword(PutBitContext * pb, codebook_t * cb, int entry) {
+static inline void put_codeword(PutBitContext * pb, vorbis_enc_codebook * cb, int entry) {
     assert(entry >= 0);
     assert(entry < cb->nentries);
     assert(cb->lens[entry]);
@@ -138,7 +138,7 @@
     return 0;
 }
 
-static void ready_codebook(codebook_t * cb) {
+static void ready_codebook(vorbis_enc_codebook * cb) {
     int i;
 
     ff_vorbis_len2vlc(cb->lens, cb->codewords, cb->nentries);
@@ -171,13 +171,13 @@
     }
 }
 
-static void ready_residue(residue_t * rc, venc_context_t * venc) {
+static void ready_residue(vorbis_enc_residue * rc, vorbis_enc_context * venc) {
     int i;
     assert(rc->type == 2);
     rc->maxes = av_mallocz(sizeof(float[2]) * rc->classifications);
     for (i = 0; i < rc->classifications; i++) {
         int j;
-        codebook_t * cb;
+        vorbis_enc_codebook * cb;
         for (j = 0; j < 8; j++)
             if (rc->books[i][j] != -1) break;
         if (j == 8) continue; // zero
@@ -203,10 +203,10 @@
     }
 }
 
-static void create_vorbis_context(venc_context_t * venc, AVCodecContext * avccontext) {
-    floor_t * fc;
-    residue_t * rc;
-    mapping_t * mc;
+static void create_vorbis_context(vorbis_enc_context * venc, AVCodecContext * avccontext) {
+    vorbis_enc_floor * fc;
+    vorbis_enc_residue * rc;
+    vorbis_enc_mapping * mc;
     int i, book;
 
     venc->channels = avccontext->channels;
@@ -214,13 +214,13 @@
     venc->log2_blocksize[0] = venc->log2_blocksize[1] = 11;
 
     venc->ncodebooks = FF_ARRAY_ELEMS(cvectors);
-    venc->codebooks = av_malloc(sizeof(codebook_t) * venc->ncodebooks);
+    venc->codebooks = av_malloc(sizeof(vorbis_enc_codebook) * venc->ncodebooks);
 
     // codebook 0..14 - floor1 book, values 0..255
     // codebook 15 residue masterbook
     // codebook 16..29 residue
     for (book = 0; book < venc->ncodebooks; book++) {
-        codebook_t * cb = &venc->codebooks[book];
+        vorbis_enc_codebook * cb = &venc->codebooks[book];
         int vals;
         cb->ndimentions = cvectors[book].dim;
         cb->nentries = cvectors[book].real_len;
@@ -246,7 +246,7 @@
     }
 
     venc->nfloors = 1;
-    venc->floors = av_malloc(sizeof(floor_t) * venc->nfloors);
+    venc->floors = av_malloc(sizeof(vorbis_enc_floor) * venc->nfloors);
 
     // just 1 floor
     fc = &venc->floors[0];
@@ -259,9 +259,9 @@
         fc->nclasses = FFMAX(fc->nclasses, fc->partition_to_class[i]);
     }
     fc->nclasses++;
-    fc->classes = av_malloc(sizeof(floor_class_t) * fc->nclasses);
+    fc->classes = av_malloc(sizeof(vorbis_enc_floor_class) * fc->nclasses);
     for (i = 0; i < fc->nclasses; i++) {
-        floor_class_t * c = &fc->classes[i];
+        vorbis_enc_floor_class * c = &fc->classes[i];
         int j, books;
         c->dim = floor_classes[i].dim;
         c->subclass = floor_classes[i].subclass;
@@ -278,7 +278,7 @@
     for (i = 0; i < fc->partitions; i++)
         fc->values += fc->classes[fc->partition_to_class[i]].dim;
 
-    fc->list = av_malloc(sizeof(floor1_entry_t) * fc->values);
+    fc->list = av_malloc(sizeof(vorbis_floor1_entry) * fc->values);
     fc->list[0].x = 0;
     fc->list[1].x = 1 << fc->rangebits;
     for (i = 2; i < fc->values; i++) {
@@ -292,7 +292,7 @@
     ff_vorbis_ready_floor1_list(fc->list, fc->values);
 
     venc->nresidues = 1;
-    venc->residues = av_malloc(sizeof(residue_t) * venc->nresidues);
+    venc->residues = av_malloc(sizeof(vorbis_enc_residue) * venc->nresidues);
 
     // single residue
     rc = &venc->residues[0];
@@ -321,7 +321,7 @@
     ready_residue(rc, venc);
 
     venc->nmappings = 1;
-    venc->mappings = av_malloc(sizeof(mapping_t) * venc->nmappings);
+    venc->mappings = av_malloc(sizeof(vorbis_enc_mapping) * venc->nmappings);
 
     // single mapping
     mc = &venc->mappings[0];
@@ -344,7 +344,7 @@
     }
 
     venc->nmodes = 1;
-    venc->modes = av_malloc(sizeof(vorbis_mode_t) * venc->nmodes);
+    venc->modes = av_malloc(sizeof(vorbis_enc_mode) * venc->nmodes);
 
     // single mode
     venc->modes[0].blockflag = 0;
@@ -373,7 +373,7 @@
     put_bits(pb, 32, res);
 }
 
-static void put_codebook_header(PutBitContext * pb, codebook_t * cb) {
+static void put_codebook_header(PutBitContext * pb, vorbis_enc_codebook * cb) {
     int i;
     int ordered = 0;
 
@@ -432,7 +432,7 @@
     }
 }
 
-static void put_floor_header(PutBitContext * pb, floor_t * fc) {
+static void put_floor_header(PutBitContext * pb, vorbis_enc_floor * fc) {
     int i;
 
     put_bits(pb, 16, 1); // type, only floor1 is supported
@@ -464,7 +464,7 @@
         put_bits(pb, fc->rangebits, fc->list[i].x);
 }
 
-static void put_residue_header(PutBitContext * pb, residue_t * rc) {
+static void put_residue_header(PutBitContext * pb, vorbis_enc_residue * rc) {
     int i;
 
     put_bits(pb, 16, rc->type);
@@ -495,7 +495,7 @@
     }
 }
 
-static int put_main_header(venc_context_t * venc, uint8_t ** out) {
+static int put_main_header(vorbis_enc_context * venc, uint8_t ** out) {
     int i;
     PutBitContext pb;
     uint8_t buffer[50000] = {0}, * p = buffer;
@@ -564,7 +564,7 @@
     // mappings
     put_bits(&pb, 6, venc->nmappings - 1);
     for (i = 0; i < venc->nmappings; i++) {
-        mapping_t * mc = &venc->mappings[i];
+        vorbis_enc_mapping * mc = &venc->mappings[i];
         int j;
         put_bits(&pb, 16, 0); // mapping type
 
@@ -624,7 +624,7 @@
     return p - *out;
 }
 
-static float get_floor_average(floor_t * fc, float * coeffs, int i) {
+static float get_floor_average(vorbis_enc_floor * fc, float * coeffs, int i) {
     int begin = fc->list[fc->list[FFMAX(i-1, 0)].sort].x;
     int end   = fc->list[fc->list[FFMIN(i+1, fc->values - 1)].sort].x;
     int j;
@@ -635,7 +635,7 @@
     return average / (end - begin);
 }
 
-static void floor_fit(venc_context_t * venc, floor_t * fc, float * coeffs, uint_fast16_t * posts, int samples) {
+static void floor_fit(vorbis_enc_context * venc, vorbis_enc_floor * fc, float * coeffs, uint_fast16_t * posts, int samples) {
     int range = 255 / fc->multiplier + 1;
     int i;
     float tot_average = 0.;
@@ -663,7 +663,7 @@
     return y0 +  (x - x0) * (y1 - y0) / (x1 - x0);
 }
 
-static void floor_encode(venc_context_t * venc, floor_t * fc, PutBitContext * pb, uint_fast16_t * posts, float * floor, int samples) {
+static void floor_encode(vorbis_enc_context * venc, vorbis_enc_floor * fc, PutBitContext * pb, uint_fast16_t * posts, float * floor, int samples) {
     int range = 255 / fc->multiplier + 1;
     int coded[fc->values]; // first 2 values are unused
     int i, counter;
@@ -704,10 +704,10 @@
 
     counter = 2;
     for (i = 0; i < fc->partitions; i++) {
-        floor_class_t * c = &fc->classes[fc->partition_to_class[i]];
+        vorbis_enc_floor_class * c = &fc->classes[fc->partition_to_class[i]];
         int k, cval = 0, csub = 1<<c->subclass;
         if (c->subclass) {
-            codebook_t * book = &venc->codebooks[c->masterbook];
+            vorbis_enc_codebook * book = &venc->codebooks[c->masterbook];
             int cshift = 0;
             for (k = 0; k < c->dim; k++) {
                 int l;
@@ -737,7 +737,7 @@
     ff_vorbis_floor1_render_list(fc->list, fc->values, posts, coded, fc->multiplier, floor, samples);
 }
 
-static float * put_vector(codebook_t * book, PutBitContext * pb, float * num) {
+static float * put_vector(vorbis_enc_codebook * book, PutBitContext * pb, float * num) {
     int i, entry = -1;
     float distance = FLT_MAX;
     assert(book->dimentions);
@@ -756,7 +756,7 @@
     return &book->dimentions[entry * book->ndimentions];
 }
 
-static void residue_encode(venc_context_t * venc, residue_t * rc, PutBitContext * pb, float * coeffs, int samples, int real_ch) {
+static void residue_encode(vorbis_enc_context * venc, vorbis_enc_residue * rc, PutBitContext * pb, float * coeffs, int samples, int real_ch) {
     int pass, i, j, p, k;
     int psize = rc->partition_size;
     int partitions = (rc->end - rc->begin) / psize;
@@ -785,7 +785,7 @@
         while (p < partitions) {
             if (pass == 0)
                 for (j = 0; j < channels; j++) {
-                    codebook_t * book = &venc->codebooks[rc->classbook];
+                    vorbis_enc_codebook * book = &venc->codebooks[rc->classbook];
                     int entry = 0;
                     for (i = 0; i < classwords; i++) {
                         entry *= rc->classifications;
@@ -796,7 +796,7 @@
             for (i = 0; i < classwords && p < partitions; i++, p++) {
                 for (j = 0; j < channels; j++) {
                     int nbook = rc->books[classes[j][p]][pass];
-                    codebook_t * book = &venc->codebooks[nbook];
+                    vorbis_enc_codebook * book = &venc->codebooks[nbook];
                     float * buf = coeffs + samples*j + rc->begin + p*psize;
                     if (nbook == -1) continue;
 
@@ -841,7 +841,7 @@
     }
 }
 
-static int apply_window_and_mdct(venc_context_t * venc, signed short * audio, int samples) {
+static int apply_window_and_mdct(vorbis_enc_context * venc, signed short * audio, int samples) {
     int i, j, channel;
     const float * win = venc->win[0];
     int window_len = 1 << (venc->log2_blocksize[0] - 1);
@@ -893,7 +893,7 @@
 
 static av_cold int vorbis_encode_init(AVCodecContext * avccontext)
 {
-    venc_context_t * venc = avccontext->priv_data;
+    vorbis_enc_context * venc = avccontext->priv_data;
 
     if (avccontext->channels != 2) {
         av_log(avccontext, AV_LOG_ERROR, "Current FFmpeg Vorbis encoder only supports 2 channels.\n");
@@ -920,11 +920,11 @@
 
 static int vorbis_encode_frame(AVCodecContext * avccontext, unsigned char * packets, int buf_size, void *data)
 {
-    venc_context_t * venc = avccontext->priv_data;
+    vorbis_enc_context * venc = avccontext->priv_data;
     signed short * audio = data;
     int samples = data ? avccontext->frame_size : 0;
-    vorbis_mode_t * mode;
-    mapping_t * mapping;
+    vorbis_enc_mode * mode;
+    vorbis_enc_mapping * mapping;
     PutBitContext pb;
     int i;
 
@@ -945,7 +945,7 @@
     }
 
     for (i = 0; i < venc->channels; i++) {
-        floor_t * fc = &venc->floors[mapping->floor[mapping->mux[i]]];
+        vorbis_enc_floor * fc = &venc->floors[mapping->floor[mapping->mux[i]]];
         uint_fast16_t posts[fc->values];
         floor_fit(venc, fc, &venc->coeffs[i * samples], posts, samples);
         floor_encode(venc, fc, &pb, posts, &venc->floor[i * samples], samples);
@@ -978,7 +978,7 @@
 
 static av_cold int vorbis_encode_close(AVCodecContext * avccontext)
 {
-    venc_context_t * venc = avccontext->priv_data;
+    vorbis_enc_context * venc = avccontext->priv_data;
     int i;
 
     if (venc->codebooks)
@@ -1040,7 +1040,7 @@
     "vorbis",
     CODEC_TYPE_AUDIO,
     CODEC_ID_VORBIS,
-    sizeof(venc_context_t),
+    sizeof(vorbis_enc_context),
     vorbis_encode_init,
     vorbis_encode_frame,
     vorbis_encode_close,