Merge remote-tracking branch 'qatar/master'

* qatar/master: (22 commits)
  prores: add FATE tests
  id3v2: reduce the scope of some non-globally-used symbols/structures
  id3v2: cosmetics: move some declarations before the places they are used
  shorten: remove the flush function.
  shn: do not allow seeking in the raw shn demuxer.
  avformat: add AVInputFormat flag AVFMT_NO_BYTE_SEEK.
  avformat: update AVInputFormat allowed flags
  avformat: don't unconditionally call ff_read_frame_flush() when trying to seek.
  truespeech: use sizeof() instead of hardcoded sizes
  truespeech: remove unneeded variable, 'consumed'
  truespeech: simplify truespeech_read_frame() by using get_bits()
  truespeech: decode directly to output buffer instead of a temp buffer
  truespeech: check to make sure channels == 1
  truespeech: check for large enough output buffer rather than truncating output
  truespeech: remove unneeded zero-size packet check.
  mlpdec: return meaningful error codes instead of -1
  mlpdec: remove unnecessary wrapper function
  mlpdec: only calculate output size once
  mlpdec: validate that the reported channel count matches the actual output channel count
  pcm: reduce pointer type casting
  ...

Conflicts:
	libavformat/avformat.h
	libavformat/id3v2.c
	libavformat/id3v2.h
	libavformat/utils.c
	libavformat/version.h

Merged-by: Michael Niedermayer <michaelni@gmx.at>

1 files changed, 73 insertions, 69 deletions

diff --git a/libavcodec/mlpdec.c b/libavcodec/mlpdec.c
index 9e59b92342..0396423b92 100644
--- a/libavcodec/mlpdec.c
+++ b/libavcodec/mlpdec.c
@@ -217,7 +217,7 @@ static inline int read_huff_channels(MLPDecodeContext *m, GetBitContext *gbp,
                             VLC_BITS, (9 + VLC_BITS - 1) / VLC_BITS);
 
         if (result < 0)
-            return -1;
+            return AVERROR_INVALIDDATA;
 
         if (lsb_bits > 0)
             result = (result << lsb_bits) + get_bits(gbp, lsb_bits);
@@ -253,61 +253,61 @@ static av_cold int mlp_decode_init(AVCodecContext *avctx)
 static int read_major_sync(MLPDecodeContext *m, GetBitContext *gb)
 {
     MLPHeaderInfo mh;
-    int substr;
+    int substr, ret;
 
-    if (ff_mlp_read_major_sync(m->avctx, &mh, gb) != 0)
-        return -1;
+    if ((ret = ff_mlp_read_major_sync(m->avctx, &mh, gb)) != 0)
+        return ret;
 
     if (mh.group1_bits == 0) {
         av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown bits per sample\n");
-        return -1;
+        return AVERROR_INVALIDDATA;
     }
     if (mh.group2_bits > mh.group1_bits) {
         av_log(m->avctx, AV_LOG_ERROR,
                "Channel group 2 cannot have more bits per sample than group 1.\n");
-        return -1;
+        return AVERROR_INVALIDDATA;
     }
 
     if (mh.group2_samplerate && mh.group2_samplerate != mh.group1_samplerate) {
         av_log(m->avctx, AV_LOG_ERROR,
                "Channel groups with differing sample rates are not currently supported.\n");
-        return -1;
+        return AVERROR_INVALIDDATA;
     }
 
     if (mh.group1_samplerate == 0) {
         av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown sampling rate\n");
-        return -1;
+        return AVERROR_INVALIDDATA;
     }
     if (mh.group1_samplerate > MAX_SAMPLERATE) {
         av_log(m->avctx, AV_LOG_ERROR,
                "Sampling rate %d is greater than the supported maximum (%d).\n",
                mh.group1_samplerate, MAX_SAMPLERATE);
-        return -1;
+        return AVERROR_INVALIDDATA;
     }
     if (mh.access_unit_size > MAX_BLOCKSIZE) {
         av_log(m->avctx, AV_LOG_ERROR,
                "Block size %d is greater than the supported maximum (%d).\n",
                mh.access_unit_size, MAX_BLOCKSIZE);
-        return -1;
+        return AVERROR_INVALIDDATA;
     }
     if (mh.access_unit_size_pow2 > MAX_BLOCKSIZE_POW2) {
         av_log(m->avctx, AV_LOG_ERROR,
                "Block size pow2 %d is greater than the supported maximum (%d).\n",
                mh.access_unit_size_pow2, MAX_BLOCKSIZE_POW2);
-        return -1;
+        return AVERROR_INVALIDDATA;
     }
 
     if (mh.num_substreams == 0)
-        return -1;
+        return AVERROR_INVALIDDATA;
     if (m->avctx->codec_id == CODEC_ID_MLP && mh.num_substreams > 2) {
         av_log(m->avctx, AV_LOG_ERROR, "MLP only supports up to 2 substreams.\n");
-        return -1;
+        return AVERROR_INVALIDDATA;
     }
     if (mh.num_substreams > MAX_SUBSTREAMS) {
         av_log(m->avctx, AV_LOG_ERROR,
                "Number of substreams %d is larger than the maximum supported "
                "by the decoder. %s\n", mh.num_substreams, sample_message);
-        return -1;
+        return AVERROR_INVALIDDATA;
     }
 
     m->access_unit_size      = mh.access_unit_size;
@@ -374,14 +374,14 @@ static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
     if (sync_word != 0x31ea >> 1) {
         av_log(m->avctx, AV_LOG_ERROR,
                "restart header sync incorrect (got 0x%04x)\n", sync_word);
-        return -1;
+        return AVERROR_INVALIDDATA;
     }
 
     s->noise_type = get_bits1(gbp);
 
     if (m->avctx->codec_id == CODEC_ID_MLP && s->noise_type) {
         av_log(m->avctx, AV_LOG_ERROR, "MLP must have 0x31ea sync word.\n");
-        return -1;
+        return AVERROR_INVALIDDATA;
     }
 
     skip_bits(gbp, 16); /* Output timestamp */
@@ -394,13 +394,13 @@ static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
         av_log(m->avctx, AV_LOG_ERROR,
                "Max matrix channel cannot be greater than %d.\n",
                max_matrix_channel);
-        return -1;
+        return AVERROR_INVALIDDATA;
     }
 
     if (s->max_channel != s->max_matrix_channel) {
         av_log(m->avctx, AV_LOG_ERROR,
                "Max channel must be equal max matrix channel.\n");
-        return -1;
+        return AVERROR_INVALIDDATA;
     }
 
     /* This should happen for TrueHD streams with >6 channels and MLP's noise
@@ -409,13 +409,13 @@ static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
         av_log(m->avctx, AV_LOG_ERROR,
                "Number of channels %d is larger than the maximum supported "
                "by the decoder. %s\n", s->max_channel+2, sample_message);
-        return -1;
+        return AVERROR_INVALIDDATA;
     }
 
     if (s->min_channel > s->max_channel) {
         av_log(m->avctx, AV_LOG_ERROR,
                "Substream min channel cannot be greater than max channel.\n");
-        return -1;
+        return AVERROR_INVALIDDATA;
     }
 
     if (m->avctx->request_channels > 0
@@ -454,7 +454,7 @@ static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
             av_log(m->avctx, AV_LOG_ERROR,
                    "Assignment of matrix channel %d to invalid output channel %d. %s\n",
                    ch, ch_assign, sample_message);
-            return -1;
+            return AVERROR_INVALIDDATA;
         }
         s->ch_assign[ch_assign] = ch;
     }
@@ -528,7 +528,7 @@ static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp,
 
     if (m->filter_changed[channel][filter]++ > 1) {
         av_log(m->avctx, AV_LOG_ERROR, "Filters may change only once per access unit.\n");
-        return -1;
+        return AVERROR_INVALIDDATA;
     }
 
     order = get_bits(gbp, 4);
@@ -536,7 +536,7 @@ static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp,
         av_log(m->avctx, AV_LOG_ERROR,
                "%cIR filter order %d is greater than maximum %d.\n",
                fchar, order, max_order);
-        return -1;
+        return AVERROR_INVALIDDATA;
     }
     fp->order = order;
 
@@ -552,13 +552,13 @@ static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp,
             av_log(m->avctx, AV_LOG_ERROR,
                    "%cIR filter coeff_bits must be between 1 and 16.\n",
                    fchar);
-            return -1;
+            return AVERROR_INVALIDDATA;
         }
         if (coeff_bits + coeff_shift > 16) {
             av_log(m->avctx, AV_LOG_ERROR,
                    "Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n",
                    fchar);
-            return -1;
+            return AVERROR_INVALIDDATA;
         }
 
         for (i = 0; i < order; i++)
@@ -570,7 +570,7 @@ static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp,
             if (filter == FIR) {
                 av_log(m->avctx, AV_LOG_ERROR,
                        "FIR filter has state data specified.\n");
-                return -1;
+                return AVERROR_INVALIDDATA;
             }
 
             state_bits  = get_bits(gbp, 4);
@@ -598,7 +598,7 @@ static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitCo
 
     if (m->matrix_changed++ > 1) {
         av_log(m->avctx, AV_LOG_ERROR, "Matrices may change only once per access unit.\n");
-        return -1;
+        return AVERROR_INVALIDDATA;
     }
 
     s->num_primitive_matrices = get_bits(gbp, 4);
@@ -607,7 +607,7 @@ static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitCo
         av_log(m->avctx, AV_LOG_ERROR,
                "Number of primitive matrices cannot be greater than %d.\n",
                max_primitive_matrices);
-        return -1;
+        return AVERROR_INVALIDDATA;
     }
 
     for (mat = 0; mat < s->num_primitive_matrices; mat++) {
@@ -620,12 +620,12 @@ static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitCo
             av_log(m->avctx, AV_LOG_ERROR,
                     "Invalid channel %d specified as output from matrix.\n",
                     s->matrix_out_ch[mat]);
-            return -1;
+            return AVERROR_INVALIDDATA;
         }
         if (frac_bits > 14) {
             av_log(m->avctx, AV_LOG_ERROR,
                     "Too many fractional bits specified.\n");
-            return -1;
+            return AVERROR_INVALIDDATA;
         }
 
         max_chan = s->max_matrix_channel;
@@ -658,27 +658,28 @@ static int read_channel_params(MLPDecodeContext *m, unsigned int substr,
     ChannelParams *cp = &s->channel_params[ch];
     FilterParams *fir = &cp->filter_params[FIR];
     FilterParams *iir = &cp->filter_params[IIR];
+    int ret;
 
     if (s->param_presence_flags & PARAM_FIR)
         if (get_bits1(gbp))
-            if (read_filter_params(m, gbp, substr, ch, FIR) < 0)
-                return -1;
+            if ((ret = read_filter_params(m, gbp, substr, ch, FIR)) < 0)
+                return ret;
 
     if (s->param_presence_flags & PARAM_IIR)
         if (get_bits1(gbp))
-            if (read_filter_params(m, gbp, substr, ch, IIR) < 0)
-                return -1;
+            if ((ret = read_filter_params(m, gbp, substr, ch, IIR)) < 0)
+                return ret;
 
     if (fir->order + iir->order > 8) {
         av_log(m->avctx, AV_LOG_ERROR, "Total filter orders too high.\n");
-        return -1;
+        return AVERROR_INVALIDDATA;
     }
 
     if (fir->order && iir->order &&
         fir->shift != iir->shift) {
         av_log(m->avctx, AV_LOG_ERROR,
                 "FIR and IIR filters must use the same precision.\n");
-        return -1;
+        return AVERROR_INVALIDDATA;
     }
     /* The FIR and IIR filters must have the same precision.
      * To simplify the filtering code, only the precision of the
@@ -697,7 +698,7 @@ static int read_channel_params(MLPDecodeContext *m, unsigned int substr,
 
     if (cp->huff_lsbs > 24) {
         av_log(m->avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n");
-        return -1;
+        return AVERROR_INVALIDDATA;
     }
 
     cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
@@ -713,6 +714,7 @@ static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,
 {
     SubStream *s = &m->substream[substr];
     unsigned int ch;
+    int ret;
 
     if (s->param_presence_flags & PARAM_PRESENCE)
         if (get_bits1(gbp))
@@ -724,14 +726,14 @@ static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,
             if (s->blocksize < 8 || s->blocksize > m->access_unit_size) {
                 av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize.");
                 s->blocksize = 0;
-                return -1;
+                return AVERROR_INVALIDDATA;
             }
         }
 
     if (s->param_presence_flags & PARAM_MATRIX)
         if (get_bits1(gbp))
-            if (read_matrix_params(m, substr, gbp) < 0)
-                return -1;
+            if ((ret = read_matrix_params(m, substr, gbp)) < 0)
+                return ret;
 
     if (s->param_presence_flags & PARAM_OUTSHIFT)
         if (get_bits1(gbp))
@@ -750,8 +752,8 @@ static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,
 
     for (ch = s->min_channel; ch <= s->max_channel; ch++)
         if (get_bits1(gbp))
-            if (read_channel_params(m, substr, gbp, ch) < 0)
-                return -1;
+            if ((ret = read_channel_params(m, substr, gbp, ch)) < 0)
+                return ret;
 
     return 0;
 }
@@ -793,6 +795,7 @@ static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp,
 {
     SubStream *s = &m->substream[substr];
     unsigned int i, ch, expected_stream_pos = 0;
+    int ret;
 
     if (s->data_check_present) {
         expected_stream_pos  = get_bits_count(gbp);
@@ -803,15 +806,15 @@ static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp,
 
     if (s->blockpos + s->blocksize > m->access_unit_size) {
         av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");
-        return -1;
+        return AVERROR_INVALIDDATA;
     }
 
     memset(&m->bypassed_lsbs[s->blockpos][0], 0,
            s->blocksize * sizeof(m->bypassed_lsbs[0]));
 
     for (i = 0; i < s->blocksize; i++)
-        if (read_huff_channels(m, gbp, substr, i) < 0)
-            return -1;
+        if ((ret = read_huff_channels(m, gbp, substr, i)) < 0)
+            return ret;
 
     for (ch = s->min_channel; ch <= s->max_channel; ch++)
         filter_channel(m, substr, ch);
@@ -942,16 +945,26 @@ static void rematrix_channels(MLPDecodeContext *m, unsigned int substr)
 
 /** Write the audio data into the output buffer. */
 
-static int output_data_internal(MLPDecodeContext *m, unsigned int substr,
-                                uint8_t *data, unsigned int *data_size, int is32)
+static int output_data(MLPDecodeContext *m, unsigned int substr,
+                       uint8_t *data, unsigned int *data_size)
 {
     SubStream *s = &m->substream[substr];
     unsigned int i, out_ch = 0;
+    int out_size;
     int32_t *data_32 = (int32_t*) data;
     int16_t *data_16 = (int16_t*) data;
+    int is32 = (m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
 
-    if (*data_size < (s->max_channel + 1) * s->blockpos * (is32 ? 4 : 2))
-        return -1;
+    if (m->avctx->channels != s->max_matrix_channel + 1) {
+        av_log(m->avctx, AV_LOG_ERROR, "channel count mismatch\n");
+        return AVERROR_INVALIDDATA;
+    }
+
+    out_size = s->blockpos * m->avctx->channels *
+               av_get_bytes_per_sample(m->avctx->sample_fmt);
+
+    if (*data_size < out_size)
+        return AVERROR(EINVAL);
 
     for (i = 0; i < s->blockpos; i++) {
         for (out_ch = 0; out_ch <= s->max_matrix_channel; out_ch++) {
@@ -964,21 +977,11 @@ static int output_data_internal(MLPDecodeContext *m, unsigned int substr,
         }
     }
 
-    *data_size = i * out_ch * (is32 ? 4 : 2);
+    *data_size = out_size;
 
     return 0;
 }
 
-static int output_data(MLPDecodeContext *m, unsigned int substr,
-                       uint8_t *data, unsigned int *data_size)
-{
-    if (m->avctx->sample_fmt == AV_SAMPLE_FMT_S32)
-        return output_data_internal(m, substr, data, data_size, 1);
-    else
-        return output_data_internal(m, substr, data, data_size, 0);
-}
-
-
 /** Read an access unit from the stream.
  *  @return negative on error, 0 if not enough data is present in the input stream,
  *  otherwise the number of bytes consumed. */
@@ -997,6 +1000,7 @@ static int read_access_unit(AVCodecContext *avctx, void* data, int *data_size,
     uint8_t substream_parity_present[MAX_SUBSTREAMS];
     uint16_t substream_data_len[MAX_SUBSTREAMS];
     uint8_t parity_bits;
+    int ret;
 
     if (buf_size < 4)
         return 0;
@@ -1004,7 +1008,7 @@ static int read_access_unit(AVCodecContext *avctx, void* data, int *data_size,
     length = (AV_RB16(buf) & 0xfff) * 2;
 
     if (length < 4 || length > buf_size)
-        return -1;
+        return AVERROR_INVALIDDATA;
 
     init_get_bits(&gb, (buf + 4), (length - 4) * 8);
 
@@ -1110,8 +1114,8 @@ static int read_access_unit(AVCodecContext *avctx, void* data, int *data_size,
             if (!s->restart_seen)
                 goto next_substr;
 
-            if (read_block_data(m, &gb, substr) < 0)
-                return -1;
+            if ((ret = read_block_data(m, &gb, substr)) < 0)
+                return ret;
 
             if (get_bits_count(&gb) >= substream_data_len[substr] * 8)
                 goto substream_length_mismatch;
@@ -1124,13 +1128,13 @@ static int read_access_unit(AVCodecContext *avctx, void* data, int *data_size,
             int shorten_by;
 
             if (get_bits(&gb, 16) != 0xD234)
-                return -1;
+                return AVERROR_INVALIDDATA;
 
             shorten_by = get_bits(&gb, 16);
             if      (m->avctx->codec_id == CODEC_ID_TRUEHD && shorten_by  & 0x2000)
                 s->blockpos -= FFMIN(shorten_by & 0x1FFF, s->blockpos);
             else if (m->avctx->codec_id == CODEC_ID_MLP    && shorten_by != 0xD234)
-                return -1;
+                return AVERROR_INVALIDDATA;
 
             if (substr == m->max_decoded_substream)
                 av_log(m->avctx, AV_LOG_INFO, "End of stream indicated.\n");
@@ -1164,18 +1168,18 @@ next_substr:
 
     rematrix_channels(m, m->max_decoded_substream);
 
-    if (output_data(m, m->max_decoded_substream, data, data_size) < 0)
-        return -1;
+    if ((ret = output_data(m, m->max_decoded_substream, data, data_size)) < 0)
+        return ret;
 
     return length;
 
 substream_length_mismatch:
     av_log(m->avctx, AV_LOG_ERROR, "substream %d length mismatch\n", substr);
-    return -1;
+    return AVERROR_INVALIDDATA;
 
 error:
     m->params_valid = 0;
-    return -1;
+    return AVERROR_INVALIDDATA;
 }
 
 AVCodec ff_mlp_decoder = {