Merge commit '744b406ff3474e77543bcf86125a2f7bc7deaa18' into release/2.2
authorMichael Niedermayer <michaelni@gmx.at>
Tue, 5 Aug 2014 02:04:01 +0000 (04:04 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Tue, 5 Aug 2014 02:04:01 +0000 (04:04 +0200)
* commit '744b406ff3474e77543bcf86125a2f7bc7deaa18':
  huffyuv: Check and propagate function return values

Conflicts:
libavcodec/huffyuvdec.c

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

@@@ -185,8 -173,9 +185,9 @@@ static int generate_joint_tables(HYuvCo
                  }
              }
          }
 -        ff_free_vlc(&s->vlc[3]);
 -        if ((ret = init_vlc(&s->vlc[3], VLC_BITS, i, len, 1, 1,
 +        ff_free_vlc(&s->vlc[4]);
-         if ((ret = init_vlc(&s->vlc[4], VLC_BITS, i, len, 1, 1, bits, 2, 2, 0)) < 0)
++        if ((ret = init_vlc(&s->vlc[4], VLC_BITS, i, len, 1, 1,
+                             bits, 2, 2, 0)) < 0)
              return ret;
      }
      return 0;
  static int read_huffman_tables(HYuvContext *s, const uint8_t *src, int length)
  {
      GetBitContext gb;
-     int i;
-     int ret;
+     int i, ret;
 +    int count = 3;
  
-     init_get_bits(&gb, src, length * 8);
+     if ((ret = init_get_bits(&gb, src, length * 8)) < 0)
+         return ret;
  
 -    for (i = 0; i < 3; i++) {
 -        if ((ret = read_len_table(s->len[i], &gb)) < 0)
 +    if (s->version > 2)
 +        count = 1 + s->alpha + 2*s->chroma;
 +
 +    for (i = 0; i < count; i++) {
-         if (read_len_table(s->len[i], &gb, s->vlc_n) < 0)
-             return -1;
-         if (ff_huffyuv_generate_bits_table(s->bits[i], s->len[i], s->vlc_n) < 0) {
-             return -1;
-         }
++        if ((ret = read_len_table(s->len[i], &gb, s->vlc_n)) < 0)
+             return ret;
 -        if ((ret = ff_huffyuv_generate_bits_table(s->bits[i], s->len[i])) < 0)
++        if ((ret = ff_huffyuv_generate_bits_table(s->bits[i], s->len[i], s->vlc_n)) < 0)
+             return ret;
          ff_free_vlc(&s->vlc[i]);
 -        if ((ret = init_vlc(&s->vlc[i], VLC_BITS, 256, s->len[i], 1, 1,
 -                            s->bits[i], 4, 4, 0)) < 0)
 +        if ((ret = init_vlc(&s->vlc[i], VLC_BITS, s->vlc_n, s->len[i], 1, 1,
 +                           s->bits[i], 4, 4, 0)) < 0)
              return ret;
      }
  
  static int read_old_huffman_tables(HYuvContext *s)
  {
      GetBitContext gb;
-     int i;
-     int ret;
+     int i, ret;
  
 -    if ((ret = init_get_bits(&gb, classic_shift_luma,
 -                             classic_shift_luma_table_size * 8)) < 0)
 -        return ret;
 -    if ((ret = read_len_table(s->len[0], &gb)) < 0)
 +    init_get_bits(&gb, classic_shift_luma,
 +                  classic_shift_luma_table_size * 8);
-     if (read_len_table(s->len[0], &gb, 256) < 0)
-         return -1;
++    if ((ret = read_len_table(s->len[0], &gb, 256)) < 0)
+         return ret;
  
 -    if ((ret = init_get_bits(&gb, classic_shift_chroma,
 -                             classic_shift_chroma_table_size * 8)) < 0)
 -        return ret;
 -    if ((ret = read_len_table(s->len[1], &gb)) < 0)
 +    init_get_bits(&gb, classic_shift_chroma,
 +                  classic_shift_chroma_table_size * 8);
-     if (read_len_table(s->len[1], &gb, 256) < 0)
-         return -1;
++    if ((ret = read_len_table(s->len[1], &gb, 256)) < 0)
+         return ret;
  
      for(i=0; i<256; i++) s->bits[0][i] = classic_add_luma  [i];
      for(i=0; i<256; i++) s->bits[1][i] = classic_add_chroma[i];
  static av_cold int decode_init(AVCodecContext *avctx)
  {
      HYuvContext *s = avctx->priv_data;
+     int ret;
  
 -    ff_huffyuv_common_init(avctx);
 -    memset(s->vlc, 0, 3 * sizeof(VLC));
 +    memset(s->vlc, 0, 4 * sizeof(VLC));
  
 -    s->interlaced = s->height > 288;
 +    s->interlaced = avctx->height > 288;
  
      s->bgr32 = 1;
  
          s->interlaced = (interlace == 1) ? 1 : (interlace == 2) ? 0 : s->interlaced;
          s->context = ((uint8_t*)avctx->extradata)[2] & 0x40 ? 1 : 0;
  
-         if ( read_huffman_tables(s, ((uint8_t*)avctx->extradata) + 4,
-                                  avctx->extradata_size - 4) < 0)
-             return AVERROR_INVALIDDATA;
-     }else{
 -        if ((ret = read_huffman_tables(s, ((uint8_t*)avctx->extradata) + 4,
++        if ((ret = read_huffman_tables(s, avctx->extradata + 4,
+                                        avctx->extradata_size - 4)) < 0)
+             return ret;
 -    }else{
++    } else {
          switch (avctx->bits_per_coded_sample & 7) {
          case 1:
              s->predictor = LEFT;
          s->bitstream_bpp = avctx->bits_per_coded_sample & ~7;
          s->context = 0;
  
-         if (read_old_huffman_tables(s) < 0)
-             return AVERROR_INVALIDDATA;
+         if ((ret = read_old_huffman_tables(s)) < 0)
+             return ret;
      }
  
 -    switch (s->bitstream_bpp) {
 -    case 12:
 -        avctx->pix_fmt = AV_PIX_FMT_YUV420P;
 -        break;
 -    case 16:
 -        if (s->yuy2) {
 -            avctx->pix_fmt = AV_PIX_FMT_YUYV422;
 -        } else {
 -            avctx->pix_fmt = AV_PIX_FMT_YUV422P;
 -        }
 -        break;
 -    case 24:
 -    case 32:
 -        if (s->bgr32) {
 +    if (s->version <= 2) {
 +        switch (s->bitstream_bpp) {
 +        case 12:
 +            avctx->pix_fmt = AV_PIX_FMT_YUV420P;
 +            s->yuv = 1;
 +            break;
 +        case 16:
 +            if (s->yuy2) {
 +                avctx->pix_fmt = AV_PIX_FMT_YUYV422;
 +            } else {
 +                avctx->pix_fmt = AV_PIX_FMT_YUV422P;
 +            }
 +            s->yuv = 1;
 +            break;
 +        case 24:
 +            if (s->bgr32) {
 +                avctx->pix_fmt = AV_PIX_FMT_0RGB32;
 +            } else {
 +                avctx->pix_fmt = AV_PIX_FMT_BGR24;
 +            }
 +            break;
 +        case 32:
 +            av_assert0(s->bgr32);
              avctx->pix_fmt = AV_PIX_FMT_RGB32;
 -        } else {
 -            avctx->pix_fmt = AV_PIX_FMT_BGR24;
 +            s->alpha = 1;
 +            break;
 +        default:
 +            return AVERROR_INVALIDDATA;
 +        }
 +        av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt,
 +                                         &s->chroma_h_shift,
 +                                         &s->chroma_v_shift);
 +    } else {
 +        switch ( (s->chroma<<10) | (s->yuv<<9) | (s->alpha<<8) | ((s->bps-1)<<4) | s->chroma_h_shift | (s->chroma_v_shift<<2)) {
 +        case 0x070:
 +            avctx->pix_fmt = AV_PIX_FMT_GRAY8;
 +            break;
 +        case 0x0F0:
 +            avctx->pix_fmt = AV_PIX_FMT_GRAY16;
 +            break;
 +        case 0x170:
 +            avctx->pix_fmt = AV_PIX_FMT_GRAY8A;
 +            break;
 +        case 0x470:
 +            avctx->pix_fmt = AV_PIX_FMT_GBRP;
 +            break;
 +        case 0x480:
 +            avctx->pix_fmt = AV_PIX_FMT_GBRP9;
 +            break;
 +        case 0x490:
 +            avctx->pix_fmt = AV_PIX_FMT_GBRP10;
 +            break;
 +        case 0x4B0:
 +            avctx->pix_fmt = AV_PIX_FMT_GBRP12;
 +            break;
 +        case 0x4D0:
 +            avctx->pix_fmt = AV_PIX_FMT_GBRP14;
 +            break;
 +        case 0x4F0:
 +            avctx->pix_fmt = AV_PIX_FMT_GBRP16;
 +            break;
 +        case 0x570:
 +            avctx->pix_fmt = AV_PIX_FMT_GBRAP;
 +            break;
 +        case 0x670:
 +            avctx->pix_fmt = AV_PIX_FMT_YUV444P;
 +            break;
 +        case 0x680:
 +            avctx->pix_fmt = AV_PIX_FMT_YUV444P9;
 +            break;
 +        case 0x690:
 +            avctx->pix_fmt = AV_PIX_FMT_YUV444P10;
 +            break;
 +        case 0x6B0:
 +            avctx->pix_fmt = AV_PIX_FMT_YUV444P12;
 +            break;
 +        case 0x6D0:
 +            avctx->pix_fmt = AV_PIX_FMT_YUV444P14;
 +            break;
 +        case 0x6F0:
 +            avctx->pix_fmt = AV_PIX_FMT_YUV444P16;
 +            break;
 +        case 0x671:
 +            avctx->pix_fmt = AV_PIX_FMT_YUV422P;
 +            break;
 +        case 0x681:
 +            avctx->pix_fmt = AV_PIX_FMT_YUV422P9;
 +            break;
 +        case 0x691:
 +            avctx->pix_fmt = AV_PIX_FMT_YUV422P10;
 +            break;
 +        case 0x6B1:
 +            avctx->pix_fmt = AV_PIX_FMT_YUV422P12;
 +            break;
 +        case 0x6D1:
 +            avctx->pix_fmt = AV_PIX_FMT_YUV422P14;
 +            break;
 +        case 0x6F1:
 +            avctx->pix_fmt = AV_PIX_FMT_YUV422P16;
 +            break;
 +        case 0x672:
 +            avctx->pix_fmt = AV_PIX_FMT_YUV411P;
 +            break;
 +        case 0x674:
 +            avctx->pix_fmt = AV_PIX_FMT_YUV440P;
 +            break;
 +        case 0x675:
 +            avctx->pix_fmt = AV_PIX_FMT_YUV420P;
 +            break;
 +        case 0x685:
 +            avctx->pix_fmt = AV_PIX_FMT_YUV420P9;
 +            break;
 +        case 0x695:
 +            avctx->pix_fmt = AV_PIX_FMT_YUV420P10;
 +            break;
 +        case 0x6B5:
 +            avctx->pix_fmt = AV_PIX_FMT_YUV420P12;
 +            break;
 +        case 0x6D5:
 +            avctx->pix_fmt = AV_PIX_FMT_YUV420P14;
 +            break;
 +        case 0x6F5:
 +            avctx->pix_fmt = AV_PIX_FMT_YUV420P16;
 +            break;
 +        case 0x67A:
 +            avctx->pix_fmt = AV_PIX_FMT_YUV410P;
 +            break;
 +        case 0x770:
 +            avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
 +            break;
 +        case 0x780:
 +            avctx->pix_fmt = AV_PIX_FMT_YUVA444P9;
 +            break;
 +        case 0x790:
 +            avctx->pix_fmt = AV_PIX_FMT_YUVA444P10;
 +            break;
 +        case 0x7F0:
 +            avctx->pix_fmt = AV_PIX_FMT_YUVA444P16;
 +            break;
 +        case 0x771:
 +            avctx->pix_fmt = AV_PIX_FMT_YUVA422P;
 +            break;
 +        case 0x781:
 +            avctx->pix_fmt = AV_PIX_FMT_YUVA422P9;
 +            break;
 +        case 0x791:
 +            avctx->pix_fmt = AV_PIX_FMT_YUVA422P10;
 +            break;
 +        case 0x7F1:
 +            avctx->pix_fmt = AV_PIX_FMT_YUVA422P16;
 +            break;
 +        case 0x775:
 +            avctx->pix_fmt = AV_PIX_FMT_YUVA420P;
 +            break;
 +        case 0x785:
 +            avctx->pix_fmt = AV_PIX_FMT_YUVA420P9;
 +            break;
 +        case 0x795:
 +            avctx->pix_fmt = AV_PIX_FMT_YUVA420P10;
 +            break;
 +        case 0x7F5:
 +            avctx->pix_fmt = AV_PIX_FMT_YUVA420P16;
 +            break;
 +        default:
 +            return AVERROR_INVALIDDATA;
          }
 -        break;
 -    default:
 -        return AVERROR_INVALIDDATA;
      }
  
 -    if ((ret = ff_huffyuv_alloc_temp(s)) < 0)
 +    ff_huffyuv_common_init(avctx);
 +
 +    if ((avctx->pix_fmt == AV_PIX_FMT_YUV422P || avctx->pix_fmt == AV_PIX_FMT_YUV420P) && avctx->width & 1) {
 +        av_log(avctx, AV_LOG_ERROR, "width must be even for this colorspace\n");
 +        return AVERROR_INVALIDDATA;
 +    }
 +    if (s->predictor == MEDIAN && avctx->pix_fmt == AV_PIX_FMT_YUV422P && avctx->width%4) {
 +        av_log(avctx, AV_LOG_ERROR, "width must be a multiple of 4 this colorspace and predictor\n");
 +        return AVERROR_INVALIDDATA;
 +    }
-     if (ff_huffyuv_alloc_temp(s)) {
++    if ((ret = ff_huffyuv_alloc_temp(s)) < 0) {
 +        ff_huffyuv_common_end(s);
-         return AVERROR(ENOMEM);
+         return ret;
 +    }
  
      return 0;
  }
  static av_cold int decode_init_thread_copy(AVCodecContext *avctx)
  {
      HYuvContext *s = avctx->priv_data;
-     int i;
+     int i, ret;
  
-     if (ff_huffyuv_alloc_temp(s)) {
 -    if ((ret = ff_huffyuv_alloc_temp(s)) < 0)
++    if ((ret = ff_huffyuv_alloc_temp(s)) < 0) {
 +        ff_huffyuv_common_end(s);
-         return AVERROR(ENOMEM);
+         return ret;
 +    }
  
 -    for (i = 0; i < 6; i++)
 +    for (i = 0; i < 8; i++)
          s->vlc[i].table = NULL;
  
 -    if (s->version == 2) {
 -        if ((ret = read_huffman_tables(s, ((uint8_t*)avctx->extradata) + 4,
 +    if (s->version >= 2) {
-         if (read_huffman_tables(s, ((uint8_t*)avctx->extradata) + 4,
-                                 avctx->extradata_size) < 0)
-             return AVERROR_INVALIDDATA;
++        if ((ret = read_huffman_tables(s, avctx->extradata + 4,
+                                        avctx->extradata_size)) < 0)
+             return ret;
      } else {
-         if (read_old_huffman_tables(s) < 0)
-             return AVERROR_INVALIDDATA;
+         if ((ret = read_old_huffman_tables(s)) < 0)
+             return ret;
      }
  
      return 0;
@@@ -802,10 -521,11 +802,11 @@@ static int decode_frame(AVCodecContext 
      }
  
      if ((unsigned)(buf_size-table_size) >= INT_MAX / 8)
 -        return -1;
 +        return AVERROR_INVALIDDATA;
  
-     init_get_bits(&s->gb, s->bitstream_buffer+table_size,
-                   (buf_size-table_size) * 8);
+     if ((ret = init_get_bits(&s->gb, s->bitstream_buffer + table_size,
+                              (buf_size - table_size) * 8)) < 0)
+         return ret;
  
      fake_ystride = s->interlaced ? p->linesize[0] * 2  : p->linesize[0];
      fake_ustride = s->interlaced ? p->linesize[1] * 2  : p->linesize[1];