imgconvert: Add the proper API guards to a deprecated function
[ffmpeg.git] / libavcodec / imgconvert.c
1 /*
2  * Misc image conversion routines
3  * Copyright (c) 2001, 2002, 2003 Fabrice Bellard
4  *
5  * This file is part of Libav.
6  *
7  * Libav is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * Libav is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with Libav; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21
22 /**
23  * @file
24  * misc image conversion routines
25  */
26
27 #include "avcodec.h"
28 #include "internal.h"
29 #include "mathops.h"
30 #include "libavutil/colorspace.h"
31 #include "libavutil/common.h"
32 #include "libavutil/pixdesc.h"
33 #include "libavutil/internal.h"
34 #include "libavutil/imgutils.h"
35
36 #if FF_API_GETCHROMA
37 void avcodec_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift)
38 {
39     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
40     *h_shift = desc->log2_chroma_w;
41     *v_shift = desc->log2_chroma_h;
42 }
43 #endif
44
45 static int is_gray(const AVPixFmtDescriptor *desc)
46 {
47     return desc->nb_components - (desc->flags & AV_PIX_FMT_FLAG_ALPHA) == 1;
48 }
49
50 int avcodec_get_pix_fmt_loss(enum AVPixelFormat dst_pix_fmt,
51                              enum AVPixelFormat src_pix_fmt,
52                              int has_alpha)
53 {
54     const AVPixFmtDescriptor *src_desc = av_pix_fmt_desc_get(src_pix_fmt);
55     const AVPixFmtDescriptor *dst_desc = av_pix_fmt_desc_get(dst_pix_fmt);
56     int loss, i, nb_components = FFMIN(src_desc->nb_components,
57                                        dst_desc->nb_components);
58
59     /* compute loss */
60     loss = 0;
61
62     if (dst_pix_fmt == src_pix_fmt)
63         return 0;
64
65     for (i = 0; i < nb_components; i++)
66         if (src_desc->comp[i].depth > dst_desc->comp[i].depth)
67             loss |= FF_LOSS_DEPTH;
68
69     if (dst_desc->log2_chroma_w > src_desc->log2_chroma_w ||
70         dst_desc->log2_chroma_h > src_desc->log2_chroma_h)
71         loss |= FF_LOSS_RESOLUTION;
72
73     if ((src_desc->flags & AV_PIX_FMT_FLAG_RGB) != (dst_desc->flags & AV_PIX_FMT_FLAG_RGB))
74         loss |= FF_LOSS_COLORSPACE;
75
76     if (has_alpha && !(dst_desc->flags & AV_PIX_FMT_FLAG_ALPHA) &&
77          (src_desc->flags & AV_PIX_FMT_FLAG_ALPHA))
78         loss |= FF_LOSS_ALPHA;
79
80     if (dst_pix_fmt == AV_PIX_FMT_PAL8 && !is_gray(src_desc))
81         return loss | FF_LOSS_COLORQUANT;
82
83     if (src_desc->nb_components > dst_desc->nb_components)
84         if (is_gray(dst_desc))
85             loss |= FF_LOSS_CHROMA;
86
87     return loss;
88 }
89
90 static enum AVPixelFormat avcodec_find_best_pix_fmt1(enum AVPixelFormat *pix_fmt_list,
91                                       enum AVPixelFormat src_pix_fmt,
92                                       int has_alpha,
93                                       int loss_mask)
94 {
95     int dist, i, loss, min_dist;
96     enum AVPixelFormat dst_pix_fmt;
97
98     /* find exact color match with smallest size */
99     dst_pix_fmt = AV_PIX_FMT_NONE;
100     min_dist = 0x7fffffff;
101     i = 0;
102     while (pix_fmt_list[i] != AV_PIX_FMT_NONE) {
103         enum AVPixelFormat pix_fmt = pix_fmt_list[i];
104
105         if (i > AV_PIX_FMT_NB) {
106             av_log(NULL, AV_LOG_ERROR, "Pixel format list longer than expected, "
107                    "it is either not properly terminated or contains duplicates\n");
108             return AV_PIX_FMT_NONE;
109         }
110
111         loss = avcodec_get_pix_fmt_loss(pix_fmt, src_pix_fmt, has_alpha) & loss_mask;
112         if (loss == 0) {
113             dist = av_get_bits_per_pixel(av_pix_fmt_desc_get(pix_fmt));
114             if (dist < min_dist) {
115                 min_dist = dist;
116                 dst_pix_fmt = pix_fmt;
117             }
118         }
119         i++;
120     }
121     return dst_pix_fmt;
122 }
123
124 enum AVPixelFormat avcodec_find_best_pix_fmt2(enum AVPixelFormat *pix_fmt_list,
125                                             enum AVPixelFormat src_pix_fmt,
126                                             int has_alpha, int *loss_ptr)
127 {
128     enum AVPixelFormat dst_pix_fmt;
129     int loss_mask, i;
130     static const int loss_mask_order[] = {
131         ~0, /* no loss first */
132         ~FF_LOSS_ALPHA,
133         ~FF_LOSS_RESOLUTION,
134         ~(FF_LOSS_COLORSPACE | FF_LOSS_RESOLUTION),
135         ~FF_LOSS_COLORQUANT,
136         ~FF_LOSS_DEPTH,
137         0,
138     };
139
140     /* try with successive loss */
141     i = 0;
142     for(;;) {
143         loss_mask = loss_mask_order[i++];
144         dst_pix_fmt = avcodec_find_best_pix_fmt1(pix_fmt_list, src_pix_fmt,
145                                                  has_alpha, loss_mask);
146         if (dst_pix_fmt >= 0)
147             goto found;
148         if (loss_mask == 0)
149             break;
150     }
151     return AV_PIX_FMT_NONE;
152  found:
153     if (loss_ptr)
154         *loss_ptr = avcodec_get_pix_fmt_loss(dst_pix_fmt, src_pix_fmt, has_alpha);
155     return dst_pix_fmt;
156 }
157
158 #if FF_API_AVPICTURE
159 FF_DISABLE_DEPRECATION_WARNINGS
160 /* return true if yuv planar */
161 static inline int is_yuv_planar(const AVPixFmtDescriptor *desc)
162 {
163     return (!(desc->flags & AV_PIX_FMT_FLAG_RGB) &&
164              (desc->flags & AV_PIX_FMT_FLAG_PLANAR));
165 }
166
167 int av_picture_crop(AVPicture *dst, const AVPicture *src,
168                     enum AVPixelFormat pix_fmt, int top_band, int left_band)
169 {
170     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
171     int y_shift;
172     int x_shift;
173
174     if (pix_fmt < 0 || pix_fmt >= AV_PIX_FMT_NB || !is_yuv_planar(desc))
175         return -1;
176
177     y_shift = desc->log2_chroma_h;
178     x_shift = desc->log2_chroma_w;
179
180     dst->data[0] = src->data[0] + (top_band * src->linesize[0]) + left_band;
181     dst->data[1] = src->data[1] + ((top_band >> y_shift) * src->linesize[1]) + (left_band >> x_shift);
182     dst->data[2] = src->data[2] + ((top_band >> y_shift) * src->linesize[2]) + (left_band >> x_shift);
183
184     dst->linesize[0] = src->linesize[0];
185     dst->linesize[1] = src->linesize[1];
186     dst->linesize[2] = src->linesize[2];
187     return 0;
188 }
189
190 int av_picture_pad(AVPicture *dst, const AVPicture *src, int height, int width,
191                    enum AVPixelFormat pix_fmt, int padtop, int padbottom, int padleft, int padright,
192             int *color)
193 {
194     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
195     uint8_t *optr;
196     int y_shift;
197     int x_shift;
198     int yheight;
199     int i, y;
200
201     if (pix_fmt < 0 || pix_fmt >= AV_PIX_FMT_NB ||
202         !is_yuv_planar(desc)) return -1;
203
204     for (i = 0; i < 3; i++) {
205         x_shift = i ? desc->log2_chroma_w : 0;
206         y_shift = i ? desc->log2_chroma_h : 0;
207
208         if (padtop || padleft) {
209             memset(dst->data[i], color[i],
210                 dst->linesize[i] * (padtop >> y_shift) + (padleft >> x_shift));
211         }
212
213         if (padleft || padright) {
214             optr = dst->data[i] + dst->linesize[i] * (padtop >> y_shift) +
215                 (dst->linesize[i] - (padright >> x_shift));
216             yheight = (height - 1 - (padtop + padbottom)) >> y_shift;
217             for (y = 0; y < yheight; y++) {
218                 memset(optr, color[i], (padleft + padright) >> x_shift);
219                 optr += dst->linesize[i];
220             }
221         }
222
223         if (src) { /* first line */
224             uint8_t *iptr = src->data[i];
225             optr = dst->data[i] + dst->linesize[i] * (padtop >> y_shift) +
226                     (padleft >> x_shift);
227             memcpy(optr, iptr, (width - padleft - padright) >> x_shift);
228             iptr += src->linesize[i];
229             optr = dst->data[i] + dst->linesize[i] * (padtop >> y_shift) +
230                 (dst->linesize[i] - (padright >> x_shift));
231             yheight = (height - 1 - (padtop + padbottom)) >> y_shift;
232             for (y = 0; y < yheight; y++) {
233                 memset(optr, color[i], (padleft + padright) >> x_shift);
234                 memcpy(optr + ((padleft + padright) >> x_shift), iptr,
235                        (width - padleft - padright) >> x_shift);
236                 iptr += src->linesize[i];
237                 optr += dst->linesize[i];
238             }
239         }
240
241         if (padbottom || padright) {
242             optr = dst->data[i] + dst->linesize[i] *
243                 ((height - padbottom) >> y_shift) - (padright >> x_shift);
244             memset(optr, color[i],dst->linesize[i] *
245                 (padbottom >> y_shift) + (padright >> x_shift));
246         }
247     }
248     return 0;
249 }
250
251 FF_ENABLE_DEPRECATION_WARNINGS
252 #endif /* FF_API_AVPICTURE */