RepoMirrors
/
ffmpeg
mirror of https://git.ffmpeg.org/ffmpeg.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Rename all vorbis encoder related typedefs to not use _t for POSIX compatibility 

Originally committed as revision 16076 to svn://svn.ffmpeg.org/ffmpeg/trunk
This commit is contained in:
Oded Shimon 2008-12-12 05:12:51 +00:00
parent bffc76bd17
commit 05dee1b7df
4 changed files with 60 additions and 60 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
libavcodec/vorbis.c
View File

@ -111,7 +111,7 @@ int ff_vorbis_len2vlc(uint8_t *bits, uint32_t *codes, uint_fast32_t num) {
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 @@ static void render_line(int x0, int y0, int x1, int y1, float * buf) {
}
}
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;

6
libavcodec/vorbis.h
View File

@ -31,12 +31,12 @@ typedef struct {
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))

4
libavcodec/vorbis_dec.c
View File

@ -90,7 +90,7 @@ typedef struct {
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 @@ static int vorbis_parse_setup_hdr_floors(vorbis_context *vc) {
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);

106
libavcodec/vorbis_enc.c
View File

@ -48,25 +48,25 @@ typedef struct {
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 @@ typedef struct {
int classbook;
int8_t (*books)[8];
float (*maxes)[2];
} residue_t;
} vorbis_enc_residue;
typedef struct {
int submaps;
@ -87,12 +87,12 @@ typedef struct {
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 @@ typedef struct {
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 @@ static int cb_lookup_vals(int lookup, int dimentions, int entries) {
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_codebook(codebook_t * cb) {
}
}
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 ready_residue(residue_t * rc, venc_context_t * venc) {
}
}
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 @@ static void create_vorbis_context(venc_context_t * venc, AVCodecContext * avccon
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 @@ static void create_vorbis_context(venc_context_t * venc, AVCodecContext * avccon
}
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 @@ static void create_vorbis_context(venc_context_t * venc, AVCodecContext * avccon
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 @@ static void create_vorbis_context(venc_context_t * venc, AVCodecContext * avccon
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 @@ static void create_vorbis_context(venc_context_t * venc, AVCodecContext * avccon
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 @@ static void create_vorbis_context(venc_context_t * venc, AVCodecContext * avccon
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 @@ static void create_vorbis_context(venc_context_t * venc, AVCodecContext * avccon
}
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 @@ static void put_float(PutBitContext * pb, float f) {
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_codebook_header(PutBitContext * pb, codebook_t * cb) {
}
}
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 @@ static void put_floor_header(PutBitContext * pb, floor_t * fc) {
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 void put_residue_header(PutBitContext * pb, residue_t * rc) {
}
}
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 @@ static int put_main_header(venc_context_t * venc, uint8_t ** out) {
// 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 @@ static int put_main_header(venc_context_t * venc, uint8_t ** out) {
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 @@ static float get_floor_average(floor_t * fc, float * coeffs, int i) {
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 @@ static int render_point(int x0, int y0, int x1, int y1, int x) {
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 @@ static void floor_encode(venc_context_t * venc, floor_t * fc, PutBitContext * pb
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 @@ static void floor_encode(venc_context_t * venc, floor_t * fc, PutBitContext * pb
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 @@ static float * put_vector(codebook_t * book, PutBitContext * pb, float * num) {
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 @@ static void residue_encode(venc_context_t * venc, residue_t * rc, PutBitContext
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 @@ static void residue_encode(venc_context_t * venc, residue_t * rc, PutBitContext
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 void residue_encode(venc_context_t * venc, residue_t * rc, PutBitContext
}
}
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 int apply_window_and_mdct(venc_context_t * venc, signed short * audio, in
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 av_cold int vorbis_encode_init(AVCodecContext * avccontext)
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 @@ static int vorbis_encode_frame(AVCodecContext * avccontext, unsigned char * pack
}
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 int vorbis_encode_frame(AVCodecContext * avccontext, unsigned char * pack
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 @@ AVCodec vorbis_encoder = {
"vorbis",
CODEC_TYPE_AUDIO,
CODEC_ID_VORBIS,
sizeof(venc_context_t),
sizeof(vorbis_enc_context),
vorbis_encode_init,
vorbis_encode_frame,
vorbis_encode_close,