Merge commit 'fbbe487b1c1f21339cff9ca86c3dfc495ad1c2c6' into release/1.1
authorMichael Niedermayer <michaelni@gmx.at>
Tue, 27 Aug 2013 15:48:04 +0000 (17:48 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Tue, 27 Aug 2013 15:54:01 +0000 (17:54 +0200)
* commit 'fbbe487b1c1f21339cff9ca86c3dfc495ad1c2c6':
  indeo: Sanitize ff_ivi_init_planes fail paths
  indeo5: return proper error codes
  indeo: Bound-check before applying motion compensation
  indeo: Bound-check before applying transform
  indeo4: Validate scantable dimension
  indeo4: Check the quantization matrix index
  indeo4: Do not access missing reference MV
  ac3dec: Increment channel pointers only once per channel
  dca: Respect the current limits in the downmixing capabilities
  dca: Error out on missing DSYNC
  pcm: always use codec->id instead of codec_id
  mlpdec: Do not set invalid context in read_restart_header
  pcx: Do not overread source buffer in pcx_rle_decode
  wmavoice: conceal clearly corrupted blocks
  iff: Do not read over the source buffer
  qdm2: Conceal broken samples
  qdm2: refactor joined stereo support

Conflicts:
libavcodec/ac3dec.c
libavcodec/dcadec.c
libavcodec/iff.c
libavcodec/indeo4.c
libavcodec/indeo5.c
libavcodec/ivi_common.c
libavcodec/mlpdec.c
libavcodec/pcx.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
libavcodec/dcadec.c
libavcodec/indeo4.c
libavcodec/indeo5.c
libavcodec/ivi_common.c
libavcodec/ivi_common.h
libavcodec/mlpdec.c
libavcodec/pcm.c
libavcodec/pcx.c
libavcodec/qdm2.c
libavcodec/wmavoice.c

Simple merge
@@@ -353,39 -348,37 +354,52 @@@ static int decode_band_hdr(IVI45DecCont
              band->inv_transform = transforms[transform_id].inv_trans;
              band->dc_transform  = transforms[transform_id].dc_trans;
              band->is_2d_trans   = transforms[transform_id].is_2d_trans;
-             band->transform_size= (transform_id < 10) ? 8 : 4;
+             if (transform_id < 10)
+                 band->transform_size = 8;
+             else
+                 band->transform_size = 4;
+             if (band->blk_size != band->transform_size)
+                 return AVERROR_INVALIDDATA;
  
              scan_indx = get_bits(&ctx->gb, 4);
 +            if ((scan_indx>4 && scan_indx<10) != (band->blk_size==4)) {
 +                av_log(avctx, AV_LOG_ERROR, "mismatching scan table!\n");
 +                return AVERROR_INVALIDDATA;
 +            }
              if (scan_indx == 15) {
                  av_log(avctx, AV_LOG_ERROR, "Custom scan pattern encountered!\n");
                  return AVERROR_INVALIDDATA;
              }
+             if (scan_indx > 4 && scan_indx < 10) {
+                 if (band->blk_size != 4)
+                     return AVERROR_INVALIDDATA;
+             } else if (band->blk_size != 8)
+                 return AVERROR_INVALIDDATA;
              band->scan = scan_index_to_tab[scan_indx];
 +            band->scan_size = band->blk_size;
  
 -            band->quant_mat = get_bits(&ctx->gb, 5);
 -            if (band->quant_mat == 31) {
 +            quant_mat = get_bits(&ctx->gb, 5);
 +            if (quant_mat == 31) {
                  av_log(avctx, AV_LOG_ERROR, "Custom quant matrix encountered!\n");
                  return AVERROR_INVALIDDATA;
              }
-             if (quant_mat > 21) {
-                 av_log(avctx, AV_LOG_ERROR, "Invalid quant matrix encountered!\n");
 -            if (band->quant_mat >= FF_ARRAY_ELEMS(quant_index_to_tab)) {
++            if (quant_mat >= FF_ARRAY_ELEMS(quant_index_to_tab)) {
+                 av_log_ask_for_sample(avctx, "Quantization matrix %d",
 -                                      band->quant_mat);
++                                      quant_mat);
                  return AVERROR_INVALIDDATA;
              }
 +            band->quant_mat = quant_mat;
 +        }
 +        if (quant_index_to_tab[band->quant_mat] > 4 && band->blk_size == 4) {
 +            av_log(avctx, AV_LOG_ERROR, "Invalid quant matrix for 4x4 block encountered!\n");
 +            band->quant_mat = 0;
 +            return AVERROR_INVALIDDATA;
 +        }
 +        if (band->scan_size != band->blk_size) {
 +            av_log(avctx, AV_LOG_ERROR, "mismatching scan table!\n");
 +            return AVERROR_INVALIDDATA;
          }
  
          /* decode block huffman codebook */
@@@ -81,11 -81,11 +81,11 @@@ static int decode_gop_header(IVI45DecCo
      /* num_levels * 3 + 1 */
      pic_conf.luma_bands   = get_bits(&ctx->gb, 2) * 3 + 1;
      pic_conf.chroma_bands = get_bits1(&ctx->gb)   * 3 + 1;
 -    ctx->is_scalable = pic_conf.luma_bands != 1 || pic_conf.chroma_bands != 1;
 -    if (ctx->is_scalable && (pic_conf.luma_bands != 4 || pic_conf.chroma_bands != 1)) {
 +    is_scalable = pic_conf.luma_bands != 1 || pic_conf.chroma_bands != 1;
 +    if (is_scalable && (pic_conf.luma_bands != 4 || pic_conf.chroma_bands != 1)) {
          av_log(avctx, AV_LOG_ERROR, "Scalability: unsupported subdivision! Luma bands: %d, chroma bands: %d\n",
                 pic_conf.luma_bands, pic_conf.chroma_bands);
-         return -1;
+         return AVERROR_INVALIDDATA;
      }
  
      pic_size_indx = get_bits(&ctx->gb, 4);
      }
  
      /* check if picture layout was changed and reallocate buffers */
-     if (ivi_pic_config_cmp(&pic_conf, &ctx->pic_conf)) {
+     if (ivi_pic_config_cmp(&pic_conf, &ctx->pic_conf) || ctx->gop_invalid) {
          result = ff_ivi_init_planes(ctx->planes, &pic_conf);
-         if (result) {
+         if (result < 0) {
              av_log(avctx, AV_LOG_ERROR, "Couldn't reallocate color planes!\n");
-             return -1;
+             return result;
          }
          ctx->pic_conf = pic_conf;
 +        ctx->is_scalable = is_scalable;
          blk_size_changed = 1; /* force reallocation of the internal structures */
      }
  
@@@ -411,6 -418,24 +422,20 @@@ static int ivi_dec_tile_data_size(GetBi
      return len;
  }
  
 -    if (!band->dc_transform)
 -        return 0;
 -
 -
+ static int ivi_dc_transform(IVIBandDesc *band, int *prev_dc, int buf_offs,
+                             int blk_size)
+ {
+     int buf_size = band->pitch * band->aheight - buf_offs;
+     int min_size = (blk_size - 1) * band->pitch + blk_size;
+     if (min_size > buf_size)
+         return AVERROR_INVALIDDATA;
+     band->dc_transform(prev_dc, band->buf + buf_offs,
+                        band->pitch, blk_size);
+     return 0;
+ }
  
  static int ivi_decode_coded_blocks(GetBitContext *gb, IVIBandDesc *band,
                                     ivi_mc_func mc, int mv_x, int mv_y,
Simple merge
@@@ -426,14 -414,14 +426,14 @@@ static int read_restart_header(MLPDecod
  
      skip_bits(gbp, 16); /* Output timestamp */
  
-     min_channel    = get_bits(gbp, 4);
-     max_channel    = get_bits(gbp, 4);
-     matrix_channel = get_bits(gbp, 4);
+     min_channel        = get_bits(gbp, 4);
+     max_channel        = get_bits(gbp, 4);
+     max_matrix_channel = get_bits(gbp, 4);
  
-     if (matrix_channel > max_matrix_channel) {
+     if (max_matrix_channel > std_max_matrix_channel) {
          av_log(m->avctx, AV_LOG_ERROR,
                 "Max matrix channel cannot be greater than %d.\n",
--               max_matrix_channel);
++               std_max_matrix_channel);
          return AVERROR_INVALIDDATA;
      }
  
@@@ -311,12 -268,10 +311,12 @@@ static int pcm_decode_frame(AVCodecCont
  
      /* av_get_bits_per_sample returns 0 for AV_CODEC_ID_PCM_DVD */
      samples_per_block = 1;
-     if (AV_CODEC_ID_PCM_DVD == avctx->codec_id) {
+     if (avctx->codec->id == AV_CODEC_ID_PCM_DVD) {
          if (avctx->bits_per_coded_sample != 20 &&
              avctx->bits_per_coded_sample != 24) {
 -            av_log(avctx, AV_LOG_ERROR, "PCM DVD unsupported sample depth\n");
 +            av_log(avctx, AV_LOG_ERROR,
 +                   "PCM DVD unsupported sample depth %i\n",
 +                   avctx->bits_per_coded_sample);
              return AVERROR(EINVAL);
          }
          /* 2 samples are interleaved per block in PCM_DVD */
@@@ -42,19 -41,24 +42,21 @@@ static av_cold int pcx_init(AVCodecCont
      return 0;
  }
  
- static void pcx_rle_decode(GetByteContext *gb, uint8_t *dst,
-                            unsigned int bytes_per_scanline, int compressed)
 -/**
 - * @return advanced src pointer
 - */
 -static const uint8_t *pcx_rle_decode(const uint8_t *src,
 -                                     const uint8_t *end,
 -                                     uint8_t *dst,
 -                                     unsigned int bytes_per_scanline,
 -                                     int compressed) {
++static void pcx_rle_decode(GetByteContext *gb,
++                           uint8_t *dst,
++                           unsigned int bytes_per_scanline,
++                           int compressed)
 +{
      unsigned int i = 0;
      unsigned char run, value;
  
      if (compressed) {
-         while (i<bytes_per_scanline) {
 -        while (i < bytes_per_scanline && src < end) {
++        while (i < bytes_per_scanline && bytestream2_get_bytes_left(gb)>0) {
              run = 1;
 -            value = *src++;
 -            if (value >= 0xc0 && src < end) {
 -                run = value & 0x3f;
 -                value = *src++;
 +            value = bytestream2_get_byte(gb);
-             if (value >= 0xc0) {
-                 run = value & 0x3f;
++            if (value >= 0xc0 && bytestream2_get_bytes_left(gb)>0) {
++                run   = value & 0x3f;
 +                value = bytestream2_get_byte(gb);
              }
              while (i<bytes_per_scanline && run--)
                  dst[i++] = value;
@@@ -114,14 -115,15 +116,15 @@@ static int pcx_decode_frame(AVCodecCont
      w = xmax - xmin + 1;
      h = ymax - ymin + 1;
  
 -    bits_per_pixel     = buf[3];
 -    bytes_per_line     = AV_RL16(buf+66);
 -    nplanes            = buf[65];
 +    bytestream2_skipu(&gb, 49);
 +    nplanes            = bytestream2_get_byteu(&gb);
 +    bytes_per_line     = bytestream2_get_le16u(&gb);
      bytes_per_scanline = nplanes * bytes_per_line;
  
-     if (bytes_per_scanline < w * bits_per_pixel * nplanes / 8) {
 -    if (bytes_per_scanline < w * bits_per_pixel * nplanes / 8 ||
 -        (!compressed && bytes_per_scanline > buf_size / h)) {
++    if (bytes_per_scanline < (w * bits_per_pixel * nplanes + 7) / 8 ||
++        (!compressed && bytes_per_scanline > bytestream2_get_bytes_left(&gb) / h)) {
          av_log(avctx, AV_LOG_ERROR, "PCX data is corrupted\n");
 -        return -1;
 +        return AVERROR_INVALIDDATA;
      }
  
      switch ((nplanes<<8) + bits_per_pixel) {
@@@ -813,11 -809,11 +816,11 @@@ static void fill_coding_method_array(sb
   * @param sb_min    lower subband processed (sb_min included)
   * @param sb_max    higher subband processed (sb_max excluded)
   */
 -static void synthfilt_build_sb_samples(QDM2Context *q, GetBitContext *gb,
 -                                       int length, int sb_min, int sb_max)
 +static int synthfilt_build_sb_samples(QDM2Context *q, GetBitContext *gb,
 +                                      int length, int sb_min, int sb_max)
  {
      int sb, j, k, n, ch, run, channels;
-     int joined_stereo, zero_encoding, chs;
+     int joined_stereo, zero_encoding;
      int type34_first;
      float type34_div = 0;
      float type34_predictor;
Simple merge