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

alac: cosmetics: rename some variables and function names

Browse Source
pull/59/head
Justin Ruggles 13 years ago
parent 1b3ef155d7
commit 2aebac6918
1 changed files with 77 additions and 93 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. 170
      libavcodec/alac.c

170
libavcodec/alac.c
Unescape View File

@ -112,14 +112,13 @@ static const uint16_t alac_channel_layouts[8] = {
AV_CH_LAYOUT_7POINT1_WIDE_BACK
};
static inline unsigned int decode_scalar(GetBitContext *gb, int k,
int readsamplesize)
static inline unsigned int decode_scalar(GetBitContext *gb, int k, int bps)
{
unsigned int x = get_unary_0_9(gb);
if (x > 8) { /* RICE THRESHOLD */
/* use alternative encoding */
x = get_bits_long(gb, readsamplesize);
x = get_bits_long(gb, bps);
} else if (k != 1) {
int extrabits = show_bits(gb, k);
@ -135,28 +134,25 @@ static inline unsigned int decode_scalar(GetBitContext *gb, int k,
return x;
}
static void bastardized_rice_decompress(ALACContext *alac,
int32_t *output_buffer,
int output_size,
int readsamplesize,
int rice_history_mult)
static void rice_decompress(ALACContext *alac, int32_t *output_buffer,
int nb_samples, int bps, int rice_history_mult)
{
int output_count;
int i;
unsigned int history = alac->rice_initial_history;
int sign_modifier = 0;
for (output_count = 0; output_count < output_size; output_count++) {
for (i = 0; i < nb_samples; i++) {
int k;
unsigned int x;
/* read k, that is bits as is */
k = av_log2((history >> 9) + 3);
k = FFMIN(k, alac->rice_limit);
x = decode_scalar(&alac->gb, k, readsamplesize);
x = decode_scalar(&alac->gb, k, bps);
x += sign_modifier;
sign_modifier = 0;
output_buffer[output_count] = (x >> 1) ^ -(x & 1);
output_buffer[i] = (x >> 1) ^ -(x & 1);
/* now update the history */
if (x > 0xffff)
@ -166,7 +162,7 @@ static void bastardized_rice_decompress(ALACContext *alac,
((history * rice_history_mult) >> 9);
/* special case: there may be compressed blocks of 0 */
if ((history < 128) && (output_count+1 < output_size)) {
if ((history < 128) && (i + 1 < nb_samples)) {
int block_size;
k = 7 - av_log2(history) + ((history + 16) >> 6 /* / 64 */);
@ -175,13 +171,15 @@ static void bastardized_rice_decompress(ALACContext *alac,
block_size = decode_scalar(&alac->gb, k, 16);
if (block_size > 0) {
if(block_size >= output_size - output_count){
av_log(alac->avctx, AV_LOG_ERROR, "invalid zero block size of %d %d %d\n", block_size, output_size, output_count);
block_size= output_size - output_count - 1;
if (block_size >= nb_samples - i) {
av_log(alac->avctx, AV_LOG_ERROR,
"invalid zero block size of %d %d %d\n", block_size,
nb_samples, i);
block_size = nb_samples - i - 1;
}
memset(&output_buffer[output_count + 1], 0,
memset(&output_buffer[i + 1], 0,
block_size * sizeof(*output_buffer));
output_count += block_size;
i += block_size;
}
if (block_size <= 0xffff)
@ -197,93 +195,86 @@ static inline int sign_only(int v)
return v ? FFSIGN(v) : 0;
}
static void predictor_decompress_fir_adapt(int32_t *error_buffer,
int32_t *buffer_out,
int output_size,
int readsamplesize,
int16_t *predictor_coef_table,
int predictor_coef_num,
int predictor_quantitization)
static void lpc_prediction(int32_t *error_buffer, int32_t *buffer_out,
int nb_samples, int bps, int16_t *lpc_coefs,
int lpc_order, int lpc_quant)
{
int i;
/* first sample always copies */
*buffer_out = *error_buffer;
if (output_size <= 1)
if (nb_samples <= 1)
return;
if (!predictor_coef_num) {
if (!lpc_order) {
memcpy(&buffer_out[1], &error_buffer[1],
(output_size - 1) * sizeof(*buffer_out));
(nb_samples - 1) * sizeof(*buffer_out));
return;
}
if (predictor_coef_num == 31) {
if (lpc_order == 31) {
/* simple 1st-order prediction */
for (i = 1; i < output_size; i++) {
for (i = 1; i < nb_samples; i++) {
buffer_out[i] = sign_extend(buffer_out[i - 1] + error_buffer[i],
readsamplesize);
bps);
}
return;
}
/* read warm-up samples */
for (i = 0; i < predictor_coef_num; i++) {
for (i = 0; i < lpc_order; i++) {
buffer_out[i + 1] = sign_extend(buffer_out[i] + error_buffer[i + 1],
readsamplesize);
bps);
}
/* NOTE: 4 and 8 are very common cases that could be optimized. */
/* general case */
for (i = predictor_coef_num; i < output_size - 1; i++) {
for (i = lpc_order; i < nb_samples - 1; i++) {
int j;
int val = 0;
int error_val = error_buffer[i + 1];
int error_sign;
int d = buffer_out[i - predictor_coef_num];
int d = buffer_out[i - lpc_order];
for (j = 0; j < predictor_coef_num; j++) {
val += (buffer_out[i - j] - d) *
predictor_coef_table[j];
for (j = 0; j < lpc_order; j++) {
val += (buffer_out[i - j] - d) * lpc_coefs[j];
}
val = (val + (1 << (predictor_quantitization - 1))) >>
predictor_quantitization;
val = (val + (1 << (lpc_quant - 1))) >> lpc_quant;
val += d + error_val;
buffer_out[i + 1] = sign_extend(val, readsamplesize);
buffer_out[i + 1] = sign_extend(val, bps);
/* adapt LPC coefficients */
error_sign = sign_only(error_val);
if (error_sign) {
for (j = predictor_coef_num - 1; j >= 0 && error_val * error_sign > 0; j--) {
for (j = lpc_order - 1; j >= 0 && error_val * error_sign > 0; j--) {
int sign;
val = d - buffer_out[i - j];
sign = sign_only(val) * error_sign;
predictor_coef_table[j] -= sign;
lpc_coefs[j] -= sign;
val *= sign;
error_val -= ((val >> predictor_quantitization) *
(predictor_coef_num - j));
error_val -= (val >> lpc_quant) * (lpc_order - j);
}
}
}
}
static void decorrelate_stereo(int32_t *buffer[2],
int numsamples, uint8_t interlacing_shift,
uint8_t interlacing_leftweight)
int nb_samples, uint8_t decorr_shift,
uint8_t decorr_left_weight)
{
int i;
for (i = 0; i < numsamples; i++) {
for (i = 0; i < nb_samples; i++) {
int32_t a, b;
a = buffer[0][i];
b = buffer[1][i];
a -= (b * interlacing_leftweight) >> interlacing_shift;
a -= (b * decorr_left_weight) >> decorr_shift;
b += a;
buffer[0][i] = b;
@ -293,12 +284,12 @@ static void decorrelate_stereo(int32_t *buffer[2],
static void append_extra_bits(int32_t *buffer[2],
int32_t *extra_bits_buffer[2],
int extra_bits, int numchannels, int numsamples)
int extra_bits, int channels, int nb_samples)
{
int i, ch;
for (ch = 0; ch < numchannels; ch++)
for (i = 0; i < numsamples; i++)
for (ch = 0; ch < channels; ch++)
for (i = 0; i < nb_samples; i++)
buffer[ch][i] = (buffer[ch][i] << extra_bits) | extra_bits_buffer[ch][i];
}
@ -306,11 +297,11 @@ static int decode_element(AVCodecContext *avctx, void *data, int ch_index,
int channels)
{
ALACContext *alac = avctx->priv_data;
int hassize;
unsigned int readsamplesize;
int has_size;
unsigned int bps;
int is_compressed;
uint8_t interlacing_shift;
uint8_t interlacing_leftweight;
uint8_t decorr_shift;
uint8_t decorr_left_weight;
uint32_t output_samples;
int i, ch, ret;
@ -318,19 +309,19 @@ static int decode_element(AVCodecContext *avctx, void *data, int ch_index,
skip_bits(&alac->gb, 12); /* unused header bits */
/* the number of output samples is stored in the frame */
hassize = get_bits1(&alac->gb);
has_size = get_bits1(&alac->gb);
alac->extra_bits = get_bits(&alac->gb, 2) << 3;
readsamplesize = alac->sample_size - alac->extra_bits + channels - 1;
if (readsamplesize > 32) {
av_log(avctx, AV_LOG_ERROR, "bps is unsupported: %d\n", readsamplesize);
bps = alac->sample_size - alac->extra_bits + channels - 1;
if (bps > 32) {
av_log(avctx, AV_LOG_ERROR, "bps is unsupported: %d\n", bps);
return AVERROR_PATCHWELCOME;
}
/* whether the frame is compressed */
is_compressed = !get_bits1(&alac->gb);
if (hassize)
if (has_size)
output_samples = get_bits_long(&alac->gb, 32);
else
output_samples = alac->max_samples_per_frame;
@ -358,25 +349,24 @@ static int decode_element(AVCodecContext *avctx, void *data, int ch_index,
alac->nb_samples = output_samples;
if (is_compressed) {
int16_t predictor_coef_table[2][32];
int predictor_coef_num[2];
int16_t lpc_coefs[2][32];
int lpc_order[2];
int prediction_type[2];
int prediction_quantitization[2];
int ricemodifier[2];
int lpc_quant[2];
int rice_history_mult[2];
interlacing_shift = get_bits(&alac->gb, 8);
interlacing_leftweight = get_bits(&alac->gb, 8);
decorr_shift = get_bits(&alac->gb, 8);
decorr_left_weight = get_bits(&alac->gb, 8);
for (ch = 0; ch < channels; ch++) {
prediction_type[ch] = get_bits(&alac->gb, 4);
prediction_quantitization[ch] = get_bits(&alac->gb, 4);
ricemodifier[ch] = get_bits(&alac->gb, 3);
predictor_coef_num[ch] = get_bits(&alac->gb, 5);
prediction_type[ch] = get_bits(&alac->gb, 4);
lpc_quant[ch] = get_bits(&alac->gb, 4);
rice_history_mult[ch] = get_bits(&alac->gb, 3);
lpc_order[ch] = get_bits(&alac->gb, 5);
/* read the predictor table */
for (i = 0; i < predictor_coef_num[ch]; i++)
predictor_coef_table[ch][i] = get_sbits(&alac->gb, 16);
for (i = 0; i < lpc_order[ch]; i++)
lpc_coefs[ch][i] = get_sbits(&alac->gb, 16);
}
if (alac->extra_bits) {
@ -386,11 +376,9 @@ static int decode_element(AVCodecContext *avctx, void *data, int ch_index,
}
}
for (ch = 0; ch < channels; ch++) {
bastardized_rice_decompress(alac,
alac->predict_error_buffer[ch],
alac->nb_samples,
readsamplesize,
ricemodifier[ch] * alac->rice_history_mult / 4);
rice_decompress(alac, alac->predict_error_buffer[ch],
alac->nb_samples, bps,
rice_history_mult[ch] * alac->rice_history_mult / 4);
/* adaptive FIR filter */
if (prediction_type[ch] == 15) {
@ -401,20 +389,16 @@ static int decode_element(AVCodecContext *avctx, void *data, int ch_index,
* However, this prediction type is not currently used by the
* reference encoder.
*/
predictor_decompress_fir_adapt(alac->predict_error_buffer[ch],
alac->predict_error_buffer[ch],
alac->nb_samples, readsamplesize,
NULL, 31, 0);
lpc_prediction(alac->predict_error_buffer[ch],
alac->predict_error_buffer[ch],
alac->nb_samples, bps, NULL, 31, 0);
} else if (prediction_type[ch] > 0) {
av_log(avctx, AV_LOG_WARNING, "unknown prediction type: %i\n",
prediction_type[ch]);
}
predictor_decompress_fir_adapt(alac->predict_error_buffer[ch],
alac->output_samples_buffer[ch],
alac->nb_samples, readsamplesize,
predictor_coef_table[ch],
predictor_coef_num[ch],
prediction_quantitization[ch]);
lpc_prediction(alac->predict_error_buffer[ch],
alac->output_samples_buffer[ch], alac->nb_samples,
bps, lpc_coefs[ch], lpc_order[ch], lpc_quant[ch]);
}
} else {
/* not compressed, easy case */
@ -424,13 +408,13 @@ static int decode_element(AVCodecContext *avctx, void *data, int ch_index,
}
}
alac->extra_bits = 0;
interlacing_shift = 0;
interlacing_leftweight = 0;
decorr_shift = 0;
decorr_left_weight = 0;
}
if (channels == 2 && interlacing_leftweight) {
if (channels == 2 && decorr_left_weight) {
decorrelate_stereo(alac->output_samples_buffer, alac->nb_samples,
interlacing_shift, interlacing_leftweight);
decorr_shift, decorr_left_weight);
}
if (alac->extra_bits) {

Write Preview
Loading…
Cancel
Save