Merge commit '50ba57e0ce63d9904269ea0728936a0c79f8bfb5'
authorMichael Niedermayer <michaelni@gmx.at>
Fri, 12 Oct 2012 14:48:26 +0000 (16:48 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Fri, 12 Oct 2012 14:48:26 +0000 (16:48 +0200)
* commit '50ba57e0ce63d9904269ea0728936a0c79f8bfb5':
  lavc: do not use av_pix_fmt_descriptors directly.

Conflicts:
libavcodec/imgconvert.c
libavcodec/libopenjpegdec.c
libavcodec/libopenjpegenc.c
libavcodec/mpegvideo.c
libavcodec/rawdec.c
libavcodec/rawenc.c
libavcodec/tiffenc.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
libavcodec/imgconvert.c
libavcodec/libopenjpegdec.c
libavcodec/libopenjpegenc.c
libavcodec/mpegvideo.c
libavcodec/rawdec.c
libavcodec/rawenc.c
libavcodec/utils.c
libavcodec/xwdenc.c

@@@ -416,41 -470,25 +418,39 @@@ int avpicture_layout(const AVPicture* s
  
  int avpicture_get_size(enum AVPixelFormat pix_fmt, int width, int height)
  {
 -    AVPicture dummy_pict;
 +    return av_image_get_buffer_size(pix_fmt, width, height, 1);
 +}
 +
 +static int get_pix_fmt_depth(int *min, int *max, enum AVPixelFormat pix_fmt)
 +{
-     const AVPixFmtDescriptor *desc = &av_pix_fmt_descriptors[pix_fmt];
+     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
 +    int i;
  
-     if (!desc->nb_components) {
 -    if(av_image_check_size(width, height, 0, NULL))
 -        return -1;
 -    if (desc->flags & PIX_FMT_PSEUDOPAL)
 -        // do not include palette for these pseudo-paletted formats
 -        return width * height;
 -    return avpicture_fill(&dummy_pict, NULL, pix_fmt, width, height);
++    if (!desc || !desc->nb_components) {
 +        *min = *max = 0;
 +        return AVERROR(EINVAL);
 +    }
 +
 +    *min = INT_MAX, *max = -INT_MAX;
 +    for (i = 0; i < desc->nb_components; i++) {
 +        *min = FFMIN(desc->comp[i].depth_minus1+1, *min);
 +        *max = FFMAX(desc->comp[i].depth_minus1+1, *max);
 +    }
 +    return 0;
  }
  
  int avcodec_get_pix_fmt_loss(enum AVPixelFormat dst_pix_fmt, enum AVPixelFormat src_pix_fmt,
                               int has_alpha)
  {
      const PixFmtInfo *pf, *ps;
-     const AVPixFmtDescriptor *src_desc;
-     const AVPixFmtDescriptor *dst_desc;
+     const AVPixFmtDescriptor *src_desc = av_pix_fmt_desc_get(src_pix_fmt);
+     const AVPixFmtDescriptor *dst_desc = av_pix_fmt_desc_get(dst_pix_fmt);
 -    int loss;
 +    int src_min_depth, src_max_depth, dst_min_depth, dst_max_depth;
 +    int ret, loss;
 +
 +    if (dst_pix_fmt >= AV_PIX_FMT_NB || dst_pix_fmt <= AV_PIX_FMT_NONE)
 +        return ~0;
  
-     src_desc = &av_pix_fmt_descriptors[src_pix_fmt];
-     dst_desc = &av_pix_fmt_descriptors[dst_pix_fmt];
      ps = &pix_fmt_info[src_pix_fmt];
  
      /* compute loss */
  
  static int avg_bits_per_pixel(enum AVPixelFormat pix_fmt)
  {
 -    int bits;
 -    const PixFmtInfo *pf;
 +    const PixFmtInfo *info = &pix_fmt_info[pix_fmt];
-     const AVPixFmtDescriptor *desc = &av_pix_fmt_descriptors[pix_fmt];
+     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
  
 -    pf = &pix_fmt_info[pix_fmt];
 -    switch(pf->pixel_type) {
 -    case FF_PIXEL_PACKED:
 -        switch(pix_fmt) {
 -        case AV_PIX_FMT_YUYV422:
 -        case AV_PIX_FMT_UYVY422:
 -        case AV_PIX_FMT_RGB565BE:
 -        case AV_PIX_FMT_RGB565LE:
 -        case AV_PIX_FMT_RGB555BE:
 -        case AV_PIX_FMT_RGB555LE:
 -        case AV_PIX_FMT_RGB444BE:
 -        case AV_PIX_FMT_RGB444LE:
 -        case AV_PIX_FMT_BGR565BE:
 -        case AV_PIX_FMT_BGR565LE:
 -        case AV_PIX_FMT_BGR555BE:
 -        case AV_PIX_FMT_BGR555LE:
 -        case AV_PIX_FMT_BGR444BE:
 -        case AV_PIX_FMT_BGR444LE:
 -            bits = 16;
 -            break;
 -        case AV_PIX_FMT_UYYVYY411:
 -            bits = 12;
 -            break;
 -        default:
 -            bits = pf->depth * pf->nb_channels;
 -            break;
 -        }
 -        break;
 -    case FF_PIXEL_PLANAR:
 -        if (desc->log2_chroma_w == 0 && desc->log2_chroma_h == 0) {
 -            bits = pf->depth * pf->nb_channels;
 -        } else {
 -            bits = pf->depth + ((2 * pf->depth) >>
 -                                (desc->log2_chroma_w + desc->log2_chroma_h));
 -        }
 -        break;
 -    case FF_PIXEL_PALETTE:
 -        bits = 8;
 -        break;
 -    default:
 -        bits = -1;
 -        break;
 -    }
 -    return bits;
 -}
 -
 -static enum AVPixelFormat avcodec_find_best_pix_fmt1(enum AVPixelFormat *pix_fmt_list,
 -                                      enum AVPixelFormat src_pix_fmt,
 -                                      int has_alpha,
 -                                      int loss_mask)
 -{
 -    int dist, i, loss, min_dist;
 -    enum AVPixelFormat dst_pix_fmt;
 -
 -    /* find exact color match with smallest size */
 -    dst_pix_fmt = AV_PIX_FMT_NONE;
 -    min_dist = 0x7fffffff;
 -    i = 0;
 -    while (pix_fmt_list[i] != AV_PIX_FMT_NONE) {
 -        enum AVPixelFormat pix_fmt = pix_fmt_list[i];
 -
 -        if (i > AV_PIX_FMT_NB) {
 -            av_log(NULL, AV_LOG_ERROR, "Pixel format list longer than expected, "
 -                   "it is either not properly terminated or contains duplicates\n");
 -            return AV_PIX_FMT_NONE;
 -        }
 -
 -        loss = avcodec_get_pix_fmt_loss(pix_fmt, src_pix_fmt, has_alpha) & loss_mask;
 -        if (loss == 0) {
 -            dist = avg_bits_per_pixel(pix_fmt);
 -            if (dist < min_dist) {
 -                min_dist = dist;
 -                dst_pix_fmt = pix_fmt;
 -            }
 -        }
 -        i++;
 -    }
 -    return dst_pix_fmt;
 +    return info->padded_size ?
 +        info->padded_size : av_get_bits_per_pixel(desc);
  }
  
  #if FF_API_FIND_BEST_PIX_FMT
@@@ -716,26 -791,11 +716,26 @@@ void avpicture_free(AVPicture *picture
  }
  
  /* return true if yuv planar */
 -static inline int is_yuv_planar(const PixFmtInfo *ps)
 +static inline int is_yuv_planar(enum AVPixelFormat fmt)
  {
 -    return (ps->color_type == FF_COLOR_YUV ||
 -            ps->color_type == FF_COLOR_YUV_JPEG) &&
 -        ps->pixel_type == FF_PIXEL_PLANAR;
 +    const PixFmtInfo         *info = &pix_fmt_info[fmt];
-     const AVPixFmtDescriptor *desc = &av_pix_fmt_descriptors[fmt];
++    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(fmt);
 +    int i;
 +    int planes[4] = { 0 };
 +
 +    if (info->color_type != FF_COLOR_YUV &&
 +        info->color_type != FF_COLOR_YUV_JPEG)
 +        return 0;
 +
 +    /* set the used planes */
 +    for (i = 0; i < desc->nb_components; i++)
 +        planes[desc->comp[i].plane] = 1;
 +
 +    /* if there is an unused plane, the format is not planar */
 +    for (i = 0; i < desc->nb_components; i++)
 +        if (!planes[i])
 +            return 0;
 +    return 1;
  }
  
  int av_picture_crop(AVPicture *dst, const AVPicture *src,
      int y_shift;
      int x_shift;
  
 -    if (pix_fmt < 0 || pix_fmt >= AV_PIX_FMT_NB || !is_yuv_planar(&pix_fmt_info[pix_fmt]))
 +    if (pix_fmt < 0 || pix_fmt >= AV_PIX_FMT_NB)
          return -1;
  
-     y_shift = av_pix_fmt_descriptors[pix_fmt].log2_chroma_h;
-     x_shift = av_pix_fmt_descriptors[pix_fmt].log2_chroma_w;
+     y_shift = desc->log2_chroma_h;
+     x_shift = desc->log2_chroma_w;
  
 +    if (is_yuv_planar(pix_fmt)) {
      dst->data[0] = src->data[0] + (top_band * src->linesize[0]) + left_band;
      dst->data[1] = src->data[1] + ((top_band >> y_shift) * src->linesize[1]) + (left_band >> x_shift);
      dst->data[2] = src->data[2] + ((top_band >> y_shift) * src->linesize[2]) + (left_band >> x_shift);
@@@ -779,11 -833,11 +781,11 @@@ int av_picture_pad(AVPicture *dst, cons
      int i, y;
  
      if (pix_fmt < 0 || pix_fmt >= AV_PIX_FMT_NB ||
 -        !is_yuv_planar(&pix_fmt_info[pix_fmt])) return -1;
 +        !is_yuv_planar(pix_fmt)) return -1;
  
      for (i = 0; i < 3; i++) {
-         x_shift = i ? av_pix_fmt_descriptors[pix_fmt].log2_chroma_w : 0;
-         y_shift = i ? av_pix_fmt_descriptors[pix_fmt].log2_chroma_h : 0;
+         x_shift = i ? desc->log2_chroma_w : 0;
+         y_shift = i ? desc->log2_chroma_h : 0;
  
          if (padtop || padleft) {
              memset(dst->data[i], color[i],
@@@ -63,28 -71,38 +63,28 @@@ typedef struct 
      int lowqual;
  } LibOpenJPEGContext;
  
 -static int libopenjpeg_matches_pix_fmt(const opj_image_t *img,
 -                                       enum AVPixelFormat pix_fmt)
 +static inline int libopenjpeg_matches_pix_fmt(const opj_image_t *image, enum AVPixelFormat pix_fmt)
  {
-     AVPixFmtDescriptor descriptor = av_pix_fmt_descriptors[pix_fmt];
+     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
      int match = 1;
  
-     if (descriptor.nb_components != image->numcomps) {
 -    if (desc->nb_components != img->numcomps) {
++    if (desc->nb_components != image->numcomps) {
          return 0;
      }
  
-     switch (descriptor.nb_components) {
-     case 4: match = match && descriptor.comp[3].depth_minus1 + 1 >= image->comps[3].prec &&
+     switch (desc->nb_components) {
 -    case 4:
 -        match = match &&
 -            desc->comp[3].depth_minus1 + 1 >= img->comps[3].prec &&
 -            1 == img->comps[3].dx &&
 -            1 == img->comps[3].dy;
 -    case 3:
 -        match = match &&
 -            desc->comp[2].depth_minus1 + 1 >= img->comps[2].prec &&
 -            1 << desc->log2_chroma_w == img->comps[2].dx &&
 -            1 << desc->log2_chroma_h == img->comps[2].dy;
 -    case 2:
 -        match = match &&
 -            desc->comp[1].depth_minus1 + 1 >= img->comps[1].prec &&
 -            1 << desc->log2_chroma_w == img->comps[1].dx &&
 -            1 << desc->log2_chroma_h == img->comps[1].dy;
 -    case 1:
 -        match = match &&
 -            desc->comp[0].depth_minus1 + 1 >= img->comps[0].prec &&
 -            1 == img->comps[0].dx &&
 -            1 == img->comps[0].dy;
++    case 4: match = match && desc->comp[3].depth_minus1 + 1 >= image->comps[3].prec &&
 +                             1 == image->comps[3].dx &&
 +                             1 == image->comps[3].dy;
-     case 3: match = match && descriptor.comp[2].depth_minus1 + 1 >= image->comps[2].prec &&
-                              1 << descriptor.log2_chroma_w == image->comps[2].dx &&
-                              1 << descriptor.log2_chroma_h == image->comps[2].dy;
-     case 2: match = match && descriptor.comp[1].depth_minus1 + 1 >= image->comps[1].prec &&
-                              1 << descriptor.log2_chroma_w == image->comps[1].dx &&
-                              1 << descriptor.log2_chroma_h == image->comps[1].dy;
-     case 1: match = match && descriptor.comp[0].depth_minus1 + 1 >= image->comps[0].prec &&
++    case 3: match = match && desc->comp[2].depth_minus1 + 1 >= image->comps[2].prec &&
++                             1 << desc->log2_chroma_w == image->comps[2].dx &&
++                             1 << desc->log2_chroma_h == image->comps[2].dy;
++    case 2: match = match && desc->comp[1].depth_minus1 + 1 >= image->comps[1].prec &&
++                             1 << desc->log2_chroma_w == image->comps[1].dx &&
++                             1 << desc->log2_chroma_h == image->comps[1].dy;
++    case 1: match = match && desc->comp[0].depth_minus1 + 1 >= image->comps[0].prec &&
 +                             1 == image->comps[0].dx &&
 +                             1 == image->comps[0].dy;
      default:
          break;
      }
@@@ -67,22 -66,26 +67,23 @@@ static void info_callback(const char *m
      av_log(data, AV_LOG_DEBUG, "%s\n", msg);
  }
  
 -static opj_image_t *libopenjpeg_create_image(AVCodecContext *avctx,
 -                                             opj_cparameters_t *parameters)
 +static opj_image_t *mj2_create_image(AVCodecContext *avctx, opj_cparameters_t *parameters)
  {
+     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
      opj_image_cmptparm_t *cmptparm;
 -    OPJ_COLOR_SPACE color_space;
      opj_image_t *img;
      int i;
      int sub_dx[4];
      int sub_dy[4];
 -    int numcomps = desc->nb_components;
 +    int numcomps;
 +    OPJ_COLOR_SPACE color_space = CLRSPC_UNKNOWN;
  
 -    sub_dx[0] =
 -    sub_dx[3] = 1;
 -    sub_dy[0] =
 -    sub_dy[3] = 1;
 -    sub_dx[1] =
 -    sub_dx[2] = 1 << desc->log2_chroma_w;
 -    sub_dy[1] =
 -    sub_dy[2] = 1 << desc->log2_chroma_h;
 +    sub_dx[0] = sub_dx[3] = 1;
 +    sub_dy[0] = sub_dy[3] = 1;
-     sub_dx[1] = sub_dx[2] = 1<<av_pix_fmt_descriptors[avctx->pix_fmt].log2_chroma_w;
-     sub_dy[1] = sub_dy[2] = 1<<av_pix_fmt_descriptors[avctx->pix_fmt].log2_chroma_h;
++    sub_dx[1] = sub_dx[2] = 1 << desc->log2_chroma_w;
++    sub_dy[1] = sub_dy[2] = 1 << desc->log2_chroma_h;
 +
-     numcomps = av_pix_fmt_descriptors[avctx->pix_fmt].nb_components;
++    numcomps = desc->nb_components;
  
      switch (avctx->pix_fmt) {
      case AV_PIX_FMT_GRAY8:
  
      cmptparm = av_mallocz(numcomps * sizeof(*cmptparm));
      if (!cmptparm) {
 -        av_log(avctx, AV_LOG_ERROR, "Not enough memory");
 +        av_log(avctx, AV_LOG_ERROR, "Not enough memory\n");
          return NULL;
      }
 -
      for (i = 0; i < numcomps; i++) {
-         cmptparm[i].prec = av_pix_fmt_descriptors[avctx->pix_fmt].comp[i].depth_minus1 + 1;
-         cmptparm[i].bpp = av_pix_fmt_descriptors[avctx->pix_fmt].comp[i].depth_minus1 + 1;
+         cmptparm[i].prec = desc->comp[i].depth_minus1 + 1;
+         cmptparm[i].bpp  = desc->comp[i].depth_minus1 + 1;
          cmptparm[i].sgnd = 0;
 -        cmptparm[i].dx   = sub_dx[i];
 -        cmptparm[i].dy   = sub_dy[i];
 -        cmptparm[i].w    = avctx->width / sub_dx[i];
 -        cmptparm[i].h    = avctx->height / sub_dy[i];
 +        cmptparm[i].dx = sub_dx[i];
 +        cmptparm[i].dy = sub_dy[i];
 +        cmptparm[i].w = avctx->width / sub_dx[i];
 +        cmptparm[i].h = avctx->height / sub_dy[i];
      }
  
      img = opj_image_create(numcomps, cmptparm, color_space);
@@@ -1521,23 -1526,22 +1521,24 @@@ void ff_MPV_frame_end(MpegEncContext *s
                s->unrestricted_mv &&
                s->current_picture.f.reference &&
                !s->intra_only &&
 -              !(s->flags & CODEC_FLAG_EMU_EDGE)) {
 -       const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
 -       int hshift = desc->log2_chroma_w;
 -       int vshift = desc->log2_chroma_h;
 -       s->dsp.draw_edges(s->current_picture.f.data[0], s->linesize,
 -                         s->h_edge_pos, s->v_edge_pos,
 -                         EDGE_WIDTH, EDGE_WIDTH,
 -                         EDGE_TOP | EDGE_BOTTOM);
 -       s->dsp.draw_edges(s->current_picture.f.data[1], s->uvlinesize,
 -                         s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
 -                         EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
 -                         EDGE_TOP | EDGE_BOTTOM);
 -       s->dsp.draw_edges(s->current_picture.f.data[2], s->uvlinesize,
 -                         s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
 -                         EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
 -                         EDGE_TOP | EDGE_BOTTOM);
 +              !(s->flags & CODEC_FLAG_EMU_EDGE) &&
 +              !s->avctx->lowres
 +            ) {
-         int hshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_w;
-         int vshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_h;
++        const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
++        int hshift = desc->log2_chroma_w;
++        int vshift = desc->log2_chroma_h;
 +        s->dsp.draw_edges(s->current_picture.f.data[0], s->current_picture.f.linesize[0],
 +                          s->h_edge_pos, s->v_edge_pos,
 +                          EDGE_WIDTH, EDGE_WIDTH,
 +                          EDGE_TOP | EDGE_BOTTOM);
 +        s->dsp.draw_edges(s->current_picture.f.data[1], s->current_picture.f.linesize[1],
 +                          s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
 +                          EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
 +                          EDGE_TOP | EDGE_BOTTOM);
 +        s->dsp.draw_edges(s->current_picture.f.data[2], s->current_picture.f.linesize[2],
 +                          s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
 +                          EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
 +                          EDGE_TOP | EDGE_BOTTOM);
      }
  
      emms_c();
@@@ -143,9 -118,9 +143,10 @@@ static int raw_decode(AVCodecContext *a
  {
      const uint8_t *buf = avpkt->data;
      int buf_size = avpkt->size;
 +    int linesize_align = 4;
      RawVideoContext *context = avctx->priv_data;
 -    int res;
+     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
 +    int res, len;
  
      AVFrame   *frame   = data;
      AVPicture *picture = data;
                                avctx->width, avctx->height)) < 0)
          return res;
      if((avctx->pix_fmt==AV_PIX_FMT_PAL8 && buf_size < context->length) ||
-        (av_pix_fmt_descriptors[avctx->pix_fmt].flags & PIX_FMT_PSEUDOPAL)) {
+        (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);
  
  static av_cold int raw_init_encoder(AVCodecContext *avctx)
  {
+     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
      avctx->coded_frame            = avctx->priv_data;
 +    avcodec_get_frame_defaults(avctx->coded_frame);
      avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
-     avctx->bits_per_coded_sample = av_get_bits_per_pixel(&av_pix_fmt_descriptors[avctx->pix_fmt]);
 -    avctx->coded_frame->key_frame = 1;
+     avctx->bits_per_coded_sample = av_get_bits_per_pixel(desc);
      if(!avctx->codec_tag)
          avctx->codec_tag = avcodec_pix_fmt_to_codec_tag(avctx->pix_fmt);
      return 0;
Simple merge
Simple merge