Original Commit: r64 | ods15 | 2006-09-25 18:39:30 +0300 (Mon, 25 Sep 2006) | 2 lines
[ffmpeg.git] / libavcodec / vorbis_enc.c
index 80a29c5..cedaec9 100644 (file)
 
 #include "avcodec.h"
 
+#define BITSTREAM_H // don't include this
+typedef int VLC;
+typedef int GetBitContext;
+#include "vorbis.h"
+
 #undef NDEBUG
 #include <assert.h>
 
-#define ALT_BITSTREAM_WRITER
-#include "bitstream.h"
+//#define ALT_BITSTREAM_WRITER
+//#include "bitstream.h"
 
 typedef struct {
     int len;
@@ -54,6 +59,13 @@ typedef struct {
     int * books;
 } floor_class_t;
 
+typedef struct {
+    int x;
+    int low;
+    int high;
+    int sort;
+} floor_entry_t;
+
 typedef struct {
     int partitions;
     int * partition_to_class;
@@ -62,7 +74,7 @@ typedef struct {
     int multiplier;
     int rangebits;
     int values;
-    struct { int x; } * list;
+    floor_entry_t * list;
 } floor_t;
 
 typedef struct {
@@ -91,6 +103,13 @@ typedef struct {
     int channels;
     int sample_rate;
     int blocksize[2]; // in (1<<n) format
+    MDCTContext mdct[2];
+    const float * win[2];
+    int have_saved;
+    float * saved;
+    float * samples;
+    float * floor; // also used for tmp values for mdct
+    float * coeffs; // also used for residue after floor
 
     int ncodebooks;
     codebook_t * codebooks;
@@ -108,6 +127,54 @@ typedef struct {
     vorbis_mode_t * modes;
 } venc_context_t;
 
+typedef struct {
+    int total;
+    int total_pos;
+    int pos;
+    uint8_t * buf_ptr;
+} PutBitContext;
+
+#define ilog(i) av_log2(2*(i))
+
+static inline void init_put_bits(PutBitContext * pb, uint8_t * buf, int buffer_len) {
+    pb->total = buffer_len * 8;
+    pb->total_pos = 0;
+    pb->pos = 0;
+    pb->buf_ptr = buf;
+}
+
+static void put_bits(PutBitContext * pb, int bits, uint64_t val) {
+    if ((pb->total_pos += bits) >= pb->total) return;
+    if (!bits) return;
+    if (pb->pos) {
+        if (pb->pos > bits) {
+            *pb->buf_ptr |= val << (8 - pb->pos);
+            pb->pos -= bits;
+            bits = 0;
+        } else {
+            *pb->buf_ptr++ |= (val << (8 - pb->pos)) & 0xFF;
+            val >>= pb->pos;
+            bits -= pb->pos;
+            pb->pos = 0;
+        }
+    }
+    for (; bits >= 8; bits -= 8) {
+        *pb->buf_ptr++ = val & 0xFF;
+        val >>= 8;
+    }
+    if (bits) {
+        *pb->buf_ptr = val;
+        pb->pos = 8 - bits;
+    }
+}
+
+static inline void flush_put_bits(PutBitContext * pb) {
+}
+
+static inline int put_bits_count(PutBitContext * pb) {
+    return pb->total_pos;
+}
+
 static int cb_lookup_vals(int lookup, int dimentions, int entries) {
     if (lookup == 1) {
         int tmp, i;
@@ -129,7 +196,11 @@ static void ready_codebook(codebook_t * cb) {
         cb_entry_t * e = &cb->entries[i];
         int j = 0;
         if (h[0]) h[0] = 0;
-        else for (j = e->len; !h[j]; j--) assert(j);
+        else {
+            for (j = e->len; j; j--)
+                if (h[j]) break;
+            assert(j);
+        }
         e->codeword = h[j];
         h[j] = 0;
         for (j++; j <= e->len; j++) h[j] = e->codeword | (1 << (j - 1));
@@ -158,6 +229,36 @@ static void ready_codebook(codebook_t * cb) {
 
 }
 
+static void ready_floor(floor_t * fc) {
+    int i;
+    fc->list[0].sort = 0;
+    fc->list[1].sort = 1;
+    for (i = 2; i < fc->values; i++) {
+        int j;
+        fc->list[i].low = 0;
+        fc->list[i].high = 1;
+        fc->list[i].sort = i;
+        for (j = 2; j < i; j++) {
+            int tmp = fc->list[j].x;
+            if (tmp < fc->list[i].x) {
+                if (tmp > fc->list[fc->list[i].low].x) fc->list[i].low = j;
+            } else {
+                if (tmp < fc->list[fc->list[i].high].x) fc->list[i].high = j;
+            }
+        }
+    }
+    for (i = 0; i < fc->values - 1; i++) {
+        int j;
+        for (j = i + 1; j < fc->values; j++) {
+            if (fc->list[fc->list[i].sort].x > fc->list[fc->list[j].sort].x) {
+                int tmp = fc->list[i].sort;
+                fc->list[i].sort = fc->list[j].sort;
+                fc->list[j].sort = tmp;
+            }
+        }
+    }
+}
+
 static void create_vorbis_context(venc_context_t * venc, AVCodecContext * avccontext) {
     codebook_t * cb;
     floor_t * fc;
@@ -172,11 +273,11 @@ static void create_vorbis_context(venc_context_t * venc, AVCodecContext * avccon
     venc->ncodebooks = 10;
     venc->codebooks = av_malloc(sizeof(codebook_t) * venc->ncodebooks);
 
-    // codebook 1 - floor1 book, values 0..255
+    // codebook 0 - floor1 book, values 0..255
     cb = &venc->codebooks[0];
-    cb->nentries = 256;
+    cb->nentries = 512;
     cb->entries = av_malloc(sizeof(cb_entry_t) * cb->nentries);
-    for (i = 0; i < cb->nentries; i++) cb->entries[i].len = 8;
+    for (i = 0; i < cb->nentries; i++) cb->entries[i].len = 9;
     cb->ndimentions = 0;
     cb->min = 0.;
     cb->delta = 0.;
@@ -185,12 +286,12 @@ static void create_vorbis_context(venc_context_t * venc, AVCodecContext * avccon
     cb->quantlist = NULL;
     ready_codebook(cb);
 
-    // codebook 2 - residue classbook, values 0..1, dimentions 200
+    // codebook 1 - residue classbook, values 0..1, dimentions 4
     cb = &venc->codebooks[1];
     cb->nentries = 2;
     cb->entries = av_malloc(sizeof(cb_entry_t) * cb->nentries);
     for (i = 0; i < cb->nentries; i++) cb->entries[i].len = 1;
-    cb->ndimentions = 200;
+    cb->ndimentions = 4;
     cb->min = 0.;
     cb->delta = 0.;
     cb->seq_p = 0;
@@ -198,7 +299,7 @@ static void create_vorbis_context(venc_context_t * venc, AVCodecContext * avccon
     cb->quantlist = NULL;
     ready_codebook(cb);
 
-    // codebook 3..10 - vector, for the residue, values -32767..32767, dimentions 1
+    // codebook 2..9 - vector, for the residue, values -32767..32767, dimentions 1
     for (book = 0; book < 8; book++) {
         cb = &venc->codebooks[2 + book];
         cb->nentries = 5;
@@ -208,7 +309,7 @@ static void create_vorbis_context(venc_context_t * venc, AVCodecContext * avccon
         cb->delta = 1 << ((7 - book) * 2);
         cb->min = -cb->delta*2;
         cb->seq_p = 0;
-        cb->lookup = 2;
+        cb->lookup = 1;
         cb->quantlist = av_malloc(sizeof(int) * cb_lookup_vals(cb->lookup, cb->ndimentions, cb->nentries));
         for (i = 0; i < cb->nentries; i++) cb->quantlist[i] = i;
         ready_codebook(cb);
@@ -235,16 +336,24 @@ static void create_vorbis_context(venc_context_t * venc, AVCodecContext * avccon
         for (j = 0; j < books; j++) c->books[j] = 0;
     }
     fc->multiplier = 1;
-    fc->rangebits = venc->blocksize[0];
+    fc->rangebits = venc->blocksize[0] - 1;
 
     fc->values = 2;
     for (i = 0; i < fc->partitions; i++)
         fc->values += fc->classes[fc->partition_to_class[i]].dim;
 
-    fc->list = av_malloc(sizeof(*fc->list) * fc->values);
+    fc->list = av_malloc(sizeof(floor_entry_t) * fc->values);
     fc->list[0].x = 0;
     fc->list[1].x = 1 << fc->rangebits;
-    for (i = 2; i < fc->values; i++) fc->list[i].x = i * 5;
+    for (i = 2; i < fc->values; i++) {
+        int a = i - 1;
+        int g = ilog(a);
+        assert(g <= fc->rangebits);
+        a ^= 1 << (g-1);
+        g = 1 << (fc->rangebits - g);
+        fc->list[i].x = g + a*2*g;
+    }
+    ready_floor(fc);
 
     venc->nresidues = 1;
     venc->residues = av_malloc(sizeof(residue_t) * venc->nresidues);
@@ -253,12 +362,16 @@ static void create_vorbis_context(venc_context_t * venc, AVCodecContext * avccon
     rc = &venc->residues[0];
     rc->type = 0;
     rc->begin = 0;
-    rc->end = 1 << venc->blocksize[0];
+    rc->end = 1 << (venc->blocksize[0] - 1);
     rc->partition_size = 64;
-    rc->classifications = 1;
+    rc->classifications = 2;
     rc->classbook = 1;
     rc->books = av_malloc(sizeof(int[8]) * rc->classifications);
-    for (i = 0; i < 8; i++) rc->books[0][i] = 2 + i;
+    for (i = 0; i < rc->classifications; i++) {
+        int j;
+        for (j = 0; j < 8; j++) rc->books[i][j] = 2 + j;
+        rc->books[i][0] = rc->books[i][1] = rc->books[i][2] = rc->books[i][3] = -1;
+    }
 
     venc->nmappings = 1;
     venc->mappings = av_malloc(sizeof(mapping_t) * venc->nmappings);
@@ -281,12 +394,21 @@ static void create_vorbis_context(venc_context_t * venc, AVCodecContext * avccon
     // single mode
     venc->modes[0].blockflag = 0;
     venc->modes[0].mapping = 0;
-}
 
-static inline int ilog(unsigned int a) {
-    int i;
-    for (i = 0; a >> i; i++);
-    return i;
+    venc->have_saved = 0;
+    venc->saved = av_malloc(sizeof(float) * venc->channels * (1 << venc->blocksize[1]) / 2);
+    venc->samples = av_malloc(sizeof(float) * venc->channels * (1 << venc->blocksize[1]));
+    venc->floor = av_malloc(sizeof(float) * venc->channels * (1 << venc->blocksize[1]) / 2);
+    venc->coeffs = av_malloc(sizeof(float) * venc->channels * (1 << venc->blocksize[1]) / 2);
+
+    {
+        const float *vwin[8]={ vwin64, vwin128, vwin256, vwin512, vwin1024, vwin2048, vwin4096, vwin8192 };
+        venc->win[0] = vwin[venc->blocksize[0] - 6];
+        venc->win[1] = vwin[venc->blocksize[1] - 6];
+    }
+
+    ff_mdct_init(&venc->mdct[0], venc->blocksize[0], 0);
+    ff_mdct_init(&venc->mdct[1], venc->blocksize[1], 0);
 }
 
 static void put_float(PutBitContext * pb, float f) {
@@ -313,7 +435,7 @@ static void put_codebook_header(PutBitContext * pb, codebook_t * cb) {
     put_bits(pb, 1, ordered);
     if (ordered) {
         int len = cb->entries[0].len;
-        put_bits(pb, 5, len);
+        put_bits(pb, 5, len - 1);
         i = 0;
         while (i < cb->nentries) {
             int j;
@@ -330,7 +452,7 @@ static void put_codebook_header(PutBitContext * pb, codebook_t * cb) {
 
         for (i = 0; i < cb->nentries; i++) {
             if (sparse) put_bits(pb, 1, !!cb->entries[i].len);
-            if (cb->entries[i].len) put_bits(pb, 5, cb->entries[i].len);
+            if (cb->entries[i].len) put_bits(pb, 5, cb->entries[i].len - 1);
         }
     }
 
@@ -387,12 +509,12 @@ static void put_residue_header(PutBitContext * pb, residue_t * rc) {
     put_bits(pb, 24, rc->begin);
     put_bits(pb, 24, rc->end);
     put_bits(pb, 24, rc->partition_size - 1);
-    put_bits(pb, 6, rc->classifications);
+    put_bits(pb, 6, rc->classifications - 1);
     put_bits(pb, 8, rc->classbook);
 
     for (i = 0; i < rc->classifications; i++) {
         int j, tmp = 0;
-        for (j = 0; j < 8; j++) tmp |= (!!rc->books[i][j]) << j;
+        for (j = 0; j < 8; j++) tmp |= (rc->books[i][j] != -1) << j;
 
         put_bits(pb, 3, tmp & 7);
         put_bits(pb, 1, tmp > 7);
@@ -403,7 +525,7 @@ static void put_residue_header(PutBitContext * pb, residue_t * rc) {
     for (i = 0; i < rc->classifications; i++) {
         int j;
         for (j = 0; j < 8; j++)
-            if (rc->books[i][j])
+            if (rc->books[i][j] != -1)
                 put_bits(pb, 8, rc->books[i][j]);
     }
 }
@@ -500,6 +622,8 @@ static int put_main_header(venc_context_t * venc, uint8_t ** out) {
         put_bits(&pb, 8, venc->modes[i].mapping);
     }
 
+    put_bits(&pb, 1, 1); // framing
+
     flush_put_bits(&pb);
     hlens[2] = (put_bits_count(&pb) + 7) / 8;
 
@@ -519,6 +643,234 @@ static int put_main_header(venc_context_t * venc, uint8_t ** out) {
     return p - *out;
 }
 
+static void floor_fit(venc_context_t * venc, floor_t * fc, float * coeffs, int * posts, int samples) {
+    int range = 255 / fc->multiplier + 1;
+    int i;
+    for (i = 0; i < fc->values; i++) {
+        int position = fc->list[fc->list[i].sort].x;
+        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;
+        float average = 0;
+        begin = (position + begin) / 2;
+        end   = (position + end  ) / 2;
+
+        assert(end <= samples);
+        for (j = begin; j < end; j++) average += fabs(coeffs[j]);
+        average /= end - begin;
+        average /= 64; // MAGIC!
+        for (j = 0; j < range; j++) if (floor1_inverse_db_table[j * fc->multiplier] > average) break;
+        posts[fc->list[i].sort] = j;
+    }
+}
+
+static int render_point(int x0, int y0, int x1, int y1, int x) {
+    return y0 +  (x - x0) * (y1 - y0) / (x1 - x0);
+}
+
+static void render_line(int x0, int y0, int x1, int y1, float * buf, int n) {
+    int dy = y1 - y0;
+    int adx = x1 - x0;
+    int ady = FFMAX(dy, -dy);
+    int base = dy / adx;
+    int x = x0;
+    int y = y0;
+    int err = 0;
+    int sy;
+    if (dy < 0) sy = base - 1;
+    else sy = base + 1;
+    ady = ady - FFMAX(base, -base) * adx;
+    if (x >= n) return;
+    buf[x] = floor1_inverse_db_table[y];
+    for (x = x0 + 1; x < x1; x++) {
+        if (x >= n) return;
+        err += ady;
+        if (err >= adx) {
+            err -= adx;
+            y += sy;
+        } else {
+            y += base;
+        }
+        buf[x] = floor1_inverse_db_table[y];
+    }
+}
+
+static void floor_encode(venc_context_t * venc, floor_t * fc, PutBitContext * pb, int * posts, float * floor, int samples) {
+    int range = 255 / fc->multiplier + 1;
+    int coded[fc->values]; // first 2 values are unused
+    int i, counter;
+    int lx, ly;
+
+    put_bits(pb, 1, 1); // non zero
+    put_bits(pb, ilog(range - 1), posts[0]);
+    put_bits(pb, ilog(range - 1), posts[1]);
+
+    for (i = 2; i < fc->values; i++) {
+        int predicted = render_point(fc->list[fc->list[i].low].x,
+                                     posts[fc->list[i].low],
+                                     fc->list[fc->list[i].high].x,
+                                     posts[fc->list[i].high],
+                                     fc->list[i].x);
+        int highroom = range -  predicted;
+        int lowroom = predicted;
+        int room = FFMIN(highroom, lowroom);
+        if (predicted == posts[i]) {
+            coded[i] = 0; // must be used later as flag!
+            continue;
+        } else {
+            if (!coded[fc->list[i].low]) coded[fc->list[i].low] = -1;
+            if (!coded[fc->list[i].high]) coded[fc->list[i].high] = -1;
+        }
+        if (posts[i] > predicted) {
+            if (posts[i] - predicted > room) coded[i] = posts[i] - predicted + lowroom;
+            else coded[i] = (posts[i] - predicted) << 1;
+        } else {
+            if (predicted - posts[i] > room) coded[i] = predicted - posts[i] + highroom - 1;
+            else coded[i] = ((predicted - posts[i]) << 1) - 1;
+        }
+    }
+
+    counter = 2;
+    for (i = 0; i < fc->partitions; i++) {
+        floor_class_t * c = &fc->classes[fc->partition_to_class[i]];
+        codebook_t * book = &venc->codebooks[c->books[0]];
+        int k;
+        assert(!c->subclass);
+        for (k = 0; k < c->dim; k++) {
+            int entry = coded[counter++];
+            if (entry == -1) entry = 0;
+            assert(entry < book->nentries);
+            assert(entry >= 0);
+            put_bits(pb, book->entries[entry].len, book->entries[entry].codeword);
+        }
+    }
+
+    lx = 0;
+    ly = posts[0] * fc->multiplier; // sorted 0 is still 0
+    coded[0] = coded[1] = 1;
+    for (i = 1; i < fc->values; i++) {
+        int pos = fc->list[i].sort;
+        if (coded[pos]) {
+            render_line(lx, ly, fc->list[pos].x, posts[pos] * fc->multiplier, floor, samples);
+            lx = fc->list[pos].x;
+            ly = posts[pos] * fc->multiplier;
+        }
+        if (lx >= samples) break;
+    }
+    if (lx < samples) render_line(lx, ly, samples, ly, floor, samples);
+}
+
+static float * put_vector(codebook_t * book, PutBitContext * pb, float * num) {
+    int i;
+    int entry = -1;
+    float distance = 0;
+    assert(book->dimentions);
+    for (i = 0; i < book->nentries; i++) {
+        float d = 0.;
+        int j;
+        for (j = 0; j < book->ndimentions; j++) {
+            float a = (book->dimentions[i * book->ndimentions + j] - num[j]);
+            d += a*a;
+        }
+        if (entry == -1 || distance > d) {
+            entry = i;
+            distance = d;
+        }
+    }
+    put_bits(pb, book->entries[entry].len, book->entries[entry].codeword);
+    return &book->dimentions[entry * book->ndimentions];
+}
+
+static void residue_encode(venc_context_t * venc, residue_t * rc, PutBitContext * pb, float * coeffs, int samples, int channels) {
+    int pass, i, j, p, k;
+    int psize = rc->partition_size;
+    int partitions = (rc->end - rc->begin) / psize;
+    int classes[channels][partitions];
+    int classwords = venc->codebooks[rc->classbook].ndimentions;
+
+    for (pass = 0; pass < 8; pass++) {
+        p = 0;
+        while (p < partitions) {
+            if (pass == 0) for (j = 0; j < channels; j++) {
+                codebook_t * book = &venc->codebooks[rc->classbook];
+                int entry = 0;
+                put_bits(pb, book->entries[entry].len, book->entries[entry].codeword);
+                for (i = classwords; i--; ) {
+                    classes[j][p + i] = entry % rc->classifications;
+                    entry /= rc->classifications;
+                }
+            }
+            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];
+                    float * buf = coeffs + samples*j + rc->begin + p*psize;
+                    if (nbook == -1) continue;
+
+                    assert(rc->type == 0);
+                    assert(!(psize % book->ndimentions));
+
+                    for (k = 0; k < psize; k += book->ndimentions) {
+                        float * a = put_vector(book, pb, &buf[k]);
+                        int l;
+                        for (l = 0; l < book->ndimentions; l++) buf[k + l] -= a[l];
+                    }
+                }
+            }
+        }
+    }
+}
+
+static int window(venc_context_t * venc, signed short * audio, int samples) {
+    int i, j, channel;
+    const float * win = venc->win[0];
+    int window_len = 1 << (venc->blocksize[0] - 1);
+    float n = (float)(1 << venc->blocksize[0]) / 4.;
+    // FIXME use dsp
+
+    if (!venc->have_saved && !samples) return 0;
+
+    if (venc->have_saved) {
+        for (channel = 0; channel < venc->channels; channel++) {
+            memcpy(venc->samples + channel*window_len*2, venc->saved + channel*window_len, sizeof(float)*window_len);
+        }
+    } else {
+        for (channel = 0; channel < venc->channels; channel++) {
+            memset(venc->samples + channel*window_len*2, 0, sizeof(float)*window_len);
+        }
+    }
+
+    if (samples) {
+        for (channel = 0; channel < venc->channels; channel++) {
+            float * offset = venc->samples + channel*window_len*2 + window_len;
+            j = channel;
+            for (i = 0; i < samples; i++, j += venc->channels)
+                offset[i] = audio[j] / 32768. * win[window_len - i] / n;
+        }
+    } else {
+        for (channel = 0; channel < venc->channels; channel++) {
+            memset(venc->samples + channel*window_len*2 + window_len, 0, sizeof(float)*window_len);
+        }
+    }
+
+    for (channel = 0; channel < venc->channels; channel++) {
+        ff_mdct_calc(&venc->mdct[0], venc->coeffs + channel*window_len, venc->samples + channel*window_len*2, venc->floor/*tmp*/);
+    }
+
+    if (samples) {
+        for (channel = 0; channel < venc->channels; channel++) {
+            float * offset = venc->saved + channel*window_len;
+            j = channel;
+            for (i = 0; i < samples; i++, j += venc->channels)
+                offset[i] = audio[j] / 32768. * win[i] / n;
+        }
+        venc->have_saved = 1;
+    } else {
+        venc->have_saved = 0;
+    }
+    return 1;
+}
+
 static int vorbis_encode_init(AVCodecContext * avccontext)
 {
     venc_context_t * venc = avccontext->priv_data;
@@ -530,7 +882,7 @@ static int vorbis_encode_init(AVCodecContext * avccontext)
 
     avccontext->extradata_size = put_main_header(venc, (uint8_t**)&avccontext->extradata);
 
-    avccontext->frame_size = 1 << venc->blocksize[0];
+    avccontext->frame_size = 1 << (venc->blocksize[0] - 1);
 
     avccontext->coded_frame = avcodec_alloc_frame();
     avccontext->coded_frame->key_frame = 1;
@@ -538,18 +890,49 @@ static int vorbis_encode_init(AVCodecContext * avccontext)
     return 0;
 }
 
-
 static int vorbis_encode_frame(AVCodecContext * avccontext, unsigned char * packets, int buf_size, void *data)
 {
-#if 0
     venc_context_t * venc = avccontext->priv_data;
     signed short * audio = data;
     int samples = data ? avccontext->frame_size : 0;
+    vorbis_mode_t * mode;
+    mapping_t * mapping;
+    PutBitContext pb;
+    int i;
+
+    if (!window(venc, audio, samples)) return 0;
+    samples = 1 << (venc->blocksize[0] - 1);
+
+    init_put_bits(&pb, packets, buf_size);
 
-    avccontext->coded_frame->pts = av_rescale_q(op2->granulepos, (AVRational){1, avccontext->sample_rate}, avccontext->time_base);
-    memcpy(packets, compressed_frame, l);
-#endif
-    return data ? 50 : 0;
+    put_bits(&pb, 1, 0); // magic bit
+
+    put_bits(&pb, ilog(venc->nmodes - 1), 0); // 0 bits, the mode
+
+    mode = &venc->modes[0];
+    mapping = &venc->mappings[mode->mapping];
+    if (mode->blockflag) {
+        put_bits(&pb, 1, 0);
+        put_bits(&pb, 1, 0);
+    }
+
+    for (i = 0; i < venc->channels; i++) {
+        floor_t * fc = &venc->floors[mapping->floor[mapping->mux[i]]];
+        int posts[fc->values];
+        floor_fit(venc, fc, &venc->coeffs[i * samples], posts, samples);
+        floor_encode(venc, fc, &pb, posts, &venc->floor[i * samples], samples);
+    }
+
+    for (i = 0; i < venc->channels; i++) {
+        int j;
+        for (j = 0; j < samples; j++) {
+            venc->coeffs[i * samples + j] /= venc->floor[i * samples + j];
+        }
+    }
+
+    residue_encode(venc, &venc->residues[mapping->residue[mapping->mux[0]]], &pb, venc->coeffs, samples, venc->channels);
+
+    return (put_bits_count(&pb) + 7) / 8;
 }
 
 
@@ -590,13 +973,21 @@ static int vorbis_encode_close(AVCodecContext * avccontext)
 
     av_freep(&venc->modes);
 
+    av_freep(&venc->saved);
+    av_freep(&venc->samples);
+    av_freep(&venc->floor);
+    av_freep(&venc->coeffs);
+
+    ff_mdct_end(&venc->mdct[0]);
+    ff_mdct_end(&venc->mdct[1]);
+
     av_freep(&avccontext->coded_frame);
     av_freep(&avccontext->extradata);
 
     return 0 ;
 }
 
-AVCodec oggvorbis_encoder = {
+AVCodec vorbis_encoder = {
     "vorbis",
     CODEC_TYPE_AUDIO,
     CODEC_ID_VORBIS,