Merge commit 'd0393d79bc3d61c9f2ff832c0e273b7774ff0269'
authorMichael Niedermayer <michaelni@gmx.at>
Mon, 4 Aug 2014 03:08:01 +0000 (05:08 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Mon, 4 Aug 2014 03:29:55 +0000 (05:29 +0200)
* commit 'd0393d79bc3d61c9f2ff832c0e273b7774ff0269':
  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

@@@ -188,8 -175,9 +188,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];
  static av_cold int decode_init(AVCodecContext *avctx)
  {
      HYuvContext *s = avctx->priv_data;
+     int ret;
  
 -    ff_huffyuv_common_init(avctx);
      ff_huffyuvdsp_init(&s->hdsp);
 -    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;
  
      if (avctx->extradata_size) {
          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;
 -        break;
 -    default:
 -        return AVERROR_INVALIDDATA;
 +            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;
 +        }
      }
  
 -    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 (s->version >= 2) {
-         if (read_huffman_tables(s, 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;