Merge commit '9e500efdbe0deeff1602500ebc229a0a6b6bb1a2'
authorMichael Niedermayer <michaelni@gmx.at>
Fri, 20 Jun 2014 20:20:28 +0000 (22:20 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Fri, 20 Jun 2014 20:20:28 +0000 (22:20 +0200)
* commit '9e500efdbe0deeff1602500ebc229a0a6b6bb1a2':
  Add av_image_check_sar() and use it to validate SAR

Conflicts:
libavcodec/dpx.c
libavcodec/dvdec.c
libavcodec/ffv1dec.c
libavcodec/utils.c
libavutil/version.h

Merged-by: Michael Niedermayer <michaelni@gmx.at>
19 files changed:
1  2 
doc/APIchanges
libavcodec/dirac.c
libavcodec/dpx.c
libavcodec/dvdec.c
libavcodec/exr.c
libavcodec/ffv1dec.c
libavcodec/h263dec.c
libavcodec/h264_slice.c
libavcodec/hevc.c
libavcodec/internal.h
libavcodec/mjpegdec.c
libavcodec/mpeg12dec.c
libavcodec/truemotion1.c
libavcodec/utils.c
libavcodec/vc1.c
libavcodec/vp3.c
libavutil/imgutils.c
libavutil/imgutils.h
libavutil/version.h

diff --cc doc/APIchanges
Simple merge
Simple merge
@@@ -174,89 -118,44 +174,91 @@@ static int decode_frame(AVCodecContext 
      }
  
      switch (bits_per_color) {
 -        case 8:
 -            if (elements == 4) {
 -                avctx->pix_fmt = AV_PIX_FMT_RGBA;
 -            } else {
 -                avctx->pix_fmt = AV_PIX_FMT_RGB24;
 -            }
 -            source_packet_size = elements;
 -            target_packet_size = elements;
 -            break;
 -        case 10:
 -            avctx->pix_fmt = AV_PIX_FMT_RGB48;
 -            target_packet_size = 6;
 -            source_packet_size = 4;
 -            break;
 -        case 12:
 -        case 16:
 -            if (endian) {
 -                avctx->pix_fmt = AV_PIX_FMT_RGB48BE;
 -            } else {
 -                avctx->pix_fmt = AV_PIX_FMT_RGB48LE;
 -            }
 -            target_packet_size = 6;
 -            source_packet_size = elements * 2;
 -            break;
 -        default:
 -            av_log(avctx, AV_LOG_ERROR, "Unsupported color depth : %d\n", bits_per_color);
 -            return AVERROR_INVALIDDATA;
 +    case 8:
 +        total_size = avctx->width * avctx->height * elements;
 +        break;
 +    case 10:
 +        if (!packing) {
 +            av_log(avctx, AV_LOG_ERROR, "Packing to 32bit required\n");
 +            return -1;
 +        }
 +        total_size = (avctx->width * elements + 2) / 3 * 4 * avctx->height;
 +        break;
 +    case 12:
 +        if (!packing) {
 +            av_log(avctx, AV_LOG_ERROR, "Packing to 16bit required\n");
 +            return -1;
 +        }
 +        total_size = 2 * avctx->width * avctx->height * elements;
 +        break;
 +    case 16:
 +        total_size = 2 * avctx->width * avctx->height * elements;
 +        break;
 +    case 1:
 +    case 32:
 +    case 64:
 +        avpriv_report_missing_feature(avctx, "Depth %d", bits_per_color);
 +        return AVERROR_PATCHWELCOME;
 +    default:
 +        return AVERROR_INVALIDDATA;
      }
  
 -    if ((ret = ff_set_dimensions(avctx, w, h)) < 0)
 -        return ret;
 +    switch (1000 * descriptor + 10 * bits_per_color + endian) {
 +    case 6081:
 +    case 6080:
 +        avctx->pix_fmt = AV_PIX_FMT_GRAY8;
 +        break;
 +    case 50081:
 +    case 50080:
 +        avctx->pix_fmt = AV_PIX_FMT_RGB24;
 +        break;
 +    case 52081:
 +    case 52080:
 +        avctx->pix_fmt = AV_PIX_FMT_ABGR;
 +        break;
 +    case 51081:
 +    case 51080:
 +        avctx->pix_fmt = AV_PIX_FMT_RGBA;
 +        break;
 +    case 50100:
 +    case 51100:
 +    case 50101:
 +    case 51101:
 +        avctx->pix_fmt = AV_PIX_FMT_GBRP10;
 +        break;
 +    case 50120:
 +    case 51120:
 +    case 50121:
 +    case 51121:
 +        avctx->pix_fmt = AV_PIX_FMT_GBRP12;
 +        break;
 +    case 6161:
 +        avctx->pix_fmt = AV_PIX_FMT_GRAY16BE;
 +        break;
 +    case 6160:
 +        avctx->pix_fmt = AV_PIX_FMT_GRAY16LE;
 +        break;
 +    case 50161:
 +        avctx->pix_fmt = AV_PIX_FMT_RGB48BE;
 +        break;
 +    case 50160:
 +        avctx->pix_fmt = AV_PIX_FMT_RGB48LE;
 +        break;
 +    case 51161:
 +        avctx->pix_fmt = AV_PIX_FMT_RGBA64BE;
 +        break;
 +    case 51160:
 +        avctx->pix_fmt = AV_PIX_FMT_RGBA64LE;
 +        break;
 +    default:
 +        av_log(avctx, AV_LOG_ERROR, "Unsupported format\n");
 +        return AVERROR_PATCHWELCOME;
 +    }
  
 -    if ((ret = ff_get_buffer(avctx, p, 0)) < 0) {
 -        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
+     ff_set_sar(avctx, avctx->sample_aspect_ratio);
 +    if ((ret = ff_get_buffer(avctx, p, 0)) < 0)
          return ret;
 -    }
  
      // Move pointer to offset from start of file
      buf =  avpkt->data + offset;
@@@ -35,8 -35,8 +35,9 @@@
   * DV decoder
   */
  
 +#include "libavutil/avassert.h"
  #include "libavutil/internal.h"
+ #include "libavutil/imgutils.h"
  #include "libavutil/pixdesc.h"
  #include "avcodec.h"
  #include "internal.h"
@@@ -348,20 -348,21 +349,24 @@@ static int dvvideo_decode_frame(AVCodec
      if (ret < 0)
          return ret;
  
 -    if (ff_get_buffer(avctx, s->frame, 0) < 0) {
 -        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 -        return -1;
 -    }
+     /* Determine the codec's sample_aspect ratio from the packet */
+     vsc_pack = buf + 80*5 + 48 + 5;
+     if ( *vsc_pack == dv_video_control ) {
+         apt = buf[4] & 0x07;
+         is16_9 = (vsc_pack && ((vsc_pack[2] & 0x07) == 0x02 || (!apt && (vsc_pack[2] & 0x07) == 0x07)));
+         ff_set_sar(avctx, s->sys->sar[is16_9]);
+     }
 +    if ((ret = ff_get_buffer(avctx, s->frame, 0)) < 0)
 +        return ret;
      s->frame->interlaced_frame = 1;
      s->frame->top_field_first  = 0;
  
-     /* Determine the codec's sample_aspect ratio and field order from the packet */
-     vsc_pack = buf + 80*5 + 48 + 5;
++    /* Determine the codec's field order from the packet */
 +    if ( *vsc_pack == dv_video_control ) {
-         apt = buf[4] & 0x07;
-         is16_9 = (vsc_pack[2] & 0x07) == 0x02 || (!apt && (vsc_pack[2] & 0x07) == 0x07);
-         avctx->sample_aspect_ratio = s->sys->sar[is16_9];
 +        s->frame->top_field_first = !(vsc_pack[3] & 0x40);
 +    }
 +
      s->buf = buf;
      avctx->execute(avctx, dv_decode_video_segment, s->work_chunks, NULL,
                     dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
Simple merge
@@@ -330,18 -327,15 +330,28 @@@ static int decode_slice_header(FFV1Cont
      }
      f->cur->sample_aspect_ratio.num = get_symbol(c, state, 0);
      f->cur->sample_aspect_ratio.den = get_symbol(c, state, 0);
+     if (av_image_check_sar(f->width, f->height,
+                            f->cur->sample_aspect_ratio) < 0) {
+         av_log(f->avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
+                f->cur->sample_aspect_ratio.num,
+                f->cur->sample_aspect_ratio.den);
+         f->cur->sample_aspect_ratio = (AVRational){ 0, 1 };
+     }
 +    if (fs->version > 3) {
 +        fs->slice_reset_contexts = get_rac(c, state);
 +        fs->slice_coding_mode = get_symbol(c, state, 0);
 +        if (fs->slice_coding_mode != 1) {
 +            fs->slice_rct_by_coef = get_symbol(c, state, 0);
 +            fs->slice_rct_ry_coef = get_symbol(c, state, 0);
 +            if ((uint64_t)fs->slice_rct_by_coef + (uint64_t)fs->slice_rct_ry_coef > 4) {
 +                av_log(f->avctx, AV_LOG_ERROR, "slice_rct_y_coef out of range\n");
 +                return AVERROR_INVALIDDATA;
 +            }
 +        }
 +    }
++
      return 0;
  }
  
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
@@@ -1347,8 -1294,17 +1347,10 @@@ static int mpeg_decode_postinit(AVCodec
              }
          } // MPEG-2
  
+         ff_set_sar(s->avctx, s->avctx->sample_aspect_ratio);
          avctx->pix_fmt = mpeg_get_pixelformat(avctx);
 -        // until then pix_fmt may be changed right after codec init
 -#if FF_API_XVMC
 -        if ((avctx->pix_fmt == AV_PIX_FMT_XVMC_MPEG2_IDCT ||
 -             avctx->hwaccel) && avctx->idct_algo == FF_IDCT_AUTO)
 -#else
 -        if (avctx->hwaccel && avctx->idct_algo == FF_IDCT_AUTO)
 -#endif /* FF_API_XVMC */
 -            avctx->idct_algo = FF_IDCT_SIMPLE;
 +        setup_hwaccel_for_pixfmt(avctx);
  
          /* Quantization matrices may need reordering
           * if DCT permutation is changed. */
@@@ -412,9 -412,9 +412,11 @@@ static int truemotion1_decode_header(Tr
          if ((ret = ff_set_dimensions(s->avctx, s->w, s->h)) < 0)
              return ret;
  
+         ff_set_sar(s->avctx, s->avctx->sample_aspect_ratio);
          av_fast_malloc(&s->vert_pred, &s->vert_pred_size, s->avctx->width * sizeof(unsigned int));
 +        if (!s->vert_pred)
 +            return AVERROR(ENOMEM);
      }
  
      /* There is 1 change bit per 4 pixels, so each change byte represents
@@@ -745,64 -560,107 +760,73 @@@ FF_ENABLE_DEPRECATION_WARNING
      }
  }
  
 -#if FF_API_GET_BUFFER
 -FF_DISABLE_DEPRECATION_WARNINGS
 -int avcodec_default_get_buffer(AVCodecContext *avctx, AVFrame *frame)
 -{
 -    return avcodec_default_get_buffer2(avctx, frame, 0);
 -}
 -
 -typedef struct CompatReleaseBufPriv {
 -    AVCodecContext avctx;
 -    AVFrame frame;
 -} CompatReleaseBufPriv;
 -
 -static void compat_free_buffer(void *opaque, uint8_t *data)
 -{
 -    CompatReleaseBufPriv *priv = opaque;
 -    if (priv->avctx.release_buffer)
 -        priv->avctx.release_buffer(&priv->avctx, &priv->frame);
 -    av_freep(&priv);
 -}
 -
 -static void compat_release_buffer(void *opaque, uint8_t *data)
 -{
 -    AVBufferRef *buf = opaque;
 -    av_buffer_unref(&buf);
 -}
 -FF_ENABLE_DEPRECATION_WARNINGS
 -#endif
 -
 -int ff_decode_frame_props(AVCodecContext *avctx, AVFrame *frame)
 +int ff_init_buffer_info(AVCodecContext *avctx, AVFrame *frame)
  {
      AVPacket *pkt = avctx->internal->pkt;
 -    uint8_t *packet_sd;
 -    int size;
 -    AVFrameSideData *frame_sd;
 -
 -#if FF_API_AVFRAME_COLORSPACE
 -    frame->color_primaries = avctx->color_primaries;
 -    frame->color_trc       = avctx->color_trc;
 -    frame->colorspace      = avctx->colorspace;
 -    frame->color_range     = avctx->color_range;
 -    frame->chroma_location = avctx->chroma_sample_location;
 -#endif
 -
 -    frame->reordered_opaque = avctx->reordered_opaque;
 -    if (!pkt) {
 -        frame->pkt_pts = AV_NOPTS_VALUE;
 -        return 0;
 -    }
  
 -    frame->pkt_pts = pkt->pts;
 -
 -    /* copy the replaygain data to the output frame */
 -    packet_sd = av_packet_get_side_data(pkt, AV_PKT_DATA_REPLAYGAIN, &size);
 -    if (packet_sd) {
 -        frame_sd = av_frame_new_side_data(frame, AV_FRAME_DATA_REPLAYGAIN, size);
 -        if (!frame_sd)
 -            return AVERROR(ENOMEM);
 +    if (pkt) {
 +        uint8_t *packet_sd;
 +        AVFrameSideData *frame_sd;
 +        int size;
 +        frame->pkt_pts = pkt->pts;
 +        av_frame_set_pkt_pos     (frame, pkt->pos);
 +        av_frame_set_pkt_duration(frame, pkt->duration);
 +        av_frame_set_pkt_size    (frame, pkt->size);
 +
 +        /* copy the replaygain data to the output frame */
 +        packet_sd = av_packet_get_side_data(pkt, AV_PKT_DATA_REPLAYGAIN, &size);
 +        if (packet_sd) {
 +            frame_sd = av_frame_new_side_data(frame, AV_FRAME_DATA_REPLAYGAIN, size);
 +            if (!frame_sd)
 +                return AVERROR(ENOMEM);
 +
 +            memcpy(frame_sd->data, packet_sd, size);
 +        }
  
 -        memcpy(frame_sd->data, packet_sd, size);
 -    }
 -    /* copy the displaymatrix to the output frame */
 -    packet_sd = av_packet_get_side_data(pkt, AV_PKT_DATA_DISPLAYMATRIX, &size);
 -    if (packet_sd) {
 -        frame_sd = av_frame_new_side_data(frame, AV_FRAME_DATA_DISPLAYMATRIX, size);
 -        if (!frame_sd)
 -            return AVERROR(ENOMEM);
 +        /* copy the displaymatrix to the output frame */
 +        packet_sd = av_packet_get_side_data(pkt, AV_PKT_DATA_DISPLAYMATRIX, &size);
 +        if (packet_sd) {
 +            frame_sd = av_frame_new_side_data(frame, AV_FRAME_DATA_DISPLAYMATRIX, size);
 +            if (!frame_sd)
 +                return AVERROR(ENOMEM);
  
 -        memcpy(frame_sd->data, packet_sd, size);
 +            memcpy(frame_sd->data, packet_sd, size);
 +        }
 +    } else {
 +        frame->pkt_pts = AV_NOPTS_VALUE;
 +        av_frame_set_pkt_pos     (frame, -1);
 +        av_frame_set_pkt_duration(frame, 0);
 +        av_frame_set_pkt_size    (frame, -1);
      }
 +    frame->reordered_opaque = avctx->reordered_opaque;
  
 -    return 0;
 -}
 -
 -int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
 -{
 -    const AVHWAccel *hwaccel = avctx->hwaccel;
 -    int override_dimensions = 1;
 -    int ret;
 +#if FF_API_AVFRAME_COLORSPACE
 +    if (frame->color_primaries == AVCOL_PRI_UNSPECIFIED)
 +        frame->color_primaries = avctx->color_primaries;
 +    if (frame->color_trc == AVCOL_TRC_UNSPECIFIED)
 +        frame->color_trc = avctx->color_trc;
 +    if (av_frame_get_colorspace(frame) == AVCOL_SPC_UNSPECIFIED)
 +        av_frame_set_colorspace(frame, avctx->colorspace);
 +    if (av_frame_get_color_range(frame) == AVCOL_RANGE_UNSPECIFIED)
 +        av_frame_set_color_range(frame, avctx->color_range);
 +    if (frame->chroma_location == AVCHROMA_LOC_UNSPECIFIED)
 +        frame->chroma_location = avctx->chroma_sample_location;
 +#endif
  
 -    switch (avctx->codec_type) {
 +    switch (avctx->codec->type) {
      case AVMEDIA_TYPE_VIDEO:
 -        if (frame->width <= 0 || frame->height <= 0) {
 -            frame->width  = FFMAX(avctx->width, avctx->coded_width);
 -            frame->height = FFMAX(avctx->height, avctx->coded_height);
 -            override_dimensions = 0;
 -        }
 -        if (frame->format < 0)
 -            frame->format              = avctx->pix_fmt;
 +        frame->format              = avctx->pix_fmt;
          if (!frame->sample_aspect_ratio.num)
              frame->sample_aspect_ratio = avctx->sample_aspect_ratio;
 -        if ((ret = av_image_check_size(avctx->width, avctx->height, 0, avctx)) < 0)
 -            return ret;
+         if (av_image_check_sar(frame->width, frame->height,
+                                frame->sample_aspect_ratio) < 0) {
+             av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
+                    frame->sample_aspect_ratio.num,
+                    frame->sample_aspect_ratio.den);
+             frame->sample_aspect_ratio = (AVRational){ 0, 1 };
+         }
          break;
      case AVMEDIA_TYPE_AUDIO:
          if (!frame->sample_rate)
Simple merge
Simple merge
  #include "common.h"
  #include "imgutils.h"
  #include "internal.h"
 +#include "intreadwrite.h"
  #include "log.h"
+ #include "mathematics.h"
  #include "pixdesc.h"
+ #include "rational.h"
  
  void av_image_fill_max_pixsteps(int max_pixsteps[4], int max_pixstep_comps[4],
                                  const AVPixFmtDescriptor *pixdesc)
Simple merge
@@@ -55,9 -53,9 +55,9 @@@
   * @{
   */
  
 -#define LIBAVUTIL_VERSION_MAJOR 53
 -#define LIBAVUTIL_VERSION_MINOR 17
 -#define LIBAVUTIL_VERSION_MICRO  0
 +#define LIBAVUTIL_VERSION_MAJOR  52
- #define LIBAVUTIL_VERSION_MINOR  89
++#define LIBAVUTIL_VERSION_MINOR  90
 +#define LIBAVUTIL_VERSION_MICRO 100
  
  #define LIBAVUTIL_VERSION_INT   AV_VERSION_INT(LIBAVUTIL_VERSION_MAJOR, \
                                                 LIBAVUTIL_VERSION_MINOR, \