Merge commit '7bcaeb408e3eb2d2f37a306009fa7fe7eb0f1d79'
authorMichael Niedermayer <michaelni@gmx.at>
Sat, 26 Jan 2013 14:42:29 +0000 (15:42 +0100)
committerMichael Niedermayer <michaelni@gmx.at>
Sat, 26 Jan 2013 14:42:29 +0000 (15:42 +0100)
* commit '7bcaeb408e3eb2d2f37a306009fa7fe7eb0f1d79':
  mjpegdec: fix indentation
  rawdec: cosmetics, reformat
  mimic: return meaningful error codes.

Conflicts:
libavcodec/mjpegdec.c
libavcodec/rawdec.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
libavcodec/mimic.c
libavcodec/mjpegdec.c
libavcodec/rawdec.c

@@@ -354,15 -359,15 +359,15 @@@ static int mimic_decode_frame(AVCodecCo
  
      if (is_pframe && !ctx->buf_ptrs[ctx->prev_index].data[0]) {
          av_log(avctx, AV_LOG_ERROR, "decoding must start with keyframe\n");
-         return -1;
+         return AVERROR_INVALIDDATA;
      }
  
 -    ctx->buf_ptrs[ctx->cur_index].reference = 1;
 +    ctx->buf_ptrs[ctx->cur_index].reference = 3;
      ctx->buf_ptrs[ctx->cur_index].pict_type = is_pframe ? AV_PICTURE_TYPE_P :
                                                            AV_PICTURE_TYPE_I;
-     if (ff_thread_get_buffer(avctx, &ctx->buf_ptrs[ctx->cur_index])) {
+     if ((res = ff_thread_get_buffer(avctx, &ctx->buf_ptrs[ctx->cur_index])) < 0) {
          av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
-         return -1;
+         return res;
      }
  
      ctx->next_prev_index = ctx->cur_index;
@@@ -1733,25 -1552,24 +1733,25 @@@ eoi_parser
                      s->bottom_field ^= 1;
                      /* if not bottom field, do not output image yet */
                      if (s->bottom_field == !s->interlace_polarity)
 -                        goto not_the_end;
 +                        break;
                  }
-                     *picture   = *s->picture_ptr;
-                     *got_frame = 1;
-                     s->got_picture = 0;
-                     if (!s->lossless) {
-                         picture->quality      = FFMAX3(s->qscale[0],
-                                                        s->qscale[1],
-                                                        s->qscale[2]);
-                         picture->qstride      = 0;
-                         picture->qscale_table = s->qscale_table;
-                         memset(picture->qscale_table, picture->quality,
-                                (s->width + 15) / 16);
-                         if (avctx->debug & FF_DEBUG_QP)
-                             av_log(avctx, AV_LOG_DEBUG,
-                                    "QP: %d\n", picture->quality);
-                         picture->quality *= FF_QP2LAMBDA;
-                     }
+                 *picture   = *s->picture_ptr;
+                 *got_frame = 1;
++                s->got_picture = 0;
+                 if (!s->lossless) {
+                     picture->quality      = FFMAX3(s->qscale[0],
+                                                    s->qscale[1],
+                                                    s->qscale[2]);
+                     picture->qstride      = 0;
+                     picture->qscale_table = s->qscale_table;
+                     memset(picture->qscale_table, picture->quality,
+                            (s->width + 15) / 16);
+                     if (avctx->debug & FF_DEBUG_QP)
+                         av_log(avctx, AV_LOG_DEBUG,
+                                "QP: %d\n", picture->quality);
+                     picture->quality *= FF_QP2LAMBDA;
+                 }
  
                  goto the_end;
              case SOS:
  #include "libavutil/common.h"
  #include "libavutil/intreadwrite.h"
  #include "libavutil/imgutils.h"
 +#include "libavutil/opt.h"
  
  typedef struct RawVideoContext {
 +    AVClass *av_class;
      uint32_t palette[AVPALETTE_COUNT];
-     unsigned char * buffer;  /* block of memory for holding one frame */
-     int             length;  /* number of bytes in buffer */
+     unsigned char *buffer;  /* block of memory for holding one frame */
+     int            length;  /* number of bytes in buffer */
      int flip;
      AVFrame pic;             ///< AVCodecContext.coded_frame
 +    int tff;
  } RawVideoContext;
  
 +static const AVOption options[]={
 +{"top", "top field first", offsetof(RawVideoContext, tff), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 1, AV_OPT_FLAG_DECODING_PARAM|AV_OPT_FLAG_VIDEO_PARAM},
 +{NULL}
 +};
 +
 +static const AVClass class = {
 +    .class_name = "rawdec",
 +    .option     = options,
 +    .version    = LIBAVUTIL_VERSION_INT,
 +};
 +
  static const PixelFormatTag pix_fmt_bps_avi[] = {
 +    { AV_PIX_FMT_MONOWHITE, 1 },
 +    { AV_PIX_FMT_PAL8,    2 },
      { AV_PIX_FMT_PAL8,    4 },
      { AV_PIX_FMT_PAL8,    8 },
      { AV_PIX_FMT_RGB444, 12 },
      { AV_PIX_FMT_RGB555, 15 },
      { AV_PIX_FMT_RGB555, 16 },
      { AV_PIX_FMT_BGR24,  24 },
 -    { AV_PIX_FMT_RGB32,  32 },
 +    { AV_PIX_FMT_BGRA,   32 },
-     { AV_PIX_FMT_NONE, 0 },
+     { AV_PIX_FMT_NONE,    0 },
  };
  
  static const PixelFormatTag pix_fmt_bps_mov[] = {
      { AV_PIX_FMT_RGB24,    24 },
      { AV_PIX_FMT_ARGB,     32 },
      { AV_PIX_FMT_MONOWHITE,33 },
-     { AV_PIX_FMT_NONE, 0 },
+     { AV_PIX_FMT_NONE,      0 },
  };
  
- enum AVPixelFormat avpriv_find_pix_fmt(const PixelFormatTag *tags, unsigned int fourcc)
 -static enum AVPixelFormat find_pix_fmt(const PixelFormatTag *tags,
++enum AVPixelFormat avpriv_find_pix_fmt(const PixelFormatTag *tags,
+                                        unsigned int fourcc)
  {
      while (tags->pix_fmt >= 0) {
          if (tags->fourcc == fourcc)
@@@ -101,52 -78,39 +102,60 @@@ static av_cold int raw_init_decoder(AVC
  {
      RawVideoContext *context = avctx->priv_data;
  
-     if (avctx->codec_tag == MKTAG('r','a','w',' ') || avctx->codec_tag == MKTAG('N','O','1','6'))
-         avctx->pix_fmt = avpriv_find_pix_fmt(pix_fmt_bps_mov, avctx->bits_per_coded_sample);
-     else if (avctx->codec_tag == MKTAG('W','R','A','W'))
-         avctx->pix_fmt = avpriv_find_pix_fmt(pix_fmt_bps_avi, avctx->bits_per_coded_sample);
 -    if (avctx->codec_tag == MKTAG('r', 'a', 'w', ' '))
 -        avctx->pix_fmt = find_pix_fmt(pix_fmt_bps_mov,
++    if (   avctx->codec_tag == MKTAG('r','a','w',' ')
++        || avctx->codec_tag == MKTAG('N','O','1','6'))
++        avctx->pix_fmt = avpriv_find_pix_fmt(pix_fmt_bps_mov,
+                                       avctx->bits_per_coded_sample);
+     else if (avctx->codec_tag == MKTAG('W', 'R', 'A', 'W'))
 -        avctx->pix_fmt = find_pix_fmt(pix_fmt_bps_avi,
++        avctx->pix_fmt = avpriv_find_pix_fmt(pix_fmt_bps_avi,
+                                       avctx->bits_per_coded_sample);
      else if (avctx->codec_tag)
 -        avctx->pix_fmt = find_pix_fmt(ff_raw_pix_fmt_tags, avctx->codec_tag);
 +        avctx->pix_fmt = avpriv_find_pix_fmt(ff_raw_pix_fmt_tags, avctx->codec_tag);
      else if (avctx->pix_fmt == AV_PIX_FMT_NONE && avctx->bits_per_coded_sample)
-         avctx->pix_fmt = avpriv_find_pix_fmt(pix_fmt_bps_avi, avctx->bits_per_coded_sample);
 -        avctx->pix_fmt = find_pix_fmt(pix_fmt_bps_avi,
++        avctx->pix_fmt = avpriv_find_pix_fmt(pix_fmt_bps_avi,
+                                       avctx->bits_per_coded_sample);
  
 +    if (avctx->pix_fmt == AV_PIX_FMT_NONE) {
 +        av_log(avctx, AV_LOG_ERROR, "Pixel format was not specified and cannot be detected\n");
 +        return AVERROR(EINVAL);
 +    }
 +
      avpriv_set_systematic_pal2(context->palette, avctx->pix_fmt);
-     if((avctx->bits_per_coded_sample == 4 || avctx->bits_per_coded_sample == 2) &&
-        avctx->pix_fmt==AV_PIX_FMT_PAL8 &&
-        (!avctx->codec_tag || avctx->codec_tag == MKTAG('r','a','w',' '))){
-         context->length = avpicture_get_size(avctx->pix_fmt, FFALIGN(avctx->width, 16), avctx->height);
 -    context->length = avpicture_get_size(avctx->pix_fmt, avctx->width,
 -                                         avctx->height);
+     if ((avctx->bits_per_coded_sample == 4 || avctx->bits_per_coded_sample == 2) &&
+         avctx->pix_fmt == AV_PIX_FMT_PAL8 &&
+        (!avctx->codec_tag || avctx->codec_tag == MKTAG('r','a','w',' '))) {
++        context->length = avpicture_get_size(avctx->pix_fmt,
++                                             FFALIGN(avctx->width, 16),
++                                             avctx->height);
 +        if (context->length < 0)
 +            return context->length;
          context->buffer = av_malloc(context->length);
          if (!context->buffer)
 -            return -1;
 +            return AVERROR(ENOMEM);
 +    } else {
 +        context->length = avpicture_get_size(avctx->pix_fmt, avctx->width, avctx->height);
 +        if (context->length < 0)
 +            return context->length;
      }
      context->pic.pict_type = AV_PICTURE_TYPE_I;
      context->pic.key_frame = 1;
  
-     avctx->coded_frame= &context->pic;
+     avctx->coded_frame = &context->pic;
  
-     if((avctx->extradata_size >= 9 && !memcmp(avctx->extradata + avctx->extradata_size - 9, "BottomUp", 9)) ||
+     if ((avctx->extradata_size >= 9 &&
+          !memcmp(avctx->extradata + avctx->extradata_size - 9, "BottomUp", 9)) ||
 +        avctx->codec_tag == MKTAG('c','y','u','v') ||
-         avctx->codec_tag == MKTAG(3, 0, 0, 0) || avctx->codec_tag == MKTAG('W','R','A','W'))
-         context->flip=1;
+         avctx->codec_tag == MKTAG(3, 0, 0, 0) ||
+         avctx->codec_tag == MKTAG('W','R','A','W'))
+         context->flip = 1;
  
 +    if (avctx->field_order > AV_FIELD_PROGRESSIVE) { /*we have interlaced material flagged in container */
 +        avctx->coded_frame->interlaced_frame = 1;
 +        if (avctx->field_order == AV_FIELD_TT  || avctx->field_order == AV_FIELD_TB)
 +            avctx->coded_frame->top_field_first = 1;
 +    }
 +
 +
      return 0;
  }
  
@@@ -155,138 -120,91 +165,138 @@@ static void flip(AVCodecContext *avctx
      picture->linesize[0] *= -1;
  }
  
- static int raw_decode(AVCodecContext *avctx,
-                             void *data, int *got_frame,
-                             AVPacket *avpkt)
+ static int raw_decode(AVCodecContext *avctx, void *data, int *got_frame,
+                       AVPacket *avpkt)
  {
-     const uint8_t *buf = avpkt->data;
-     int buf_size = avpkt->size;
-     int linesize_align = 4;
-     RawVideoContext *context = avctx->priv_data;
      const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
 -    int res;
+     RawVideoContext *context       = avctx->priv_data;
+     const uint8_t *buf             = avpkt->data;
+     int buf_size                   = avpkt->size;
++    int linesize_align             = 4;
 +    int res, len;
  
      AVFrame   *frame   = data;
      AVPicture *picture = data;
  
      frame->pict_type        = avctx->coded_frame->pict_type;
      frame->interlaced_frame = avctx->coded_frame->interlaced_frame;
-     frame->top_field_first = avctx->coded_frame->top_field_first;
+     frame->top_field_first  = avctx->coded_frame->top_field_first;
      frame->reordered_opaque = avctx->reordered_opaque;
      frame->pkt_pts          = avctx->pkt->pts;
-     if(context->tff>=0){
 +    frame->pkt_pos          = avctx->pkt->pos;
 +    frame->pkt_duration     = avctx->pkt->duration;
 +
++    if (context->tff >= 0) {
 +        frame->interlaced_frame = 1;
 +        frame->top_field_first  = context->tff;
 +    }
  
 -    if (buf_size < context->length - (avctx->pix_fmt == AV_PIX_FMT_PAL8 ? 256 * 4 : 0))
 -        return -1;
 +    if ((res = av_image_check_size(avctx->width, avctx->height, 0, avctx)) < 0)
 +        return res;
  
      //2bpp and 4bpp raw in avi and mov (yes this is ugly ...)
      if (context->buffer) {
          int i;
          uint8_t *dst = context->buffer;
 -        buf_size = context->length - 256 * 4;
 +        buf_size = context->length - AVPALETTE_SIZE;
-         if (avctx->bits_per_coded_sample == 4){
-             for(i=0; 2*i+1 < buf_size && i<avpkt->size; i++){
-                 dst[2*i+0]= buf[i]>>4;
-                 dst[2*i+1]= buf[i]&15;
+         if (avctx->bits_per_coded_sample == 4) {
 -            for (i = 0; 2 * i + 1 < buf_size; i++) {
++            for (i = 0; 2 * i + 1 < buf_size && i<avpkt->size; i++) {
+                 dst[2 * i + 0] = buf[i] >> 4;
+                 dst[2 * i + 1] = buf[i] & 15;
              }
 +            linesize_align = 8;
          } else {
 -            for (i = 0; 4 * i + 3 < buf_size; i++) {
 +            av_assert0(avctx->bits_per_coded_sample == 2);
-             for(i=0; 4*i+3 < buf_size && i<avpkt->size; i++){
-                 dst[4*i+0]= buf[i]>>6;
-                 dst[4*i+1]= buf[i]>>4&3;
-                 dst[4*i+2]= buf[i]>>2&3;
-                 dst[4*i+3]= buf[i]   &3;
++            for (i = 0; 4 * i + 3 < buf_size && i<avpkt->size; i++) {
+                 dst[4 * i + 0] = buf[i] >> 6;
+                 dst[4 * i + 1] = buf[i] >> 4 & 3;
+                 dst[4 * i + 2] = buf[i] >> 2 & 3;
+                 dst[4 * i + 3] = buf[i]      & 3;
              }
 +            linesize_align = 16;
          }
-         buf= dst;
+         buf = dst;
      }
  
-     if(avctx->codec_tag == MKTAG('A', 'V', '1', 'x') ||
-        avctx->codec_tag == MKTAG('A', 'V', 'u', 'p'))
+     if (avctx->codec_tag == MKTAG('A', 'V', '1', 'x') ||
+         avctx->codec_tag == MKTAG('A', 'V', 'u', 'p'))
          buf += buf_size - context->length;
  
 +    len = context->length - (avctx->pix_fmt==AV_PIX_FMT_PAL8 ? AVPALETTE_SIZE : 0);
 +    if (buf_size < len) {
 +        av_log(avctx, AV_LOG_ERROR, "Invalid buffer size, packet size %d < expected length %d\n", buf_size, len);
 +        return AVERROR(EINVAL);
 +    }
 +
      if ((res = avpicture_fill(picture, buf, avctx->pix_fmt,
                                avctx->width, avctx->height)) < 0)
          return res;
-     if((avctx->pix_fmt==AV_PIX_FMT_PAL8 && buf_size < context->length) ||
-        (desc->flags & PIX_FMT_PSEUDOPAL)) {
-         frame->data[1]= (uint8_t*)context->palette;
+     if ((avctx->pix_fmt == AV_PIX_FMT_PAL8 && buf_size < context->length) ||
+         (desc->flags & PIX_FMT_PSEUDOPAL)) {
 -        frame->data[1] = context->palette;
++        frame->data[1] = (uint8_t*)context->palette;
      }
      if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {
-         const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, NULL);
+         const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE,
+                                                      NULL);
  
          if (pal) {
              memcpy(frame->data[1], pal, AVPALETTE_SIZE);
              frame->palette_has_changed = 1;
          }
      }
-     if((avctx->pix_fmt==AV_PIX_FMT_BGR24    ||
 -    if (avctx->pix_fmt == AV_PIX_FMT_BGR24 &&
 -        ((frame->linesize[0] + 3) & ~3) * avctx->height <= buf_size)
 -        frame->linesize[0] = (frame->linesize[0] + 3) & ~3;
++    if ((avctx->pix_fmt==AV_PIX_FMT_BGR24    ||
 +        avctx->pix_fmt==AV_PIX_FMT_GRAY8    ||
 +        avctx->pix_fmt==AV_PIX_FMT_RGB555LE ||
 +        avctx->pix_fmt==AV_PIX_FMT_RGB555BE ||
 +        avctx->pix_fmt==AV_PIX_FMT_RGB565LE ||
 +        avctx->pix_fmt==AV_PIX_FMT_MONOWHITE ||
 +        avctx->pix_fmt==AV_PIX_FMT_PAL8) &&
-         FFALIGN(frame->linesize[0], linesize_align)*avctx->height <= buf_size)
++        FFALIGN(frame->linesize[0], linesize_align) * avctx->height <= buf_size)
 +        frame->linesize[0] = FFALIGN(frame->linesize[0], linesize_align);
 +
-     if(avctx->pix_fmt == AV_PIX_FMT_NV12 && avctx->codec_tag == MKTAG('N', 'V', '1', '2') &&
-         FFALIGN(frame->linesize[0], linesize_align)*avctx->height +
-         FFALIGN(frame->linesize[1], linesize_align)*((avctx->height+1)/2) <= buf_size) {
++    if (avctx->pix_fmt == AV_PIX_FMT_NV12 && avctx->codec_tag == MKTAG('N', 'V', '1', '2') &&
++        FFALIGN(frame->linesize[0], linesize_align) * avctx->height +
++        FFALIGN(frame->linesize[1], linesize_align) * ((avctx->height + 1) / 2) <= buf_size) {
 +        int la0 = FFALIGN(frame->linesize[0], linesize_align);
-         frame->data[1] += (la0 - frame->linesize[0])*avctx->height;
++        frame->data[1] += (la0 - frame->linesize[0]) * avctx->height;
 +        frame->linesize[0] = la0;
 +        frame->linesize[1] = FFALIGN(frame->linesize[1], linesize_align);
 +    }
  
-     if(context->flip)
+     if (context->flip)
          flip(avctx, picture);
  
-     if (   avctx->codec_tag == MKTAG('Y', 'V', '1', '2')
-         || avctx->codec_tag == MKTAG('Y', 'V', '1', '6')
-         || avctx->codec_tag == MKTAG('Y', 'V', '2', '4')
-         || avctx->codec_tag == MKTAG('Y', 'V', 'U', '9'))
+     if (avctx->codec_tag == MKTAG('Y', 'V', '1', '2') ||
+         avctx->codec_tag == MKTAG('Y', 'V', '1', '6') ||
+         avctx->codec_tag == MKTAG('Y', 'V', '2', '4') ||
+         avctx->codec_tag == MKTAG('Y', 'V', 'U', '9'))
          FFSWAP(uint8_t *, picture->data[1], picture->data[2]);
  
-         picture->data[1] = picture->data[1] + (avctx->width+1)*(avctx->height+1) -avctx->width*avctx->height;
 +    if (avctx->codec_tag == AV_RL32("I420") && (avctx->width+1)*(avctx->height+1) * 3/2 == buf_size) {
-     if(avctx->codec_tag == AV_RL32("yuv2") &&
-        avctx->pix_fmt   == AV_PIX_FMT_YUYV422) {
++        picture->data[1] = picture->data[1] +  (avctx->width+1)*(avctx->height+1) -avctx->width*avctx->height;
 +        picture->data[2] = picture->data[2] + ((avctx->width+1)*(avctx->height+1) -avctx->width*avctx->height)*5/4;
 +    }
 +
+     if (avctx->codec_tag == AV_RL32("yuv2") &&
+         avctx->pix_fmt   == AV_PIX_FMT_YUYV422) {
          int x, y;
          uint8_t *line = picture->data[0];
-         for(y = 0; y < avctx->height; y++) {
-             for(x = 0; x < avctx->width; x++)
-                 line[2*x + 1] ^= 0x80;
+         for (y = 0; y < avctx->height; y++) {
+             for (x = 0; x < avctx->width; x++)
+                 line[2 * x + 1] ^= 0x80;
              line += picture->linesize[0];
          }
      }
-     if(avctx->codec_tag == AV_RL32("YVYU") &&
-        avctx->pix_fmt   == AV_PIX_FMT_YUYV422) {
++    if (avctx->codec_tag == AV_RL32("YVYU") &&
++        avctx->pix_fmt   == AV_PIX_FMT_YUYV422) {
 +        int x, y;
 +        uint8_t *line = picture->data[0];
 +        for(y = 0; y < avctx->height; y++) {
 +            for(x = 0; x < avctx->width - 1; x += 2)
 +                FFSWAP(uint8_t, line[2*x + 1], line[2*x + 3]);
 +            line += picture->linesize[0];
 +        }
 +    }
  
      *got_frame = 1;
      return buf_size;