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

Merge remote-tracking branch 'qatar/master'

Browse Source 
* qatar/master: (38 commits)
  alac: cosmetics: general pretty-printing and comment clean up
  alac: calculate buffer size outside the loop in allocate_buffers()
  alac: change some data types to plain int
  alac: cosmetics: rename some variables and function names
  alac: multi-channel decoding support
  alac: split element parsing into a separate function
  alac: support a read sample size of up to 32
  alac: output in planar sample format
  alac: add 32-bit decoding support
  alac: simplify channel interleaving
  alac: use AVPacket fields directly in alac_decode_frame()
  alac: fix check for valid max_samples_per_frame
  alac: use get_sbits() to read LPC coefficients instead of casting
  alac: move the current samples per frame to the ALACContext
  alac: avoid using a double-negative when checking if the frame is compressed
  alac: factor out output_size check in predictor_decompress_fir_adapt()
  alac: factor out loading of next decoded sample in LPC prediction
  alac: use index into buffer_out instead of incrementing the pointer
  alac: simplify lpc coefficient adaptation
  alac: reduce the number of local variables needed in lpc prediction
  ...

Conflicts:
	libavcodec/alac.c
	libavformat/cafdec.c
	libavformat/mov.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
pull/59/head
Michael Niedermayer 13 years ago
parent a8d8e868c6 eeb55f5f2f
commit e4c00aca96
8 changed files with 414 additions and 462 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. 642
      libavcodec/alac.c
  2. 3
      libavformat/aiffdec.c
  3. 55
      libavformat/cafdec.c
  4. 16
      libavformat/isom.c
  5. 2
      libavformat/isom.h
  6. 41
      libavformat/mov.c
  7. 46
      libavformat/mov_chan.c
  8. 19
      libavformat/mov_chan.h

642
libavcodec/alac.c
Unescape View File

@ -37,7 +37,7 @@
* 8bit sample size * 8bit sample size
* 8bit history mult (40) * 8bit history mult (40)
* 8bit initial history (14) * 8bit initial history (14)
* 8bit kmodifier (10) * 8bit rice param limit (10)
* 8bit channels * 8bit channels
* 16bit maxRun (255) * 16bit maxRun (255)
* 32bit max coded frame size (0 means unknown) * 32bit max coded frame size (0 means unknown)
@ -45,7 +45,7 @@
* 32bit samplerate * 32bit samplerate
*/ */
#include "libavutil/audioconvert.h"
#include "avcodec.h" #include "avcodec.h"
#include "get_bits.h" #include "get_bits.h"
#include "bytestream.h" #include "bytestream.h"
@ -53,46 +53,70 @@
#include "mathops.h" #include "mathops.h"
#define ALAC_EXTRADATA_SIZE 36 #define ALAC_EXTRADATA_SIZE 36
#define MAX_CHANNELS 2 #define MAX_CHANNELS 8
typedef struct { typedef struct {
AVCodecContext *avctx; AVCodecContext *avctx;
AVFrame frame; AVFrame frame;
GetBitContext gb; GetBitContext gb;
int channels;
int numchannels; int32_t *predict_error_buffer[2];
int32_t *output_samples_buffer[2];
int32_t *extra_bits_buffer[2];
/* buffers */ uint32_t max_samples_per_frame;
int32_t *predicterror_buffer[MAX_CHANNELS]; uint8_t sample_size;
uint8_t rice_history_mult;
uint8_t rice_initial_history;
uint8_t rice_limit;
int32_t *outputsamples_buffer[MAX_CHANNELS]; int extra_bits; /**< number of extra bits beyond 16-bit */
int nb_samples; /**< number of samples in the current frame */
} ALACContext;
int32_t *extra_bits_buffer[MAX_CHANNELS]; enum RawDataBlockType {
/* At the moment, only SCE, CPE, LFE, and END are recognized. */
TYPE_SCE,
TYPE_CPE,
TYPE_CCE,
TYPE_LFE,
TYPE_DSE,
TYPE_PCE,
TYPE_FIL,
TYPE_END
};
/* stuff from setinfo */ static const uint8_t alac_channel_layout_offsets[8][8] = {
uint32_t setinfo_max_samples_per_frame; /* 0x1000 = 4096 */ /* max samples per frame? */ { 0 },
uint8_t setinfo_sample_size; /* 0x10 */ { 0, 1 },
uint8_t setinfo_rice_historymult; /* 0x28 */ { 2, 0, 1 },
uint8_t setinfo_rice_initialhistory; /* 0x0a */ { 2, 0, 1, 3 },
uint8_t setinfo_rice_kmodifier; /* 0x0e */ { 2, 0, 1, 3, 4 },
/* end setinfo stuff */ { 2, 0, 1, 4, 5, 3 },
{ 2, 0, 1, 4, 5, 6, 3 },
{ 2, 6, 7, 0, 1, 4, 5, 3 }
};
int extra_bits; /**< number of extra bits beyond 16-bit */ static const uint16_t alac_channel_layouts[8] = {
} ALACContext; AV_CH_LAYOUT_MONO,
AV_CH_LAYOUT_STEREO,
AV_CH_LAYOUT_SURROUND,
AV_CH_LAYOUT_4POINT0,
AV_CH_LAYOUT_5POINT0_BACK,
AV_CH_LAYOUT_5POINT1_BACK,
AV_CH_LAYOUT_6POINT1_BACK,
AV_CH_LAYOUT_7POINT1_WIDE_BACK
};
static inline int decode_scalar(GetBitContext *gb, int k, int limit, int readsamplesize){ static inline unsigned int decode_scalar(GetBitContext *gb, int k, int bps)
/* read x - number of 1s before 0 represent the rice */ {
int x = get_unary_0_9(gb); unsigned int x = get_unary_0_9(gb);
if (x > 8) { /* RICE THRESHOLD */ if (x > 8) { /* RICE THRESHOLD */
/* use alternative encoding */ /* use alternative encoding */
x = get_bits(gb, readsamplesize); x = get_bits_long(gb, bps);
} else { } else if (k != 1) {
if (k >= limit)
k = limit;
if (k != 1) {
int extrabits = show_bits(gb, k); int extrabits = show_bits(gb, k);
/* multiply x by 2^k - 1, as part of their strange algorithm */ /* multiply x by 2^k - 1, as part of their strange algorithm */
@ -104,77 +128,60 @@ static inline int decode_scalar(GetBitContext *gb, int k, int limit, int readsam
} else } else
skip_bits(gb, k - 1); skip_bits(gb, k - 1);
} }
}
return x; return x;
} }
static int bastardized_rice_decompress(ALACContext *alac, static int rice_decompress(ALACContext *alac, int32_t *output_buffer,
int32_t *output_buffer, int nb_samples, int bps, int rice_history_mult)
int output_size,
int readsamplesize, /* arg_10 */
int rice_initialhistory, /* arg424->b */
int rice_kmodifier, /* arg424->d */
int rice_historymult, /* arg424->c */
int rice_kmodifier_mask /* arg424->e */
)
{ {
int output_count; int i;
unsigned int history = rice_initialhistory; unsigned int history = alac->rice_initial_history;
int sign_modifier = 0; int sign_modifier = 0;
for (output_count = 0; output_count < output_size; output_count++) { for (i = 0; i < nb_samples; i++) {
int32_t x; int k;
int32_t x_modified; unsigned int x;
int32_t final_val;
/* standard rice encoding */
int k; /* size of extra bits */
if(get_bits_left(&alac->gb) <= 0) if(get_bits_left(&alac->gb) <= 0)
return -1; return -1;
/* read k, that is bits as is */ /* calculate rice param and decode next value */
k = av_log2((history >> 9) + 3); k = av_log2((history >> 9) + 3);
x= decode_scalar(&alac->gb, k, rice_kmodifier, readsamplesize); k = FFMIN(k, alac->rice_limit);
x = decode_scalar(&alac->gb, k, bps);
x_modified = sign_modifier + x; x += sign_modifier;
final_val = (x_modified + 1) / 2;
if (x_modified & 1) final_val *= -1;
output_buffer[output_count] = final_val;
sign_modifier = 0; sign_modifier = 0;
output_buffer[i] = (x >> 1) ^ -(x & 1);
/* now update the history */ /* update the history */
history += x_modified * rice_historymult if (x > 0xffff)
- ((history * rice_historymult) >> 9);
if (x_modified > 0xffff)
history = 0xffff; history = 0xffff;
else
history += x * rice_history_mult -
((history * rice_history_mult) >> 9);
/* special case: there may be compressed blocks of 0 */ /* 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 k; int block_size;
unsigned int block_size;
sign_modifier = 1;
k = 7 - av_log2(history) + ((history + 16) >> 6 /* / 64 */); /* calculate rice param and decode block size */
k = 7 - av_log2(history) + ((history + 16) >> 6);
block_size= decode_scalar(&alac->gb, k, rice_kmodifier, 16); k = FFMIN(k, alac->rice_limit);
block_size = decode_scalar(&alac->gb, k, 16);
if (block_size > 0) { if (block_size > 0) {
if(block_size >= output_size - output_count){ if (block_size >= nb_samples - i) {
av_log(alac->avctx, AV_LOG_ERROR, "invalid zero block size of %d %d %d\n", block_size, output_size, output_count); av_log(alac->avctx, AV_LOG_ERROR,
block_size= output_size - output_count - 1; "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, block_size * 4); memset(&output_buffer[i + 1], 0,
output_count += block_size; block_size * sizeof(*output_buffer));
i += block_size;
} }
if (block_size <= 0xffff)
if (block_size > 0xffff) sign_modifier = 1;
sign_modifier = 0;
history = 0; history = 0;
} }
} }
@ -186,131 +193,82 @@ static inline int sign_only(int v)
return v ? FFSIGN(v) : 0; return v ? FFSIGN(v) : 0;
} }
static void predictor_decompress_fir_adapt(int32_t *error_buffer, static void lpc_prediction(int32_t *error_buffer, int32_t *buffer_out,
int32_t *buffer_out, int nb_samples, int bps, int16_t *lpc_coefs,
int output_size, int lpc_order, int lpc_quant)
int readsamplesize,
int16_t *predictor_coef_table,
int predictor_coef_num,
int predictor_quantitization)
{ {
int i; int i;
/* first sample always copies */ /* first sample always copies */
*buffer_out = *error_buffer; *buffer_out = *error_buffer;
if (!predictor_coef_num) { if (nb_samples <= 1)
if (output_size <= 1)
return; return;
memcpy(buffer_out+1, error_buffer+1, (output_size-1) * 4); if (!lpc_order) {
memcpy(&buffer_out[1], &error_buffer[1],
(nb_samples - 1) * sizeof(*buffer_out));
return; return;
} }
if (predictor_coef_num == 0x1f) { /* 11111 - max value of predictor_coef_num */ if (lpc_order == 31) {
/* second-best case scenario for fir decompression, /* simple 1st-order prediction */
* error describes a small difference from the previous sample only for (i = 1; i < nb_samples; i++) {
*/ buffer_out[i] = sign_extend(buffer_out[i - 1] + error_buffer[i],
if (output_size <= 1) bps);
return;
for (i = 0; i < output_size - 1; i++) {
int32_t prev_value;
int32_t error_value;
prev_value = buffer_out[i];
error_value = error_buffer[i+1];
buffer_out[i+1] =
sign_extend((prev_value + error_value), readsamplesize);
} }
return; return;
} }
/* read warm-up samples */ /* read warm-up samples */
if (predictor_coef_num > 0) for (i = 0; i < lpc_order; i++) {
for (i = 0; i < predictor_coef_num; i++) { buffer_out[i + 1] = sign_extend(buffer_out[i] + error_buffer[i + 1],
int32_t val; bps);
val = buffer_out[i] + error_buffer[i+1];
val = sign_extend(val, readsamplesize);
buffer_out[i+1] = val;
} }
/* 4 and 8 are very common cases (the only ones i've seen). these /* NOTE: 4 and 8 are very common cases that could be optimized. */
* should be unrolled and optimized
*/
/* general case */ for (i = lpc_order; i < nb_samples - 1; i++) {
if (predictor_coef_num > 0) {
for (i = predictor_coef_num + 1; i < output_size; i++) {
int j; int j;
int sum = 0; int val = 0;
int outval; int error_val = error_buffer[i + 1];
int error_val = error_buffer[i]; int error_sign;
int d = buffer_out[i - lpc_order];
for (j = 0; j < predictor_coef_num; j++) {
sum += (buffer_out[predictor_coef_num-j] - buffer_out[0]) * /* LPC prediction */
predictor_coef_table[j]; for (j = 0; j < lpc_order; j++)
} val += (buffer_out[i - j] - d) * lpc_coefs[j];
val = (val + (1 << (lpc_quant - 1))) >> lpc_quant;
outval = (1 << (predictor_quantitization-1)) + sum; val += d + error_val;
outval = outval >> predictor_quantitization; buffer_out[i + 1] = sign_extend(val, bps);
outval = outval + buffer_out[0] + error_val;
outval = sign_extend(outval, readsamplesize); /* adapt LPC coefficients */
error_sign = sign_only(error_val);
buffer_out[predictor_coef_num+1] = outval; if (error_sign) {
for (j = lpc_order - 1; j >= 0 && error_val * error_sign > 0; j--) {
if (error_val > 0) { int sign;
int predictor_num = predictor_coef_num - 1; val = d - buffer_out[i - j];
sign = sign_only(val) * error_sign;
while (predictor_num >= 0 && error_val > 0) { lpc_coefs[j] -= sign;
int val = buffer_out[0] - buffer_out[predictor_coef_num - predictor_num]; val *= sign;
int sign = sign_only(val); error_val -= (val >> lpc_quant) * (lpc_order - j);
predictor_coef_table[predictor_num] -= sign;
val *= sign; /* absolute value */
error_val -= ((val >> predictor_quantitization) *
(predictor_coef_num - predictor_num));
predictor_num--;
}
} else if (error_val < 0) {
int predictor_num = predictor_coef_num - 1;
while (predictor_num >= 0 && error_val < 0) {
int val = buffer_out[0] - buffer_out[predictor_coef_num - predictor_num];
int sign = - sign_only(val);
predictor_coef_table[predictor_num] -= sign;
val *= sign; /* neg value */
error_val -= ((val >> predictor_quantitization) *
(predictor_coef_num - predictor_num));
predictor_num--;
}
} }
buffer_out++;
} }
} }
} }
static void decorrelate_stereo(int32_t *buffer[MAX_CHANNELS], static void decorrelate_stereo(int32_t *buffer[2], int nb_samples,
int numsamples, uint8_t interlacing_shift, int decorr_shift, int decorr_left_weight)
uint8_t interlacing_leftweight)
{ {
int i; int i;
for (i = 0; i < numsamples; i++) { for (i = 0; i < nb_samples; i++) {
int32_t a, b; int32_t a, b;
a = buffer[0][i]; a = buffer[0][i];
b = buffer[1][i]; b = buffer[1][i];
a -= (b * interlacing_leftweight) >> interlacing_shift; a -= (b * decorr_left_weight) >> decorr_shift;
b += a; b += a;
buffer[0][i] = b; buffer[0][i] = b;
@ -318,141 +276,90 @@ static void decorrelate_stereo(int32_t *buffer[MAX_CHANNELS],
} }
} }
static void append_extra_bits(int32_t *buffer[MAX_CHANNELS], static void append_extra_bits(int32_t *buffer[2], int32_t *extra_bits_buffer[2],
int32_t *extra_bits_buffer[MAX_CHANNELS], int extra_bits, int channels, int nb_samples)
int extra_bits, int numchannels, int numsamples)
{ {
int i, ch; int i, ch;
for (ch = 0; ch < numchannels; ch++) for (ch = 0; ch < channels; ch++)
for (i = 0; i < numsamples; i++) for (i = 0; i < nb_samples; i++)
buffer[ch][i] = (buffer[ch][i] << extra_bits) | extra_bits_buffer[ch][i]; buffer[ch][i] = (buffer[ch][i] << extra_bits) | extra_bits_buffer[ch][i];
} }
static void interleave_stereo_16(int32_t *buffer[MAX_CHANNELS], static int decode_element(AVCodecContext *avctx, void *data, int ch_index,
int16_t *buffer_out, int numsamples) int channels)
{
int i;
for (i = 0; i < numsamples; i++) {
*buffer_out++ = buffer[0][i];
*buffer_out++ = buffer[1][i];
}
}
static void interleave_stereo_24(int32_t *buffer[MAX_CHANNELS],
int32_t *buffer_out, int numsamples)
{ {
int i;
for (i = 0; i < numsamples; i++) {
*buffer_out++ = buffer[0][i] << 8;
*buffer_out++ = buffer[1][i] << 8;
}
}
static void interleave_stereo_32(int32_t *buffer[MAX_CHANNELS],
int32_t *buffer_out, int numsamples)
{
int i;
for (i = 0; i < numsamples; i++) {
*buffer_out++ = buffer[0][i];
*buffer_out++ = buffer[1][i];
}
}
static int alac_decode_frame(AVCodecContext *avctx, void *data,
int *got_frame_ptr, AVPacket *avpkt)
{
const uint8_t *inbuffer = avpkt->data;
int input_buffer_size = avpkt->size;
ALACContext *alac = avctx->priv_data; ALACContext *alac = avctx->priv_data;
int has_size, bps, is_compressed, decorr_shift, decorr_left_weight, ret;
uint32_t output_samples;
int i, ch;
int channels; skip_bits(&alac->gb, 4); /* element instance tag */
unsigned int outputsamples; skip_bits(&alac->gb, 12); /* unused header bits */
int hassize;
unsigned int readsamplesize;
int isnotcompressed;
uint8_t interlacing_shift;
uint8_t interlacing_leftweight;
int i, ch, ret;
init_get_bits(&alac->gb, inbuffer, input_buffer_size * 8);
channels = get_bits(&alac->gb, 3) + 1;
if (channels != avctx->channels) {
av_log(avctx, AV_LOG_ERROR, "frame header channel count mismatch\n");
return AVERROR_INVALIDDATA;
}
/* 2^result = something to do with output waiting.
* perhaps matters if we read > 1 frame in a pass?
*/
skip_bits(&alac->gb, 4);
skip_bits(&alac->gb, 12); /* unknown, skip 12 bits */
/* the output sample size is stored soon */ /* 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; alac->extra_bits = get_bits(&alac->gb, 2) << 3;
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 */ /* whether the frame is compressed */
isnotcompressed = get_bits1(&alac->gb); is_compressed = !get_bits1(&alac->gb);
if (hassize) {
/* now read the number of samples as a 32bit integer */
outputsamples = get_bits_long(&alac->gb, 32);
if(outputsamples > alac->setinfo_max_samples_per_frame){
av_log(avctx, AV_LOG_ERROR, "outputsamples %d > %d\n", outputsamples, alac->setinfo_max_samples_per_frame);
return -1;
}
} else
outputsamples = alac->setinfo_max_samples_per_frame;
/* get output buffer */ if (has_size)
if (outputsamples > INT32_MAX) { output_samples = get_bits_long(&alac->gb, 32);
av_log(avctx, AV_LOG_ERROR, "unsupported block size: %u\n", outputsamples); else
output_samples = alac->max_samples_per_frame;
if (!output_samples || output_samples > alac->max_samples_per_frame) {
av_log(avctx, AV_LOG_ERROR, "invalid samples per frame: %d\n",
output_samples);
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
alac->frame.nb_samples = outputsamples; if (!alac->nb_samples) {
/* get output buffer */
alac->frame.nb_samples = output_samples;
if ((ret = avctx->get_buffer(avctx, &alac->frame)) < 0) { if ((ret = avctx->get_buffer(avctx, &alac->frame)) < 0) {
av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n"); av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
return ret; return ret;
} }
if (alac->sample_size > 16) {
readsamplesize = alac->setinfo_sample_size - alac->extra_bits + channels - 1; for (ch = 0; ch < channels; ch++)
if (readsamplesize > MIN_CACHE_BITS) { alac->output_samples_buffer[ch] = (int32_t *)alac->frame.extended_data[ch_index + ch];
av_log(avctx, AV_LOG_ERROR, "readsamplesize too big (%d)\n", readsamplesize); }
return -1; } else if (output_samples != alac->nb_samples) {
av_log(avctx, AV_LOG_ERROR, "sample count mismatch: %u != %d\n",
output_samples, alac->nb_samples);
return AVERROR_INVALIDDATA;
} }
alac->nb_samples = output_samples;
if (!isnotcompressed) { if (is_compressed) {
/* so it is compressed */ int16_t lpc_coefs[2][32];
int16_t predictor_coef_table[MAX_CHANNELS][32]; int lpc_order[2];
int predictor_coef_num[MAX_CHANNELS]; int prediction_type[2];
int prediction_type[MAX_CHANNELS]; int lpc_quant[2];
int prediction_quantitization[MAX_CHANNELS]; int rice_history_mult[2];
int ricemodifier[MAX_CHANNELS];
interlacing_shift = get_bits(&alac->gb, 8); decorr_shift = get_bits(&alac->gb, 8);
interlacing_leftweight = get_bits(&alac->gb, 8); decorr_left_weight = get_bits(&alac->gb, 8);
for (ch = 0; ch < channels; ch++) { for (ch = 0; ch < channels; ch++) {
prediction_type[ch] = get_bits(&alac->gb, 4); prediction_type[ch] = get_bits(&alac->gb, 4);
prediction_quantitization[ch] = get_bits(&alac->gb, 4); lpc_quant[ch] = get_bits(&alac->gb, 4);
rice_history_mult[ch] = get_bits(&alac->gb, 3);
ricemodifier[ch] = get_bits(&alac->gb, 3); lpc_order[ch] = get_bits(&alac->gb, 5);
predictor_coef_num[ch] = get_bits(&alac->gb, 5);
/* read the predictor table */ /* read the predictor table */
for (i = 0; i < predictor_coef_num[ch]; i++) for (i = 0; i < lpc_order[ch]; i++)
predictor_coef_table[ch][i] = (int16_t)get_bits(&alac->gb, 16); lpc_coefs[ch][i] = get_sbits(&alac->gb, 16);
} }
if (alac->extra_bits) { if (alac->extra_bits) {
for (i = 0; i < outputsamples; i++) { for (i = 0; i < alac->nb_samples; i++) {
if(get_bits_left(&alac->gb) <= 0) if(get_bits_left(&alac->gb) <= 0)
return -1; return -1;
for (ch = 0; ch < channels; ch++) for (ch = 0; ch < channels; ch++)
@ -460,14 +367,9 @@ static int alac_decode_frame(AVCodecContext *avctx, void *data,
} }
} }
for (ch = 0; ch < channels; ch++) { for (ch = 0; ch < channels; ch++) {
int ret = bastardized_rice_decompress(alac, int ret=rice_decompress(alac, alac->predict_error_buffer[ch],
alac->predicterror_buffer[ch], alac->nb_samples, bps,
outputsamples, rice_history_mult[ch] * alac->rice_history_mult / 4);
readsamplesize,
alac->setinfo_rice_initialhistory,
alac->setinfo_rice_kmodifier,
ricemodifier[ch] * alac->setinfo_rice_historymult / 4,
(1 << alac->setinfo_rice_kmodifier) - 1);
if(ret<0) if(ret<0)
return ret; return ret;
@ -480,89 +382,106 @@ static int alac_decode_frame(AVCodecContext *avctx, void *data,
* However, this prediction type is not currently used by the * However, this prediction type is not currently used by the
* reference encoder. * reference encoder.
*/ */
predictor_decompress_fir_adapt(alac->predicterror_buffer[ch], lpc_prediction(alac->predict_error_buffer[ch],
alac->predicterror_buffer[ch], alac->predict_error_buffer[ch],
outputsamples, readsamplesize, alac->nb_samples, bps, NULL, 31, 0);
NULL, 31, 0);
} else if (prediction_type[ch] > 0) { } else if (prediction_type[ch] > 0) {
av_log(avctx, AV_LOG_WARNING, "unknown prediction type: %i\n", av_log(avctx, AV_LOG_WARNING, "unknown prediction type: %i\n",
prediction_type[ch]); prediction_type[ch]);
} }
predictor_decompress_fir_adapt(alac->predicterror_buffer[ch], lpc_prediction(alac->predict_error_buffer[ch],
alac->outputsamples_buffer[ch], alac->output_samples_buffer[ch], alac->nb_samples,
outputsamples, readsamplesize, bps, lpc_coefs[ch], lpc_order[ch], lpc_quant[ch]);
predictor_coef_table[ch],
predictor_coef_num[ch],
prediction_quantitization[ch]);
} }
} else { } else {
/* not compressed, easy case */ /* not compressed, easy case */
for (i = 0; i < outputsamples; i++) { for (i = 0; i < alac->nb_samples; i++) {
if(get_bits_left(&alac->gb) <= 0) if(get_bits_left(&alac->gb) <= 0)
return -1; return -1;
for (ch = 0; ch < channels; ch++) { for (ch = 0; ch < channels; ch++) {
alac->outputsamples_buffer[ch][i] = get_sbits_long(&alac->gb, alac->output_samples_buffer[ch][i] =
alac->setinfo_sample_size); get_sbits_long(&alac->gb, alac->sample_size);
} }
} }
alac->extra_bits = 0; alac->extra_bits = 0;
interlacing_shift = 0; decorr_shift = 0;
interlacing_leftweight = 0; decorr_left_weight = 0;
} }
if (get_bits(&alac->gb, 3) != 7)
av_log(avctx, AV_LOG_ERROR, "Error : Wrong End Of Frame\n");
if (channels == 2 && interlacing_leftweight) { if (channels == 2 && decorr_left_weight) {
decorrelate_stereo(alac->outputsamples_buffer, outputsamples, decorrelate_stereo(alac->output_samples_buffer, alac->nb_samples,
interlacing_shift, interlacing_leftweight); decorr_shift, decorr_left_weight);
} }
if (alac->extra_bits) { if (alac->extra_bits) {
append_extra_bits(alac->outputsamples_buffer, alac->extra_bits_buffer, append_extra_bits(alac->output_samples_buffer, alac->extra_bits_buffer,
alac->extra_bits, alac->numchannels, outputsamples); alac->extra_bits, channels, alac->nb_samples);
} }
switch(alac->setinfo_sample_size) { switch(alac->sample_size) {
case 16: case 16: {
if (channels == 2) { for (ch = 0; ch < channels; ch++) {
interleave_stereo_16(alac->outputsamples_buffer, int16_t *outbuffer = (int16_t *)alac->frame.extended_data[ch_index + ch];
(int16_t *)alac->frame.data[0], outputsamples); for (i = 0; i < alac->nb_samples; i++)
} else { *outbuffer++ = alac->output_samples_buffer[ch][i];
int16_t *outbuffer = (int16_t *)alac->frame.data[0]; }}
for (i = 0; i < outputsamples; i++) {
outbuffer[i] = alac->outputsamples_buffer[0][i];
}
}
break; break;
case 24: case 24: {
if (channels == 2) { for (ch = 0; ch < channels; ch++) {
interleave_stereo_24(alac->outputsamples_buffer, for (i = 0; i < alac->nb_samples; i++)
(int32_t *)alac->frame.data[0], outputsamples); alac->output_samples_buffer[ch][i] <<= 8;
} else { }}
int32_t *outbuffer = (int32_t *)alac->frame.data[0];
for (i = 0; i < outputsamples; i++)
outbuffer[i] = alac->outputsamples_buffer[0][i] << 8;
}
break; break;
case 32:
if (channels == 2) {
interleave_stereo_32(alac->outputsamples_buffer,
(int32_t *)alac->frame.data[0], outputsamples);
} else {
int32_t *outbuffer = (int32_t *)alac->frame.data[0];
for (i = 0; i < outputsamples; i++)
outbuffer[i] = alac->outputsamples_buffer[0][i];
} }
return 0;
}
static int alac_decode_frame(AVCodecContext *avctx, void *data,
int *got_frame_ptr, AVPacket *avpkt)
{
ALACContext *alac = avctx->priv_data;
enum RawDataBlockType element;
int channels;
int ch, ret;
init_get_bits(&alac->gb, avpkt->data, avpkt->size * 8);
alac->nb_samples = 0;
ch = 0;
while (get_bits_left(&alac->gb)) {
element = get_bits(&alac->gb, 3);
if (element == TYPE_END)
break; break;
if (element > TYPE_CPE && element != TYPE_LFE) {
av_log(avctx, AV_LOG_ERROR, "syntax element unsupported: %d", element);
return AVERROR_PATCHWELCOME;
}
channels = (element == TYPE_CPE) ? 2 : 1;
if (ch + channels > alac->channels) {
av_log(avctx, AV_LOG_ERROR, "invalid element channel count\n");
return AVERROR_INVALIDDATA;
} }
if (input_buffer_size * 8 - get_bits_count(&alac->gb) > 8) ret = decode_element(avctx, data,
av_log(avctx, AV_LOG_ERROR, "Error : %d bits left\n", input_buffer_size * 8 - get_bits_count(&alac->gb)); alac_channel_layout_offsets[alac->channels - 1][ch],
channels);
if (ret < 0)
return ret;
ch += channels;
}
if (avpkt->size * 8 - get_bits_count(&alac->gb) > 8) {
av_log(avctx, AV_LOG_ERROR, "Error : %d bits left\n",
avpkt->size * 8 - get_bits_count(&alac->gb));
}
*got_frame_ptr = 1; *got_frame_ptr = 1;
*(AVFrame *)data = alac->frame; *(AVFrame *)data = alac->frame;
return input_buffer_size; return avpkt->size;
} }
static av_cold int alac_decode_close(AVCodecContext *avctx) static av_cold int alac_decode_close(AVCodecContext *avctx)
@ -570,9 +489,10 @@ static av_cold int alac_decode_close(AVCodecContext *avctx)
ALACContext *alac = avctx->priv_data; ALACContext *alac = avctx->priv_data;
int ch; int ch;
for (ch = 0; ch < alac->numchannels; ch++) { for (ch = 0; ch < FFMIN(alac->channels, 2); ch++) {
av_freep(&alac->predicterror_buffer[ch]); av_freep(&alac->predict_error_buffer[ch]);
av_freep(&alac->outputsamples_buffer[ch]); if (alac->sample_size == 16)
av_freep(&alac->output_samples_buffer[ch]);
av_freep(&alac->extra_bits_buffer[ch]); av_freep(&alac->extra_bits_buffer[ch]);
} }
@ -582,14 +502,16 @@ static av_cold int alac_decode_close(AVCodecContext *avctx)
static int allocate_buffers(ALACContext *alac) static int allocate_buffers(ALACContext *alac)
{ {
int ch; int ch;
for (ch = 0; ch < alac->numchannels; ch++) { int buf_size = alac->max_samples_per_frame * sizeof(int32_t);
int buf_size = alac->setinfo_max_samples_per_frame * sizeof(int32_t);
FF_ALLOC_OR_GOTO(alac->avctx, alac->predicterror_buffer[ch], for (ch = 0; ch < FFMIN(alac->channels, 2); ch++) {
FF_ALLOC_OR_GOTO(alac->avctx, alac->predict_error_buffer[ch],
buf_size, buf_alloc_fail); buf_size, buf_alloc_fail);
FF_ALLOC_OR_GOTO(alac->avctx, alac->outputsamples_buffer[ch], if (alac->sample_size == 16) {
FF_ALLOC_OR_GOTO(alac->avctx, alac->output_samples_buffer[ch],
buf_size, buf_alloc_fail); buf_size, buf_alloc_fail);
}
FF_ALLOC_OR_GOTO(alac->avctx, alac->extra_bits_buffer[ch], FF_ALLOC_OR_GOTO(alac->avctx, alac->extra_bits_buffer[ch],
buf_size, buf_alloc_fail); buf_size, buf_alloc_fail);
@ -609,19 +531,18 @@ static int alac_set_info(ALACContext *alac)
bytestream2_skipu(&gb, 12); // size:4, alac:4, version:4 bytestream2_skipu(&gb, 12); // size:4, alac:4, version:4
/* buffer size / 2 ? */ alac->max_samples_per_frame = bytestream2_get_be32u(&gb);
alac->setinfo_max_samples_per_frame = bytestream2_get_be32u(&gb); if (!alac->max_samples_per_frame || alac->max_samples_per_frame > INT_MAX) {
if (alac->setinfo_max_samples_per_frame >= UINT_MAX/4){ av_log(alac->avctx, AV_LOG_ERROR, "max samples per frame invalid: %u\n",
av_log(alac->avctx, AV_LOG_ERROR, alac->max_samples_per_frame);
"setinfo_max_samples_per_frame too large\n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
bytestream2_skipu(&gb, 1); // compatible version bytestream2_skipu(&gb, 1); // compatible version
alac->setinfo_sample_size = bytestream2_get_byteu(&gb); alac->sample_size = bytestream2_get_byteu(&gb);
alac->setinfo_rice_historymult = bytestream2_get_byteu(&gb); alac->rice_history_mult = bytestream2_get_byteu(&gb);
alac->setinfo_rice_initialhistory = bytestream2_get_byteu(&gb); alac->rice_initial_history = bytestream2_get_byteu(&gb);
alac->setinfo_rice_kmodifier = bytestream2_get_byteu(&gb); alac->rice_limit = bytestream2_get_byteu(&gb);
alac->numchannels = bytestream2_get_byteu(&gb); alac->channels = bytestream2_get_byteu(&gb);
bytestream2_get_be16u(&gb); // maxRun bytestream2_get_be16u(&gb); // maxRun
bytestream2_get_be32u(&gb); // max coded frame size bytestream2_get_be32u(&gb); // max coded frame size
bytestream2_get_be32u(&gb); // average bitrate bytestream2_get_be32u(&gb); // average bitrate
@ -647,31 +568,32 @@ static av_cold int alac_decode_init(AVCodecContext * avctx)
return -1; return -1;
} }
switch (alac->setinfo_sample_size) { switch (alac->sample_size) {
case 16: avctx->sample_fmt = AV_SAMPLE_FMT_S16; case 16: avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
break; break;
case 32: case 24:
case 24: avctx->sample_fmt = AV_SAMPLE_FMT_S32; case 32: avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
break; break;
default: av_log_ask_for_sample(avctx, "Sample depth %d is not supported.\n", default: av_log_ask_for_sample(avctx, "Sample depth %d is not supported.\n",
alac->setinfo_sample_size); alac->sample_size);
return AVERROR_PATCHWELCOME; return AVERROR_PATCHWELCOME;
} }
if (alac->numchannels < 1) { if (alac->channels < 1) {
av_log(avctx, AV_LOG_WARNING, "Invalid channel count\n"); av_log(avctx, AV_LOG_WARNING, "Invalid channel count\n");
alac->numchannels = avctx->channels; alac->channels = avctx->channels;
} else { } else {
if (alac->numchannels > MAX_CHANNELS) if (alac->channels > MAX_CHANNELS)
alac->numchannels = avctx->channels; alac->channels = avctx->channels;
else else
avctx->channels = alac->numchannels; avctx->channels = alac->channels;
} }
if (avctx->channels > MAX_CHANNELS) { if (avctx->channels > MAX_CHANNELS) {
av_log(avctx, AV_LOG_ERROR, "Unsupported channel count: %d\n", av_log(avctx, AV_LOG_ERROR, "Unsupported channel count: %d\n",
avctx->channels); avctx->channels);
return AVERROR_PATCHWELCOME; return AVERROR_PATCHWELCOME;
} }
avctx->channel_layout = alac_channel_layouts[alac->channels - 1];
if ((ret = allocate_buffers(alac)) < 0) { if ((ret = allocate_buffers(alac)) < 0) {
av_log(avctx, AV_LOG_ERROR, "Error allocating buffers\n"); av_log(avctx, AV_LOG_ERROR, "Error allocating buffers\n");

3
libavformat/aiffdec.c
Unescape View File

@ -275,9 +275,8 @@ static int aiff_read_header(AVFormatContext *s)
avio_read(pb, st->codec->extradata, size); avio_read(pb, st->codec->extradata, size);
break; break;
case MKTAG('C','H','A','N'): case MKTAG('C','H','A','N'):
if (size < 12) if(ff_mov_read_chan(s, st, size) < 0)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
ff_mov_read_chan(s, size, st->codec);
break; break;
default: /* Jump */ default: /* Jump */
if (size & 1) /* Always even aligned */ if (size & 1) /* Always even aligned */

55
libavformat/cafdec.c
Unescape View File

@ -29,6 +29,7 @@
#include "internal.h" #include "internal.h"
#include "riff.h" #include "riff.h"
#include "isom.h" #include "isom.h"
#include "mov_chan.h"
#include "libavutil/intreadwrite.h" #include "libavutil/intreadwrite.h"
#include "libavutil/intfloat.h" #include "libavutil/intfloat.h"
#include "libavutil/dict.h" #include "libavutil/dict.h"
@ -122,27 +123,39 @@ static int read_kuki_chunk(AVFormatContext *s, int64_t size)
#define ALAC_PREAMBLE 12 #define ALAC_PREAMBLE 12
#define ALAC_HEADER 36 #define ALAC_HEADER 36
#define ALAC_NEW_KUKI 24 #define ALAC_NEW_KUKI 24
if (size == ALAC_NEW_KUKI) { uint8_t preamble[12];
st->codec->extradata = av_mallocz(ALAC_HEADER + FF_INPUT_BUFFER_PADDING_SIZE); if (size < ALAC_NEW_KUKI || size > ALAC_PREAMBLE + ALAC_HEADER) {
if (!st->codec->extradata)
return AVERROR(ENOMEM);
memcpy(st->codec->extradata, "\0\0\0\24alac", 8);
avio_read(pb, st->codec->extradata + ALAC_HEADER - ALAC_NEW_KUKI, ALAC_NEW_KUKI);
st->codec->extradata_size = ALAC_HEADER;
} else {
if (size < ALAC_PREAMBLE + ALAC_HEADER) {
av_log(s, AV_LOG_ERROR, "invalid ALAC magic cookie\n"); av_log(s, AV_LOG_ERROR, "invalid ALAC magic cookie\n");
avio_skip(pb, size); avio_skip(pb, size);
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
avio_skip(pb, ALAC_PREAMBLE); avio_read(pb, preamble, ALAC_PREAMBLE);
st->codec->extradata = av_mallocz(ALAC_HEADER + FF_INPUT_BUFFER_PADDING_SIZE); st->codec->extradata = av_mallocz(ALAC_HEADER + FF_INPUT_BUFFER_PADDING_SIZE);
if (!st->codec->extradata) if (!st->codec->extradata)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
/* For the old style cookie, we skip 12 bytes, then read 36 bytes.
* The new style cookie only contains the last 24 bytes of what was
* 36 bytes in the old style cookie, so we fabricate the first 12 bytes
* in that case to maintain compatibility. */
if (!memcmp(&preamble[4], "frmaalac", 8)) {
if (size < ALAC_PREAMBLE + ALAC_HEADER) {
av_log(s, AV_LOG_ERROR, "invalid ALAC magic cookie\n");
av_freep(&st->codec->extradata);
return AVERROR_INVALIDDATA;
}
avio_read(pb, st->codec->extradata, ALAC_HEADER); avio_read(pb, st->codec->extradata, ALAC_HEADER);
st->codec->extradata_size = ALAC_HEADER;
avio_skip(pb, size - ALAC_PREAMBLE - ALAC_HEADER); avio_skip(pb, size - ALAC_PREAMBLE - ALAC_HEADER);
} else {
AV_WB32(st->codec->extradata, 36);
memcpy(&st->codec->extradata[4], "alac", 4);
AV_WB32(&st->codec->extradata[8], 0);
memcpy(&st->codec->extradata[12], preamble, 12);
avio_read(pb, &st->codec->extradata[24], ALAC_NEW_KUKI - 12);
avio_skip(pb, size - ALAC_NEW_KUKI);
} }
st->codec->extradata_size = ALAC_HEADER;
} else { } else {
st->codec->extradata = av_mallocz(size + FF_INPUT_BUFFER_PADDING_SIZE); st->codec->extradata = av_mallocz(size + FF_INPUT_BUFFER_PADDING_SIZE);
if (!st->codec->extradata) if (!st->codec->extradata)
@ -160,8 +173,8 @@ static int read_pakt_chunk(AVFormatContext *s, int64_t size)
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
AVStream *st = s->streams[0]; AVStream *st = s->streams[0];
CaffContext *caf = s->priv_data; CaffContext *caf = s->priv_data;
int64_t pos = 0, ccount; int64_t pos = 0, ccount, num_packets;
int num_packets, i; int i;
ccount = avio_tell(pb); ccount = avio_tell(pb);
@ -180,10 +193,11 @@ static int read_pakt_chunk(AVFormatContext *s, int64_t size)
st->duration += caf->frames_per_packet ? caf->frames_per_packet : ff_mp4_read_descr_len(pb); st->duration += caf->frames_per_packet ? caf->frames_per_packet : ff_mp4_read_descr_len(pb);
} }
if (avio_tell(pb) - ccount != size) { if (avio_tell(pb) - ccount > size) {
av_log(s, AV_LOG_ERROR, "error reading packet table\n"); av_log(s, AV_LOG_ERROR, "error reading packet table\n");
return -1; return AVERROR_INVALIDDATA;
} }
avio_skip(pb, ccount + size - avio_tell(pb));
caf->num_bytes = pos; caf->num_bytes = pos;
return 0; return 0;
@ -253,6 +267,11 @@ static int read_header(AVFormatContext *s)
found_data = 1; found_data = 1;
break; break;
case MKBETAG('c','h','a','n'):
if ((ret = ff_mov_read_chan(s, st, size)) < 0)
return ret;
break;
/* magic cookie chunk */ /* magic cookie chunk */
case MKBETAG('k','u','k','i'): case MKBETAG('k','u','k','i'):
if (read_kuki_chunk(s, size)) if (read_kuki_chunk(s, size))
@ -269,12 +288,6 @@ static int read_header(AVFormatContext *s)
read_info_chunk(s, size); read_info_chunk(s, size);
break; break;
case MKBETAG('c','h','a','n'):
if (size < 12)
return AVERROR_INVALIDDATA;
ff_mov_read_chan(s, size, st->codec);
break;
default: default:
#define _(x) ((x) >= ' ' ? (x) : ' ') #define _(x) ((x) >= ' ' ? (x) : ' ')
av_log(s, AV_LOG_WARNING, "skipping CAF chunk: %08X (%c%c%c%c), size %"PRId64"\n", av_log(s, AV_LOG_WARNING, "skipping CAF chunk: %08X (%c%c%c%c), size %"PRId64"\n",

16
libavformat/isom.c
Unescape View File

@ -499,25 +499,30 @@ static const MovChannelLayout mov_channel_layout[] = {
{ AV_CH_LAYOUT_4POINT0|AV_CH_LOW_FREQUENCY, (137<<16) | 5}, // kCAFChannelLayoutTag_DVD_11 { AV_CH_LAYOUT_4POINT0|AV_CH_LOW_FREQUENCY, (137<<16) | 5}, // kCAFChannelLayoutTag_DVD_11
{ 0, 0}, { 0, 0},
}; };
#if 0
void ff_mov_read_chan(AVFormatContext *s, int64_t size, AVCodecContext *codec) int ff_mov_read_chan(AVFormatContext *s, AVStream *st, int64_t size)
{ {
AVCodecContext *codec= st->codec;
uint32_t layout_tag; uint32_t layout_tag;
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
const MovChannelLayout *layouts = mov_channel_layout; const MovChannelLayout *layouts = mov_channel_layout;
if (size < 12)
return AVERROR_INVALIDDATA;
layout_tag = avio_rb32(pb); layout_tag = avio_rb32(pb);
size -= 4; size -= 4;
if (layout_tag == 0) { // kCAFChannelLayoutTag_UseChannelDescriptions if (layout_tag == 0) { // kCAFChannelLayoutTag_UseChannelDescriptions
// Channel descriptions not implemented // Channel descriptions not implemented
av_log_ask_for_sample(s, "Unimplemented container channel layout.\n"); av_log_ask_for_sample(s, "Unimplemented container channel layout.\n");
avio_skip(pb, size); avio_skip(pb, size);
return; return 0;
} }
if (layout_tag == 0x10000) { // kCAFChannelLayoutTag_UseChannelBitmap if (layout_tag == 0x10000) { // kCAFChannelLayoutTag_UseChannelBitmap
codec->channel_layout = avio_rb32(pb); codec->channel_layout = avio_rb32(pb);
size -= 4; size -= 4;
avio_skip(pb, size); avio_skip(pb, size);
return; return 0;
} }
while (layouts->channel_layout) { while (layouts->channel_layout) {
if (layout_tag == layouts->layout_tag) { if (layout_tag == layouts->layout_tag) {
@ -529,7 +534,10 @@ void ff_mov_read_chan(AVFormatContext *s, int64_t size, AVCodecContext *codec)
if (!codec->channel_layout) if (!codec->channel_layout)
av_log(s, AV_LOG_WARNING, "Unknown container channel layout.\n"); av_log(s, AV_LOG_WARNING, "Unknown container channel layout.\n");
avio_skip(pb, size); avio_skip(pb, size);
return 0;
} }
#endif
void ff_mov_write_chan(AVIOContext *pb, int64_t channel_layout) void ff_mov_write_chan(AVIOContext *pb, int64_t channel_layout)
{ {

2
libavformat/isom.h
Unescape View File

@ -197,7 +197,7 @@ int ff_mov_read_esds(AVFormatContext *fc, AVIOContext *pb, MOVAtom atom);
enum CodecID ff_mov_get_lpcm_codec_id(int bps, int flags); enum CodecID ff_mov_get_lpcm_codec_id(int bps, int flags);
int ff_mov_read_stsd_entries(MOVContext *c, AVIOContext *pb, int entries); int ff_mov_read_stsd_entries(MOVContext *c, AVIOContext *pb, int entries);
void ff_mov_read_chan(AVFormatContext *s, int64_t size, AVCodecContext *codec); int ff_mov_read_chan(AVFormatContext *s, AVStream *st, int64_t size);
void ff_mov_write_chan(AVIOContext *pb, int64_t channel_layout); void ff_mov_write_chan(AVIOContext *pb, int64_t channel_layout);
#endif /* AVFORMAT_ISOM_H */ #endif /* AVFORMAT_ISOM_H */

41
libavformat/mov.c
Unescape View File

@ -597,10 +597,6 @@ static int mov_read_dec3(MOVContext *c, AVIOContext *pb, MOVAtom atom)
static int mov_read_chan(MOVContext *c, AVIOContext *pb, MOVAtom atom) static int mov_read_chan(MOVContext *c, AVIOContext *pb, MOVAtom atom)
{ {
AVStream *st; AVStream *st;
uint8_t av_unused version;
uint32_t av_unused flags;
uint32_t layout_tag, bitmap, num_descr, label_mask;
int i;
if (c->fc->nb_streams < 1) if (c->fc->nb_streams < 1)
return 0; return 0;
@ -609,40 +605,7 @@ static int mov_read_chan(MOVContext *c, AVIOContext *pb, MOVAtom atom)
if (atom.size < 16) if (atom.size < 16)
return 0; return 0;
version = avio_r8(pb); ff_mov_read_chan(c->fc, st, atom.size - 4);
flags = avio_rb24(pb);
layout_tag = avio_rb32(pb);
bitmap = avio_rb32(pb);
num_descr = avio_rb32(pb);
if (atom.size < 16ULL + num_descr * 20ULL)
return 0;
av_dlog(c->fc, "chan: size=%" PRId64 " version=%u flags=%u layout=%u bitmap=%u num_descr=%u\n",
atom.size, version, flags, layout_tag, bitmap, num_descr);
label_mask = 0;
for (i = 0; i < num_descr; i++) {
uint32_t label;
label = avio_rb32(pb); // mChannelLabel
avio_rb32(pb); // mChannelFlags
avio_rl32(pb); // mCoordinates[0]
avio_rl32(pb); // mCoordinates[1]
avio_rl32(pb); // mCoordinates[2]
if (layout_tag == 0) {
uint32_t mask_incr = ff_mov_get_channel_label(label);
if (mask_incr == 0) {
label_mask = 0;
break;
}
label_mask |= mask_incr;
}
}
if (layout_tag == 0)
st->codec->channel_layout = label_mask;
else
st->codec->channel_layout = ff_mov_get_channel_layout(layout_tag, bitmap);
return 0; return 0;
} }
@ -2556,7 +2519,7 @@ static int mov_read_chan2(MOVContext *c, AVIOContext *pb, MOVAtom atom)
if (atom.size < 16) if (atom.size < 16)
return 0; return 0;
avio_skip(pb, 4); avio_skip(pb, 4);
ff_mov_read_chan(c->fc, atom.size - 4, c->fc->streams[0]->codec); ff_mov_read_chan(c->fc,c->fc->streams[0], atom.size - 4);
return 0; return 0;
} }

46
libavformat/mov_chan.c
Unescape View File

@ -477,7 +477,7 @@ uint64_t ff_mov_get_channel_layout(uint32_t tag, uint32_t bitmap)
return layout_map[i].layout; return layout_map[i].layout;
} }
uint32_t ff_mov_get_channel_label(uint32_t label) static uint32_t mov_get_channel_label(uint32_t label)
{ {
if (label == 0) if (label == 0)
return 0; return 0;
@ -542,3 +542,47 @@ uint32_t ff_mov_get_channel_layout_tag(enum CodecID codec_id,
return tag; return tag;
} }
int ff_mov_read_chan(AVFormatContext *s, AVStream *st, int64_t size)
{
AVIOContext *pb = s->pb;
uint32_t layout_tag, bitmap, num_descr, label_mask;
int i;
if (size < 12)
return AVERROR_INVALIDDATA;
layout_tag = avio_rb32(pb);
bitmap = avio_rb32(pb);
num_descr = avio_rb32(pb);
av_dlog(s, "chan: layout=%u bitmap=%u num_descr=%u\n",
layout_tag, bitmap, num_descr);
if (size < 12ULL + num_descr * 20ULL)
return 0;
label_mask = 0;
for (i = 0; i < num_descr; i++) {
uint32_t label;
label = avio_rb32(pb); // mChannelLabel
avio_rb32(pb); // mChannelFlags
avio_rl32(pb); // mCoordinates[0]
avio_rl32(pb); // mCoordinates[1]
avio_rl32(pb); // mCoordinates[2]
if (layout_tag == 0) {
uint32_t mask_incr = mov_get_channel_label(label);
if (mask_incr == 0) {
label_mask = 0;
break;
}
label_mask |= mask_incr;
}
}
if (layout_tag == 0)
st->codec->channel_layout = label_mask;
else
st->codec->channel_layout = ff_mov_get_channel_layout(layout_tag, bitmap);
return 0;
}

19
libavformat/mov_chan.h
Unescape View File

@ -29,6 +29,7 @@
#include <stdint.h> #include <stdint.h>
#include "libavcodec/avcodec.h" #include "libavcodec/avcodec.h"
#include "avformat.h"
/** /**
* Get the channel layout for the specified channel layout tag. * Get the channel layout for the specified channel layout tag.
@ -39,14 +40,6 @@
*/ */
uint64_t ff_mov_get_channel_layout(uint32_t tag, uint32_t bitmap); uint64_t ff_mov_get_channel_layout(uint32_t tag, uint32_t bitmap);
/**
* Get the channel layout for the specified channel label.
*
* @param[in] label channel label
* @return channel layout mask fragment
*/
uint32_t ff_mov_get_channel_label(uint32_t label);
/** /**
* Get the channel layout tag for the specified codec id and channel layout. * Get the channel layout tag for the specified codec id and channel layout.
* If the layout tag was not found, use a channel bitmap if possible. * If the layout tag was not found, use a channel bitmap if possible.
@ -60,4 +53,14 @@ uint32_t ff_mov_get_channel_layout_tag(enum CodecID codec_id,
uint64_t channel_layout, uint64_t channel_layout,
uint32_t *bitmap); uint32_t *bitmap);
/**
* Read 'chan' tag from the input stream.
*
* @param s AVFormatContext
* @param st The stream to set codec values for
* @param size Remaining size in the 'chan' tag
* @return 0 if ok, or negative AVERROR code on failure
*/
int ff_mov_read_chan(AVFormatContext *s, AVStream *st, int64_t size);
#endif /* AVFORMAT_MOV_CHAN_H */ #endif /* AVFORMAT_MOV_CHAN_H */

Write Preview
Loading…
Cancel
Save