30 #define BITSTREAM_READER_LE 41 #define V_MAX_VLCS (1 << 16) 42 #define V_MAX_PARTITIONS (1 << 20) 56 struct vorbis_context_s;
82 int16_t subclass_books[16][8];
120 typedef struct vorbis_context_s {
134 uint32_t blocksize[2];
155 (13.1f * atan(0.00074f * (x)) + 2.24f * atan(1.85e-8f * (x) * (x)) + 1e-4f * (x)) 157 static const char idx_err_str[] =
"Index value %d out of range (0 - %d) for %s at %s:%i\n";
158 #define VALIDATE_INDEX(idx, limit) \ 160 av_log(vc->avctx, AV_LOG_ERROR,\ 162 (int)(idx), (int)(limit - 1), #idx, __FILE__, __LINE__);\ 163 return AVERROR_INVALIDDATA;\ 165 #define GET_VALIDATED_INDEX(idx, bits, limit) \ 167 idx = get_bits(gb, bits);\ 168 VALIDATE_INDEX(idx, limit)\ 173 double mant = val & 0x1fffff;
174 long exp = (val & 0x7fe00000
L) >> 21;
175 if (val & 0x80000000)
177 return ldexp(mant, exp - 20 - 768);
232 uint32_t *tmp_vlc_codes =
NULL;
234 uint16_t *codebook_multiplicands =
NULL;
246 !tmp_vlc_bits || !tmp_vlc_codes || !codebook_multiplicands) {
253 unsigned ordered, t, entries, used_entries = 0;
259 " %u. Codebook setup data corrupt.\n", cb);
267 " %u. Codebook's dimension is invalid (%d).\n",
275 " %u. Codebook has too many entries (%u).\n",
283 ff_dlog(
NULL,
" codebook_dimensions %d, codebook_entries %u\n",
296 for (ce = 0; ce < entries; ++ce) {
299 tmp_vlc_bits[ce] =
get_bits(gb, 5) + 1;
302 tmp_vlc_bits[ce] = 0;
307 used_entries = entries;
308 for (ce = 0; ce < entries; ++ce)
309 tmp_vlc_bits[ce] =
get_bits(gb, 5) + 1;
312 unsigned current_entry = 0;
313 unsigned current_length =
get_bits(gb, 5) + 1;
315 ff_dlog(
NULL,
" ordered, current length: %u\n", current_length);
317 used_entries = entries;
318 for (; current_entry < used_entries && current_length <= 32; ++current_length) {
327 for (i = current_entry; i < number+current_entry; ++i)
328 if (i < used_entries)
329 tmp_vlc_bits[i] = current_length;
331 current_entry+=number;
333 if (current_entry>used_entries) {
353 unsigned codebook_value_bits =
get_bits(gb, 4) + 1;
354 unsigned codebook_sequence_p =
get_bits1(gb);
356 ff_dlog(
NULL,
" We expect %d numbers for building the codevectors. \n",
357 codebook_lookup_values);
359 codebook_delta_value, codebook_minimum_value);
361 for (i = 0; i < codebook_lookup_values; ++i) {
362 codebook_multiplicands[i] =
get_bits(gb, codebook_value_bits);
364 ff_dlog(
NULL,
" multiplicands*delta+minmum : %e \n",
365 (
float)codebook_multiplicands[i] * codebook_delta_value + codebook_minimum_value);
366 ff_dlog(
NULL,
" multiplicand %u\n", codebook_multiplicands[i]);
379 for (j = 0, i = 0; i < entries; ++i) {
382 if (tmp_vlc_bits[i]) {
384 unsigned lookup_offset = i;
388 for (k = 0; k <
dim; ++k) {
389 unsigned multiplicand_offset = lookup_offset % codebook_lookup_values;
390 codebook_setup->
codevectors[j * dim + k] = codebook_multiplicands[multiplicand_offset] * codebook_delta_value + codebook_minimum_value + last;
391 if (codebook_sequence_p)
393 lookup_offset/=codebook_lookup_values;
395 tmp_vlc_bits[j] = tmp_vlc_bits[i];
397 ff_dlog(vc->
avctx,
"real lookup offset %u, vector: ", j);
398 for (k = 0; k <
dim; ++k)
406 if (j != used_entries) {
411 entries = used_entries;
425 for (t = 0; t < entries; ++t)
426 if (tmp_vlc_bits[t] >= codebook_setup->
maxdepth)
427 codebook_setup->
maxdepth = tmp_vlc_bits[t];
437 entries, tmp_vlc_bits,
sizeof(*tmp_vlc_bits),
438 sizeof(*tmp_vlc_bits), tmp_vlc_codes,
439 sizeof(*tmp_vlc_codes),
sizeof(*tmp_vlc_codes),
448 av_free(codebook_multiplicands);
455 av_free(codebook_multiplicands);
464 unsigned i, vorbis_time_count =
get_bits(gb, 6) + 1;
466 for (i = 0; i < vorbis_time_count; ++i) {
467 unsigned vorbis_tdtransform =
get_bits(gb, 16);
469 ff_dlog(
NULL,
" Vorbis time domain transform %u: %u\n",
470 vorbis_time_count, vorbis_tdtransform);
472 if (vorbis_tdtransform) {
506 int maximum_class = -1;
507 unsigned rangebits, rangemax, floor1_values = 2;
521 ff_dlog(
NULL,
" %d. floor %d partition class %d \n",
526 ff_dlog(
NULL,
" maximum class %d \n", maximum_class);
528 for (j = 0; j <= maximum_class; ++j) {
532 ff_dlog(
NULL,
" %d floor %d class dim: %d subclasses %d \n", i, j,
564 rangemax = (1 << rangebits);
567 "Floor value is too large for blocksize: %u (%"PRIu32
")\n",
578 ff_dlog(
NULL,
" %u. floor1 Y coord. %d\n", floor1_values,
590 unsigned max_codebook_dim = 0;
607 "Floor 0 bark map size is 0.\n");
687 unsigned high_bits, low_bits;
697 if (res_setup->
begin>res_setup->
end ||
701 "partition out of bounds: type, begin, end, size, blocksize: %"PRIu16
", %"PRIu32
", %"PRIu32
", %u, %"PRIu32
"\n",
718 ff_dlog(
NULL,
" begin %d end %d part.size %d classif.s %d classbook %d \n",
727 cascade[j] = (high_bits << 3) + low_bits;
734 for (k = 0; k < 8; ++k) {
735 if (cascade[j]&(1 << k)) {
738 ff_dlog(
NULL,
" %u class cascade depth %u book: %d\n",
739 j, k, res_setup->
books[j][k]);
744 res_setup->
books[j][k] = -1;
770 av_log(vc->
avctx,
AV_LOG_ERROR,
"Other mappings than type 0 are not compliant with the Vorbis I specification. \n");
784 sizeof(*mapping_setup->
angle));
804 if (mapping_setup->
submaps>1) {
806 sizeof(*mapping_setup->
mux));
807 if (!mapping_setup->
mux)
814 for (j = 0; j < mapping_setup->
submaps; ++j) {
819 ff_dlog(
NULL,
" %u mapping %u submap : floor %d, residue %d\n", i, j,
837 for (blockflag = 0; blockflag < 2; ++blockflag) {
839 floors[floor_number].
data.
t0.
map[blockflag] =
841 if (!floors[floor_number].
data.t0.map[blockflag])
844 map = floors[floor_number].
data.
t0.
map[blockflag];
845 vf = &floors[floor_number].
data.
t0;
847 for (idx = 0; idx < n; ++idx) {
848 map[idx] = floor(
BARK((vf->rate * idx) / (2.0f * n)) *
849 (vf->bark_map_size /
BARK(vf->rate / 2.0f)));
850 if (vf->bark_map_size-1 < map[idx])
851 map[idx] = vf->bark_map_size - 1;
854 vf->map_size[blockflag] = n;
857 for (idx = 0; idx <= n; ++idx) {
858 ff_dlog(
NULL,
"floor0 map: map at pos %d is %d\n", idx, map[idx]);
884 ff_dlog(
NULL,
" %u mode: blockflag %d, windowtype %d, transformtype %d, mapping %d\n",
969 if (bl0 > 13 || bl0 < 6 || bl1 > 13 || bl1 < 6 || bl1 < bl0) {
991 ff_dlog(
NULL,
" vorbis version %d \n audio_channels %d \n audio_samplerate %d \n bitrate_max %d \n bitrate_nom %d \n bitrate_min %d \n blk_0 %d blk_1 %d \n ",
1034 if (hdr_type != 1) {
1046 if (hdr_type != 5) {
1076 float *lsp = vf->lsp;
1077 unsigned amplitude, book_idx;
1080 if (!vf->amplitude_bits)
1083 amplitude =
get_bits(&vc->
gb, vf->amplitude_bits);
1084 if (amplitude > 0) {
1086 unsigned idx, lsp_len = 0;
1090 if (book_idx >= vf->num_books) {
1094 ff_dlog(
NULL,
"floor0 dec: booknumber: %u\n", book_idx);
1095 codebook = vc->
codebooks[vf->book_list[book_idx]];
1100 while (lsp_len<vf->order) {
1109 ff_dlog(
NULL,
"floor0 dec: vector offset: %d\n", vec_off);
1111 for (idx = 0; idx < codebook.
dimensions; ++idx)
1112 lsp[lsp_len+idx] = codebook.
codevectors[vec_off+idx] + last;
1113 last = lsp[lsp_len+idx-1];
1120 for (idx = 0; idx < lsp_len; ++idx)
1121 ff_dlog(
NULL,
"floor0 dec: coeff at %d is %f\n", idx, lsp[idx]);
1127 int order = vf->order;
1128 float wstep = M_PI / vf->bark_map_size;
1130 for (i = 0; i < order; i++)
1131 lsp[i] = 2.0f * cos(lsp[i]);
1133 ff_dlog(
NULL,
"floor0 synth: map_size = %"PRIu32
"; m = %d; wstep = %f\n",
1134 vf->map_size[blockflag], order, wstep);
1137 while (i < vf->map_size[blockflag]) {
1138 int j, iter_cond = vf->map[blockflag][i];
1141 float two_cos_w = 2.0f * cos(wstep * iter_cond);
1144 for (j = 0; j + 1 < order; j += 2) {
1145 q *= lsp[j] - two_cos_w;
1146 p *= lsp[j + 1] - two_cos_w;
1149 p *= p * (2.0f - two_cos_w);
1150 q *= q * (2.0f + two_cos_w);
1152 q *= two_cos_w-lsp[j];
1155 p *= p * (4.f - two_cos_w * two_cos_w);
1160 q = exp((((amplitude*vf->amplitude_offset) /
1161 (((1 << vf->amplitude_bits) - 1) * sqrt(p + q)))
1162 - vf->amplitude_offset) * .11512925f);
1167 }
while (vf->map[blockflag][i] == iter_cond);
1185 uint16_t range_v[4] = { 256, 128, 86, 64 };
1186 unsigned range = range_v[vf->multiplier - 1];
1187 uint16_t floor1_Y[258];
1188 uint16_t floor1_Y_final[258];
1189 int floor1_flag[258];
1190 unsigned class, cdim, cbits, csub, cval, offset, i, j;
1191 int book, adx, ady, dy, off, predicted, err;
1202 ff_dlog(
NULL,
"floor 0 Y %d floor 1 Y %d \n", floor1_Y[0], floor1_Y[1]);
1205 for (i = 0; i < vf->partitions; ++i) {
1206 class = vf->partition_class[i];
1207 cdim = vf->class_dimensions[
class];
1208 cbits = vf->class_subclasses[
class];
1209 csub = (1 << cbits) - 1;
1218 for (j = 0; j < cdim; ++j) {
1219 book = vf->subclass_books[
class][cval & csub];
1221 ff_dlog(
NULL,
"book %d Cbits %u cval %u bits:%d\n",
1224 cval = cval >> cbits;
1229 floor1_Y[offset+j] = 0;
1233 vf->list[offset+j].x, floor1_Y[offset+j]);
1242 floor1_Y_final[0] = floor1_Y[0];
1243 floor1_Y_final[1] = floor1_Y[1];
1245 for (i = 2; i < vf->x_list_dim; ++i) {
1246 unsigned val, highroom, lowroom, room, high_neigh_offs, low_neigh_offs;
1248 low_neigh_offs = vf->list[i].low;
1249 high_neigh_offs = vf->list[i].high;
1250 dy = floor1_Y_final[high_neigh_offs] - floor1_Y_final[low_neigh_offs];
1251 adx = vf->list[high_neigh_offs].x - vf->list[low_neigh_offs].x;
1253 err = ady * (vf->list[i].x - vf->list[low_neigh_offs].x);
1256 predicted = floor1_Y_final[low_neigh_offs] - off;
1258 predicted = floor1_Y_final[low_neigh_offs] + off;
1262 highroom = range-predicted;
1263 lowroom = predicted;
1264 if (highroom < lowroom) {
1265 room = highroom * 2;
1270 floor1_flag[low_neigh_offs] = 1;
1271 floor1_flag[high_neigh_offs] = 1;
1274 if (highroom > lowroom) {
1275 floor1_Y_final[i] = av_clip_uint16(val - lowroom + predicted);
1277 floor1_Y_final[i] = av_clip_uint16(predicted - val + highroom - 1);
1281 floor1_Y_final[i] = av_clip_uint16(predicted - (val + 1) / 2);
1283 floor1_Y_final[i] = av_clip_uint16(predicted + val / 2);
1288 floor1_Y_final[i] = av_clip_uint16(predicted);
1291 ff_dlog(
NULL,
" Decoded floor(%d) = %u / val %u\n",
1292 vf->list[i].x, floor1_Y_final[i], val);
1308 int partition_count)
1315 for (p = 0, j = 0; j < ch_used; ++j) {
1316 if (!do_not_decode[j]) {
1324 "Invalid vlc code decoding %d channel.", j);
1328 for (i = partition_count + c_p_c - 1; i >= partition_count; i--) {
1329 temp2 = (((uint64_t)temp) * inverse_class) >> 32;
1331 if (i < vr->ptns_to_read)
1354 unsigned pass, ch_used, i, j, k, l;
1355 unsigned max_output = (ch - 1) * vlen;
1359 for (j = 1; j < ch; ++j)
1360 do_not_decode[0] &= do_not_decode[j];
1361 if (do_not_decode[0])
1364 max_output += vr->
end / ch;
1367 max_output += vr->
end;
1370 if (max_output > ch_left * vlen) {
1375 ff_dlog(
NULL,
" residue type 0/1/2 decode begin, ch: %d cpc %d \n", ch, c_p_c);
1378 int voffset, partition_count, j_times_ptns_to_read;
1380 voffset = vr->
begin;
1381 for (partition_count = 0; partition_count < ptns_to_read;) {
1383 int ret =
setup_classifs(vc, vr, do_not_decode, ch_used, partition_count);
1387 for (i = 0; (i < c_p_c) && (partition_count < ptns_to_read); ++i) {
1388 for (j_times_ptns_to_read = 0, j = 0; j < ch_used; ++j) {
1391 if (!do_not_decode[j]) {
1392 unsigned vqclass = classifs[j_times_ptns_to_read + partition_count];
1403 voffs = voffset+j*vlen;
1404 for (k = 0; k <
step; ++k) {
1406 for (l = 0; l <
dim; ++l)
1407 vec[voffs + k + l * step] += codebook.
codevectors[coffs + l];
1409 }
else if (vr_type == 1) {
1410 voffs = voffset + j * vlen;
1411 for (k = 0; k <
step; ++k) {
1413 for (l = 0; l <
dim; ++l, ++voffs) {
1416 ff_dlog(
NULL,
" pass %d offs: %d curr: %f change: %f cv offs.: %d \n",
1417 pass, voffs, vec[voffs], codebook.
codevectors[coffs+l], coffs);
1420 }
else if (vr_type == 2 && ch == 2 && (voffset & 1) == 0 && (dim & 1) == 0) {
1421 voffs = voffset >> 1;
1424 for (k = 0; k <
step; ++k) {
1427 vec[voffs + k + vlen] += codebook.
codevectors[coffs + 1];
1429 }
else if (dim == 4) {
1430 for (k = 0; k <
step; ++k, voffs += 2) {
1433 vec[voffs + 1 ] += codebook.
codevectors[coffs + 2];
1434 vec[voffs + vlen ] += codebook.
codevectors[coffs + 1];
1435 vec[voffs + vlen + 1] += codebook.
codevectors[coffs + 3];
1438 for (k = 0; k <
step; ++k) {
1440 for (l = 0; l <
dim; l += 2, voffs++) {
1442 vec[voffs + vlen] += codebook.
codevectors[coffs + l + 1];
1444 ff_dlog(
NULL,
" pass %d offs: %d curr: %f change: %f cv offs.: %d+%d \n",
1445 pass, voffset / ch + (voffs % ch) * vlen,
1446 vec[voffset / ch + (voffs % ch) * vlen],
1451 }
else if (vr_type == 2) {
1452 unsigned voffs_div =
FASTDIV(voffset << 1, ch <<1);
1453 unsigned voffs_mod = voffset - voffs_div * ch;
1455 for (k = 0; k <
step; ++k) {
1457 for (l = 0; l <
dim; ++l) {
1458 vec[voffs_div + voffs_mod * vlen] +=
1461 ff_dlog(
NULL,
" pass %d offs: %d curr: %f change: %f cv offs.: %d+%d \n",
1462 pass, voffs_div + voffs_mod * vlen,
1463 vec[voffs_div + voffs_mod * vlen],
1466 if (++voffs_mod == ch) {
1475 j_times_ptns_to_read += ptns_to_read;
1488 float *vec,
unsigned vlen,
1493 else if (vr->
type == 1)
1495 else if (vr->
type == 0)
1506 for (i = 0; i < blocksize; i++) {
1509 ang[i] = mag[i] - ang[i];
1511 float temp = ang[i];
1519 float temp = ang[i];
1534 unsigned mode_number, blockflag, blocksize;
1541 unsigned res_num = 0;
1559 ff_dlog(
NULL,
" Mode number: %u , mapping: %d , blocktype %d\n", mode_number,
1564 vlen = blocksize / 2;
1570 memset(ch_res_ptr, 0,
sizeof(
float) * vc->
audio_channels * vlen);
1572 memset(floor_ptr[i], 0, vlen *
sizeof(floor_ptr[0][0]));
1585 ret = floor->
decode(vc, &floor->
data, floor_ptr[i]);
1591 no_residue[i] = ret;
1597 if (!(no_residue[mapping->
magnitude[i]] & no_residue[mapping->
angle[i]])) {
1599 no_residue[mapping->
angle[i]] = 0;
1605 for (i = 0; i < mapping->
submaps; ++i) {
1611 if ((mapping->
submaps == 1) || (i == mapping->
mux[j])) {
1612 res_chan[j] = res_num;
1613 if (no_residue[j]) {
1614 do_not_decode[ch] = 1;
1616 do_not_decode[ch] = 0;
1633 ch_res_ptr += ch * vlen;
1652 mdct = &vc->
mdct[blockflag];
1656 vc->
fdsp.
vector_fmul(floor_ptr[j], floor_ptr[j], ch_res_ptr, blocksize / 2);
1657 mdct->
imdct_half(mdct, ch_res_ptr, floor_ptr[j]);
1662 retlen = (blocksize + vc->
blocksize[previous_window]) / 4;
1667 float *saved = vc->
saved + j * bs1 / 4;
1668 float *ret = floor_ptr[j];
1669 float *buf = residue;
1670 const float *win = vc->
win[blockflag & previous_window];
1672 if (blockflag == previous_window) {
1674 }
else if (blockflag > previous_window) {
1676 memcpy(ret+bs0/2, buf+bs0/4, ((bs1-bs0)/4) *
sizeof(
float));
1678 memcpy(ret, saved, ((bs1 - bs0) / 4) *
sizeof(
float));
1681 memcpy(saved, buf + blocksize / 4, blocksize / 4 *
sizeof(
float));
1691 int *got_frame_ptr,
AVPacket *avpkt)
1694 int buf_size = avpkt->
size;
1698 float *channel_ptrs[255];
1732 ff_dlog(
NULL,
"parsed %d bytes %d bits, returned %d samples (*ch*bits) \n",
1758 sizeof(*vc->
saved));
vorbis_codebook * codebooks
void * av_malloc(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
struct vorbis_floor1_s vorbis_floor1
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
unsigned int ff_vorbis_nth_root(unsigned int x, unsigned int n)
static int vorbis_parse_setup_hdr_floors(vorbis_context *vc)
This structure describes decoded (raw) audio or video data.
void ff_vorbis_inverse_coupling(float *mag, float *ang, intptr_t blocksize)
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
int(* vorbis_floor_decode_func)(struct vorbis_context_s *, vorbis_floor_data *, float *)
static av_cold int vorbis_decode_close(AVCodecContext *avctx)
av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (%s)\, len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt), use_generic ? ac->func_descr_generic :ac->func_descr)
static const char idx_err_str[]
uint8_t class_subclasses[16]
#define init_vlc(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)
static av_always_inline int vorbis_residue_decode_internal(vorbis_context *vc, vorbis_residue *vr, unsigned ch, uint8_t *do_not_decode, float *vec, unsigned vlen, unsigned ch_left, int vr_type)
uint32_t audio_samplerate
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
const uint32_t ff_inverse[257]
enum AVSampleFormat sample_fmt
audio sample format
static int vorbis_floor0_decode(vorbis_context *vc, vorbis_floor_data *vfu, float *vec)
void(* vector_fmul)(float *dst, const float *src0, const float *src1, int len)
Calculate the product of two vectors of floats and store the result in a vector of floats...
#define VALIDATE_INDEX(idx, limit)
vorbis_residue * residues
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
void(* vorbis_inverse_coupling)(float *mag, float *ang, intptr_t blocksize)
static int get_bits_count(const GetBitContext *s)
bitstream reader API header.
int16_t subclass_books[16][8]
void(* vector_fmul_window)(float *dst, const float *src0, const float *src1, const float *win, int len)
Overlap/add with window function.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
void av_free(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc(). ...
static int create_map(vorbis_context *vc, unsigned floor_number)
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
av_cold void ff_vorbisdsp_init(VorbisDSPContext *dsp)
static int vorbis_floor1_decode(vorbis_context *vc, vorbis_floor_data *vfu, float *vec)
int flags
AV_CODEC_FLAG_*.
const char * name
Name of the codec implementation.
AVCodec ff_vorbis_decoder
uint64_t channel_layout
Audio channel layout.
union vorbis_floor_u vorbis_floor_data
static int vorbis_parse_id_hdr(vorbis_context *vc)
#define GET_VALIDATED_INDEX(idx, bits, limit)
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
union vorbis_floor::vorbis_floor_u data
static int decode(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *pkt)
static void vorbis_free(vorbis_context *vc)
int ff_vorbis_len2vlc(uint8_t *bits, uint32_t *codes, unsigned num)
struct vorbis_floor0_s vorbis_floor0
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
if(ac->has_optimized_func)
uint8_t submap_residue[16]
static int vorbis_parse_setup_hdr_residues(vorbis_context *vc)
static int vorbis_parse_setup_hdr_mappings(vorbis_context *vc)
Libavcodec external API header.
AVSampleFormat
Audio Sample Formats.
static int vorbis_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
int sample_rate
samples per second
main external API structure.
const uint64_t ff_vorbis_channel_layouts[9]
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
static unsigned int get_bits1(GetBitContext *s)
vorbis_mapping * mappings
static void skip_bits1(GetBitContext *s)
static void skip_bits(GetBitContext *s, int n)
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
static int vorbis_parse_setup_hdr(vorbis_context *vc)
int avpriv_split_xiph_headers(uint8_t *extradata, int extradata_size, int first_header_size, uint8_t *header_start[3], int header_len[3])
Split a single extradata buffer into the three headers that most Xiph codecs use. ...
const VDPAUPixFmtMap * map
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
void(* imdct_half)(struct FFTContext *s, FFTSample *output, const FFTSample *input)
const float *const ff_vorbis_vwin[8]
vorbis_floor1_entry * list
uint8_t class_dimensions[16]
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
av_cold void avpriv_float_dsp_init(AVFloatDSPContext *fdsp, int bit_exact)
Initialize a float DSP context.
static float vorbisfloat2float(unsigned val)
static av_cold int vorbis_decode_init(AVCodecContext *avctx)
uint8_t class_masterbook[16]
common internal api header.
struct vorbis_floor::vorbis_floor_u::vorbis_floor1_s t1
uint8_t partition_class[32]
static av_cold void flush(AVCodecContext *avctx)
Flush (reset) the frame ID after seeking.
static int vorbis_residue_decode(vorbis_context *vc, vorbis_residue *vr, unsigned ch, uint8_t *do_not_decode, float *vec, unsigned vlen, unsigned ch_left)
static av_always_inline int setup_classifs(vorbis_context *vc, vorbis_residue *vr, uint8_t *do_not_decode, unsigned ch_used, int partition_count)
static av_cold int init(AVCodecParserContext *s)
vorbis_floor_decode_func decode
static int vorbis_parse_setup_hdr_tdtransforms(vorbis_context *vc)
static int vorbis_parse_setup_hdr_modes(vorbis_context *vc)
int channels
number of audio channels
VLC_TYPE(* table)[2]
code, bits
void ff_vorbis_floor1_render_list(vorbis_floor1_entry *list, int values, uint16_t *y_list, int *flag, int multiplier, float *out, int samples)
static enum AVSampleFormat sample_fmts[]
struct vorbis_floor::vorbis_floor_u::vorbis_floor0_s t0
const uint8_t ff_vorbis_channel_layout_offsets[8][8]
uint8_t ** extended_data
pointers to the data planes/channels.
static av_cold void vorbis_decode_flush(AVCodecContext *avctx)
This structure stores compressed data.
static int vorbis_parse_setup_hdr_codebooks(vorbis_context *vc)
void ff_free_vlc(VLC *vlc)
static int vorbis_parse_audio_packet(vorbis_context *vc, float **floor_ptr)
int nb_samples
number of audio samples (per channel) described by this frame
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
int ff_vorbis_ready_floor1_list(AVCodecContext *avctx, vorbis_floor1_entry *list, int values)