{
int i;
- if (s->bitshift != 0)
+ if (s->bitshift == 32) {
+ for (i = 0; i < s->blocksize; i++)
+ buffer[i] = 0;
+ } else if (s->bitshift != 0) {
for (i = 0; i < s->blocksize; i++)
buffer[i] <<= s->bitshift;
+ }
}
static int init_offset(ShortenContext *s)
return 0;
}
+static int decode_aiff_header(AVCodecContext *avctx, const uint8_t *header,
+ int header_size)
+{
+ int len, bps, exp;
+ GetByteContext gb;
+ uint64_t val;
+ uint32_t tag;
+
+ bytestream2_init(&gb, header, header_size);
+
+ if (bytestream2_get_le32(&gb) != MKTAG('F', 'O', 'R', 'M')) {
+ av_log(avctx, AV_LOG_ERROR, "missing FORM tag\n");
+ return AVERROR_INVALIDDATA;
+ }
+
+ bytestream2_skip(&gb, 4); /* chunk size */
+
+ tag = bytestream2_get_le32(&gb);
+ if (tag != MKTAG('A', 'I', 'F', 'F')) {
+ av_log(avctx, AV_LOG_ERROR, "missing AIFF tag\n");
+ return AVERROR_INVALIDDATA;
+ }
+
+ while (bytestream2_get_le32(&gb) != MKTAG('C', 'O', 'M', 'M')) {
+ len = bytestream2_get_be32(&gb);
+ bytestream2_skip(&gb, len + (len & 1));
+ if (len < 0 || bytestream2_get_bytes_left(&gb) < 18) {
+ av_log(avctx, AV_LOG_ERROR, "no COMM chunk found\n");
+ return AVERROR_INVALIDDATA;
+ }
+ }
+ len = bytestream2_get_be32(&gb);
+
+ if (len < 18) {
+ av_log(avctx, AV_LOG_ERROR, "COMM chunk was too short\n");
+ return AVERROR_INVALIDDATA;
+ }
+
+ bytestream2_skip(&gb, 6);
+ bps = bytestream2_get_be16(&gb);
+ avctx->bits_per_coded_sample = bps;
+
+ if (bps != 16 && bps != 8) {
+ av_log(avctx, AV_LOG_ERROR, "unsupported number of bits per sample: %d\n", bps);
+ return AVERROR(ENOSYS);
+ }
+
+ exp = bytestream2_get_be16(&gb) - 16383 - 63;
+ val = bytestream2_get_be64(&gb);
+ if (exp < -63 || exp > 63) {
+ av_log(avctx, AV_LOG_ERROR, "exp %d is out of range\n", exp);
+ return AVERROR_INVALIDDATA;
+ }
+ if (exp >= 0)
+ avctx->sample_rate = val << exp;
+ else
+ avctx->sample_rate = (val + (1ULL<<(-exp-1))) >> -exp;
+ len -= 18;
+ if (len > 0)
+ av_log(avctx, AV_LOG_INFO, "%d header bytes unparsed\n", len);
+
+ return 0;
+}
+
static int decode_wave_header(AVCodecContext *avctx, const uint8_t *header,
int header_size)
{
for (i = 0; i < s->header_size; i++)
s->header[i] = (char)get_ur_golomb_shorten(&s->gb, VERBATIM_BYTE_SIZE);
- if ((ret = decode_wave_header(s->avctx, s->header, s->header_size)) < 0)
- return ret;
+ if (AV_RL32(s->header) == MKTAG('R','I','F','F')) {
+ if ((ret = decode_wave_header(s->avctx, s->header, s->header_size)) < 0)
+ return ret;
+ } else if (AV_RL32(s->header) == MKTAG('F','O','R','M')) {
+ if ((ret = decode_aiff_header(s->avctx, s->header, s->header_size)) < 0)
+ return ret;
+ } else {
+ avpriv_report_missing_feature(s->avctx, "unsupported bit packing %X", AV_RL32(s->header));
+ return AVERROR_PATCHWELCOME;
+ }
end:
s->cur_chan = 0;
}
/* append current packet data to bitstream buffer */
- if (1 && s->max_framesize) { //FIXME truncated
- buf_size = FFMIN(buf_size, s->max_framesize - s->bitstream_size);
- input_buf_size = buf_size;
-
- if (s->bitstream_index + s->bitstream_size + buf_size + AV_INPUT_BUFFER_PADDING_SIZE >
- s->allocated_bitstream_size) {
- memmove(s->bitstream, &s->bitstream[s->bitstream_index],
- s->bitstream_size);
- s->bitstream_index = 0;
- }
- if (buf)
- memcpy(&s->bitstream[s->bitstream_index + s->bitstream_size], buf,
- buf_size);
- buf = &s->bitstream[s->bitstream_index];
- buf_size += s->bitstream_size;
- s->bitstream_size = buf_size;
-
- /* do not decode until buffer has at least max_framesize bytes or
- * the end of the file has been reached */
- if (buf_size < s->max_framesize && avpkt->data) {
- *got_frame_ptr = 0;
- return input_buf_size;
- }
+ buf_size = FFMIN(buf_size, s->max_framesize - s->bitstream_size);
+ input_buf_size = buf_size;
+
+ if (s->bitstream_index + s->bitstream_size + buf_size + AV_INPUT_BUFFER_PADDING_SIZE >
+ s->allocated_bitstream_size) {
+ memmove(s->bitstream, &s->bitstream[s->bitstream_index],
+ s->bitstream_size);
+ s->bitstream_index = 0;
+ }
+ if (buf)
+ memcpy(&s->bitstream[s->bitstream_index + s->bitstream_size], buf,
+ buf_size);
+ buf = &s->bitstream[s->bitstream_index];
+ buf_size += s->bitstream_size;
+ s->bitstream_size = buf_size;
+
+ /* do not decode until buffer has at least max_framesize bytes or
+ * the end of the file has been reached */
+ if (buf_size < s->max_framesize && avpkt->data) {
+ *got_frame_ptr = 0;
+ return input_buf_size;
}
/* init and position bitstream reader */
if ((ret = init_get_bits8(&s->gb, buf, buf_size)) < 0)
/* process header or next subblock */
if (!s->got_header) {
+
if ((ret = read_header(s)) < 0)
return ret;
- *got_frame_ptr = 0;
- goto finish_frame;
+
+ if (avpkt->size) {
+ int max_framesize;
+ void *tmp_ptr;
+
+ max_framesize = FFMAX(s->max_framesize, s->blocksize * s->channels * 2);
+ tmp_ptr = av_fast_realloc(s->bitstream, &s->allocated_bitstream_size,
+ max_framesize + AV_INPUT_BUFFER_PADDING_SIZE);
+ if (!tmp_ptr) {
+ av_log(avctx, AV_LOG_ERROR, "error allocating bitstream buffer\n");
+ return AVERROR(ENOMEM);
+ }
+ s->bitstream = tmp_ptr;
+ s->max_framesize = max_framesize;
+ *got_frame_ptr = 0;
+ goto finish_frame;
+ }
}
/* if quit command was read previously, don't decode anything */
break;
case FN_BITSHIFT: {
unsigned bitshift = get_ur_golomb_shorten(&s->gb, BITSHIFTSIZE);
- if (bitshift > 31) {
+ if (bitshift > 32) {
av_log(avctx, AV_LOG_ERROR, "bitshift %d is invalid\n",
bitshift);
return AVERROR_INVALIDDATA;
if (s->version < 2)
s->offset[channel][s->nmean - 1] = sum / s->blocksize;
else
- s->offset[channel][s->nmean - 1] = (sum / s->blocksize) << s->bitshift;
+ s->offset[channel][s->nmean - 1] = s->bitshift == 32 ? 0 : (sum / s->blocksize) << s->bitshift;
}
/* copy wrap samples for use with next block */
.init = shorten_decode_init,
.close = shorten_decode_close,
.decode = shorten_decode_frame,
- .capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_DR1,
+ .capabilities = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DELAY | AV_CODEC_CAP_DR1,
.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,
AV_SAMPLE_FMT_U8P,
AV_SAMPLE_FMT_NONE },
projects / ffmpeg / blobdiff