Merge commit '892f037c55d86ce36f8705fbeab052189312a13e'
authorDerek Buitenhuis <derek.buitenhuis@gmail.com>
Wed, 27 Jan 2016 19:58:35 +0000 (19:58 +0000)
committerDerek Buitenhuis <derek.buitenhuis@gmail.com>
Wed, 27 Jan 2016 19:58:35 +0000 (19:58 +0000)
* commit '892f037c55d86ce36f8705fbeab052189312a13e':
  imgconvert: Move the shrink functions only where needed

Merged-by: Derek Buitenhuis <derek.buitenhuis@gmail.com>
1  2 
libavcodec/imgconvert.c
libavcodec/mpegvideoencdsp.c

   */
  
  #include "avcodec.h"
- #include "imgconvert.h"
  #include "internal.h"
  #include "mathops.h"
 +#include "libavutil/avassert.h"
  #include "libavutil/colorspace.h"
  #include "libavutil/common.h"
  #include "libavutil/pixdesc.h"
@@@ -47,128 -49,110 +46,42 @@@ int avcodec_get_pix_fmt_loss(enum AVPix
                               enum AVPixelFormat src_pix_fmt,
                               int has_alpha)
  {
 -    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, i, nb_components = FFMIN(src_desc->nb_components,
 -                                       dst_desc->nb_components);
 -
 -    /* compute loss */
 -    loss = 0;
 -
 -    if (dst_pix_fmt == src_pix_fmt)
 -        return 0;
 -
 -    for (i = 0; i < nb_components; i++)
 -        if (src_desc->comp[i].depth > dst_desc->comp[i].depth)
 -            loss |= FF_LOSS_DEPTH;
 -
 -    if (dst_desc->log2_chroma_w > src_desc->log2_chroma_w ||
 -        dst_desc->log2_chroma_h > src_desc->log2_chroma_h)
 -        loss |= FF_LOSS_RESOLUTION;
 -
 -    if ((src_desc->flags & AV_PIX_FMT_FLAG_RGB) != (dst_desc->flags & AV_PIX_FMT_FLAG_RGB))
 -        loss |= FF_LOSS_COLORSPACE;
 -
 -    if (has_alpha && !(dst_desc->flags & AV_PIX_FMT_FLAG_ALPHA) &&
 -         (src_desc->flags & AV_PIX_FMT_FLAG_ALPHA))
 -        loss |= FF_LOSS_ALPHA;
 -
 -    if (dst_pix_fmt == AV_PIX_FMT_PAL8 && !is_gray(src_desc))
 -        return loss | FF_LOSS_COLORQUANT;
 -
 -    if (src_desc->nb_components > dst_desc->nb_components)
 -        if (is_gray(dst_desc))
 -            loss |= FF_LOSS_CHROMA;
 -
 -    return loss;
 +    return av_get_pix_fmt_loss(dst_pix_fmt, src_pix_fmt, has_alpha);
  }
  
 -static enum AVPixelFormat avcodec_find_best_pix_fmt1(enum AVPixelFormat *pix_fmt_list,
 -                                      enum AVPixelFormat src_pix_fmt,
 -                                      int has_alpha,
 -                                      int loss_mask)
 +enum AVPixelFormat avcodec_find_best_pix_fmt_of_2(enum AVPixelFormat dst_pix_fmt1, enum AVPixelFormat dst_pix_fmt2,
 +                                            enum AVPixelFormat src_pix_fmt, int has_alpha, int *loss_ptr)
  {
 -    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 = av_get_bits_per_pixel(av_pix_fmt_desc_get(pix_fmt));
 -            if (dist < min_dist) {
 -                min_dist = dist;
 -                dst_pix_fmt = pix_fmt;
 -            }
 -        }
 -        i++;
 -    }
 -    return dst_pix_fmt;
 +    return av_find_best_pix_fmt_of_2(dst_pix_fmt1, dst_pix_fmt2, src_pix_fmt, has_alpha, loss_ptr);
  }
  
 -enum AVPixelFormat avcodec_find_best_pix_fmt2(enum AVPixelFormat *pix_fmt_list,
 +#if AV_HAVE_INCOMPATIBLE_LIBAV_ABI
 +enum AVPixelFormat avcodec_find_best_pix_fmt2(const enum AVPixelFormat *pix_fmt_list,
                                              enum AVPixelFormat src_pix_fmt,
 -                                            int has_alpha, int *loss_ptr)
 +                                            int has_alpha, int *loss_ptr){
 +    return avcodec_find_best_pix_fmt_of_list(pix_fmt_list, src_pix_fmt, has_alpha, loss_ptr);
 +}
 +#else
 +enum AVPixelFormat avcodec_find_best_pix_fmt2(enum AVPixelFormat dst_pix_fmt1, enum AVPixelFormat dst_pix_fmt2,
 +                                            enum AVPixelFormat src_pix_fmt, int has_alpha, int *loss_ptr)
  {
 -    enum AVPixelFormat dst_pix_fmt;
 -    int loss_mask, i;
 -    static const int loss_mask_order[] = {
 -        ~0, /* no loss first */
 -        ~FF_LOSS_ALPHA,
 -        ~FF_LOSS_RESOLUTION,
 -        ~(FF_LOSS_COLORSPACE | FF_LOSS_RESOLUTION),
 -        ~FF_LOSS_COLORQUANT,
 -        ~FF_LOSS_DEPTH,
 -        0,
 -    };
 -
 -    /* try with successive loss */
 -    i = 0;
 -    for(;;) {
 -        loss_mask = loss_mask_order[i++];
 -        dst_pix_fmt = avcodec_find_best_pix_fmt1(pix_fmt_list, src_pix_fmt,
 -                                                 has_alpha, loss_mask);
 -        if (dst_pix_fmt >= 0)
 -            goto found;
 -        if (loss_mask == 0)
 -            break;
 -    }
 -    return AV_PIX_FMT_NONE;
 - found:
 -    if (loss_ptr)
 -        *loss_ptr = avcodec_get_pix_fmt_loss(dst_pix_fmt, src_pix_fmt, has_alpha);
 -    return dst_pix_fmt;
 +    return avcodec_find_best_pix_fmt_of_2(dst_pix_fmt1, dst_pix_fmt2, src_pix_fmt, has_alpha, loss_ptr);
 +}
 +#endif
 +
 +enum AVPixelFormat avcodec_find_best_pix_fmt_of_list(const enum AVPixelFormat *pix_fmt_list,
 +                                            enum AVPixelFormat src_pix_fmt,
 +                                            int has_alpha, int *loss_ptr){
 +    int i;
 +
 +    enum AVPixelFormat best = AV_PIX_FMT_NONE;
 +
 +    for(i=0; pix_fmt_list[i] != AV_PIX_FMT_NONE; i++)
 +        best = avcodec_find_best_pix_fmt_of_2(best, pix_fmt_list[i], src_pix_fmt, has_alpha, loss_ptr);
 +
 +    return best;
  }
  
- /* 2x2 -> 1x1 */
- void ff_shrink22(uint8_t *dst, int dst_wrap,
-                      const uint8_t *src, int src_wrap,
-                      int width, int height)
- {
-     int w;
-     const uint8_t *s1, *s2;
-     uint8_t *d;
-     for(;height > 0; height--) {
-         s1 = src;
-         s2 = s1 + src_wrap;
-         d = dst;
-         for(w = width;w >= 4; w-=4) {
-             d[0] = (s1[0] + s1[1] + s2[0] + s2[1] + 2) >> 2;
-             d[1] = (s1[2] + s1[3] + s2[2] + s2[3] + 2) >> 2;
-             d[2] = (s1[4] + s1[5] + s2[4] + s2[5] + 2) >> 2;
-             d[3] = (s1[6] + s1[7] + s2[6] + s2[7] + 2) >> 2;
-             s1 += 8;
-             s2 += 8;
-             d += 4;
-         }
-         for(;w > 0; w--) {
-             d[0] = (s1[0] + s1[1] + s2[0] + s2[1] + 2) >> 2;
-             s1 += 2;
-             s2 += 2;
-             d++;
-         }
-         src += 2 * src_wrap;
-         dst += dst_wrap;
-     }
- }
- /* 4x4 -> 1x1 */
- void ff_shrink44(uint8_t *dst, int dst_wrap,
-                      const uint8_t *src, int src_wrap,
-                      int width, int height)
- {
-     int w;
-     const uint8_t *s1, *s2, *s3, *s4;
-     uint8_t *d;
-     for(;height > 0; height--) {
-         s1 = src;
-         s2 = s1 + src_wrap;
-         s3 = s2 + src_wrap;
-         s4 = s3 + src_wrap;
-         d = dst;
-         for(w = width;w > 0; w--) {
-             d[0] = (s1[0] + s1[1] + s1[2] + s1[3] +
-                     s2[0] + s2[1] + s2[2] + s2[3] +
-                     s3[0] + s3[1] + s3[2] + s3[3] +
-                     s4[0] + s4[1] + s4[2] + s4[3] + 8) >> 4;
-             s1 += 4;
-             s2 += 4;
-             s3 += 4;
-             s4 += 4;
-             d++;
-         }
-         src += 4 * src_wrap;
-         dst += dst_wrap;
-     }
- }
- /* 8x8 -> 1x1 */
- void ff_shrink88(uint8_t *dst, int dst_wrap,
-                      const uint8_t *src, int src_wrap,
-                      int width, int height)
- {
-     int w, i;
-     for(;height > 0; height--) {
-         for(w = width;w > 0; w--) {
-             int tmp=0;
-             for(i=0; i<8; i++){
-                 tmp += src[0] + src[1] + src[2] + src[3] + src[4] + src[5] + src[6] + src[7];
-                 src += src_wrap;
-             }
-             *(dst++) = (tmp + 32)>>6;
-             src += 8 - 8*src_wrap;
-         }
-         src += 8*src_wrap - 8*width;
-         dst += dst_wrap - width;
-     }
- }
  /* return true if yuv planar */
  static inline int is_yuv_planar(const AVPixFmtDescriptor *desc)
  {
Simple merge