Merge commit '57d11e5e28bfe0bc445ad78fc033aafa73068bb4'
authorMichael Niedermayer <michaelni@gmx.at>
Sun, 6 Jan 2013 23:38:25 +0000 (00:38 +0100)
committerMichael Niedermayer <michaelni@gmx.at>
Sun, 6 Jan 2013 23:41:06 +0000 (00:41 +0100)
* commit '57d11e5e28bfe0bc445ad78fc033aafa73068bb4':
  fraps: return meaningful error codes.
  kgv1dec: return meaningful error codes.
  kmvc: return meaningful error codes.
  wnv1: return meaningful error codes.
  dpx: return meaningful error codes.
  truemotion1: return meaningful error codes
  pnm: return meaningful error codes.

Conflicts:
libavcodec/dpx.c
libavcodec/fraps.c
libavcodec/kmvc.c
libavcodec/pnm.c
libavcodec/pnmdec.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
libavcodec/dpx.c
libavcodec/fraps.c
libavcodec/kgv1dec.c
libavcodec/kmvc.c
libavcodec/pnm.c
libavcodec/pnmdec.c
libavcodec/truemotion1.c

@@@ -71,11 -65,10 +71,11 @@@ static int decode_frame(AVCodecContext 
  
      unsigned int offset;
      int magic_num, endian;
-     int x, y, i;
 -    int x, y, ret;
 -    int w, h, stride, bits_per_color, descriptor, elements, target_packet_size, source_packet_size;
++    int x, y, i, ret;
 +    int w, h, bits_per_color, descriptor, elements, packing, total_size;
  
 -    unsigned int rgbBuffer;
 +    unsigned int rgbBuffer = 0;
 +    int n_datum = 0;
  
      if (avpkt->size <= 1634) {
          av_log(avctx, AV_LOG_ERROR, "Packet too small for DPX header\n");
      buf = avpkt->data + 0x304;
      w = read32(&buf, endian);
      h = read32(&buf, endian);
-     if (av_image_check_size(w, h, 0, avctx))
-         return AVERROR(EINVAL);
++    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);
  
      // Need to end in 0x320 to read the descriptor
      buf += 20;
  
      if (s->picture.data[0])
          avctx->release_buffer(avctx, &s->picture);
-     if (ff_get_buffer(avctx, p) < 0) {
 -    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 ((ret = ff_get_buffer(avctx, p)) < 0) {
          av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
-         return -1;
+         return ret;
      }
  
      // Move pointer to offset from start of file
      buf =  avpkt->data + offset;
  
 -    ptr    = p->data[0];
 -    stride = p->linesize[0];
 +    for (i=0; i<AV_NUM_DATA_POINTERS; i++)
 +        ptr[i] = p->data[i];
  
 -    if (source_packet_size*avctx->width*avctx->height > buf_end - buf) {
 +    if (total_size > avpkt->size) {
          av_log(avctx, AV_LOG_ERROR, "Overread buffer. Invalid header?\n");
-         return -1;
+         return AVERROR_INVALIDDATA;
      }
      switch (bits_per_color) {
 -        case 10:
 -            for (x = 0; x < avctx->height; x++) {
 -               uint16_t *dst = (uint16_t*)ptr;
 -               for (y = 0; y < avctx->width; y++) {
 -                   rgbBuffer = read32(&buf, endian);
 -                   // Read out the 10-bit colors and convert to 16-bit
 -                   *dst++ = make_16bit(rgbBuffer >> 16);
 -                   *dst++ = make_16bit(rgbBuffer >>  6);
 -                   *dst++ = make_16bit(rgbBuffer <<  4);
 -               }
 -               ptr += stride;
 +    case 10:
 +        for (x = 0; x < avctx->height; x++) {
 +            uint16_t *dst[3] = {(uint16_t*)ptr[0],
 +                                (uint16_t*)ptr[1],
 +                                (uint16_t*)ptr[2]};
 +            for (y = 0; y < avctx->width; y++) {
 +                *dst[2]++ = read10in32(&buf, &rgbBuffer,
 +                                       &n_datum, endian);
 +                *dst[0]++ = read10in32(&buf, &rgbBuffer,
 +                                       &n_datum, endian);
 +                *dst[1]++ = read10in32(&buf, &rgbBuffer,
 +                                       &n_datum, endian);
 +                // For 10 bit, ignore alpha
 +                if (elements == 4)
 +                    read10in32(&buf, &rgbBuffer,
 +                               &n_datum, endian);
              }
 -            break;
 -        case 8:
 -        case 12: // Treat 12-bit as 16-bit
 -        case 16:
 -            if (source_packet_size == target_packet_size) {
 -                for (x = 0; x < avctx->height; x++) {
 -                    memcpy(ptr, buf, target_packet_size*avctx->width);
 -                    ptr += stride;
 -                    buf += source_packet_size*avctx->width;
 -                }
 -            } else {
 -                for (x = 0; x < avctx->height; x++) {
 -                    uint8_t *dst = ptr;
 -                    for (y = 0; y < avctx->width; y++) {
 -                        memcpy(dst, buf, target_packet_size);
 -                        dst += target_packet_size;
 -                        buf += source_packet_size;
 -                    }
 -                    ptr += stride;
 -                }
 +            for (i = 0; i < 3; i++)
 +                ptr[i] += p->linesize[i];
 +        }
 +        break;
 +    case 12:
 +        for (x = 0; x < avctx->height; x++) {
 +            uint16_t *dst[3] = {(uint16_t*)ptr[0],
 +                                (uint16_t*)ptr[1],
 +                                (uint16_t*)ptr[2]};
 +            for (y = 0; y < avctx->width; y++) {
 +                *dst[2] = *((uint16_t*)buf);
 +                *dst[2] = (*dst[2] >> 4) | (*dst[2] << 12);
 +                dst[2]++;
 +                buf += 2;
 +                *dst[0] = *((uint16_t*)buf);
 +                *dst[0] = (*dst[0] >> 4) | (*dst[0] << 12);
 +                dst[0]++;
 +                buf += 2;
 +                *dst[1] = *((uint16_t*)buf);
 +                *dst[1] = (*dst[1] >> 4) | (*dst[1] << 12);
 +                dst[1]++;
 +                buf += 2;
 +                // For 12 bit, ignore alpha
 +                if (elements == 4)
 +                    buf += 2;
              }
 -            break;
 +            for (i = 0; i < 3; i++)
 +                ptr[i] += p->linesize[i];
 +        }
 +        break;
 +    case 16:
 +        elements *= 2;
 +    case 8:
 +        for (x = 0; x < avctx->height; x++) {
 +            memcpy(ptr[0], buf, elements*avctx->width);
 +            ptr[0] += p->linesize[0];
 +            buf += elements*avctx->width;
 +        }
 +        break;
      }
  
      *picture   = s->picture;
@@@ -139,11 -138,8 +139,10 @@@ static int decode_frame(AVCodecContext 
      const uint32_t *buf32;
      uint32_t *luma1,*luma2,*cb,*cr;
      uint32_t offs[4];
-     int i, j, is_chroma;
 -    int i, j, ret, is_chroma, planes;
++    int i, j, ret, is_chroma;
 +    const int planes = 3;
 +    uint8_t *out;
      enum AVPixelFormat pix_fmt;
-     int ret;
  
      header = AV_RL32(buf);
      version = header & 0xff;
  
      case 1:
          /* Fraps v1 is an upside-down BGR24 */
 -        if ( (buf_size != avctx->width*avctx->height*3+header_size) &&
 -             (buf_size != header_size) ) {
 -            av_log(avctx, AV_LOG_ERROR,
 -                   "Invalid frame length %d (should be %d)\n",
 -                   buf_size, avctx->width*avctx->height*3+header_size);
 -            return AVERROR_INVALIDDATA;
 -        }
 +        for(y=0; y<avctx->height; y++)
 +            memcpy(&f->data[0][ (avctx->height-y)*f->linesize[0] ],
 +                   &buf[y*avctx->width*3],
 +                   3*avctx->width);
 -        f->reference = 1;
 -        f->buffer_hints = FF_BUFFER_HINTS_VALID |
 -                          FF_BUFFER_HINTS_PRESERVE |
 -                          FF_BUFFER_HINTS_REUSABLE;
 -        if ((ret = avctx->reget_buffer(avctx, f)) < 0) {
 -            av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
 -            return ret;
 -        }
 -        /* bit 31 means same as previous pic */
 -        f->pict_type = (header & (1U<<31))? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
 -        f->key_frame = f->pict_type == AV_PICTURE_TYPE_I;
 -
 -        if (f->pict_type == AV_PICTURE_TYPE_I) {
 -            for(y=0; y<avctx->height; y++)
 -                memcpy(&f->data[0][ (avctx->height-y)*f->linesize[0] ],
 -                       &buf[y*avctx->width*3],
 -                       3*avctx->width);
 -        }
          break;
  
      case 2:
           * Fraps v2 is Huffman-coded YUV420 planes
           * Fraps v4 is virtually the same
           */
 -        planes = 3;
 -        f->reference = 1;
 -        f->buffer_hints = FF_BUFFER_HINTS_VALID |
 -                          FF_BUFFER_HINTS_PRESERVE |
 -                          FF_BUFFER_HINTS_REUSABLE;
 -        if ((ret = avctx->reget_buffer(avctx, f)) < 0) {
 -            av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
 -            return ret;
 -        }
 -        /* skip frame */
 -        if(buf_size == 8) {
 -            f->pict_type = AV_PICTURE_TYPE_P;
 -            f->key_frame = 0;
 -            break;
 -        }
 -        f->pict_type = AV_PICTURE_TYPE_I;
 -        f->key_frame = 1;
 -        if ((AV_RL32(buf) != FPS_TAG)||(buf_size < (planes*1024 + 24))) {
 -            av_log(avctx, AV_LOG_ERROR, "Fraps: error in data stream\n");
 -            return AVERROR_INVALIDDATA;
 -        }
 -        for(i = 0; i < planes; i++) {
 -            offs[i] = AV_RL32(buf + 4 + i * 4);
 -            if(offs[i] >= buf_size || (i && offs[i] <= offs[i - 1] + 1024)) {
 -                av_log(avctx, AV_LOG_ERROR, "Fraps: plane %i offset is out of bounds\n", i);
 -                return AVERROR_INVALIDDATA;
 -            }
 -        }
 -        offs[planes] = buf_size;
          for(i = 0; i < planes; i++){
              is_chroma = !!i;
-             if(fraps2_decode_plane(s, f->data[i], f->linesize[i], avctx->width >> is_chroma,
-                     avctx->height >> is_chroma, buf + offs[i], offs[i + 1] - offs[i], is_chroma, 1) < 0) {
 -            av_fast_padded_malloc(&s->tmpbuf, &s->tmpbuf_size,
 -                                  offs[i + 1] - offs[i] - 1024);
 -            if (!s->tmpbuf)
 -                return AVERROR(ENOMEM);
+             if ((ret = fraps2_decode_plane(s, f->data[i], f->linesize[i],
+                                            avctx->width  >> is_chroma,
+                                            avctx->height >> is_chroma,
+                                            buf + offs[i], offs[i + 1] - offs[i],
+                                            is_chroma, 1)) < 0) {
                  av_log(avctx, AV_LOG_ERROR, "Error decoding plane %i\n", i);
-                 return AVERROR_INVALIDDATA;
+                 return ret;
              }
          }
          break;
      case 3:
      case 5:
          /* Virtually the same as version 4, but is for RGB24 */
 -        planes = 3;
 -        f->reference = 1;
 -        f->buffer_hints = FF_BUFFER_HINTS_VALID |
 -                          FF_BUFFER_HINTS_PRESERVE |
 -                          FF_BUFFER_HINTS_REUSABLE;
 -        if ((ret = avctx->reget_buffer(avctx, f)) < 0) {
 -            av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
 -            return ret;
 -        }
 -        /* skip frame */
 -        if(buf_size == 8) {
 -            f->pict_type = AV_PICTURE_TYPE_P;
 -            f->key_frame = 0;
 -            break;
 -        }
 -        f->pict_type = AV_PICTURE_TYPE_I;
 -        f->key_frame = 1;
 -        if ((AV_RL32(buf) != FPS_TAG)||(buf_size < (planes*1024 + 24))) {
 -            av_log(avctx, AV_LOG_ERROR, "Fraps: error in data stream\n");
 -            return AVERROR_INVALIDDATA;
 -        }
 -        for(i = 0; i < planes; i++) {
 -            offs[i] = AV_RL32(buf + 4 + i * 4);
 -            if(offs[i] >= buf_size || (i && offs[i] <= offs[i - 1] + 1024)) {
 -                av_log(avctx, AV_LOG_ERROR, "Fraps: plane %i offset is out of bounds\n", i);
 -                return AVERROR_INVALIDDATA;
 -            }
 -        }
 -        offs[planes] = buf_size;
          for(i = 0; i < planes; i++){
-             if(fraps2_decode_plane(s, f->data[0] + i + (f->linesize[0] * (avctx->height - 1)), -f->linesize[0],
-                     avctx->width, avctx->height, buf + offs[i], offs[i + 1] - offs[i], 0, 3) < 0) {
 -            av_fast_padded_malloc(&s->tmpbuf, &s->tmpbuf_size,
 -                                  offs[i + 1] - offs[i] - 1024);
 -            if (!s->tmpbuf)
 -                return AVERROR(ENOMEM);
+             if ((ret = fraps2_decode_plane(s, f->data[0] + i + (f->linesize[0] * (avctx->height - 1)),
+                                            -f->linesize[0], avctx->width, avctx->height,
+                                            buf + offs[i], offs[i + 1] - offs[i], 0, 3)) < 0) {
                  av_log(avctx, AV_LOG_ERROR, "Error decoding plane %i\n", i);
-                 return AVERROR_INVALIDDATA;
+                 return ret;
              }
          }
 +        out = f->data[0];
          // convert pseudo-YUV into real RGB
          for(j = 0; j < avctx->height; j++){
 -            for(i = 0; i < avctx->width; i++){
 -                f->data[0][0 + i*3 + j*f->linesize[0]] += f->data[0][1 + i*3 + j*f->linesize[0]];
 -                f->data[0][2 + i*3 + j*f->linesize[0]] += f->data[0][1 + i*3 + j*f->linesize[0]];
 +            uint8_t *line_end = out + 3*avctx->width;
 +            while (out < line_end) {
 +                out[0]  += out[1];
 +                out[2]  += out[1];
 +                out += 3;
              }
 +            out += f->linesize[0] - 3*avctx->width;
          }
          break;
      }
Simple merge
Simple merge
@@@ -107,53 -107,42 +107,53 @@@ int ff_pnm_decode_header(AVCodecContex
              }
          }
          /* check that all tags are present */
 -        if (w <= 0 || h <= 0 || maxval <= 0 || depth <= 0 || tuple_type[0] == '\0' || av_image_check_size(w, h, 0, avctx))
 +        if (w <= 0 || h <= 0 || maxval <= 0 || depth <= 0 || tuple_type[0] == '\0' || av_image_check_size(w, h, 0, avctx) || s->bytestream >= s->bytestream_end)
-             return -1;
+             return AVERROR_INVALIDDATA;
  
          avctx->width  = w;
          avctx->height = h;
 +        s->maxval     = maxval;
          if (depth == 1) {
 -            if (maxval == 1)
 -                avctx->pix_fmt = AV_PIX_FMT_MONOWHITE;
 -            else
 +            if (maxval == 1) {
 +                avctx->pix_fmt = AV_PIX_FMT_MONOBLACK;
 +            } else if (maxval == 255) {
                  avctx->pix_fmt = AV_PIX_FMT_GRAY8;
 +            } else {
 +                avctx->pix_fmt = AV_PIX_FMT_GRAY16BE;
 +            }
 +        } else if (depth == 2) {
 +            if (maxval == 255)
 +                avctx->pix_fmt = AV_PIX_FMT_GRAY8A;
          } else if (depth == 3) {
              if (maxval < 256) {
 -            avctx->pix_fmt = AV_PIX_FMT_RGB24;
 +                avctx->pix_fmt = AV_PIX_FMT_RGB24;
              } else {
 -                av_log(avctx, AV_LOG_ERROR, "16-bit components are only supported for grayscale\n");
 -                avctx->pix_fmt = AV_PIX_FMT_NONE;
 -                return AVERROR_INVALIDDATA;
 +                avctx->pix_fmt = AV_PIX_FMT_RGB48BE;
              }
          } else if (depth == 4) {
 -            avctx->pix_fmt = AV_PIX_FMT_RGB32;
 +            if (maxval < 256) {
 +                avctx->pix_fmt = AV_PIX_FMT_RGBA;
 +            } else {
 +                avctx->pix_fmt = AV_PIX_FMT_RGBA64BE;
 +            }
          } else {
-             return -1;
+             return AVERROR_INVALIDDATA;
          }
          return 0;
      } else {
-         return -1;
+         return AVERROR_INVALIDDATA;
      }
      pnm_get(s, buf1, sizeof(buf1));
 -    avctx->width = atoi(buf1);
 -    if (avctx->width <= 0)
 -        return AVERROR_INVALIDDATA;
 +    w = atoi(buf1);
      pnm_get(s, buf1, sizeof(buf1));
 -    avctx->height = atoi(buf1);
 -    if(av_image_check_size(avctx->width, avctx->height, 0, avctx))
 +    h = atoi(buf1);
 +    if(w <= 0 || h <= 0 || av_image_check_size(w, h, 0, avctx) || s->bytestream >= s->bytestream_end)
-         return -1;
+         return AVERROR_INVALIDDATA;
 -    if (avctx->pix_fmt != AV_PIX_FMT_MONOWHITE) {
 +
 +    avctx->width  = w;
 +    avctx->height = h;
 +
 +    if (avctx->pix_fmt != AV_PIX_FMT_MONOWHITE && avctx->pix_fmt != AV_PIX_FMT_MONOBLACK) {
          pnm_get(s, buf1, sizeof(buf1));
          s->maxval = atoi(buf1);
          if (s->maxval <= 0) {
@@@ -38,11 -39,11 +38,11 @@@ static int pnm_decode_frame(AVCodecCont
      int components, sample_len, ret;
  
      s->bytestream_start =
 -    s->bytestream       = buf;
 -    s->bytestream_end   = buf + buf_size;
 +    s->bytestream       = (uint8_t *)buf;
 +    s->bytestream_end   = (uint8_t *)buf + buf_size;
  
-     if (ff_pnm_decode_header(avctx, s) < 0)
-         return AVERROR_INVALIDDATA;
+     if ((ret = ff_pnm_decode_header(avctx, s)) < 0)
+         return ret;
  
      if (p->data[0])
          avctx->release_buffer(avctx, p);
  
      switch (avctx->pix_fmt) {
      default:
-         return AVERROR_INVALIDDATA;
+         return AVERROR(EINVAL);
 +    case AV_PIX_FMT_RGBA64BE:
 +        n = avctx->width * 8;
 +        components=4;
 +        sample_len=16;
 +        goto do_read;
      case AV_PIX_FMT_RGB48BE:
          n = avctx->width * 6;
          components=3;
@@@ -316,10 -316,10 +316,10 @@@ static int truemotion1_decode_header(Tr
      const uint8_t *sel_vector_table;
  
      header.header_size = ((s->buf[0] >> 5) | (s->buf[0] << 3)) & 0x7f;
 -    if (s->buf[0] < 0x10)
 +    if (s->buf[0] < 0x10 || header.header_size >= s->size)
      {
          av_log(s->avctx, AV_LOG_ERROR, "invalid header size (%d)\n", s->buf[0]);
-         return -1;
+         return AVERROR_INVALIDDATA;
      }
  
      /* unscramble the header bytes with a XOR operation */
@@@ -866,15 -849,15 +866,15 @@@ static int truemotion1_decode_frame(AVC
      s->buf = buf;
      s->size = buf_size;
  
-     if (truemotion1_decode_header(s) == -1)
-         return -1;
+     if ((ret = truemotion1_decode_header(s)) < 0)
+         return ret;
  
 -    s->frame.reference = 1;
 +    s->frame.reference = 3;
      s->frame.buffer_hints = FF_BUFFER_HINTS_VALID |
          FF_BUFFER_HINTS_PRESERVE | FF_BUFFER_HINTS_REUSABLE;
-     if (avctx->reget_buffer(avctx, &s->frame) < 0) {
+     if ((ret = avctx->reget_buffer(avctx, &s->frame)) < 0) {
          av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
-         return -1;
+         return ret;
      }
  
      if (compression_types[s->compression].algorithm == ALGO_RGB24H) {