Merge remote-tracking branch 'qatar/master'
authorMichael Niedermayer <michaelni@gmx.at>
Fri, 12 Oct 2012 15:21:01 +0000 (17:21 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Fri, 12 Oct 2012 15:21:01 +0000 (17:21 +0200)
* qatar/master:
  lavu,lavd: do not use av_pix_fmt_descriptors directly.

Conflicts:
libavutil/imgutils.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
libavdevice/fbdev.c
libavutil/imgutils.c

Simple merge
@@@ -46,55 -45,50 +46,59 @@@ void av_image_fill_max_pixsteps(int max
      }
  }
  
 +static inline
 +int image_get_linesize(int width, int plane,
 +                       int max_step, int max_step_comp,
 +                       const AVPixFmtDescriptor *desc)
 +{
 +    int s, shifted_w, linesize;
 +
++    if (!desc)
++        return AVERROR(EINVAL);
++
 +    if (width < 0)
 +        return AVERROR(EINVAL);
 +    s = (max_step_comp == 1 || max_step_comp == 2) ? desc->log2_chroma_w : 0;
 +    shifted_w = ((width + (1 << s) - 1)) >> s;
 +    if (shifted_w && max_step > INT_MAX / shifted_w)
 +        return AVERROR(EINVAL);
 +    linesize = max_step * shifted_w;
++
 +    if (desc->flags & PIX_FMT_BITSTREAM)
 +        linesize = (linesize + 7) >> 3;
 +    return linesize;
 +}
 +
  int av_image_get_linesize(enum AVPixelFormat pix_fmt, int width, int plane)
  {
-     const AVPixFmtDescriptor *desc = &av_pix_fmt_descriptors[pix_fmt];
+     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
      int max_step     [4];       /* max pixel step for each plane */
      int max_step_comp[4];       /* the component for each plane which has the max pixel step */
 -    int s;
  
 -    if (!desc)
 +    if ((unsigned)pix_fmt >= AV_PIX_FMT_NB || desc->flags & PIX_FMT_HWACCEL)
          return AVERROR(EINVAL);
  
 -    if (desc->flags & PIX_FMT_BITSTREAM)
 -        return (width * (desc->comp[0].step_minus1+1) + 7) >> 3;
 -
      av_image_fill_max_pixsteps(max_step, max_step_comp, desc);
 -    s = (max_step_comp[plane] == 1 || max_step_comp[plane] == 2) ? desc->log2_chroma_w : 0;
 -    return max_step[plane] * (((width + (1 << s) - 1)) >> s);
 +    return image_get_linesize(width, plane, max_step[plane], max_step_comp[plane], desc);
  }
  
  int av_image_fill_linesizes(int linesizes[4], enum AVPixelFormat pix_fmt, int width)
  {
 -    int i;
 +    int i, ret;
-     const AVPixFmtDescriptor *desc = &av_pix_fmt_descriptors[pix_fmt];
+     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
      int max_step     [4];       /* max pixel step for each plane */
      int max_step_comp[4];       /* the component for each plane which has the max pixel step */
  
      memset(linesizes, 0, 4*sizeof(linesizes[0]));
  
-     if ((unsigned)pix_fmt >= AV_PIX_FMT_NB || desc->flags & PIX_FMT_HWACCEL)
+     if (!desc || desc->flags & PIX_FMT_HWACCEL)
          return AVERROR(EINVAL);
  
 -    if (desc->flags & PIX_FMT_BITSTREAM) {
 -        if (width > (INT_MAX -7) / (desc->comp[0].step_minus1+1))
 -            return AVERROR(EINVAL);
 -        linesizes[0] = (width * (desc->comp[0].step_minus1+1) + 7) >> 3;
 -        return 0;
 -    }
 -
      av_image_fill_max_pixsteps(max_step, max_step_comp, desc);
      for (i = 0; i < 4; i++) {
 -        int s = (max_step_comp[i] == 1 || max_step_comp[i] == 2) ? desc->log2_chroma_w : 0;
 -        int shifted_w = ((width + (1 << s) - 1)) >> s;
 -        if (max_step[i] > INT_MAX / shifted_w)
 -            return AVERROR(EINVAL);
 -        linesizes[i] = max_step[i] * shifted_w;
 +        if ((ret = image_get_linesize(width, i, max_step[i], max_step_comp[i], desc)) < 0)
 +            return ret;
 +        linesizes[i] = ret;
      }
  
      return 0;
@@@ -188,9 -183,12 +193,12 @@@ int av_image_alloc(uint8_t *pointers[4]
      int i, ret;
      uint8_t *buf;
  
+     if (!desc)
+         return AVERROR(EINVAL);
      if ((ret = av_image_check_size(w, h, 0, NULL)) < 0)
          return ret;
 -    if ((ret = av_image_fill_linesizes(linesizes, pix_fmt, w)) < 0)
 +    if ((ret = av_image_fill_linesizes(linesizes, pix_fmt, align>7 ? FFALIGN(w, 8) : w)) < 0)
          return ret;
  
      for (i = 0; i < 4; i++)
@@@ -278,73 -275,3 +285,73 @@@ void av_image_copy(uint8_t *dst_data[4]
          }
      }
  }
-     const AVPixFmtDescriptor *desc = &av_pix_fmt_descriptors[pix_fmt];
 +
 +int av_image_fill_arrays(uint8_t *dst_data[4], int dst_linesize[4],
 +                         const uint8_t *src,
 +                         enum AVPixelFormat pix_fmt, int width, int height, int align)
 +{
 +    int ret, i;
 +
 +    if ((ret = av_image_check_size(width, height, 0, NULL)) < 0)
 +        return ret;
 +
 +    if ((ret = av_image_fill_linesizes(dst_linesize, pix_fmt, width)) < 0)
 +        return ret;
 +
 +    for (i = 0; i < 4; i++)
 +        dst_linesize[i] = FFALIGN(dst_linesize[i], align);
 +
 +    if ((ret = av_image_fill_pointers(dst_data, pix_fmt, width, NULL, dst_linesize)) < 0)
 +        return ret;
 +
 +    return av_image_fill_pointers(dst_data, pix_fmt, height, (uint8_t *)src, dst_linesize);
 +}
 +
 +int av_image_get_buffer_size(enum AVPixelFormat pix_fmt, int width, int height, int align)
 +{
 +    uint8_t *data[4];
 +    int linesize[4];
 +    if (av_image_check_size(width, height, 0, NULL) < 0)
 +        return AVERROR(EINVAL);
 +    if (av_pix_fmt_descriptors[pix_fmt].flags & PIX_FMT_PSEUDOPAL)
 +        // do not include palette for these pseudo-paletted formats
 +        return width * height;
 +    return av_image_fill_arrays(data, linesize, NULL, pix_fmt, width, height, align);
 +}
 +
 +int av_image_copy_to_buffer(uint8_t *dst, int dst_size,
 +                            const uint8_t * const src_data[4], const int src_linesize[4],
 +                            enum AVPixelFormat pix_fmt, int width, int height, int align)
 +{
 +    int i, j, nb_planes = 0, linesize[4];
++    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
 +    int size = av_image_get_buffer_size(pix_fmt, width, height, align);
 +
 +    if (size > dst_size || size < 0)
 +        return AVERROR(EINVAL);
 +
 +    for (i = 0; i < desc->nb_components; i++)
 +        nb_planes = FFMAX(desc->comp[i].plane, nb_planes);
 +    nb_planes++;
 +
 +    av_image_fill_linesizes(linesize, pix_fmt, width);
 +    for (i = 0; i < nb_planes; i++) {
 +        int h, shift = (i == 1 || i == 2) ? desc->log2_chroma_h : 0;
 +        const uint8_t *src = src_data[i];
 +        h = (height + (1 << shift) - 1) >> shift;
 +
 +        for (j = 0; j < h; j++) {
 +            memcpy(dst, src, linesize[i]);
 +            dst += FFALIGN(linesize[i], align);
 +            src += src_linesize[i];
 +        }
 +    }
 +
 +    if (desc->flags & PIX_FMT_PAL) {
 +        uint32_t *d32 = (uint32_t *)(((size_t)dst + 3) & ~3);
 +        for (i = 0; i<256; i++)
 +            AV_WL32(d32 + i, AV_RN32(src_data[1] + 4*i));
 +    }
 +
 +    return size;
 +}