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

vorbisdec: cosmetics: rename variable avccontext to avctx

Browse Source 
This is consistent with the rest of libavcodec.
pull/10/head
Justin Ruggles 12 years ago
parent b2d688ea9f
commit e951b6d94c
3 changed files with 73 additions and 76 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. 4
      libavcodec/vorbis.c
  2. 2
      libavcodec/vorbis.h
  3. 143
      libavcodec/vorbisdec.c

4
libavcodec/vorbis.c
Unescape View File

@ -117,7 +117,7 @@ int ff_vorbis_len2vlc(uint8_t *bits, uint32_t *codes, unsigned num)
return 0; return 0;
} }
int ff_vorbis_ready_floor1_list(AVCodecContext *avccontext, int ff_vorbis_ready_floor1_list(AVCodecContext *avctx,
vorbis_floor1_entry *list, int values) vorbis_floor1_entry *list, int values)
{ {
int i; int i;
@ -143,7 +143,7 @@ int ff_vorbis_ready_floor1_list(AVCodecContext *avccontext,
int j; int j;
for (j = i + 1; j < values; j++) { for (j = i + 1; j < values; j++) {
if (list[i].x == list[j].x) { if (list[i].x == list[j].x) {
av_log(avccontext, AV_LOG_ERROR, av_log(avctx, AV_LOG_ERROR,
"Duplicate value found in floor 1 X coordinates\n"); "Duplicate value found in floor 1 X coordinates\n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }

2
libavcodec/vorbis.h
Unescape View File

@ -36,7 +36,7 @@ typedef struct vorbis_floor1_entry {
uint16_t high; uint16_t high;
} vorbis_floor1_entry; } vorbis_floor1_entry;
int ff_vorbis_ready_floor1_list(AVCodecContext *avccontext, int ff_vorbis_ready_floor1_list(AVCodecContext *avctx,
vorbis_floor1_entry *list, int values); vorbis_floor1_entry *list, int values);
unsigned int ff_vorbis_nth_root(unsigned int x, unsigned int n); // x^(1/n) 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, unsigned num); int ff_vorbis_len2vlc(uint8_t *bits, uint32_t *codes, unsigned num);

143
libavcodec/vorbisdec.c
Unescape View File

@ -122,7 +122,7 @@ typedef struct {
} vorbis_mode; } vorbis_mode;
typedef struct vorbis_context_s { typedef struct vorbis_context_s {
AVCodecContext *avccontext; AVCodecContext *avctx;
GetBitContext gb; GetBitContext gb;
VorbisDSPContext dsp; VorbisDSPContext dsp;
AVFloatDSPContext fdsp; AVFloatDSPContext fdsp;
@ -162,7 +162,7 @@ typedef struct vorbis_context_s {
static const char idx_err_str[] = "Index value %d out of range (0 - %d) for %s at %s:%i\n"; static const char idx_err_str[] = "Index value %d out of range (0 - %d) for %s at %s:%i\n";
#define VALIDATE_INDEX(idx, limit) \ #define VALIDATE_INDEX(idx, limit) \
if (idx >= limit) {\ if (idx >= limit) {\
av_log(vc->avccontext, AV_LOG_ERROR,\ av_log(vc->avctx, AV_LOG_ERROR,\
idx_err_str,\ idx_err_str,\
(int)(idx), (int)(limit - 1), #idx, __FILE__, __LINE__);\ (int)(idx), (int)(limit - 1), #idx, __FILE__, __LINE__);\
return AVERROR_INVALIDDATA;\ return AVERROR_INVALIDDATA;\
@ -255,7 +255,7 @@ static int vorbis_parse_setup_hdr_codebooks(vorbis_context *vc)
av_dlog(NULL, " %u. Codebook\n", cb); av_dlog(NULL, " %u. Codebook\n", cb);
if (get_bits(gb, 24) != 0x564342) { if (get_bits(gb, 24) != 0x564342) {
av_log(vc->avccontext, AV_LOG_ERROR, av_log(vc->avctx, AV_LOG_ERROR,
" %u. Codebook setup data corrupt.\n", cb); " %u. Codebook setup data corrupt.\n", cb);
ret = AVERROR_INVALIDDATA; ret = AVERROR_INVALIDDATA;
goto error; goto error;
@ -263,7 +263,7 @@ static int vorbis_parse_setup_hdr_codebooks(vorbis_context *vc)
codebook_setup->dimensions=get_bits(gb, 16); codebook_setup->dimensions=get_bits(gb, 16);
if (codebook_setup->dimensions > 16 || codebook_setup->dimensions == 0) { if (codebook_setup->dimensions > 16 || codebook_setup->dimensions == 0) {
av_log(vc->avccontext, AV_LOG_ERROR, av_log(vc->avctx, AV_LOG_ERROR,
" %u. Codebook's dimension is invalid (%d).\n", " %u. Codebook's dimension is invalid (%d).\n",
cb, codebook_setup->dimensions); cb, codebook_setup->dimensions);
ret = AVERROR_INVALIDDATA; ret = AVERROR_INVALIDDATA;
@ -271,7 +271,7 @@ static int vorbis_parse_setup_hdr_codebooks(vorbis_context *vc)
} }
entries = get_bits(gb, 24); entries = get_bits(gb, 24);
if (entries > V_MAX_VLCS) { if (entries > V_MAX_VLCS) {
av_log(vc->avccontext, AV_LOG_ERROR, av_log(vc->avctx, AV_LOG_ERROR,
" %u. Codebook has too many entries (%u).\n", " %u. Codebook has too many entries (%u).\n",
cb, entries); cb, entries);
ret = AVERROR_INVALIDDATA; ret = AVERROR_INVALIDDATA;
@ -331,7 +331,7 @@ static int vorbis_parse_setup_hdr_codebooks(vorbis_context *vc)
current_entry+=number; current_entry+=number;
} }
if (current_entry>used_entries) { if (current_entry>used_entries) {
av_log(vc->avccontext, AV_LOG_ERROR, " More codelengths than codes in codebook. \n"); av_log(vc->avctx, AV_LOG_ERROR, " More codelengths than codes in codebook. \n");
ret = AVERROR_INVALIDDATA; ret = AVERROR_INVALIDDATA;
goto error; goto error;
} }
@ -378,7 +378,7 @@ static int vorbis_parse_setup_hdr_codebooks(vorbis_context *vc)
float last = 0.0; float last = 0.0;
unsigned lookup_offset = i; unsigned lookup_offset = i;
av_dlog(vc->avccontext, "Lookup offset %u ,", i); av_dlog(vc->avctx, "Lookup offset %u ,", i);
for (k = 0; k < dim; ++k) { for (k = 0; k < dim; ++k) {
unsigned multiplicand_offset = lookup_offset % codebook_lookup_values; unsigned multiplicand_offset = lookup_offset % codebook_lookup_values;
@ -389,30 +389,30 @@ static int vorbis_parse_setup_hdr_codebooks(vorbis_context *vc)
} }
tmp_vlc_bits[j] = tmp_vlc_bits[i]; tmp_vlc_bits[j] = tmp_vlc_bits[i];
av_dlog(vc->avccontext, "real lookup offset %u, vector: ", j); av_dlog(vc->avctx, "real lookup offset %u, vector: ", j);
for (k = 0; k < dim; ++k) for (k = 0; k < dim; ++k)
av_dlog(vc->avccontext, " %f ", av_dlog(vc->avctx, " %f ",
codebook_setup->codevectors[j * dim + k]); codebook_setup->codevectors[j * dim + k]);
av_dlog(vc->avccontext, "\n"); av_dlog(vc->avctx, "\n");
++j; ++j;
} }
} }
if (j != used_entries) { if (j != used_entries) {
av_log(vc->avccontext, AV_LOG_ERROR, "Bug in codevector vector building code. \n"); av_log(vc->avctx, AV_LOG_ERROR, "Bug in codevector vector building code. \n");
ret = AVERROR_INVALIDDATA; ret = AVERROR_INVALIDDATA;
goto error; goto error;
} }
entries = used_entries; entries = used_entries;
} else if (codebook_setup->lookup_type >= 2) { } else if (codebook_setup->lookup_type >= 2) {
av_log(vc->avccontext, AV_LOG_ERROR, "Codebook lookup type not supported. \n"); av_log(vc->avctx, AV_LOG_ERROR, "Codebook lookup type not supported. \n");
ret = AVERROR_INVALIDDATA; ret = AVERROR_INVALIDDATA;
goto error; goto error;
} }
// Initialize VLC table // Initialize VLC table
if (ff_vorbis_len2vlc(tmp_vlc_bits, tmp_vlc_codes, entries)) { if (ff_vorbis_len2vlc(tmp_vlc_bits, tmp_vlc_codes, entries)) {
av_log(vc->avccontext, AV_LOG_ERROR, " Invalid code lengths while generating vlcs. \n"); av_log(vc->avctx, AV_LOG_ERROR, " Invalid code lengths while generating vlcs. \n");
ret = AVERROR_INVALIDDATA; ret = AVERROR_INVALIDDATA;
goto error; goto error;
} }
@ -433,7 +433,7 @@ static int vorbis_parse_setup_hdr_codebooks(vorbis_context *vc)
sizeof(*tmp_vlc_bits), tmp_vlc_codes, sizeof(*tmp_vlc_bits), tmp_vlc_codes,
sizeof(*tmp_vlc_codes), sizeof(*tmp_vlc_codes), sizeof(*tmp_vlc_codes), sizeof(*tmp_vlc_codes),
INIT_VLC_LE))) { INIT_VLC_LE))) {
av_log(vc->avccontext, AV_LOG_ERROR, " Error generating vlc tables. \n"); av_log(vc->avctx, AV_LOG_ERROR, " Error generating vlc tables. \n");
goto error; goto error;
} }
} }
@ -465,7 +465,7 @@ static int vorbis_parse_setup_hdr_tdtransforms(vorbis_context *vc)
vorbis_time_count, vorbis_tdtransform); vorbis_time_count, vorbis_tdtransform);
if (vorbis_tdtransform) { if (vorbis_tdtransform) {
av_log(vc->avccontext, AV_LOG_ERROR, "Vorbis time domain transform data nonzero. \n"); av_log(vc->avctx, AV_LOG_ERROR, "Vorbis time domain transform data nonzero. \n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
} }
@ -555,7 +555,7 @@ static int vorbis_parse_setup_hdr_floors(vorbis_context *vc)
rangebits = get_bits(gb, 4); rangebits = get_bits(gb, 4);
rangemax = (1 << rangebits); rangemax = (1 << rangebits);
if (rangemax > vc->blocksize[1] / 2) { if (rangemax > vc->blocksize[1] / 2) {
av_log(vc->avccontext, AV_LOG_ERROR, av_log(vc->avctx, AV_LOG_ERROR,
"Floor value is too large for blocksize: %u (%"PRIu32")\n", "Floor value is too large for blocksize: %u (%"PRIu32")\n",
rangemax, vc->blocksize[1] / 2); rangemax, vc->blocksize[1] / 2);
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
@ -573,7 +573,7 @@ static int vorbis_parse_setup_hdr_floors(vorbis_context *vc)
} }
// Precalculate order of x coordinates - needed for decode // Precalculate order of x coordinates - needed for decode
if (ff_vorbis_ready_floor1_list(vc->avccontext, if (ff_vorbis_ready_floor1_list(vc->avctx,
floor_setup->data.t1.list, floor_setup->data.t1.list,
floor_setup->data.t1.x_list_dim)) { floor_setup->data.t1.x_list_dim)) {
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
@ -585,19 +585,17 @@ static int vorbis_parse_setup_hdr_floors(vorbis_context *vc)
floor_setup->data.t0.order = get_bits(gb, 8); floor_setup->data.t0.order = get_bits(gb, 8);
if (!floor_setup->data.t0.order) { if (!floor_setup->data.t0.order) {
av_log(vc->avccontext, AV_LOG_ERROR, av_log(vc->avctx, AV_LOG_ERROR, "Floor 0 order is 0.\n");
"Floor 0 order is 0.\n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
floor_setup->data.t0.rate = get_bits(gb, 16); floor_setup->data.t0.rate = get_bits(gb, 16);
if (!floor_setup->data.t0.rate) { if (!floor_setup->data.t0.rate) {
av_log(vc->avccontext, AV_LOG_ERROR, av_log(vc->avctx, AV_LOG_ERROR, "Floor 0 rate is 0.\n");
"Floor 0 rate is 0.\n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
floor_setup->data.t0.bark_map_size = get_bits(gb, 16); floor_setup->data.t0.bark_map_size = get_bits(gb, 16);
if (!floor_setup->data.t0.bark_map_size) { if (!floor_setup->data.t0.bark_map_size) {
av_log(vc->avccontext, AV_LOG_ERROR, av_log(vc->avctx, AV_LOG_ERROR,
"Floor 0 bark map size is 0.\n"); "Floor 0 bark map size is 0.\n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
@ -653,7 +651,7 @@ static int vorbis_parse_setup_hdr_floors(vorbis_context *vc)
} }
} }
} else { } else {
av_log(vc->avccontext, AV_LOG_ERROR, "Invalid floor type!\n"); av_log(vc->avctx, AV_LOG_ERROR, "Invalid floor type!\n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
} }
@ -686,9 +684,9 @@ static int vorbis_parse_setup_hdr_residues(vorbis_context *vc)
res_setup->partition_size = get_bits(gb, 24) + 1; res_setup->partition_size = get_bits(gb, 24) + 1;
/* Validations to prevent a buffer overflow later. */ /* Validations to prevent a buffer overflow later. */
if (res_setup->begin>res_setup->end || if (res_setup->begin>res_setup->end ||
res_setup->end > (res_setup->type == 2 ? vc->avccontext->channels : 1) * vc->blocksize[1] / 2 || res_setup->end > (res_setup->type == 2 ? vc->avctx->channels : 1) * vc->blocksize[1] / 2 ||
(res_setup->end-res_setup->begin) / res_setup->partition_size > V_MAX_PARTITIONS) { (res_setup->end-res_setup->begin) / res_setup->partition_size > V_MAX_PARTITIONS) {
av_log(vc->avccontext, AV_LOG_ERROR, av_log(vc->avctx, AV_LOG_ERROR,
"partition out of bounds: type, begin, end, size, blocksize: %"PRIu16", %"PRIu32", %"PRIu32", %u, %"PRIu32"\n", "partition out of bounds: type, begin, end, size, blocksize: %"PRIu16", %"PRIu32", %"PRIu32", %u, %"PRIu32"\n",
res_setup->type, res_setup->begin, res_setup->end, res_setup->type, res_setup->begin, res_setup->end,
res_setup->partition_size, vc->blocksize[1] / 2); res_setup->partition_size, vc->blocksize[1] / 2);
@ -756,7 +754,7 @@ static int vorbis_parse_setup_hdr_mappings(vorbis_context *vc)
vorbis_mapping *mapping_setup = &vc->mappings[i]; vorbis_mapping *mapping_setup = &vc->mappings[i];
if (get_bits(gb, 16)) { if (get_bits(gb, 16)) {
av_log(vc->avccontext, AV_LOG_ERROR, "Other mappings than type 0 are not compliant with the Vorbis I specification. \n"); av_log(vc->avctx, AV_LOG_ERROR, "Other mappings than type 0 are not compliant with the Vorbis I specification. \n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
if (get_bits1(gb)) { if (get_bits1(gb)) {
@ -783,7 +781,7 @@ static int vorbis_parse_setup_hdr_mappings(vorbis_context *vc)
i, mapping_setup->coupling_steps); i, mapping_setup->coupling_steps);
if (get_bits(gb, 2)) { if (get_bits(gb, 2)) {
av_log(vc->avccontext, AV_LOG_ERROR, "%u. mapping setup data invalid.\n", i); av_log(vc->avctx, AV_LOG_ERROR, "%u. mapping setup data invalid.\n", i);
return AVERROR_INVALIDDATA; // following spec. return AVERROR_INVALIDDATA; // following spec.
} }
@ -875,36 +873,36 @@ static int vorbis_parse_setup_hdr(vorbis_context *vc)
if ((get_bits(gb, 8) != 'v') || (get_bits(gb, 8) != 'o') || if ((get_bits(gb, 8) != 'v') || (get_bits(gb, 8) != 'o') ||
(get_bits(gb, 8) != 'r') || (get_bits(gb, 8) != 'b') || (get_bits(gb, 8) != 'r') || (get_bits(gb, 8) != 'b') ||
(get_bits(gb, 8) != 'i') || (get_bits(gb, 8) != 's')) { (get_bits(gb, 8) != 'i') || (get_bits(gb, 8) != 's')) {
av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis setup header packet corrupt (no vorbis signature). \n"); av_log(vc->avctx, AV_LOG_ERROR, " Vorbis setup header packet corrupt (no vorbis signature). \n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
if ((ret = vorbis_parse_setup_hdr_codebooks(vc))) { if ((ret = vorbis_parse_setup_hdr_codebooks(vc))) {
av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis setup header packet corrupt (codebooks). \n"); av_log(vc->avctx, AV_LOG_ERROR, " Vorbis setup header packet corrupt (codebooks). \n");
return ret; return ret;
} }
if ((ret = vorbis_parse_setup_hdr_tdtransforms(vc))) { if ((ret = vorbis_parse_setup_hdr_tdtransforms(vc))) {
av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis setup header packet corrupt (time domain transforms). \n"); av_log(vc->avctx, AV_LOG_ERROR, " Vorbis setup header packet corrupt (time domain transforms). \n");
return ret; return ret;
} }
if ((ret = vorbis_parse_setup_hdr_floors(vc))) { if ((ret = vorbis_parse_setup_hdr_floors(vc))) {
av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis setup header packet corrupt (floors). \n"); av_log(vc->avctx, AV_LOG_ERROR, " Vorbis setup header packet corrupt (floors). \n");
return ret; return ret;
} }
if ((ret = vorbis_parse_setup_hdr_residues(vc))) { if ((ret = vorbis_parse_setup_hdr_residues(vc))) {
av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis setup header packet corrupt (residues). \n"); av_log(vc->avctx, AV_LOG_ERROR, " Vorbis setup header packet corrupt (residues). \n");
return ret; return ret;
} }
if ((ret = vorbis_parse_setup_hdr_mappings(vc))) { if ((ret = vorbis_parse_setup_hdr_mappings(vc))) {
av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis setup header packet corrupt (mappings). \n"); av_log(vc->avctx, AV_LOG_ERROR, " Vorbis setup header packet corrupt (mappings). \n");
return ret; return ret;
} }
if ((ret = vorbis_parse_setup_hdr_modes(vc))) { if ((ret = vorbis_parse_setup_hdr_modes(vc))) {
av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis setup header packet corrupt (modes). \n"); av_log(vc->avctx, AV_LOG_ERROR, " Vorbis setup header packet corrupt (modes). \n");
return ret; return ret;
} }
if (!get_bits1(gb)) { if (!get_bits1(gb)) {
av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis setup header packet corrupt (framing flag). \n"); av_log(vc->avctx, AV_LOG_ERROR, " Vorbis setup header packet corrupt (framing flag). \n");
return AVERROR_INVALIDDATA; // framing flag bit unset error return AVERROR_INVALIDDATA; // framing flag bit unset error
} }
@ -921,19 +919,19 @@ static int vorbis_parse_id_hdr(vorbis_context *vc)
if ((get_bits(gb, 8) != 'v') || (get_bits(gb, 8) != 'o') || if ((get_bits(gb, 8) != 'v') || (get_bits(gb, 8) != 'o') ||
(get_bits(gb, 8) != 'r') || (get_bits(gb, 8) != 'b') || (get_bits(gb, 8) != 'r') || (get_bits(gb, 8) != 'b') ||
(get_bits(gb, 8) != 'i') || (get_bits(gb, 8) != 's')) { (get_bits(gb, 8) != 'i') || (get_bits(gb, 8) != 's')) {
av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis id header packet corrupt (no vorbis signature). \n"); av_log(vc->avctx, AV_LOG_ERROR, " Vorbis id header packet corrupt (no vorbis signature). \n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
vc->version = get_bits_long(gb, 32); //FIXME check 0 vc->version = get_bits_long(gb, 32); //FIXME check 0
vc->audio_channels = get_bits(gb, 8); vc->audio_channels = get_bits(gb, 8);
if (vc->audio_channels <= 0) { if (vc->audio_channels <= 0) {
av_log(vc->avccontext, AV_LOG_ERROR, "Invalid number of channels\n"); av_log(vc->avctx, AV_LOG_ERROR, "Invalid number of channels\n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
vc->audio_samplerate = get_bits_long(gb, 32); vc->audio_samplerate = get_bits_long(gb, 32);
if (vc->audio_samplerate <= 0) { if (vc->audio_samplerate <= 0) {
av_log(vc->avccontext, AV_LOG_ERROR, "Invalid samplerate\n"); av_log(vc->avctx, AV_LOG_ERROR, "Invalid samplerate\n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
vc->bitrate_maximum = get_bits_long(gb, 32); vc->bitrate_maximum = get_bits_long(gb, 32);
@ -944,14 +942,14 @@ static int vorbis_parse_id_hdr(vorbis_context *vc)
vc->blocksize[0] = (1 << bl0); vc->blocksize[0] = (1 << bl0);
vc->blocksize[1] = (1 << bl1); vc->blocksize[1] = (1 << bl1);
if (bl0 > 13 || bl0 < 6 || bl1 > 13 || bl1 < 6 || bl1 < bl0) { if (bl0 > 13 || bl0 < 6 || bl1 > 13 || bl1 < 6 || bl1 < bl0) {
av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis id header packet corrupt (illegal blocksize). \n"); av_log(vc->avctx, AV_LOG_ERROR, " Vorbis id header packet corrupt (illegal blocksize). \n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
vc->win[0] = ff_vorbis_vwin[bl0 - 6]; vc->win[0] = ff_vorbis_vwin[bl0 - 6];
vc->win[1] = ff_vorbis_vwin[bl1 - 6]; vc->win[1] = ff_vorbis_vwin[bl1 - 6];
if ((get_bits1(gb)) == 0) { if ((get_bits1(gb)) == 0) {
av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis id header packet corrupt (framing flag not set). \n"); av_log(vc->avctx, AV_LOG_ERROR, " Vorbis id header packet corrupt (framing flag not set). \n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
@ -977,41 +975,41 @@ static int vorbis_parse_id_hdr(vorbis_context *vc)
// Process the extradata using the functions above (identification header, setup header) // Process the extradata using the functions above (identification header, setup header)
static av_cold int vorbis_decode_init(AVCodecContext *avccontext) static av_cold int vorbis_decode_init(AVCodecContext *avctx)
{ {
vorbis_context *vc = avccontext->priv_data; vorbis_context *vc = avctx->priv_data;
uint8_t *headers = avccontext->extradata; uint8_t *headers = avctx->extradata;
int headers_len = avccontext->extradata_size; int headers_len = avctx->extradata_size;
uint8_t *header_start[3]; uint8_t *header_start[3];
int header_len[3]; int header_len[3];
GetBitContext *gb = &vc->gb; GetBitContext *gb = &vc->gb;
int hdr_type, ret; int hdr_type, ret;
vc->avccontext = avccontext; vc->avctx = avctx;
ff_vorbisdsp_init(&vc->dsp); ff_vorbisdsp_init(&vc->dsp);
avpriv_float_dsp_init(&vc->fdsp, avccontext->flags & CODEC_FLAG_BITEXACT); avpriv_float_dsp_init(&vc->fdsp, avctx->flags & CODEC_FLAG_BITEXACT);
ff_fmt_convert_init(&vc->fmt_conv, avccontext); ff_fmt_convert_init(&vc->fmt_conv, avctx);
avccontext->sample_fmt = AV_SAMPLE_FMT_FLTP; avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
if (!headers_len) { if (!headers_len) {
av_log(avccontext, AV_LOG_ERROR, "Extradata missing.\n"); av_log(avctx, AV_LOG_ERROR, "Extradata missing.\n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
if ((ret = avpriv_split_xiph_headers(headers, headers_len, 30, header_start, header_len)) < 0) { if ((ret = avpriv_split_xiph_headers(headers, headers_len, 30, header_start, header_len)) < 0) {
av_log(avccontext, AV_LOG_ERROR, "Extradata corrupt.\n"); av_log(avctx, AV_LOG_ERROR, "Extradata corrupt.\n");
return ret; return ret;
} }
init_get_bits(gb, header_start[0], header_len[0]*8); init_get_bits(gb, header_start[0], header_len[0]*8);
hdr_type = get_bits(gb, 8); hdr_type = get_bits(gb, 8);
if (hdr_type != 1) { if (hdr_type != 1) {
av_log(avccontext, AV_LOG_ERROR, "First header is not the id header.\n"); av_log(avctx, AV_LOG_ERROR, "First header is not the id header.\n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
if ((ret = vorbis_parse_id_hdr(vc))) { if ((ret = vorbis_parse_id_hdr(vc))) {
av_log(avccontext, AV_LOG_ERROR, "Id header corrupt.\n"); av_log(avctx, AV_LOG_ERROR, "Id header corrupt.\n");
vorbis_free(vc); vorbis_free(vc);
return ret; return ret;
} }
@ -1019,23 +1017,23 @@ static av_cold int vorbis_decode_init(AVCodecContext *avccontext)
init_get_bits(gb, header_start[2], header_len[2]*8); init_get_bits(gb, header_start[2], header_len[2]*8);
hdr_type = get_bits(gb, 8); hdr_type = get_bits(gb, 8);
if (hdr_type != 5) { if (hdr_type != 5) {
av_log(avccontext, AV_LOG_ERROR, "Third header is not the setup header.\n"); av_log(avctx, AV_LOG_ERROR, "Third header is not the setup header.\n");
vorbis_free(vc); vorbis_free(vc);
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
if ((ret = vorbis_parse_setup_hdr(vc))) { if ((ret = vorbis_parse_setup_hdr(vc))) {
av_log(avccontext, AV_LOG_ERROR, "Setup header corrupt.\n"); av_log(avctx, AV_LOG_ERROR, "Setup header corrupt.\n");
vorbis_free(vc); vorbis_free(vc);
return ret; return ret;
} }
if (vc->audio_channels > 8) if (vc->audio_channels > 8)
avccontext->channel_layout = 0; avctx->channel_layout = 0;
else else
avccontext->channel_layout = ff_vorbis_channel_layouts[vc->audio_channels - 1]; avctx->channel_layout = ff_vorbis_channel_layouts[vc->audio_channels - 1];
avccontext->channels = vc->audio_channels; avctx->channels = vc->audio_channels;
avccontext->sample_rate = vc->audio_samplerate; avctx->sample_rate = vc->audio_samplerate;
return 0; return 0;
} }
@ -1063,8 +1061,7 @@ static int vorbis_floor0_decode(vorbis_context *vc,
book_idx = get_bits(&vc->gb, ilog(vf->num_books)); book_idx = get_bits(&vc->gb, ilog(vf->num_books));
if (book_idx >= vf->num_books) { if (book_idx >= vf->num_books) {
av_log(vc->avccontext, AV_LOG_ERROR, av_log(vc->avctx, AV_LOG_ERROR, "floor0 dec: booknumber too high!\n");
"floor0 dec: booknumber too high!\n");
book_idx = 0; book_idx = 0;
} }
av_dlog(NULL, "floor0 dec: booknumber: %u\n", book_idx); av_dlog(NULL, "floor0 dec: booknumber: %u\n", book_idx);
@ -1308,7 +1305,7 @@ static av_always_inline int vorbis_residue_decode_internal(vorbis_context *vc,
} }
if (max_output > ch_left * vlen) { if (max_output > ch_left * vlen) {
av_log(vc->avccontext, AV_LOG_ERROR, "Insufficient output buffer\n"); av_log(vc->avctx, AV_LOG_ERROR, "Insufficient output buffer\n");
return -1; return -1;
} }
@ -1452,7 +1449,7 @@ static inline int vorbis_residue_decode(vorbis_context *vc, vorbis_residue *vr,
else if (vr->type == 0) else if (vr->type == 0)
return vorbis_residue_decode_internal(vc, vr, ch, do_not_decode, vec, vlen, ch_left, 0); return vorbis_residue_decode_internal(vc, vr, ch, do_not_decode, vec, vlen, ch_left, 0);
else { else {
av_log(vc->avccontext, AV_LOG_ERROR, " Invalid residue type while residue decode?! \n"); av_log(vc->avctx, AV_LOG_ERROR, " Invalid residue type while residue decode?! \n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
} }
@ -1501,7 +1498,7 @@ static int vorbis_parse_audio_packet(vorbis_context *vc, float **floor_ptr)
unsigned vlen; unsigned vlen;
if (get_bits1(gb)) { if (get_bits1(gb)) {
av_log(vc->avccontext, AV_LOG_ERROR, "Not a Vorbis I audio packet.\n"); av_log(vc->avctx, AV_LOG_ERROR, "Not a Vorbis I audio packet.\n");
return AVERROR_INVALIDDATA; // packet type not audio return AVERROR_INVALIDDATA; // packet type not audio
} }
@ -1542,7 +1539,7 @@ static int vorbis_parse_audio_packet(vorbis_context *vc, float **floor_ptr)
ret = floor->decode(vc, &floor->data, floor_ptr[i]); ret = floor->decode(vc, &floor->data, floor_ptr[i]);
if (ret < 0) { if (ret < 0) {
av_log(vc->avccontext, AV_LOG_ERROR, "Invalid codebook in vorbis_floor_decode.\n"); av_log(vc->avctx, AV_LOG_ERROR, "Invalid codebook in vorbis_floor_decode.\n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
no_residue[i] = ret; no_residue[i] = ret;
@ -1578,7 +1575,7 @@ static int vorbis_parse_audio_packet(vorbis_context *vc, float **floor_ptr)
} }
residue = &vc->residues[mapping->submap_residue[i]]; residue = &vc->residues[mapping->submap_residue[i]];
if (ch_left < ch) { if (ch_left < ch) {
av_log(vc->avccontext, AV_LOG_ERROR, "Too many channels in vorbis_floor_decode.\n"); av_log(vc->avctx, AV_LOG_ERROR, "Too many channels in vorbis_floor_decode.\n");
return -1; return -1;
} }
if (ch) { if (ch) {
@ -1644,12 +1641,12 @@ static int vorbis_parse_audio_packet(vorbis_context *vc, float **floor_ptr)
// Return the decoded audio packet through the standard api // Return the decoded audio packet through the standard api
static int vorbis_decode_frame(AVCodecContext *avccontext, void *data, static int vorbis_decode_frame(AVCodecContext *avctx, void *data,
int *got_frame_ptr, AVPacket *avpkt) int *got_frame_ptr, AVPacket *avpkt)
{ {
const uint8_t *buf = avpkt->data; const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size; int buf_size = avpkt->size;
vorbis_context *vc = avccontext->priv_data; vorbis_context *vc = avctx->priv_data;
AVFrame *frame = data; AVFrame *frame = data;
GetBitContext *gb = &vc->gb; GetBitContext *gb = &vc->gb;
float *channel_ptrs[255]; float *channel_ptrs[255];
@ -1659,8 +1656,8 @@ static int vorbis_decode_frame(AVCodecContext *avccontext, void *data,
/* get output buffer */ /* get output buffer */
frame->nb_samples = vc->blocksize[1] / 2; frame->nb_samples = vc->blocksize[1] / 2;
if ((ret = ff_get_buffer(avccontext, frame)) < 0) { if ((ret = ff_get_buffer(avctx, frame)) < 0) {
av_log(avccontext, AV_LOG_ERROR, "get_buffer() failed\n"); av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
return ret; return ret;
} }
@ -1696,18 +1693,18 @@ static int vorbis_decode_frame(AVCodecContext *avccontext, void *data,
// Close decoder // Close decoder
static av_cold int vorbis_decode_close(AVCodecContext *avccontext) static av_cold int vorbis_decode_close(AVCodecContext *avctx)
{ {
vorbis_context *vc = avccontext->priv_data; vorbis_context *vc = avctx->priv_data;
vorbis_free(vc); vorbis_free(vc);
return 0; return 0;
} }
static av_cold void vorbis_decode_flush(AVCodecContext *avccontext) static av_cold void vorbis_decode_flush(AVCodecContext *avctx)
{ {
vorbis_context *vc = avccontext->priv_data; vorbis_context *vc = avctx->priv_data;
if (vc->saved) { if (vc->saved) {
memset(vc->saved, 0, (vc->blocksize[1] / 4) * vc->audio_channels * memset(vc->saved, 0, (vc->blocksize[1] / 4) * vc->audio_channels *

Write Preview
Loading…
Cancel
Save