Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

whitespace cosmetics, prettyprinting, K&R coding style

Browse Source 
Originally committed as revision 20080 to svn://svn.ffmpeg.org/ffmpeg/trunk
release/0.6
Diego Biurrun 15 years ago
parent badce93dad
commit a7adcf29cf
5 changed files with 3194 additions and 3190 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 67
      libavcodec/vorbis.c
  2. 1
      libavcodec/vorbis_data.c
  3. 1045
      libavcodec/vorbis_dec.c
  4. 180
      libavcodec/vorbis_enc.c
  5. 9
      libavcodec/vorbis_enc_data.h

67
libavcodec/vorbis.c
Unescape View File

@ -2,7 +2,7 @@
* @file libavcodec/vorbis.c * @file libavcodec/vorbis.c
* Common code for Vorbis I encoder and decoder * Common code for Vorbis I encoder and decoder
* @author Denes Balatoni ( dbalatoni programozo hu ) * @author Denes Balatoni ( dbalatoni programozo hu )
*
* This file is part of FFmpeg. * This file is part of FFmpeg.
* *
* FFmpeg is free software; you can redistribute it and/or * FFmpeg is free software; you can redistribute it and/or
@ -35,13 +35,13 @@
// x^(1/n) // x^(1/n)
unsigned int ff_vorbis_nth_root(unsigned int x, unsigned int n) unsigned int ff_vorbis_nth_root(unsigned int x, unsigned int n)
{ {
unsigned int ret=0, i, j; unsigned int ret = 0, i, j;
do { do {
++ret; ++ret;
for(i=0,j=ret;i<n-1;i++) for (i = 0, j = ret; i < n - 1; i++)
j*=ret; j *= ret;
} while (j<=x); } while (j <= x);
return ret - 1; return ret - 1;
} }
@ -53,61 +53,62 @@ unsigned int ff_vorbis_nth_root(unsigned int x, unsigned int n)
// reasonable to check redundantly. // reasonable to check redundantly.
int ff_vorbis_len2vlc(uint8_t *bits, uint32_t *codes, uint_fast32_t num) int ff_vorbis_len2vlc(uint8_t *bits, uint32_t *codes, uint_fast32_t num)
{ {
uint_fast32_t exit_at_level[33]={404,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, uint_fast32_t exit_at_level[33] = {
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; 404, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
uint_fast8_t i,j; uint_fast8_t i, j;
uint_fast32_t code,p; uint_fast32_t code, p;
#ifdef V_DEBUG #ifdef V_DEBUG
GetBitContext gb; GetBitContext gb;
#endif #endif
for(p=0;(bits[p]==0) && (p<num);++p) for (p = 0; (bits[p] == 0) && (p < num); ++p)
; ;
if (p==num) { if (p == num) {
// av_log(vc->avccontext, AV_LOG_INFO, "An empty codebook. Heh?! \n"); // av_log(vc->avccontext, AV_LOG_INFO, "An empty codebook. Heh?! \n");
return 0; return 0;
} }
codes[p]=0; codes[p] = 0;
if (bits[p] > 32) if (bits[p] > 32)
return 1; return 1;
for(i=0;i<bits[p];++i) for (i = 0; i < bits[p]; ++i)
exit_at_level[i+1]=1<<i; exit_at_level[i+1] = 1 << i;
#ifdef V_DEBUG #ifdef V_DEBUG
av_log(NULL, AV_LOG_INFO, " %d. of %d code len %d code %d - ", p, num, bits[p], codes[p]); av_log(NULL, AV_LOG_INFO, " %d. of %d code len %d code %d - ", p, num, bits[p], codes[p]);
init_get_bits(&gb, (uint_fast8_t *)&codes[p], bits[p]); init_get_bits(&gb, (uint_fast8_t *)&codes[p], bits[p]);
for(i=0;i<bits[p];++i) for (i = 0; i < bits[p]; ++i)
av_log(NULL, AV_LOG_INFO, "%s", get_bits1(&gb) ? "1" : "0"); av_log(NULL, AV_LOG_INFO, "%s", get_bits1(&gb) ? "1" : "0");
av_log(NULL, AV_LOG_INFO, "\n"); av_log(NULL, AV_LOG_INFO, "\n");
#endif #endif
++p; ++p;
for(;p<num;++p) { for (; p < num; ++p) {
if (bits[p] > 32) if (bits[p] > 32)
return 1; return 1;
if (bits[p]==0) if (bits[p] == 0)
continue; continue;
// find corresponding exit(node which the tree can grow further from) // find corresponding exit(node which the tree can grow further from)
for(i=bits[p];i>0;--i) for (i = bits[p]; i > 0; --i)
if (exit_at_level[i]) if (exit_at_level[i])
break; break;
if (!i) // overspecified tree if (!i) // overspecified tree
return 1; return 1;
code=exit_at_level[i]; code = exit_at_level[i];
exit_at_level[i]=0; exit_at_level[i] = 0;
// construct code (append 0s to end) and introduce new exits // construct code (append 0s to end) and introduce new exits
for(j=i+1;j<=bits[p];++j) for (j = i + 1 ;j <= bits[p]; ++j)
exit_at_level[j]=code+(1<<(j-1)); exit_at_level[j] = code + (1 << (j - 1));
codes[p]=code; codes[p] = code;
#ifdef V_DEBUG #ifdef V_DEBUG
av_log(NULL, AV_LOG_INFO, " %d. code len %d code %d - ", p, bits[p], codes[p]); av_log(NULL, AV_LOG_INFO, " %d. code len %d code %d - ", p, bits[p], codes[p]);
init_get_bits(&gb, (uint_fast8_t *)&codes[p], bits[p]); init_get_bits(&gb, (uint_fast8_t *)&codes[p], bits[p]);
for(i=0;i<bits[p];++i) for (i = 0; i < bits[p]; ++i)
av_log(NULL, AV_LOG_INFO, "%s", get_bits1(&gb) ? "1" : "0"); av_log(NULL, AV_LOG_INFO, "%s", get_bits1(&gb) ? "1" : "0");
av_log(NULL, AV_LOG_INFO, "\n"); av_log(NULL, AV_LOG_INFO, "\n");
#endif #endif
@ -115,7 +116,7 @@ int ff_vorbis_len2vlc(uint8_t *bits, uint32_t *codes, uint_fast32_t num)
} }
//no exits should be left (underspecified tree - ie. unused valid vlcs - not allowed by SPEC) //no exits should be left (underspecified tree - ie. unused valid vlcs - not allowed by SPEC)
for (p=1; p<33; p++) for (p = 1; p < 33; p++)
if (exit_at_level[p]) if (exit_at_level[p])
return 1; return 1;
@ -157,11 +158,11 @@ void ff_vorbis_ready_floor1_list(vorbis_floor1_entry * list, int values)
static inline void render_line_unrolled(intptr_t x, intptr_t y, int x1, static inline void render_line_unrolled(intptr_t x, intptr_t y, int x1,
intptr_t sy, int ady, int adx, intptr_t sy, int ady, int adx,
float * buf) float *buf)
{ {
int err = -adx; int err = -adx;
x -= x1-1; x -= x1 - 1;
buf += x1-1; buf += x1 - 1;
while (++x < 0) { while (++x < 0) {
err += ady; err += ady;
if (err >= 0) { if (err >= 0) {
@ -178,14 +179,14 @@ static inline void render_line_unrolled(intptr_t x, intptr_t y, int x1,
} }
} }
static void render_line(int x0, int y0, int x1, int y1, float * buf) static void render_line(int x0, int y0, int x1, int y1, float *buf)
{ {
int dy = y1 - y0; int dy = y1 - y0;
int adx = x1 - x0; int adx = x1 - x0;
int ady = FFABS(dy); int ady = FFABS(dy);
int sy = dy<0 ? -1 : 1; int sy = dy < 0 ? -1 : 1;
buf[x0] = ff_vorbis_floor1_inverse_db_table[y0]; buf[x0] = ff_vorbis_floor1_inverse_db_table[y0];
if(ady*2<=adx) { // optimized common case if (ady*2 <= adx) { // optimized common case
render_line_unrolled(x0, y0, x1, sy, ady, adx, buf); render_line_unrolled(x0, y0, x1, sy, ady, adx, buf);
} else { } else {
int base = dy / adx; int base = dy / adx;
@ -206,8 +207,8 @@ static void render_line(int x0, int y0, int x1, int y1, float * buf)
} }
void ff_vorbis_floor1_render_list(vorbis_floor1_entry * list, int values, void ff_vorbis_floor1_render_list(vorbis_floor1_entry * list, int values,
uint_fast16_t * y_list, int * flag, uint_fast16_t *y_list, int *flag,
int multiplier, float * out, int samples) int multiplier, float *out, int samples)
{ {
int lx, ly, i; int lx, ly, i;
lx = 0; lx = 0;

1
libavcodec/vorbis_data.c
Unescape View File

@ -2156,4 +2156,3 @@ const float * const ff_vorbis_vwin[8] = {
vwin64, vwin128, vwin256, vwin512, vwin64, vwin128, vwin256, vwin512,
vwin1024, vwin2048, vwin4096, vwin8192 vwin1024, vwin2048, vwin4096, vwin8192
}; };

1045
libavcodec/vorbis_dec.c
View File

File diff suppressed because it is too large Load Diff

180
libavcodec/vorbis_enc.c
Unescape View File

@ -38,34 +38,34 @@
typedef struct { typedef struct {
int nentries; int nentries;
uint8_t * lens; uint8_t *lens;
uint32_t * codewords; uint32_t *codewords;
int ndimentions; int ndimentions;
float min; float min;
float delta; float delta;
int seq_p; int seq_p;
int lookup; int lookup;
int * quantlist; int *quantlist;
float * dimentions; float *dimentions;
float * pow2; float *pow2;
} vorbis_enc_codebook; } vorbis_enc_codebook;
typedef struct { typedef struct {
int dim; int dim;
int subclass; int subclass;
int masterbook; int masterbook;
int * books; int *books;
} vorbis_enc_floor_class; } vorbis_enc_floor_class;
typedef struct { typedef struct {
int partitions; int partitions;
int * partition_to_class; int *partition_to_class;
int nclasses; int nclasses;
vorbis_enc_floor_class * classes; vorbis_enc_floor_class *classes;
int multiplier; int multiplier;
int rangebits; int rangebits;
int values; int values;
vorbis_floor1_entry * list; vorbis_floor1_entry *list;
} vorbis_enc_floor; } vorbis_enc_floor;
typedef struct { typedef struct {
@ -81,12 +81,12 @@ typedef struct {
typedef struct { typedef struct {
int submaps; int submaps;
int * mux; int *mux;
int * floor; int *floor;
int * residue; int *residue;
int coupling_steps; int coupling_steps;
int * magnitude; int *magnitude;
int * angle; int *angle;
} vorbis_enc_mapping; } vorbis_enc_mapping;
typedef struct { typedef struct {
@ -99,33 +99,33 @@ typedef struct {
int sample_rate; int sample_rate;
int log2_blocksize[2]; int log2_blocksize[2];
FFTContext mdct[2]; FFTContext mdct[2];
const float * win[2]; const float *win[2];
int have_saved; int have_saved;
float * saved; float *saved;
float * samples; float *samples;
float * floor; // also used for tmp values for mdct float *floor; // also used for tmp values for mdct
float * coeffs; // also used for residue after floor float *coeffs; // also used for residue after floor
float quality; float quality;
int ncodebooks; int ncodebooks;
vorbis_enc_codebook * codebooks; vorbis_enc_codebook *codebooks;
int nfloors; int nfloors;
vorbis_enc_floor * floors; vorbis_enc_floor *floors;
int nresidues; int nresidues;
vorbis_enc_residue * residues; vorbis_enc_residue *residues;
int nmappings; int nmappings;
vorbis_enc_mapping * mappings; vorbis_enc_mapping *mappings;
int nmodes; int nmodes;
vorbis_enc_mode * modes; vorbis_enc_mode *modes;
int64_t sample_count; int64_t sample_count;
} vorbis_enc_context; } vorbis_enc_context;
static inline void put_codeword(PutBitContext * pb, vorbis_enc_codebook * cb, static inline void put_codeword(PutBitContext *pb, vorbis_enc_codebook *cb,
int entry) int entry)
{ {
assert(entry >= 0); assert(entry >= 0);
@ -139,19 +139,19 @@ static int cb_lookup_vals(int lookup, int dimentions, int entries)
if (lookup == 1) if (lookup == 1)
return ff_vorbis_nth_root(entries, dimentions); return ff_vorbis_nth_root(entries, dimentions);
else if (lookup == 2) else if (lookup == 2)
return dimentions * entries; return dimentions *entries;
return 0; return 0;
} }
static void ready_codebook(vorbis_enc_codebook * cb) static void ready_codebook(vorbis_enc_codebook *cb)
{ {
int i; int i;
ff_vorbis_len2vlc(cb->lens, cb->codewords, cb->nentries); ff_vorbis_len2vlc(cb->lens, cb->codewords, cb->nentries);
if (!cb->lookup) if (!cb->lookup) {
cb->pow2 = cb->dimentions = NULL; cb->pow2 = cb->dimentions = NULL;
else { } else {
int vals = cb_lookup_vals(cb->lookup, cb->ndimentions, cb->nentries); int vals = cb_lookup_vals(cb->lookup, cb->ndimentions, cb->nentries);
cb->dimentions = av_malloc(sizeof(float) * cb->nentries * cb->ndimentions); cb->dimentions = av_malloc(sizeof(float) * cb->nentries * cb->ndimentions);
cb->pow2 = av_mallocz(sizeof(float) * cb->nentries); cb->pow2 = av_mallocz(sizeof(float) * cb->nentries);
@ -169,7 +169,7 @@ static void ready_codebook(vorbis_enc_codebook * cb)
cb->dimentions[i * cb->ndimentions + j] = last + cb->min + cb->quantlist[off] * cb->delta; cb->dimentions[i * cb->ndimentions + j] = last + cb->min + cb->quantlist[off] * cb->delta;
if (cb->seq_p) if (cb->seq_p)
last = cb->dimentions[i * cb->ndimentions + j]; last = cb->dimentions[i * cb->ndimentions + j];
cb->pow2[i] += cb->dimentions[i * cb->ndimentions + j]*cb->dimentions[i * cb->ndimentions + j]; cb->pow2[i] += cb->dimentions[i * cb->ndimentions + j] * cb->dimentions[i * cb->ndimentions + j];
div *= vals; div *= vals;
} }
cb->pow2[i] /= 2.; cb->pow2[i] /= 2.;
@ -177,7 +177,7 @@ static void ready_codebook(vorbis_enc_codebook * cb)
} }
} }
static void ready_residue(vorbis_enc_residue * rc, vorbis_enc_context * venc) static void ready_residue(vorbis_enc_residue *rc, vorbis_enc_context *venc)
{ {
int i; int i;
assert(rc->type == 2); assert(rc->type == 2);
@ -188,8 +188,8 @@ static void ready_residue(vorbis_enc_residue * rc, vorbis_enc_context * venc)
for (j = 0; j < 8; j++) for (j = 0; j < 8; j++)
if (rc->books[i][j] != -1) if (rc->books[i][j] != -1)
break; break;
if (j == 8) if (j == 8) // zero
continue; // zero continue;
cb = &venc->codebooks[rc->books[i][j]]; cb = &venc->codebooks[rc->books[i][j]];
assert(cb->ndimentions >= 2); assert(cb->ndimentions >= 2);
assert(cb->lookup); assert(cb->lookup);
@ -213,12 +213,12 @@ static void ready_residue(vorbis_enc_residue * rc, vorbis_enc_context * venc)
} }
} }
static void create_vorbis_context(vorbis_enc_context * venc, static void create_vorbis_context(vorbis_enc_context *venc,
AVCodecContext * avccontext) AVCodecContext *avccontext)
{ {
vorbis_enc_floor * fc; vorbis_enc_floor *fc;
vorbis_enc_residue * rc; vorbis_enc_residue *rc;
vorbis_enc_mapping * mc; vorbis_enc_mapping *mc;
int i, book; int i, book;
venc->channels = avccontext->channels; venc->channels = avccontext->channels;
@ -232,7 +232,7 @@ static void create_vorbis_context(vorbis_enc_context * venc,
// codebook 15 residue masterbook // codebook 15 residue masterbook
// codebook 16..29 residue // codebook 16..29 residue
for (book = 0; book < venc->ncodebooks; book++) { for (book = 0; book < venc->ncodebooks; book++) {
vorbis_enc_codebook * cb = &venc->codebooks[book]; vorbis_enc_codebook *cb = &venc->codebooks[book];
int vals; int vals;
cb->ndimentions = cvectors[book].dim; cb->ndimentions = cvectors[book].dim;
cb->nentries = cvectors[book].real_len; cb->nentries = cvectors[book].real_len;
@ -266,7 +266,7 @@ static void create_vorbis_context(vorbis_enc_context * venc,
fc->partition_to_class = av_malloc(sizeof(int) * fc->partitions); fc->partition_to_class = av_malloc(sizeof(int) * fc->partitions);
fc->nclasses = 0; fc->nclasses = 0;
for (i = 0; i < fc->partitions; i++) { for (i = 0; i < fc->partitions; i++) {
static const int a[] = {0,1,2,2,3,3,4,4}; static const int a[] = {0, 1, 2, 2, 3, 3, 4, 4};
fc->partition_to_class[i] = a[i]; fc->partition_to_class[i] = a[i];
fc->nclasses = FFMAX(fc->nclasses, fc->partition_to_class[i]); fc->nclasses = FFMAX(fc->nclasses, fc->partition_to_class[i]);
} }
@ -375,7 +375,7 @@ static void create_vorbis_context(vorbis_enc_context * venc,
ff_mdct_init(&venc->mdct[1], venc->log2_blocksize[1], 0, 1.0); ff_mdct_init(&venc->mdct[1], venc->log2_blocksize[1], 0, 1.0);
} }
static void put_float(PutBitContext * pb, float f) static void put_float(PutBitContext *pb, float f)
{ {
int exp, mant; int exp, mant;
uint32_t res = 0; uint32_t res = 0;
@ -389,7 +389,7 @@ static void put_float(PutBitContext * pb, float f)
put_bits(pb, 32, res); put_bits(pb, 32, res);
} }
static void put_codebook_header(PutBitContext * pb, vorbis_enc_codebook * cb) static void put_codebook_header(PutBitContext *pb, vorbis_enc_codebook *cb)
{ {
int i; int i;
int ordered = 0; int ordered = 0;
@ -454,7 +454,7 @@ static void put_codebook_header(PutBitContext * pb, vorbis_enc_codebook * cb)
} }
} }
static void put_floor_header(PutBitContext * pb, vorbis_enc_floor * fc) static void put_floor_header(PutBitContext *pb, vorbis_enc_floor *fc)
{ {
int i; int i;
@ -487,7 +487,7 @@ static void put_floor_header(PutBitContext * pb, vorbis_enc_floor * fc)
put_bits(pb, fc->rangebits, fc->list[i].x); put_bits(pb, fc->rangebits, fc->list[i].x);
} }
static void put_residue_header(PutBitContext * pb, vorbis_enc_residue * rc) static void put_residue_header(PutBitContext *pb, vorbis_enc_residue *rc)
{ {
int i; int i;
@ -519,11 +519,11 @@ static void put_residue_header(PutBitContext * pb, vorbis_enc_residue * rc)
} }
} }
static int put_main_header(vorbis_enc_context * venc, uint8_t ** out) static int put_main_header(vorbis_enc_context *venc, uint8_t **out)
{ {
int i; int i;
PutBitContext pb; PutBitContext pb;
uint8_t buffer[50000] = {0}, * p = buffer; uint8_t buffer[50000] = {0}, *p = buffer;
int buffer_len = sizeof buffer; int buffer_len = sizeof buffer;
int len, hlens[3]; int len, hlens[3];
@ -589,7 +589,7 @@ static int put_main_header(vorbis_enc_context * venc, uint8_t ** out)
// mappings // mappings
put_bits(&pb, 6, venc->nmappings - 1); put_bits(&pb, 6, venc->nmappings - 1);
for (i = 0; i < venc->nmappings; i++) { for (i = 0; i < venc->nmappings; i++) {
vorbis_enc_mapping * mc = &venc->mappings[i]; vorbis_enc_mapping *mc = &venc->mappings[i];
int j; int j;
put_bits(&pb, 16, 0); // mapping type put_bits(&pb, 16, 0); // mapping type
@ -649,7 +649,7 @@ static int put_main_header(vorbis_enc_context * venc, uint8_t ** out)
return p - *out; return p - *out;
} }
static float get_floor_average(vorbis_enc_floor * 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 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 end = fc->list[fc->list[FFMIN(i+1, fc->values - 1)].sort].x;
@ -661,14 +661,14 @@ static float get_floor_average(vorbis_enc_floor * fc, float * coeffs, int i)
return average / (end - begin); return average / (end - begin);
} }
static void floor_fit(vorbis_enc_context * venc, vorbis_enc_floor * fc, static void floor_fit(vorbis_enc_context *venc, vorbis_enc_floor *fc,
float * coeffs, uint_fast16_t * posts, int samples) float *coeffs, uint_fast16_t *posts, int samples)
{ {
int range = 255 / fc->multiplier + 1; int range = 255 / fc->multiplier + 1;
int i; int i;
float tot_average = 0.; float tot_average = 0.;
float averages[fc->values]; float averages[fc->values];
for (i = 0; i < fc->values; i++){ for (i = 0; i < fc->values; i++) {
averages[i] = get_floor_average(fc, coeffs, i); averages[i] = get_floor_average(fc, coeffs, i);
tot_average += averages[i]; tot_average += averages[i];
} }
@ -693,9 +693,9 @@ static int render_point(int x0, int y0, int x1, int y1, int x)
return y0 + (x - x0) * (y1 - y0) / (x1 - x0); return y0 + (x - x0) * (y1 - y0) / (x1 - x0);
} }
static void floor_encode(vorbis_enc_context * venc, vorbis_enc_floor * fc, static void floor_encode(vorbis_enc_context *venc, vorbis_enc_floor *fc,
PutBitContext * pb, uint_fast16_t * posts, PutBitContext *pb, uint_fast16_t *posts,
float * floor, int samples) float *floor, int samples)
{ {
int range = 255 / fc->multiplier + 1; int range = 255 / fc->multiplier + 1;
int coded[fc->values]; // first 2 values are unused int coded[fc->values]; // first 2 values are unused
@ -772,10 +772,12 @@ static void floor_encode(vorbis_enc_context * venc, vorbis_enc_floor * fc,
} }
} }
ff_vorbis_floor1_render_list(fc->list, fc->values, posts, coded, fc->multiplier, floor, samples); ff_vorbis_floor1_render_list(fc->list, fc->values, posts, coded,
fc->multiplier, floor, samples);
} }
static float * put_vector(vorbis_enc_codebook * book, PutBitContext * pb, float * num) static float *put_vector(vorbis_enc_codebook *book, PutBitContext *pb,
float *num)
{ {
int i, entry = -1; int i, entry = -1;
float distance = FLT_MAX; float distance = FLT_MAX;
@ -796,8 +798,8 @@ static float * put_vector(vorbis_enc_codebook * book, PutBitContext * pb, float
return &book->dimentions[entry * book->ndimentions]; return &book->dimentions[entry * book->ndimentions];
} }
static void residue_encode(vorbis_enc_context * venc, vorbis_enc_residue * rc, static void residue_encode(vorbis_enc_context *venc, vorbis_enc_residue *rc,
PutBitContext * pb, float * coeffs, int samples, PutBitContext *pb, float *coeffs, int samples,
int real_ch) int real_ch)
{ {
int pass, i, j, p, k; int pass, i, j, p, k;
@ -840,7 +842,7 @@ static void residue_encode(vorbis_enc_context * venc, vorbis_enc_residue * rc,
for (j = 0; j < channels; j++) { for (j = 0; j < channels; j++) {
int nbook = rc->books[classes[j][p]][pass]; int nbook = rc->books[classes[j][p]][pass];
vorbis_enc_codebook * book = &venc->codebooks[nbook]; vorbis_enc_codebook * book = &venc->codebooks[nbook];
float * buf = coeffs + samples*j + rc->begin + p*psize; float *buf = coeffs + samples*j + rc->begin + p*psize;
if (nbook == -1) if (nbook == -1)
continue; continue;
@ -849,7 +851,7 @@ static void residue_encode(vorbis_enc_context * venc, vorbis_enc_residue * rc,
if (rc->type == 0) { if (rc->type == 0) {
for (k = 0; k < psize; k += book->ndimentions) { for (k = 0; k < psize; k += book->ndimentions) {
float * a = put_vector(book, pb, &buf[k]); float *a = put_vector(book, pb, &buf[k]);
int l; int l;
for (l = 0; l < book->ndimentions; l++) for (l = 0; l < book->ndimentions; l++)
buf[k + l] -= a[l]; buf[k + l] -= a[l];
@ -861,11 +863,11 @@ static void residue_encode(vorbis_enc_context * venc, vorbis_enc_residue * rc,
s = real_ch * samples; s = real_ch * samples;
for (k = 0; k < psize; k += book->ndimentions) { for (k = 0; k < psize; k += book->ndimentions) {
int dim, a2 = a1, b2 = b1; int dim, a2 = a1, b2 = b1;
float vec[book->ndimentions], * pv = vec; float vec[book->ndimentions], *pv = vec;
for (dim = book->ndimentions; dim--; ) { for (dim = book->ndimentions; dim--; ) {
*pv++ = coeffs[a2 + b2]; *pv++ = coeffs[a2 + b2];
if ((a2 += samples) == s) { if ((a2 += samples) == s) {
a2=0; a2 = 0;
b2++; b2++;
} }
} }
@ -873,7 +875,7 @@ static void residue_encode(vorbis_enc_context * venc, vorbis_enc_residue * rc,
for (dim = book->ndimentions; dim--; ) { for (dim = book->ndimentions; dim--; ) {
coeffs[a1 + b1] -= *pv++; coeffs[a1 + b1] -= *pv++;
if ((a1 += samples) == s) { if ((a1 += samples) == s) {
a1=0; a1 = 0;
b1++; b1++;
} }
} }
@ -885,8 +887,8 @@ static void residue_encode(vorbis_enc_context * venc, vorbis_enc_residue * rc,
} }
} }
static int apply_window_and_mdct(vorbis_enc_context * venc, static int apply_window_and_mdct(vorbis_enc_context *venc, signed short *audio,
signed short * audio, int samples) int samples)
{ {
int i, j, channel; int i, j, channel;
const float * win = venc->win[0]; const float * win = venc->win[0];
@ -897,12 +899,15 @@ static int apply_window_and_mdct(vorbis_enc_context * venc,
if (!venc->have_saved && !samples) if (!venc->have_saved && !samples)
return 0; return 0;
if (venc->have_saved) if (venc->have_saved) {
for (channel = 0; channel < venc->channels; channel++) for (channel = 0; channel < venc->channels; channel++)
memcpy(venc->samples + channel*window_len*2, venc->saved + channel*window_len, sizeof(float)*window_len); memcpy(venc->samples + channel * window_len * 2,
else venc->saved + channel * window_len, sizeof(float) * window_len);
} else {
for (channel = 0; channel < venc->channels; channel++) for (channel = 0; channel < venc->channels; channel++)
memset(venc->samples + channel*window_len*2, 0, sizeof(float)*window_len); memset(venc->samples + channel * window_len * 2, 0,
sizeof(float) * window_len);
}
if (samples) { if (samples) {
for (channel = 0; channel < venc->channels; channel++) { for (channel = 0; channel < venc->channels; channel++) {
@ -913,15 +918,17 @@ static int apply_window_and_mdct(vorbis_enc_context * venc,
} }
} else { } else {
for (channel = 0; channel < venc->channels; channel++) for (channel = 0; channel < venc->channels; channel++)
memset(venc->samples + channel*window_len*2 + window_len, 0, sizeof(float)*window_len); memset(venc->samples + channel * window_len * 2 + window_len,
0, sizeof(float) * window_len);
} }
for (channel = 0; channel < venc->channels; channel++) for (channel = 0; channel < venc->channels; channel++)
ff_mdct_calc(&venc->mdct[0], venc->coeffs + channel*window_len, venc->samples + channel*window_len*2); ff_mdct_calc(&venc->mdct[0], venc->coeffs + channel * window_len,
venc->samples + channel * window_len * 2);
if (samples) { if (samples) {
for (channel = 0; channel < venc->channels; channel++) { for (channel = 0; channel < venc->channels; channel++) {
float * offset = venc->saved + channel*window_len; float *offset = venc->saved + channel * window_len;
j = channel; j = channel;
for (i = 0; i < samples; i++, j += venc->channels) for (i = 0; i < samples; i++, j += venc->channels)
offset[i] = -audio[j] / 32768. / n * win[i]; //FIXME find out why the sign has to be fliped offset[i] = -audio[j] / 32768. / n * win[i]; //FIXME find out why the sign has to be fliped
@ -933,9 +940,9 @@ static int apply_window_and_mdct(vorbis_enc_context * venc,
return 1; return 1;
} }
static av_cold int vorbis_encode_init(AVCodecContext * avccontext) static av_cold int vorbis_encode_init(AVCodecContext *avccontext)
{ {
vorbis_enc_context * venc = avccontext->priv_data; vorbis_enc_context *venc = avccontext->priv_data;
if (avccontext->channels != 2) { if (avccontext->channels != 2) {
av_log(avccontext, AV_LOG_ERROR, "Current FFmpeg Vorbis encoder only supports 2 channels.\n"); av_log(avccontext, AV_LOG_ERROR, "Current FFmpeg Vorbis encoder only supports 2 channels.\n");
@ -960,13 +967,15 @@ static av_cold int vorbis_encode_init(AVCodecContext * avccontext)
return 0; return 0;
} }
static int vorbis_encode_frame(AVCodecContext * avccontext, unsigned char * packets, int buf_size, void *data) static int vorbis_encode_frame(AVCodecContext *avccontext,
unsigned char *packets,
int buf_size, void *data)
{ {
vorbis_enc_context * venc = avccontext->priv_data; vorbis_enc_context *venc = avccontext->priv_data;
signed short * audio = data; signed short *audio = data;
int samples = data ? avccontext->frame_size : 0; int samples = data ? avccontext->frame_size : 0;
vorbis_enc_mode * mode; vorbis_enc_mode *mode;
vorbis_enc_mapping * mapping; vorbis_enc_mapping *mapping;
PutBitContext pb; PutBitContext pb;
int i; int i;
@ -988,7 +997,7 @@ static int vorbis_encode_frame(AVCodecContext * avccontext, unsigned char * pack
} }
for (i = 0; i < venc->channels; i++) { for (i = 0; i < venc->channels; i++) {
vorbis_enc_floor * 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]; uint_fast16_t posts[fc->values];
floor_fit(venc, fc, &venc->coeffs[i * samples], posts, samples); floor_fit(venc, fc, &venc->coeffs[i * samples], posts, samples);
floor_encode(venc, fc, &pb, posts, &venc->floor[i * samples], samples); floor_encode(venc, fc, &pb, posts, &venc->floor[i * samples], samples);
@ -998,8 +1007,8 @@ static int vorbis_encode_frame(AVCodecContext * avccontext, unsigned char * pack
venc->coeffs[i] /= venc->floor[i]; venc->coeffs[i] /= venc->floor[i];
for (i = 0; i < mapping->coupling_steps; i++) { for (i = 0; i < mapping->coupling_steps; i++) {
float * mag = venc->coeffs + mapping->magnitude[i] * samples; float *mag = venc->coeffs + mapping->magnitude[i] * samples;
float * ang = venc->coeffs + mapping->angle[i] * samples; float *ang = venc->coeffs + mapping->angle[i] * samples;
int j; int j;
for (j = 0; j < samples; j++) { for (j = 0; j < samples; j++) {
float a = ang[j]; float a = ang[j];
@ -1011,7 +1020,8 @@ static int vorbis_encode_frame(AVCodecContext * avccontext, unsigned char * pack
} }
} }
residue_encode(venc, &venc->residues[mapping->residue[mapping->mux[0]]], &pb, venc->coeffs, samples, venc->channels); residue_encode(venc, &venc->residues[mapping->residue[mapping->mux[0]]],
&pb, venc->coeffs, samples, venc->channels);
avccontext->coded_frame->pts = venc->sample_count; avccontext->coded_frame->pts = venc->sample_count;
venc->sample_count += avccontext->frame_size; venc->sample_count += avccontext->frame_size;
@ -1020,9 +1030,9 @@ static int vorbis_encode_frame(AVCodecContext * avccontext, unsigned char * pack
} }
static av_cold int vorbis_encode_close(AVCodecContext * avccontext) static av_cold int vorbis_encode_close(AVCodecContext *avccontext)
{ {
vorbis_enc_context * venc = avccontext->priv_data; vorbis_enc_context *venc = avccontext->priv_data;
int i; int i;
if (venc->codebooks) if (venc->codebooks)

9
libavcodec/vorbis_enc_data.h
Unescape View File

@ -24,8 +24,7 @@
#include <stdint.h> #include <stdint.h>
static const uint8_t codebook0[] = { static const uint8_t codebook0[] = {
2, 10, 8, 14, 7, 12, 11, 14, 1, 5, 3, 7, 4, 9, 7, 2, 10, 8, 14, 7, 12, 11, 14, 1, 5, 3, 7, 4, 9, 7, 13,
13,
}; };
static const uint8_t codebook1[] = { static const uint8_t codebook1[] = {
@ -452,11 +451,11 @@ static const struct {
int dim; int dim;
int len; int len;
int real_len; int real_len;
const uint8_t * clens; const uint8_t *clens;
int lookup; int lookup;
float min; float min;
float delta; float delta;
const uint8_t * quant; const uint8_t *quant;
} cvectors[] = { } cvectors[] = {
{ 2, 16, 16, codebook0, 0 }, { 2, 16, 16, codebook0, 0 },
{ 2, 8, 8, codebook1, 0 }, { 2, 8, 8, codebook1, 0 },
@ -493,7 +492,7 @@ static const struct {
int dim; int dim;
int subclass; int subclass;
int masterbook; int masterbook;
const int * nbooks; const int *nbooks;
} floor_classes[] = { } floor_classes[] = {
{ 3, 0, 0, (const int[]){ 4 } }, { 3, 0, 0, (const int[]){ 4 } },
{ 4, 1, 0, (const int[]){ 5, 6 } }, { 4, 1, 0, (const int[]){ 5, 6 } },

Write Preview
Loading…
Cancel
Save