Merge commit 'dd3754a48854cd570d38db72394491aab0f36570'
authorMichael Niedermayer <michaelni@gmx.at>
Mon, 1 Jul 2013 09:37:13 +0000 (11:37 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Mon, 1 Jul 2013 09:37:37 +0000 (11:37 +0200)
* commit 'dd3754a48854cd570d38db72394491aab0f36570':
  indeo: use proper error code

Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
libavcodec/ivi_common.c

diff --combined libavcodec/ivi_common.c
@@@ -3,20 -3,20 +3,20 @@@
   *
   * Copyright (c) 2009 Maxim Poliakovski
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
@@@ -59,7 -59,7 +59,7 @@@ static uint16_t inv_bits(uint16_t val, 
  
  /*
   *  Generate a huffman codebook from the given descriptor
 - *  and convert it into the Libav VLC table.
 + *  and convert it into the FFmpeg VLC table.
   *
   *  @param[in]   cb    pointer to codebook descriptor
   *  @param[out]  vlc   where to place the generated VLC table
@@@ -85,7 -85,7 +85,7 @@@ static int ivi_create_huff_from_desc(co
  
              bits[pos] = i + cb->xbits[i] + not_last_row;
              if (bits[pos] > IVI_VLC_BITS)
-                 return -1; /* invalid descriptor */
+                 return AVERROR_INVALIDDATA; /* invalid descriptor */
  
              codewords[pos] = inv_bits((prefix | j), bits[pos]);
              if (!bits[pos])
@@@ -168,7 -168,7 +168,7 @@@ int ff_ivi_dec_huff_desc(GetBitContext 
                  new_huff.xbits[i] = get_bits(gb, 4);
  
              /* Have we got the same custom table? Rebuild if not. */
 -            if (ivi_huff_desc_cmp(&new_huff, &huff_tab->cust_desc)) {
 +            if (ivi_huff_desc_cmp(&new_huff, &huff_tab->cust_desc) || !huff_tab->cust_tab.table) {
                  ivi_huff_desc_copy(&huff_tab->cust_desc, &new_huff);
  
                  if (huff_tab->cust_tab.table)
@@@ -203,7 -203,6 +203,7 @@@ static av_cold void ivi_free_buffers(IV
      int p, b, t;
  
      for (p = 0; p < 3; p++) {
 +        if (planes[p].bands)
          for (b = 0; b < planes[p].num_bands; b++) {
              av_freep(&planes[p].bands[b].bufs[0]);
              av_freep(&planes[p].bands[b].bufs[1]);
@@@ -265,7 -264,6 +265,7 @@@ av_cold int ff_ivi_init_planes(IVIPlane
              band->aheight  = height_aligned;
              band->bufs[0]  = av_mallocz(buf_size);
              band->bufs[1]  = av_mallocz(buf_size);
 +            band->bufsize  = buf_size/2;
              if (!band->bufs[0] || !band->bufs[1])
                  return AVERROR(ENOMEM);
  
@@@ -297,8 -295,6 +297,8 @@@ av_cold int ff_ivi_init_tiles(IVIPlaneD
              t_width  >>= 1;
              t_height >>= 1;
          }
 +        if(t_width<=0 || t_height<=0)
 +            return AVERROR(EINVAL);
  
          for (b = 0; b < planes[p].num_bands; b++) {
              band = &planes[p].bands[b];
  
                      tile->ref_mbs = 0;
                      if (p || b) {
 -                        tile->ref_mbs = ref_tile->mbs;
 +                        if (tile->num_MBs <= ref_tile->num_MBs) {
 +                            tile->ref_mbs = ref_tile->mbs;
 +                        }else
 +                            av_log(NULL, AV_LOG_DEBUG, "Cannot use ref_tile, too few mbs\n");
                          ref_tile++;
                      }
  
@@@ -395,10 -388,10 +395,10 @@@ static int ivi_decode_blocks(GetBitCont
                               AVCodecContext *avctx)
  {
      int         mbn, blk, num_blocks, num_coeffs, blk_size, scan_pos, run, val,
 -                pos, is_intra, mc_type = 0, mv_x, mv_y, col_mask;
 +                pos, is_intra, mc_type = 0, av_uninit(mv_x), av_uninit(mv_y), col_mask;
      uint8_t     col_flags[8];
      int32_t     prev_dc, trvec[64];
 -    uint32_t    cbp, sym, lo, hi, quant, buf_offs, q;
 +    uint32_t    cbp, av_uninit(sym), lo, hi, quant, buf_offs, q;
      IVIMbInfo   *mb;
      RVMapDesc   *rvmap = band->rv_map;
      void (*mc_with_delta_func)(int16_t *buf, const int16_t *ref_buf, uint32_t pitch, int mc_type);
                      } else {
                          if (sym >= 256U) {
                              av_log(avctx, AV_LOG_ERROR, "Invalid sym encountered: %d.\n", sym);
-                             return -1;
+                             return AVERROR_INVALIDDATA;
                          }
                          run = rvmap->runtab[sym];
                          val = rvmap->valtab[sym];
  
                      /* de-zigzag and dequantize */
                      scan_pos += run;
 -                    if (scan_pos >= num_coeffs)
 +                    if (scan_pos >= (unsigned)num_coeffs)
                          break;
                      pos = band->scan[scan_pos];
  
                  }// while
  
                  if (scan_pos >= num_coeffs && sym != rvmap->eob_sym)
-                     return -1; /* corrupt block data */
+                     return AVERROR_INVALIDDATA; /* corrupt block data */
  
                  /* undoing DC coeff prediction for intra-blocks */
                  if (is_intra && band->is_2d_trans) {
                      trvec[0]      = prev_dc;
                      col_flags[0] |= !!prev_dc;
                  }
 -
 +                if(band->transform_size > band->blk_size){
 +                    av_log(NULL, AV_LOG_ERROR, "Too large transform\n");
 +                    return AVERROR_INVALIDDATA;
 +                }
                  /* apply inverse transform */
                  band->inv_transform(trvec, band->buf + buf_offs,
                                      band->pitch, col_flags);
                  /* for intra blocks apply the dc slant transform */
                  /* for inter - perform the motion compensation without delta */
                  if (is_intra) {
 -                    if (band->dc_transform)
                          band->dc_transform(&prev_dc, band->buf + buf_offs,
                                             band->pitch, blk_size);
                  } else
@@@ -612,7 -603,7 +612,7 @@@ static int ivi_process_empty_tile(AVCod
              if (band->inherit_qdelta && ref_mb)
                  mb->q_delta = ref_mb->q_delta;
  
 -            if (band->inherit_mv) {
 +            if (band->inherit_mv && ref_mb) {
                  /* motion vector inheritance */
                  if (mv_scale) {
                      mb->mv_x = ivi_scale_mv(ref_mb->mv_x, mv_scale);
                      mb->mv_y = ref_mb->mv_y;
                  }
                  need_mc |= mb->mv_x || mb->mv_y; /* tracking non-zero motion vectors */
 +                {
 +                    int dmv_x, dmv_y, cx, cy;
 +
 +                    dmv_x = mb->mv_x >> band->is_halfpel;
 +                    dmv_y = mb->mv_y >> band->is_halfpel;
 +                    cx    = mb->mv_x &  band->is_halfpel;
 +                    cy    = mb->mv_y &  band->is_halfpel;
 +
 +                    if (   mb->xpos + dmv_x < 0
 +                        || mb->xpos + dmv_x + band->mb_size + cx > band->pitch
 +                        || mb->ypos + dmv_y < 0
 +                        || mb->ypos + dmv_y + band->mb_size + cy > band->aheight) {
 +                        av_log(avctx, AV_LOG_ERROR, "MV out of bounds\n");
 +                        return AVERROR_INVALIDDATA;
 +                    }
 +                }
              }
  
              mb++;
@@@ -772,10 -747,6 +772,10 @@@ static int decode_band(IVI45DecContext 
          idx2 = band->corr[i * 2 + 1];
          FFSWAP(uint8_t, band->rv_map->runtab[idx1], band->rv_map->runtab[idx2]);
          FFSWAP(int16_t, band->rv_map->valtab[idx1], band->rv_map->valtab[idx2]);
 +        if (idx1 == band->rv_map->eob_sym || idx2 == band->rv_map->eob_sym)
 +            band->rv_map->eob_sym ^= idx1 ^ idx2;
 +        if (idx1 == band->rv_map->esc_sym || idx2 == band->rv_map->esc_sym)
 +            band->rv_map->esc_sym ^= idx1 ^ idx2;
      }
  
      pos = get_bits_count(&ctx->gb);
              tile->data_size = ivi_dec_tile_data_size(&ctx->gb);
              if (!tile->data_size) {
                  av_log(avctx, AV_LOG_ERROR, "Tile data size is zero!\n");
 -                return AVERROR_INVALIDDATA;
 +                result = AVERROR_INVALIDDATA;
 +                break;
              }
  
              result = ctx->decode_mb_info(ctx, band, tile, avctx);
          idx2 = band->corr[i*2+1];
          FFSWAP(uint8_t, band->rv_map->runtab[idx1], band->rv_map->runtab[idx2]);
          FFSWAP(int16_t, band->rv_map->valtab[idx1], band->rv_map->valtab[idx2]);
 +        if (idx1 == band->rv_map->eob_sym || idx2 == band->rv_map->eob_sym)
 +            band->rv_map->eob_sym ^= idx1 ^ idx2;
 +        if (idx1 == band->rv_map->esc_sym || idx2 == band->rv_map->esc_sym)
 +            band->rv_map->esc_sym ^= idx1 ^ idx2;
      }
  
  #ifdef DEBUG
@@@ -870,14 -836,14 +870,14 @@@ int ff_ivi_decode_frame(AVCodecContext 
      if (result) {
          av_log(avctx, AV_LOG_ERROR,
                 "Error while decoding picture header: %d\n", result);
-         return -1;
+         return result;
      }
      if (ctx->gop_invalid)
          return AVERROR_INVALIDDATA;
  
      if (ctx->gop_flags & IVI5_IS_PROTECTED) {
-         av_log(avctx, AV_LOG_ERROR, "Password-protected clip!\n");
-         return -1;
+         avpriv_report_missing_feature(avctx, "Password-protected clip!\n");
+         return AVERROR_PATCHWELCOME;
      }
  
      ctx->switch_buffers(ctx);
      //{ START_TIMER;
  
      if (ctx->is_nonnull_frame(ctx)) {
 +        ctx->buf_invalid[ctx->dst_buf] = 1;
          for (p = 0; p < 3; p++) {
              for (b = 0; b < ctx->planes[p].num_bands; b++) {
                  result = decode_band(ctx, &ctx->planes[p].bands[b], avctx);
-                 if (result) {
+                 if (result < 0) {
                      av_log(avctx, AV_LOG_ERROR,
                             "Error while decoding band: %d, plane: %d\n", b, p);
-                     return -1;
+                     return result;
                  }
              }
          }
 +        ctx->buf_invalid[ctx->dst_buf] = 0;
      }
 +    if (ctx->buf_invalid[ctx->dst_buf])
 +        return -1;
  
      //STOP_TIMER("decode_planes"); }
  
              av_log(avctx, AV_LOG_ERROR, "Buffer contains IP frames!\n");
      }
  
 +    if (!ctx->is_nonnull_frame(ctx))
 +        return buf_size;
 +
      avcodec_set_dimensions(avctx, ctx->planes[0].width, ctx->planes[0].height);
 -    if ((result = ff_get_buffer(avctx, frame, 0)) < 0) {
 -        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 +    if ((result = ff_get_buffer(avctx, frame, 0)) < 0)
          return result;
 -    }
  
      if (ctx->is_scalable) {
          if (avctx->codec_id == AV_CODEC_ID_INDEO4)