#include <stddef.h>
#include <stdio.h>
-#define BITSTREAM_READER_LE
#include "libavutil/channel_layout.h"
+
+#define BITSTREAM_READER_LE
#include "avcodec.h"
-#include "get_bits.h"
+#include "bitstream.h"
#include "internal.h"
-#include "rdft.h"
-#include "mpegaudiodsp.h"
#include "mpegaudio.h"
+#include "mpegaudiodsp.h"
+#include "rdft.h"
#include "qdm2data.h"
#include "qdm2_tablegen.h"
-#undef NDEBUG
-#include <assert.h>
-
#define QDM2_LIST_ADD(list, size, packet) \
do { \
/**
* Subpacket
*/
-typedef struct {
+typedef struct QDM2SubPacket {
int type; ///< subpacket type
unsigned int size; ///< subpacket size
const uint8_t *data; ///< pointer to subpacket data (points to input data buffer, it's not a private copy)
struct QDM2SubPNode *next; ///< pointer to next packet in the list, NULL if leaf node
} QDM2SubPNode;
-typedef struct {
+typedef struct QDM2Complex {
float re;
float im;
} QDM2Complex;
-typedef struct {
+typedef struct FFTTone {
float level;
QDM2Complex *complex;
const float *table;
short cutoff;
} FFTTone;
-typedef struct {
+typedef struct FFTCoefficient {
int16_t sub_packet;
uint8_t channel;
int16_t offset;
uint8_t phase;
} FFTCoefficient;
-typedef struct {
+typedef struct QDM2FFT {
DECLARE_ALIGNED(32, QDM2Complex, complex)[MPA_MAX_CHANNELS][256];
} QDM2FFT;
/**
* QDM2 decoder context
*/
-typedef struct {
+typedef struct QDM2Context {
/// Parameters from codec header, do not change during playback
int nb_channels; ///< number of channels
int channels; ///< number of channels
INIT_VLC_USE_NEW_STATIC | INIT_VLC_LE);
}
-static int qdm2_get_vlc(GetBitContext *gb, VLC *vlc, int flag, int depth)
+static int qdm2_get_vlc(BitstreamContext *bc, VLC *vlc, int flag, int depth)
{
int value;
- value = get_vlc2(gb, vlc->table, vlc->bits, depth);
+ value = bitstream_read_vlc(bc, vlc->table, vlc->bits, depth);
/* stage-2, 3 bits exponent escape sequence */
if (value-- == 0)
- value = get_bits(gb, get_bits(gb, 3) + 1);
+ value = bitstream_read(bc, bitstream_read(bc, 3) + 1);
/* stage-3, optional */
if (flag) {
int tmp = vlc_stage3_values[value];
if ((value & ~3) > 0)
- tmp += get_bits(gb, (value >> 2));
+ tmp += bitstream_read(bc, value >> 2);
value = tmp;
}
return value;
}
-static int qdm2_get_se_vlc(VLC *vlc, GetBitContext *gb, int depth)
+static int qdm2_get_se_vlc(VLC *vlc, BitstreamContext *bc, int depth)
{
- int value = qdm2_get_vlc(gb, vlc, 0, depth);
+ int value = qdm2_get_vlc(bc, vlc, 0, depth);
return (value & 1) ? ((value + 1) >> 1) : -(value >> 1);
}
/**
* QDM2 checksum
*
- * @param data pointer to data to be checksum'ed
+ * @param data pointer to data to be checksummed
* @param length data length
* @param value checksum value
*
/**
* Fill a QDM2SubPacket structure with packet type, size, and data pointer.
*
- * @param gb bitreader context
+ * @param bc bitreader context
* @param sub_packet packet under analysis
*/
-static void qdm2_decode_sub_packet_header(GetBitContext *gb,
+static void qdm2_decode_sub_packet_header(BitstreamContext *bc,
QDM2SubPacket *sub_packet)
{
- sub_packet->type = get_bits(gb, 8);
+ sub_packet->type = bitstream_read(bc, 8);
if (sub_packet->type == 0) {
sub_packet->size = 0;
sub_packet->data = NULL;
} else {
- sub_packet->size = get_bits(gb, 8);
+ sub_packet->size = bitstream_read(bc, 8);
if (sub_packet->type & 0x80) {
sub_packet->size <<= 8;
- sub_packet->size |= get_bits(gb, 8);
+ sub_packet->size |= bitstream_read(bc, 8);
sub_packet->type &= 0x7f;
}
if (sub_packet->type == 0x7f)
- sub_packet->type |= (get_bits(gb, 8) << 8);
+ sub_packet->type |= bitstream_read(bc, 8) << 8;
// FIXME: this depends on bitreader-internal data
- sub_packet->data = &gb->buffer[get_bits_count(gb) / 8];
+ sub_packet->data = &bc->buffer[bitstream_tell(bc) / 8];
}
av_log(NULL, AV_LOG_DEBUG, "Subpacket: type=%d size=%d start_offs=%x\n",
- sub_packet->type, sub_packet->size, get_bits_count(gb) / 8);
+ sub_packet->type, sub_packet->size, bitstream_tell(bc) / 8);
}
/**
static QDM2SubPNode *qdm2_search_subpacket_type_in_list(QDM2SubPNode *list,
int type)
{
- while (list != NULL && list->packet != NULL) {
+ while (list && list->packet) {
if (list->packet->type == type)
return list;
list = list->next;
* @param channels number of channels
* @param coding_method q->coding_method[0][0][0]
*/
-static void fix_coding_method_array(int sb, int channels,
- sb_int8_array coding_method)
+static int fix_coding_method_array(int sb, int channels,
+ sb_int8_array coding_method)
{
int j, k;
int ch;
for (ch = 0; ch < channels; ch++) {
for (j = 0; j < 64; ) {
+ if (coding_method[ch][sb][j] < 8)
+ return -1;
if ((coding_method[ch][sb][j] - 8) > 22) {
run = 1;
case_val = 8;
j += run;
}
}
+ return 0;
}
/**
}
tone_level_idx_temp[ch][sb][0] = tone_level_idx_temp[ch][sb][1];
}
- acc = 0;
- for (ch = 0; ch < nb_channels; ch++)
- for (sb = 0; sb < 30; sb++)
- for (j = 0; j < 64; j++)
- acc += tone_level_idx_temp[ch][sb][j];
-
- multres = 0x66666667 * (acc * 10);
- esp_40 = (multres >> 32) / 8 + ((multres & 0xffffffff) >> 31);
- for (ch = 0; ch < nb_channels; ch++)
- for (sb = 0; sb < 30; sb++)
- for (j = 0; j < 64; j++) {
- comp = tone_level_idx_temp[ch][sb][j]* esp_40 * 10;
- if (comp < 0)
- comp += 0xff;
- comp /= 256; // signed shift
- switch(sb) {
- case 0:
- if (comp < 30)
- comp = 30;
- comp += 15;
- break;
- case 1:
- if (comp < 24)
- comp = 24;
- comp += 10;
- break;
- case 2:
- case 3:
- case 4:
- if (comp < 16)
- comp = 16;
- }
- if (comp <= 5)
- tmp = 0;
- else if (comp <= 10)
- tmp = 10;
- else if (comp <= 16)
- tmp = 16;
- else if (comp <= 24)
- tmp = -1;
- else
- tmp = 0;
- coding_method[ch][sb][j] = ((tmp & 0xfffa) + 30 )& 0xff;
+
+ acc = 0;
+ for (ch = 0; ch < nb_channels; ch++)
+ for (sb = 0; sb < 30; sb++)
+ for (j = 0; j < 64; j++)
+ acc += tone_level_idx_temp[ch][sb][j];
+
+ multres = 0x66666667LL * (acc * 10);
+ esp_40 = (multres >> 32) / 8 + ((multres & 0xffffffff) >> 31);
+ for (ch = 0; ch < nb_channels; ch++)
+ for (sb = 0; sb < 30; sb++)
+ for (j = 0; j < 64; j++) {
+ comp = tone_level_idx_temp[ch][sb][j]* esp_40 * 10;
+ if (comp < 0)
+ comp += 0xff;
+ comp /= 256; // signed shift
+ switch(sb) {
+ case 0:
+ if (comp < 30)
+ comp = 30;
+ comp += 15;
+ break;
+ case 1:
+ if (comp < 24)
+ comp = 24;
+ comp += 10;
+ break;
+ case 2:
+ case 3:
+ case 4:
+ if (comp < 16)
+ comp = 16;
}
+ if (comp <= 5)
+ tmp = 0;
+ else if (comp <= 10)
+ tmp = 10;
+ else if (comp <= 16)
+ tmp = 16;
+ else if (comp <= 24)
+ tmp = -1;
+ else
+ tmp = 0;
+ coding_method[ch][sb][j] = ((tmp & 0xfffa) + 30 )& 0xff;
+ }
+ for (sb = 0; sb < 30; sb++)
+ fix_coding_method_array(sb, nb_channels, coding_method);
+ for (ch = 0; ch < nb_channels; ch++)
for (sb = 0; sb < 30; sb++)
- fix_coding_method_array(sb, nb_channels, coding_method);
- for (ch = 0; ch < nb_channels; ch++)
- for (sb = 0; sb < 30; sb++)
- for (j = 0; j < 64; j++)
- if (sb >= 10) {
- if (coding_method[ch][sb][j] < 10)
- coding_method[ch][sb][j] = 10;
+ for (j = 0; j < 64; j++)
+ if (sb >= 10) {
+ if (coding_method[ch][sb][j] < 10)
+ coding_method[ch][sb][j] = 10;
+ } else {
+ if (sb >= 2) {
+ if (coding_method[ch][sb][j] < 16)
+ coding_method[ch][sb][j] = 16;
} else {
- if (sb >= 2) {
- if (coding_method[ch][sb][j] < 16)
- coding_method[ch][sb][j] = 16;
- } else {
- if (coding_method[ch][sb][j] < 30)
- coding_method[ch][sb][j] = 30;
- }
+ if (coding_method[ch][sb][j] < 30)
+ coding_method[ch][sb][j] = 30;
}
+ }
} else { // superblocktype_2_3 != 0
for (ch = 0; ch < nb_channels; ch++)
for (sb = 0; sb < 30; sb++)
}
/**
- *
* Called by process_subpacket_11 to process more data from subpacket 11
* with sb 0-8.
* Called by process_subpacket_12 to process data from subpacket 12 with
* sb 8-sb_used.
*
* @param q context
- * @param gb bitreader context
+ * @param bc bitreader context
* @param length packet length in bits
* @param sb_min lower subband processed (sb_min included)
* @param sb_max higher subband processed (sb_max excluded)
*/
-static void synthfilt_build_sb_samples(QDM2Context *q, GetBitContext *gb,
+static void synthfilt_build_sb_samples(QDM2Context *q, BitstreamContext *bc,
int length, int sb_min, int sb_max)
{
int sb, j, k, n, ch, run, channels;
- int joined_stereo, zero_encoding, chs;
+ int joined_stereo, zero_encoding;
int type34_first;
float type34_div = 0;
float type34_predictor;
if (length == 0) {
// If no data use noise
for (sb=sb_min; sb < sb_max; sb++)
- build_sb_samples_from_noise (q, sb);
+ build_sb_samples_from_noise(q, sb);
return;
}
else if (sb >= 24)
joined_stereo = 1;
else
- joined_stereo = (get_bits_left(gb) >= 1) ? get_bits1 (gb) : 0;
+ joined_stereo = (bitstream_bits_left(bc) >= 1) ? bitstream_read_bit(bc) : 0;
if (joined_stereo) {
- if (get_bits_left(gb) >= 16)
+ if (bitstream_bits_left(bc) >= 16)
for (j = 0; j < 16; j++)
- sign_bits[j] = get_bits1 (gb);
+ sign_bits[j] = bitstream_read_bit(bc);
for (j = 0; j < 64; j++)
if (q->coding_method[1][sb][j] > q->coding_method[0][sb][j])
q->coding_method[0][sb][j] = q->coding_method[1][sb][j];
- fix_coding_method_array(sb, q->nb_channels, q->coding_method);
+ if (fix_coding_method_array(sb, q->nb_channels,
+ q->coding_method)) {
+ build_sb_samples_from_noise(q, sb);
+ continue;
+ }
channels = 1;
}
for (ch = 0; ch < channels; ch++) {
FIX_NOISE_IDX(q->noise_idx);
- zero_encoding = (get_bits_left(gb) >= 1) ? get_bits1(gb) : 0;
+ zero_encoding = (bitstream_bits_left(bc) >= 1) ? bitstream_read_bit(bc) : 0;
type34_predictor = 0.0;
type34_first = 1;
for (j = 0; j < 128; ) {
switch (q->coding_method[ch][sb][j / 2]) {
case 8:
- if (get_bits_left(gb) >= 10) {
+ if (bitstream_bits_left(bc) >= 10) {
if (zero_encoding) {
for (k = 0; k < 5; k++) {
if ((j + 2 * k) >= 128)
break;
- samples[2 * k] = get_bits1(gb) ? dequant_1bit[joined_stereo][2 * get_bits1(gb)] : 0;
+ samples[2 * k] = bitstream_read_bit(bc) ? dequant_1bit[joined_stereo][2 * bitstream_read_bit(bc)] : 0;
}
} else {
- n = get_bits(gb, 8);
+ n = bitstream_read(bc, 8);
for (k = 0; k < 5; k++)
samples[2 * k] = dequant_1bit[joined_stereo][random_dequant_index[n][k]];
}
break;
case 10:
- if (get_bits_left(gb) >= 1) {
+ if (bitstream_bits_left(bc) >= 1) {
float f = 0.81;
- if (get_bits1(gb))
+ if (bitstream_read_bit(bc))
f = -f;
f -= noise_samples[((sb + 1) * (j +5 * ch + 1)) & 127] * 9.0 / 40.0;
samples[0] = f;
break;
case 16:
- if (get_bits_left(gb) >= 10) {
+ if (bitstream_bits_left(bc) >= 10) {
if (zero_encoding) {
for (k = 0; k < 5; k++) {
if ((j + k) >= 128)
break;
- samples[k] = (get_bits1(gb) == 0) ? 0 : dequant_1bit[joined_stereo][2 * get_bits1(gb)];
+ samples[k] = (bitstream_read_bit(bc) == 0) ? 0 : dequant_1bit[joined_stereo][2 * bitstream_read_bit(bc)];
}
} else {
- n = get_bits (gb, 8);
+ n = bitstream_read (bc, 8);
for (k = 0; k < 5; k++)
samples[k] = dequant_1bit[joined_stereo][random_dequant_index[n][k]];
}
break;
case 24:
- if (get_bits_left(gb) >= 7) {
- n = get_bits(gb, 7);
+ if (bitstream_bits_left(bc) >= 7) {
+ n = bitstream_read(bc, 7);
for (k = 0; k < 3; k++)
samples[k] = (random_dequant_type24[n][k] - 2.0) * 0.5;
} else {
break;
case 30:
- if (get_bits_left(gb) >= 4) {
- unsigned index = qdm2_get_vlc(gb, &vlc_tab_type30, 0, 1);
+ if (bitstream_bits_left(bc) >= 4) {
+ unsigned index = qdm2_get_vlc(bc, &vlc_tab_type30, 0, 1);
if (index < FF_ARRAY_ELEMS(type30_dequant)) {
samples[0] = type30_dequant[index];
} else
break;
case 34:
- if (get_bits_left(gb) >= 7) {
+ if (bitstream_bits_left(bc) >= 7) {
if (type34_first) {
- type34_div = (float)(1 << get_bits(gb, 2));
- samples[0] = ((float)get_bits(gb, 5) - 16.0) / 15.0;
+ type34_div = (float)(1 << bitstream_read(bc, 2));
+ samples[0] = ((float)bitstream_read(bc, 5) - 16.0) / 15.0;
type34_predictor = samples[0];
type34_first = 0;
} else {
- unsigned index = qdm2_get_vlc(gb, &vlc_tab_type34, 0, 1);
+ unsigned index = qdm2_get_vlc(bc, &vlc_tab_type34, 0, 1);
if (index < FF_ARRAY_ELEMS(type34_delta)) {
samples[0] = type34_delta[index] / type34_div + type34_predictor;
type34_predictor = samples[0];
}
if (joined_stereo) {
- float tmp[10][MPA_MAX_CHANNELS];
-
- for (k = 0; k < run; k++) {
- tmp[k][0] = samples[k];
- tmp[k][1] = (sign_bits[(j + k) / 8]) ? -samples[k] : samples[k];
+ for (k = 0; k < run && j + k < 128; k++) {
+ q->sb_samples[0][j + k][sb] =
+ q->tone_level[0][sb][(j + k) / 2] * samples[k];
+ if (q->nb_channels == 2) {
+ if (sign_bits[(j + k) / 8])
+ q->sb_samples[1][j + k][sb] =
+ q->tone_level[1][sb][(j + k) / 2] * -samples[k];
+ else
+ q->sb_samples[1][j + k][sb] =
+ q->tone_level[1][sb][(j + k) / 2] * samples[k];
+ }
}
- for (chs = 0; chs < q->nb_channels; chs++)
- for (k = 0; k < run; k++)
- if ((j + k) < 128)
- q->sb_samples[chs][j + k][sb] = q->tone_level[chs][sb][((j + k)/2)] * tmp[k][chs];
} else {
for (k = 0; k < run; k++)
if ((j + k) < 128)
* same VLC tables as process_subpacket_9 are used.
*
* @param quantized_coeffs pointer to quantized_coeffs[ch][0]
- * @param gb bitreader context
+ * @param bc bitreader context
*/
static void init_quantized_coeffs_elem0(int8_t *quantized_coeffs,
- GetBitContext *gb)
+ BitstreamContext *bc)
{
int i, k, run, level, diff;
- if (get_bits_left(gb) < 16)
+ if (bitstream_bits_left(bc) < 16)
return;
- level = qdm2_get_vlc(gb, &vlc_tab_level, 0, 2);
+ level = qdm2_get_vlc(bc, &vlc_tab_level, 0, 2);
quantized_coeffs[0] = level;
for (i = 0; i < 7; ) {
- if (get_bits_left(gb) < 16)
+ if (bitstream_bits_left(bc) < 16)
break;
- run = qdm2_get_vlc(gb, &vlc_tab_run, 0, 1) + 1;
+ run = qdm2_get_vlc(bc, &vlc_tab_run, 0, 1) + 1;
- if (get_bits_left(gb) < 16)
+ if (bitstream_bits_left(bc) < 16)
break;
- diff = qdm2_get_se_vlc(&vlc_tab_diff, gb, 2);
+ diff = qdm2_get_se_vlc(&vlc_tab_diff, bc, 2);
for (k = 1; k <= run; k++)
quantized_coeffs[i + k] = (level + ((k * diff) / run));
* data from packet 10
*
* @param q context
- * @param gb bitreader context
+ * @param bc bitreader context
*/
-static void init_tone_level_dequantization (QDM2Context *q, GetBitContext *gb)
+static void init_tone_level_dequantization(QDM2Context *q, BitstreamContext *bc)
{
int sb, j, k, n, ch;
for (ch = 0; ch < q->nb_channels; ch++) {
- init_quantized_coeffs_elem0(q->quantized_coeffs[ch][0], gb);
+ init_quantized_coeffs_elem0(q->quantized_coeffs[ch][0], bc);
- if (get_bits_left(gb) < 16) {
+ if (bitstream_bits_left(bc) < 16) {
memset(q->quantized_coeffs[ch][0], 0, 8);
break;
}
for (sb = 0; sb < n; sb++)
for (ch = 0; ch < q->nb_channels; ch++)
for (j = 0; j < 8; j++) {
- if (get_bits_left(gb) < 1)
+ if (bitstream_bits_left(bc) < 1)
break;
- if (get_bits1(gb)) {
+ if (bitstream_read_bit(bc)) {
for (k=0; k < 8; k++) {
- if (get_bits_left(gb) < 16)
+ if (bitstream_bits_left(bc) < 16)
break;
- q->tone_level_idx_hi1[ch][sb][j][k] = qdm2_get_vlc(gb, &vlc_tab_tone_level_idx_hi1, 0, 2);
+ q->tone_level_idx_hi1[ch][sb][j][k] = qdm2_get_vlc(bc, &vlc_tab_tone_level_idx_hi1, 0, 2);
}
} else {
for (k=0; k < 8; k++)
for (sb = 0; sb < n; sb++)
for (ch = 0; ch < q->nb_channels; ch++) {
- if (get_bits_left(gb) < 16)
+ if (bitstream_bits_left(bc) < 16)
break;
- q->tone_level_idx_hi2[ch][sb] = qdm2_get_vlc(gb, &vlc_tab_tone_level_idx_hi2, 0, 2);
+ q->tone_level_idx_hi2[ch][sb] = qdm2_get_vlc(bc, &vlc_tab_tone_level_idx_hi2, 0, 2);
if (sb > 19)
q->tone_level_idx_hi2[ch][sb] -= 16;
else
for (sb = 0; sb < n; sb++)
for (ch = 0; ch < q->nb_channels; ch++)
for (j = 0; j < 8; j++) {
- if (get_bits_left(gb) < 16)
+ if (bitstream_bits_left(bc) < 16)
break;
- q->tone_level_idx_mid[ch][sb][j] = qdm2_get_vlc(gb, &vlc_tab_tone_level_idx_mid, 0, 2) - 32;
+ q->tone_level_idx_mid[ch][sb][j] = qdm2_get_vlc(bc, &vlc_tab_tone_level_idx_mid, 0, 2) - 32;
}
}
*/
static void process_subpacket_9(QDM2Context *q, QDM2SubPNode *node)
{
- GetBitContext gb;
+ BitstreamContext bc;
int i, j, k, n, ch, run, level, diff;
- init_get_bits(&gb, node->packet->data, node->packet->size * 8);
+ bitstream_init(&bc, node->packet->data, node->packet->size * 8);
n = coeff_per_sb_for_avg[q->coeff_per_sb_select][QDM2_SB_USED(q->sub_sampling) - 1] + 1;
for (i = 1; i < n; i++)
for (ch = 0; ch < q->nb_channels; ch++) {
- level = qdm2_get_vlc(&gb, &vlc_tab_level, 0, 2);
+ level = qdm2_get_vlc(&bc, &vlc_tab_level, 0, 2);
q->quantized_coeffs[ch][i][0] = level;
for (j = 0; j < (8 - 1); ) {
- run = qdm2_get_vlc(&gb, &vlc_tab_run, 0, 1) + 1;
- diff = qdm2_get_se_vlc(&vlc_tab_diff, &gb, 2);
+ run = qdm2_get_vlc(&bc, &vlc_tab_run, 0, 1) + 1;
+ diff = qdm2_get_se_vlc(&vlc_tab_diff, &bc, 2);
for (k = 1; k <= run; k++)
q->quantized_coeffs[ch][i][j + k] = (level + ((k * diff) / run));
*/
static void process_subpacket_10(QDM2Context *q, QDM2SubPNode *node)
{
- GetBitContext gb;
+ BitstreamContext bc;
if (node) {
- init_get_bits(&gb, node->packet->data, node->packet->size * 8);
- init_tone_level_dequantization(q, &gb);
+ bitstream_init(&bc, node->packet->data, node->packet->size * 8);
+ init_tone_level_dequantization(q, &bc);
fill_tone_level_array(q, 1);
} else {
fill_tone_level_array(q, 0);
*/
static void process_subpacket_11(QDM2Context *q, QDM2SubPNode *node)
{
- GetBitContext gb;
+ BitstreamContext bc;
int length = 0;
if (node) {
length = node->packet->size * 8;
- init_get_bits(&gb, node->packet->data, length);
+ bitstream_init(&bc, node->packet->data, length);
}
if (length >= 32) {
- int c = get_bits(&gb, 13);
+ int c = bitstream_read(&bc, 13);
if (c > 3)
fill_coding_method_array(q->tone_level_idx,
q->superblocktype_2_3, q->cm_table_select);
}
- synthfilt_build_sb_samples(q, &gb, length, 0, 8);
+ synthfilt_build_sb_samples(q, &bc, length, 0, 8);
}
/**
*/
static void process_subpacket_12(QDM2Context *q, QDM2SubPNode *node)
{
- GetBitContext gb;
+ BitstreamContext bc;
int length = 0;
if (node) {
length = node->packet->size * 8;
- init_get_bits(&gb, node->packet->data, length);
+ bitstream_init(&bc, node->packet->data, length);
}
- synthfilt_build_sb_samples(q, &gb, length, 8, QDM2_SB_USED(q->sub_sampling));
+ synthfilt_build_sb_samples(q, &bc, length, 8, QDM2_SB_USED(q->sub_sampling));
}
/*
QDM2SubPNode *nodes[4];
nodes[0] = qdm2_search_subpacket_type_in_list(list, 9);
- if (nodes[0] != NULL)
+ if (nodes[0])
process_subpacket_9(q, nodes[0]);
nodes[1] = qdm2_search_subpacket_type_in_list(list, 10);
- if (nodes[1] != NULL)
+ if (nodes[1])
process_subpacket_10(q, nodes[1]);
else
process_subpacket_10(q, NULL);
nodes[2] = qdm2_search_subpacket_type_in_list(list, 11);
- if (nodes[0] != NULL && nodes[1] != NULL && nodes[2] != NULL)
+ if (nodes[0] && nodes[1] && nodes[2])
process_subpacket_11(q, nodes[2]);
else
process_subpacket_11(q, NULL);
nodes[3] = qdm2_search_subpacket_type_in_list(list, 12);
- if (nodes[0] != NULL && nodes[1] != NULL && nodes[3] != NULL)
+ if (nodes[0] && nodes[1] && nodes[3])
process_subpacket_12(q, nodes[3]);
else
process_subpacket_12(q, NULL);
*/
static void qdm2_decode_super_block(QDM2Context *q)
{
- GetBitContext gb;
+ BitstreamContext bc;
QDM2SubPacket header, *packet;
int i, packet_bytes, sub_packet_size, sub_packets_D;
unsigned int next_index = 0;
average_quantized_coeffs(q); // average elements in quantized_coeffs[max_ch][10][8]
- init_get_bits(&gb, q->compressed_data, q->compressed_size * 8);
- qdm2_decode_sub_packet_header(&gb, &header);
+ bitstream_init(&bc, q->compressed_data, q->compressed_size * 8);
+ qdm2_decode_sub_packet_header(&bc, &header);
if (header.type < 2 || header.type >= 8) {
q->has_errors = 1;
}
q->superblocktype_2_3 = (header.type == 2 || header.type == 3);
- packet_bytes = (q->compressed_size - get_bits_count(&gb) / 8);
+ packet_bytes = (q->compressed_size - bitstream_tell(&bc) / 8);
- init_get_bits(&gb, header.data, header.size * 8);
+ bitstream_init(&bc, header.data, header.size * 8);
if (header.type == 2 || header.type == 4 || header.type == 5) {
- int csum = 257 * get_bits(&gb, 8);
- csum += 2 * get_bits(&gb, 8);
+ int csum = 257 * bitstream_read(&bc, 8);
+ csum += 2 * bitstream_read(&bc, 8);
csum = qdm2_packet_checksum(q->compressed_data, q->checksum_size, csum);
q->sub_packet_list_A[i - 1].next = &q->sub_packet_list_A[i];
/* seek to next block */
- init_get_bits(&gb, header.data, header.size * 8);
- skip_bits(&gb, next_index * 8);
+ bitstream_init(&bc, header.data, header.size * 8);
+ bitstream_skip(&bc, next_index * 8);
if (next_index >= header.size)
break;
/* decode subpacket */
packet = &q->sub_packets[i];
- qdm2_decode_sub_packet_header(&gb, packet);
- next_index = packet->size + get_bits_count(&gb) / 8;
+ qdm2_decode_sub_packet_header(&bc, packet);
+ next_index = packet->size + bitstream_tell(&bc) / 8;
sub_packet_size = ((packet->size > 0xff) ? 1 : 0) + packet->size + 2;
if (packet->type == 0)
QDM2_LIST_ADD(q->sub_packet_list_D, sub_packets_D, packet);
} else if (packet->type == 13) {
for (j = 0; j < 6; j++)
- q->fft_level_exp[j] = get_bits(&gb, 6);
+ q->fft_level_exp[j] = bitstream_read(&bc, 6);
} else if (packet->type == 14) {
for (j = 0; j < 6; j++)
- q->fft_level_exp[j] = qdm2_get_vlc(&gb, &fft_level_exp_vlc, 0, 2);
+ q->fft_level_exp[j] = qdm2_get_vlc(&bc, &fft_level_exp_vlc, 0, 2);
} else if (packet->type == 15) {
SAMPLES_NEEDED_2("packet type 15")
return;
}
} // Packet bytes loop
- if (q->sub_packet_list_D[0].packet != NULL) {
+ if (q->sub_packet_list_D[0].packet) {
process_synthesis_subpackets(q, q->sub_packet_list_D);
q->do_synth_filter = 1;
} else if (q->do_synth_filter) {
}
static void qdm2_fft_decode_tones(QDM2Context *q, int duration,
- GetBitContext *gb, int b)
+ BitstreamContext *bc, int b)
{
int channel, stereo, phase, exp;
int local_int_4, local_int_8, stereo_phase, local_int_10;
while (1) {
if (q->superblocktype_2_3) {
- while ((n = qdm2_get_vlc(gb, &vlc_tab_fft_tone_offset[local_int_8], 1, 2)) < 2) {
+ while ((n = qdm2_get_vlc(bc, &vlc_tab_fft_tone_offset[local_int_8], 1, 2)) < 2) {
offset = 1;
if (n == 0) {
local_int_4 += local_int_10;
}
offset += (n - 2);
} else {
- offset += qdm2_get_vlc(gb, &vlc_tab_fft_tone_offset[local_int_8], 1, 2);
+ offset += qdm2_get_vlc(bc, &vlc_tab_fft_tone_offset[local_int_8], 1, 2);
while (offset >= (local_int_10 - 1)) {
offset += (1 - (local_int_10 - 1));
local_int_4 += local_int_10;
return;
if (q->nb_channels > 1) {
- channel = get_bits1(gb);
- stereo = get_bits1(gb);
+ channel = bitstream_read_bit(bc);
+ stereo = bitstream_read_bit(bc);
} else {
channel = 0;
stereo = 0;
}
- exp = qdm2_get_vlc(gb, (b ? &fft_level_exp_vlc : &fft_level_exp_alt_vlc), 0, 2);
+ exp = qdm2_get_vlc(bc, (b ? &fft_level_exp_vlc : &fft_level_exp_alt_vlc), 0, 2);
exp += q->fft_level_exp[fft_level_index_table[local_int_14]];
exp = (exp < 0) ? 0 : exp;
- phase = get_bits(gb, 3);
+ phase = bitstream_read(bc, 3);
stereo_exp = 0;
stereo_phase = 0;
if (stereo) {
- stereo_exp = (exp - qdm2_get_vlc(gb, &fft_stereo_exp_vlc, 0, 1));
- stereo_phase = (phase - qdm2_get_vlc(gb, &fft_stereo_phase_vlc, 0, 1));
+ stereo_exp = (exp - qdm2_get_vlc(bc, &fft_stereo_exp_vlc, 0, 1));
+ stereo_phase = (phase - qdm2_get_vlc(bc, &fft_stereo_phase_vlc, 0, 1));
if (stereo_phase < 0)
stereo_phase += 8;
}
static void qdm2_decode_fft_packets(QDM2Context *q)
{
int i, j, min, max, value, type, unknown_flag;
- GetBitContext gb;
+ BitstreamContext bc;
- if (q->sub_packet_list_B[0].packet == NULL)
+ if (!q->sub_packet_list_B[0].packet)
return;
/* reset minimum indexes for FFT coefficients */
return;
/* decode FFT tones */
- init_get_bits(&gb, packet->data, packet->size * 8);
+ bitstream_init(&bc, packet->data, packet->size * 8);
if (packet->type >= 32 && packet->type < 48 && !fft_subpackets[packet->type - 16])
unknown_flag = 1;
int duration = q->sub_sampling + 5 - (type & 15);
if (duration >= 0 && duration < 4)
- qdm2_fft_decode_tones(q, duration, &gb, unknown_flag);
+ qdm2_fft_decode_tones(q, duration, &bc, unknown_flag);
} else if (type == 31) {
for (j = 0; j < 4; j++)
- qdm2_fft_decode_tones(q, j, &gb, unknown_flag);
+ qdm2_fft_decode_tones(q, j, &bc, unknown_flag);
} else if (type == 46) {
for (j = 0; j < 6; j++)
- q->fft_level_exp[j] = get_bits(&gb, 6);
+ q->fft_level_exp[j] = bitstream_read(&bc, 6);
for (j = 0; j < 4; j++)
- qdm2_fft_decode_tones(q, j, &gb, unknown_flag);
+ qdm2_fft_decode_tones(q, j, &bc, unknown_flag);
}
} // Loop on B packets
if (!avctx->extradata || (avctx->extradata_size < 48)) {
av_log(avctx, AV_LOG_ERROR, "extradata missing or truncated\n");
- return -1;
+ return AVERROR_INVALIDDATA;
}
extradata = avctx->extradata;
if (extradata_size < 12) {
av_log(avctx, AV_LOG_ERROR, "not enough extradata (%i)\n",
extradata_size);
- return -1;
+ return AVERROR_INVALIDDATA;
}
if (memcmp(extradata, "frmaQDM", 7)) {
av_log(avctx, AV_LOG_ERROR, "invalid headers, QDM? not found\n");
- return -1;
+ return AVERROR_INVALIDDATA;
}
if (extradata[7] == 'C') {
// s->is_qdmc = 1;
- av_log(avctx, AV_LOG_ERROR, "stream is QDMC version 1, which is not supported\n");
- return -1;
+ avpriv_report_missing_feature(avctx, "QDMC version 1");
+ return AVERROR_PATCHWELCOME;
}
extradata += 8;
if(size > extradata_size){
av_log(avctx, AV_LOG_ERROR, "extradata size too small, %i < %i\n",
extradata_size, size);
- return -1;
+ return AVERROR_INVALIDDATA;
}
extradata += 4;
av_log(avctx, AV_LOG_DEBUG, "size: %d\n", size);
if (AV_RB32(extradata) != MKBETAG('Q','D','C','A')) {
av_log(avctx, AV_LOG_ERROR, "invalid extradata, expecting QDCA\n");
- return -1;
+ return AVERROR_INVALIDDATA;
}
extradata += 8;
// Fail on unknown fft order
if ((s->fft_order < 7) || (s->fft_order > 9)) {
- av_log(avctx, AV_LOG_ERROR, "Unknown FFT order (%d), contact the developers!\n", s->fft_order);
- return -1;
+ avpriv_request_sample(avctx, "Unknown FFT order %d", s->fft_order);
+ return AVERROR_PATCHWELCOME;
}
if (s->fft_size != (1 << (s->fft_order - 1))) {
av_log(avctx, AV_LOG_ERROR, "FFT size %d not power of 2.\n", s->fft_size);
for (ch = 0; ch < q->channels; ch++) {
qdm2_calculate_fft(q, ch, q->sub_packet);
- if (!q->has_errors && q->sub_packet_list_C[0].packet != NULL) {
+ if (!q->has_errors && q->sub_packet_list_C[0].packet) {
SAMPLES_NEEDED_2("has errors, and C list is not empty")
return -1;
}
q->sub_packet = (q->sub_packet + 1) % 16;
- /* clip and convert output float[] to 16bit signed samples */
+ /* clip and convert output float[] to 16-bit signed samples */
for (i = 0; i < frame_size; i++) {
int value = (int)q->output_buffer[i];
out = (int16_t *)frame->data[0];
for (i = 0; i < 16; i++) {
- if (qdm2_decode(s, buf, out) < 0)
- return -1;
+ if ((ret = qdm2_decode(s, buf, out)) < 0)
+ return ret;
out += s->channels * s->frame_size;
}
AVCodec ff_qdm2_decoder = {
.name = "qdm2",
+ .long_name = NULL_IF_CONFIG_SMALL("QDesign Music Codec 2"),
.type = AVMEDIA_TYPE_AUDIO,
.id = AV_CODEC_ID_QDM2,
.priv_data_size = sizeof(QDM2Context),
.init_static_data = qdm2_init_static_data,
.close = qdm2_decode_close,
.decode = qdm2_decode_frame,
- .capabilities = CODEC_CAP_DR1,
- .long_name = NULL_IF_CONFIG_SMALL("QDesign Music Codec 2"),
+ .capabilities = AV_CODEC_CAP_DR1,
};
projects / ffmpeg / blobdiff