mlpdec: return meaningful error codes instead of -1
authorJustin Ruggles <justin.ruggles@gmail.com>
Thu, 13 Oct 2011 02:47:50 +0000 (22:47 -0400)
committerJustin Ruggles <justin.ruggles@gmail.com>
Thu, 13 Oct 2011 19:13:02 +0000 (15:13 -0400)
libavcodec/mlp_parser.c
libavcodec/mlpdec.c

index e85eb72..e1f4c56 100644 (file)
@@ -138,11 +138,11 @@ int ff_mlp_read_major_sync(void *log, MLPHeaderInfo *mh, GetBitContext *gb)
     checksum = ff_mlp_checksum16(gb->buffer, 26);
     if (checksum != AV_RL16(gb->buffer+26)) {
         av_log(log, AV_LOG_ERROR, "major sync info header checksum error\n");
-        return -1;
+        return AVERROR_INVALIDDATA;
     }
 
     if (get_bits_long(gb, 24) != 0xf8726f) /* Sync words */
-        return -1;
+        return AVERROR_INVALIDDATA;
 
     mh->stream_type = get_bits(gb, 8);
 
@@ -173,7 +173,7 @@ int ff_mlp_read_major_sync(void *log, MLPHeaderInfo *mh, GetBitContext *gb)
 
         mh->channels_thd_stream2 = get_bits(gb, 13);
     } else
-        return -1;
+        return AVERROR_INVALIDDATA;
 
     mh->access_unit_size = 40 << (ratebits & 7);
     mh->access_unit_size_pow2 = 64 << (ratebits & 7);
index 794f896..cefd0b5 100644 (file)
@@ -214,7 +214,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);
@@ -250,61 +250,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;
@@ -351,14 +351,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 */
@@ -371,13 +371,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
@@ -386,13 +386,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
@@ -431,7 +431,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;
     }
@@ -487,7 +487,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);
@@ -495,7 +495,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;
 
@@ -511,13 +511,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++)
@@ -529,7 +529,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);
@@ -557,7 +557,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);
@@ -566,7 +566,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++) {
@@ -579,12 +579,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;
@@ -617,27 +617,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
@@ -656,7 +657,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);
@@ -672,6 +673,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))
@@ -683,14 +685,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))
@@ -709,8 +711,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;
 }
@@ -752,6 +754,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);
@@ -762,15 +765,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);
@@ -956,6 +959,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;
@@ -963,7 +967,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);
 
@@ -1069,8 +1073,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;
@@ -1083,13 +1087,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");
@@ -1123,18 +1127,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 = {