Merge commit 'ade402804a0e811cd00862c90559121a793054a6'
authorMichael Niedermayer <michaelni@gmx.at>
Sat, 26 Jan 2013 13:39:02 +0000 (14:39 +0100)
committerMichael Niedermayer <michaelni@gmx.at>
Sat, 26 Jan 2013 13:39:02 +0000 (14:39 +0100)
* commit 'ade402804a0e811cd00862c90559121a793054a6':
  eatgv: return meaningful error codes.
  cyuv: return meaningful error codes.
  txd: return meaningful error codes.

Conflicts:
libavcodec/cyuv.c
libavcodec/eatgv.c

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

diff --combined libavcodec/cyuv.c
@@@ -6,20 -6,20 +6,20 @@@
   *
   * Copyright (C) 2003 the ffmpeg project
   *
 - * 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
   */
  
@@@ -52,9 -52,9 +52,9 @@@ static av_cold int cyuv_decode_init(AVC
      s->width = avctx->width;
      /* width needs to be divisible by 4 for this codec to work */
      if (s->width & 0x3)
-         return -1;
+         return AVERROR_INVALIDDATA;
      s->height = avctx->height;
 -    avctx->pix_fmt = AV_PIX_FMT_YUV411P;
 +    avcodec_get_frame_defaults(&s->frame);
  
      return 0;
  }
@@@ -83,7 -83,7 +83,8 @@@ static int cyuv_decode_frame(AVCodecCon
      int stream_ptr;
      unsigned char cur_byte;
      int pixel_groups;
 +    int rawsize = s->height * FFALIGN(s->width,2) * 2;
+     int ret;
  
      if (avctx->codec_id == AV_CODEC_ID_AURA) {
          y_table = u_table;
       * followed by (height) lines each with 3 bytes to represent groups
       * of 4 pixels. Thus, the total size of the buffer ought to be:
       *    (3 * 16) + height * (width * 3 / 4) */
 -    if (buf_size != 48 + s->height * (s->width * 3 / 4)) {
 +    if (buf_size == 48 + s->height * (s->width * 3 / 4)) {
 +        avctx->pix_fmt = AV_PIX_FMT_YUV411P;
 +    } else if(buf_size == rawsize ) {
 +        avctx->pix_fmt = AV_PIX_FMT_UYVY422;
 +    } else {
          av_log(avctx, AV_LOG_ERROR, "got a buffer with %d bytes when %d were expected\n",
                 buf_size, 48 + s->height * (s->width * 3 / 4));
-         return -1;
+         return AVERROR_INVALIDDATA;
      }
  
      /* pixel data starts 48 bytes in, after 3x16-byte tables */
  
      s->frame.buffer_hints = FF_BUFFER_HINTS_VALID;
      s->frame.reference = 0;
-     if (ff_get_buffer(avctx, &s->frame) < 0) {
+     if ((ret = ff_get_buffer(avctx, &s->frame)) < 0) {
          av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
-         return -1;
+         return ret;
      }
  
      y_plane = s->frame.data[0];
      u_plane = s->frame.data[1];
      v_plane = s->frame.data[2];
  
 +    if (buf_size == rawsize) {
 +        int linesize = FFALIGN(s->width,2) * 2;
 +        y_plane += s->frame.linesize[0] * s->height;
 +        for (stream_ptr = 0; stream_ptr < rawsize; stream_ptr += linesize) {
 +            y_plane -= s->frame.linesize[0];
 +            memcpy(y_plane, buf+stream_ptr, linesize);
 +        }
 +    } else {
 +
      /* iterate through each line in the height */
      for (y_ptr = 0, u_ptr = 0, v_ptr = 0;
           y_ptr < (s->height * s->frame.linesize[0]);
  
          }
      }
 +    }
  
      *got_frame = 1;
      *(AVFrame*)data= s->frame;
diff --combined libavcodec/eatgv.c
@@@ -2,20 -2,20 +2,20 @@@
   * Electronic Arts TGV Video Decoder
   * Copyright (c) 2007-2008 Peter Ross
   *
 - * 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 St, Fifth Floor, Boston, MA  02110-1301  USA
   */
  
@@@ -55,8 -55,6 +55,8 @@@ static av_cold int tgv_decode_init(AVCo
      s->avctx = avctx;
      avctx->time_base = (AVRational){1, 15};
      avctx->pix_fmt = AV_PIX_FMT_PAL8;
 +    avcodec_get_frame_defaults(&s->frame);
 +    avcodec_get_frame_defaults(&s->last_frame);
      return 0;
  }
  
@@@ -74,8 -72,8 +74,8 @@@ static int unpack(const uint8_t *src, c
      else
          src += 2;
  
 -    if (src+3>src_end)
 +    if (src_end - src < 3)
-         return -1;
+         return AVERROR_INVALIDDATA;
      size = AV_RB24(src);
      src += 3;
  
@@@ -147,8 -145,8 +147,8 @@@ static int tgv_decode_inter(TgvContext 
      int mvbits;
      const unsigned char *blocks_raw;
  
 -    if(buf+12>buf_end)
 +    if(buf_end - buf < 12)
-         return -1;
+         return AVERROR_INVALIDDATA;
  
      num_mvs           = AV_RL16(&buf[0]);
      num_blocks_raw    = AV_RL16(&buf[2]);
      /* read motion vectors */
      mvbits = (num_mvs*2*10+31) & ~31;
  
 -    if (buf+(mvbits>>3)+16*num_blocks_raw+8*num_blocks_packed>buf_end)
 +    if (buf_end - buf < (mvbits>>3)+16*num_blocks_raw+8*num_blocks_packed)
-         return -1;
+         return AVERROR_INVALIDDATA;
  
      init_get_bits(&gb, buf, mvbits);
      for (i=0; i<num_mvs; i++) {
  
      if (get_bits_left(&gb) < vector_bits *
          (s->avctx->height/4) * (s->avctx->width/4))
-         return -1;
+         return AVERROR_INVALIDDATA;
  
      /* read vectors and build frame */
      for(y=0; y<s->avctx->height/4; y++)
              int my = y * 4 + s->mv_codebook[vector][1];
  
              if (   mx < 0 || mx + 4 > s->avctx->width
 -                || my < 0 || my + 4 > s->avctx->height)
 +                || my < 0 || my + 4 > s->avctx->height) {
 +                av_log(s->avctx, AV_LOG_ERROR, "MV %d %d out of picture\n", mx, my);
                  continue;
 +            }
  
              src = s->last_frame.data[0] + mx + my * s->last_frame.linesize[0];
              src_stride = s->last_frame.linesize[0];
@@@ -260,19 -256,16 +260,19 @@@ static int tgv_decode_frame(AVCodecCont
      int buf_size = avpkt->size;
      TgvContext *s = avctx->priv_data;
      const uint8_t *buf_end = buf + buf_size;
-     int chunk_type;
+     int chunk_type, ret;
  
 +    if (buf_end - buf < EA_PREAMBLE_SIZE)
 +        return AVERROR_INVALIDDATA;
 +
      chunk_type = AV_RL32(&buf[0]);
      buf += EA_PREAMBLE_SIZE;
  
      if (chunk_type==kVGT_TAG) {
          int pal_count, i;
 -        if(buf+12>buf_end) {
 +        if(buf_end - buf < 12) {
              av_log(avctx, AV_LOG_WARNING, "truncated header\n");
-             return -1;
+             return AVERROR_INVALIDDATA;
          }
  
          s->width  = AV_RL16(&buf[0]);
  
          pal_count = AV_RL16(&buf[6]);
          buf += 12;
 -        for(i=0; i<pal_count && i<AVPALETTE_COUNT && buf+2<buf_end; i++) {
 -            s->palette[i] = AV_RB24(buf);
 +        for(i=0; i<pal_count && i<AVPALETTE_COUNT && buf_end - buf >= 3; i++) {
 +            s->palette[i] = 0xFFU << 24 | AV_RB24(buf);
              buf += 3;
          }
      }
  
-     if (av_image_check_size(s->width, s->height, 0, avctx))
-         return -1;
+     if ((ret = av_image_check_size(s->width, s->height, 0, avctx)) < 0)
+         return ret;
  
      /* shuffle */
      FFSWAP(AVFrame, s->frame, s->last_frame);
      if (!s->frame.data[0]) {
 -        s->frame.reference = 1;
 +        s->frame.reference = 3;
          s->frame.buffer_hints = FF_BUFFER_HINTS_VALID;
          s->frame.linesize[0] = s->width;
  
          s->frame.pict_type = AV_PICTURE_TYPE_I;
          if (unpack(buf, buf_end, s->frame.data[0], s->avctx->width, s->avctx->height)<0) {
              av_log(avctx, AV_LOG_WARNING, "truncated intra frame\n");
-             return -1;
+             return AVERROR_INVALIDDATA;
          }
      }else{
          if (!s->last_frame.data[0]) {
          s->frame.pict_type = AV_PICTURE_TYPE_P;
          if (tgv_decode_inter(s, buf, buf_end)<0) {
              av_log(avctx, AV_LOG_WARNING, "truncated inter frame\n");
-             return -1;
+             return AVERROR_INVALIDDATA;
          }
      }
  
diff --combined libavcodec/txd.c
@@@ -4,27 -4,27 +4,27 @@@
   *
   * See also: http://wiki.multimedia.cx/index.php?title=TXD
   *
 - * 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
   */
  
  #include "libavutil/intreadwrite.h"
  #include "libavutil/imgutils.h"
 -#include "avcodec.h"
  #include "bytestream.h"
 +#include "avcodec.h"
  #include "internal.h"
  #include "s3tc.h"
  
@@@ -51,6 -51,7 +51,7 @@@ static int txd_decode_frame(AVCodecCont
      unsigned int y, v;
      uint8_t *ptr;
      uint32_t *pal;
+     int ret;
  
      bytestream2_init(&gb, avpkt->data, avpkt->size);
      version         = bytestream2_get_le32(&gb);
@@@ -65,7 -66,7 +66,7 @@@
      if (version < 8 || version > 9) {
          av_log(avctx, AV_LOG_ERROR, "texture data version %i is unsupported\n",
                                                                      version);
-         return -1;
+         return AVERROR_PATCHWELCOME;
      }
  
      if (depth == 8) {
          avctx->pix_fmt = AV_PIX_FMT_RGB32;
      } else {
          av_log(avctx, AV_LOG_ERROR, "depth of %i is unsupported\n", depth);
-         return -1;
+         return AVERROR_PATCHWELCOME;
      }
  
      if (p->data[0])
          avctx->release_buffer(avctx, p);
  
-     if (av_image_check_size(w, h, 0, avctx))
-         return -1;
+     if ((ret = av_image_check_size(w, h, 0, avctx)) < 0)
+         return ret;
      if (w != avctx->width || h != avctx->height)
          avcodec_set_dimensions(avctx, w, h);
-     if (ff_get_buffer(avctx, p) < 0) {
+     if ((ret = ff_get_buffer(avctx, p)) < 0) {
          av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
-         return -1;
+         return ret;
      }
  
      p->pict_type = AV_PICTURE_TYPE_I;
              v = bytestream2_get_be32(&gb);
              pal[y] = (v >> 8) + (v << 24);
          }
 +        if (bytestream2_get_bytes_left(&gb) < w * h)
 +            return AVERROR_INVALIDDATA;
          bytestream2_skip(&gb, 4);
          for (y=0; y<h; y++) {
              bytestream2_get_buffer(&gb, ptr, w);
              if (!(flags & 1))
                  goto unsupported;
          case FF_S3TC_DXT1:
 +            if (bytestream2_get_bytes_left(&gb) < (w/4) * (h/4) * 8)
 +                return AVERROR_INVALIDDATA;
              ff_decode_dxt1(&gb, ptr, w, h, stride);
              break;
          case FF_S3TC_DXT3:
 +            if (bytestream2_get_bytes_left(&gb) < (w/4) * (h/4) * 16)
 +                return AVERROR_INVALIDDATA;
              ff_decode_dxt3(&gb, ptr, w, h, stride);
              break;
          default:
          switch (d3d_format) {
          case 0x15:
          case 0x16:
 +            if (bytestream2_get_bytes_left(&gb) < h * w * 4)
 +                return AVERROR_INVALIDDATA;
              for (y=0; y<h; y++) {
                  bytestream2_get_buffer(&gb, ptr, w * 4);
                  ptr += stride;
  
  unsupported:
      av_log(avctx, AV_LOG_ERROR, "unsupported d3d format (%08x)\n", d3d_format);
-     return -1;
+     return AVERROR_PATCHWELCOME;
  }
  
  static av_cold int txd_end(AVCodecContext *avctx) {