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

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

Browse Source 
Originally committed as revision 16076 to svn://svn.ffmpeg.org/ffmpeg/trunk
pull/126/head
Oded Shimon 16 years ago
parent bffc76bd17
commit 05dee1b7df
4 changed files with 60 additions and 60 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 4
      libavcodec/vorbis.c
  2. 6
      libavcodec/vorbis.h
  3. 4
      libavcodec/vorbis_dec.c
  4. 106
      libavcodec/vorbis_enc.c

4
libavcodec/vorbis.c
Unescape 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
Unescape 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
Unescape 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
Unescape 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,

Write Preview
Loading…
Cancel
Save