swscale.h 11.9 KB
Newer Older
1
/*
2
 * Copyright (C) 2001-2011 Michael Niedermayer <michaelni@gmx.at>
3 4 5
 *
 * This file is part of FFmpeg.
 *
6 7 8 9
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
10 11 12
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
15
 *
16 17
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
18
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19
 */
Arpi's avatar
Arpi committed
20

21 22
#ifndef SWSCALE_SWSCALE_H
#define SWSCALE_SWSCALE_H
23

24
/**
25
 * @file
26
 * @ingroup libsws
27 28 29
 * external API header
 */

30 31
#include <stdint.h>

32
#include "libavutil/avutil.h"
33
#include "libavutil/log.h"
34
#include "libavutil/pixfmt.h"
35
#include "version.h"
36

37
/**
38 39 40
 * @defgroup libsws Color conversion and scaling
 * @{
 *
41
 * Return the LIBSWSCALE_VERSION_INT constant.
42 43 44
 */
unsigned swscale_version(void);

45
/**
46
 * Return the libswscale build-time configuration.
47
 */
48
const char *swscale_configuration(void);
49 50

/**
51
 * Return the libswscale license.
52
 */
53
const char *swscale_license(void);
54

55
/* values for the flags, the stuff on the command line is different */
56 57 58 59 60 61 62 63 64 65 66
#define SWS_FAST_BILINEAR     1
#define SWS_BILINEAR          2
#define SWS_BICUBIC           4
#define SWS_X                 8
#define SWS_POINT          0x10
#define SWS_AREA           0x20
#define SWS_BICUBLIN       0x40
#define SWS_GAUSS          0x80
#define SWS_SINC          0x100
#define SWS_LANCZOS       0x200
#define SWS_SPLINE        0x400
67

68 69
#define SWS_SRC_V_CHR_DROP_MASK     0x30000
#define SWS_SRC_V_CHR_DROP_SHIFT    16
70

71
#define SWS_PARAM_DEFAULT           123456
Michael Niedermayer's avatar
Michael Niedermayer committed
72

73
#define SWS_PRINT_INFO              0x1000
Michael Niedermayer's avatar
Michael Niedermayer committed
74

Diego Biurrun's avatar
Diego Biurrun committed
75 76
//the following 3 flags are not completely implemented
//internal chrominace subsampling info
77
#define SWS_FULL_CHR_H_INT    0x2000
78
//input subsampling info
79 80 81
#define SWS_FULL_CHR_H_INP    0x4000
#define SWS_DIRECT_BGR        0x8000
#define SWS_ACCURATE_RND      0x40000
Michael Niedermayer's avatar
Michael Niedermayer committed
82
#define SWS_BITEXACT          0x80000
83
#define SWS_ERROR_DIFFUSION  0x800000
84

85 86 87 88 89
#if FF_API_SWS_CPU_CAPS
/**
 * CPU caps are autodetected now, those flags
 * are only provided for API compatibility.
 */
90
#define SWS_CPU_CAPS_MMX      0x80000000
91
#define SWS_CPU_CAPS_MMXEXT   0x20000000
92 93 94
#define SWS_CPU_CAPS_MMX2     0x20000000
#define SWS_CPU_CAPS_3DNOW    0x40000000
#define SWS_CPU_CAPS_ALTIVEC  0x10000000
95
#if FF_API_ARCH_BFIN
96
#define SWS_CPU_CAPS_BFIN     0x01000000
97
#endif
98
#define SWS_CPU_CAPS_SSE2     0x02000000
99
#endif
100

101
#define SWS_MAX_REDUCE_CUTOFF 0.002
102

103 104 105 106 107 108 109
#define SWS_CS_ITU709         1
#define SWS_CS_FCC            4
#define SWS_CS_ITU601         5
#define SWS_CS_ITU624         5
#define SWS_CS_SMPTE170M      5
#define SWS_CS_SMPTE240M      7
#define SWS_CS_DEFAULT        5
110

111
/**
112
 * Return a pointer to yuv<->rgb coefficients for the given colorspace
113 114 115 116
 * suitable for sws_setColorspaceDetails().
 *
 * @param colorspace One of the SWS_CS_* macros. If invalid,
 * SWS_CS_DEFAULT is used.
117
 */
118
const int *sws_getCoefficients(int colorspace);
Michael Niedermayer's avatar
Michael Niedermayer committed
119

120 121
// when used for filters they must have an odd number of elements
// coeffs cannot be shared between vectors
122
typedef struct SwsVector {
123 124
    double *coeff;              ///< pointer to the list of coefficients
    int length;                 ///< number of coefficients in the vector
125 126 127
} SwsVector;

// vectors can be shared
128
typedef struct SwsFilter {
129 130 131 132
    SwsVector *lumH;
    SwsVector *lumV;
    SwsVector *chrH;
    SwsVector *chrV;
133 134
} SwsFilter;

135
struct SwsContext;
136

137
/**
138
 * Return a positive value if pix_fmt is a supported input format, 0
139 140
 * otherwise.
 */
141
int sws_isSupportedInput(enum AVPixelFormat pix_fmt);
142 143

/**
144
 * Return a positive value if pix_fmt is a supported output format, 0
145 146
 * otherwise.
 */
147
int sws_isSupportedOutput(enum AVPixelFormat pix_fmt);
148

149 150 151 152 153 154 155
/**
 * @param[in]  pix_fmt the pixel format
 * @return a positive value if an endianness conversion for pix_fmt is
 * supported, 0 otherwise.
 */
int sws_isSupportedEndiannessConversion(enum AVPixelFormat pix_fmt);

156
/**
157
 * Allocate an empty SwsContext. This must be filled and passed to
Ramiro Polla's avatar
Ramiro Polla committed
158 159
 * sws_init_context(). For filling see AVOptions, options.c and
 * sws_setColorspaceDetails().
160 161 162 163
 */
struct SwsContext *sws_alloc_context(void);

/**
164
 * Initialize the swscaler context sws_context.
165 166 167
 *
 * @return zero or positive value on success, a negative value on
 * error
168 169 170
 */
int sws_init_context(struct SwsContext *sws_context, SwsFilter *srcFilter, SwsFilter *dstFilter);

171
/**
172
 * Free the swscaler context swsContext.
Stefano Sabatini's avatar
Stefano Sabatini committed
173
 * If swsContext is NULL, then does nothing.
174
 */
175
void sws_freeContext(struct SwsContext *swsContext);
176

177
/**
178
 * Allocate and return an SwsContext. You need it to perform
179 180 181 182 183 184 185 186 187 188
 * scaling/conversion operations using sws_scale().
 *
 * @param srcW the width of the source image
 * @param srcH the height of the source image
 * @param srcFormat the source image format
 * @param dstW the width of the destination image
 * @param dstH the height of the destination image
 * @param dstFormat the destination image format
 * @param flags specify which algorithm and options to use for rescaling
 * @return a pointer to an allocated context, or NULL in case of error
189 190
 * @note this function is to be removed after a saner alternative is
 *       written
191
 */
192 193
struct SwsContext *sws_getContext(int srcW, int srcH, enum AVPixelFormat srcFormat,
                                  int dstW, int dstH, enum AVPixelFormat dstFormat,
194
                                  int flags, SwsFilter *srcFilter,
195
                                  SwsFilter *dstFilter, const double *param);
Stefano Sabatini's avatar
Stefano Sabatini committed
196 197

/**
198
 * Scale the image slice in srcSlice and put the resulting scaled
199
 * slice in the image in dst. A slice is a sequence of consecutive
200 201 202 203 204
 * rows in an image.
 *
 * Slices have to be provided in sequential order, either in
 * top-bottom or bottom-top order. If slices are provided in
 * non-sequential order the behavior of the function is undefined.
Stefano Sabatini's avatar
Stefano Sabatini committed
205
 *
206
 * @param c         the scaling context previously created with
Stefano Sabatini's avatar
Stefano Sabatini committed
207
 *                  sws_getContext()
208
 * @param srcSlice  the array containing the pointers to the planes of
Stefano Sabatini's avatar
Stefano Sabatini committed
209 210 211 212 213 214 215 216 217 218 219 220 221 222
 *                  the source slice
 * @param srcStride the array containing the strides for each plane of
 *                  the source image
 * @param srcSliceY the position in the source image of the slice to
 *                  process, that is the number (counted starting from
 *                  zero) in the image of the first row of the slice
 * @param srcSliceH the height of the source slice, that is the number
 *                  of rows in the slice
 * @param dst       the array containing the pointers to the planes of
 *                  the destination image
 * @param dstStride the array containing the strides for each plane of
 *                  the destination image
 * @return          the height of the output slice
 */
223
int sws_scale(struct SwsContext *c, const uint8_t *const srcSlice[],
224
              const int srcStride[], int srcSliceY, int srcSliceH,
225
              uint8_t *const dst[], const int dstStride[]);
226

227
/**
228 229 230 231 232 233 234
 * @param dstRange flag indicating the while-black range of the output (1=jpeg / 0=mpeg)
 * @param srcRange flag indicating the while-black range of the input (1=jpeg / 0=mpeg)
 * @param table the yuv2rgb coefficients describing the output yuv space, normally ff_yuv2rgb_coeffs[x]
 * @param inv_table the yuv2rgb coefficients describing the input yuv space, normally ff_yuv2rgb_coeffs[x]
 * @param brightness 16.16 fixed point brightness correction
 * @param contrast 16.16 fixed point contrast correction
 * @param saturation 16.16 fixed point saturation correction
235 236
 * @return -1 if not supported
 */
237 238 239
int sws_setColorspaceDetails(struct SwsContext *c, const int inv_table[4],
                             int srcRange, const int table[4], int dstRange,
                             int brightness, int contrast, int saturation);
240 241 242 243

/**
 * @return -1 if not supported
 */
244 245 246
int sws_getColorspaceDetails(struct SwsContext *c, int **inv_table,
                             int *srcRange, int **table, int *dstRange,
                             int *brightness, int *contrast, int *saturation);
247

248
/**
249
 * Allocate and return an uninitialized vector with length coefficients.
250 251 252
 */
SwsVector *sws_allocVec(int length);

253
/**
254 255
 * Return a normalized Gaussian curve used to filter stuff
 * quality = 3 is high quality, lower is lower quality.
256
 */
257
SwsVector *sws_getGaussianVec(double variance, double quality);
258 259

/**
260
 * Allocate and return a vector with length coefficients, all
261
 * with the same value c.
262
 */
263
SwsVector *sws_getConstVec(double c, int length);
264 265

/**
266
 * Allocate and return a vector with just one coefficient, with
267 268
 * value 1.0.
 */
269
SwsVector *sws_getIdentityVec(void);
270 271

/**
272
 * Scale all the coefficients of a by the scalar value.
273
 */
274
void sws_scaleVec(SwsVector *a, double scalar);
275 276

/**
277
 * Scale all the coefficients of a so that their sum equals height.
278
 */
279 280 281 282 283
void sws_normalizeVec(SwsVector *a, double height);
void sws_convVec(SwsVector *a, SwsVector *b);
void sws_addVec(SwsVector *a, SwsVector *b);
void sws_subVec(SwsVector *a, SwsVector *b);
void sws_shiftVec(SwsVector *a, int shift);
284 285

/**
286
 * Allocate and return a clone of the vector a, that is a vector
287
 * with the same coefficients as a.
288
 */
289 290
SwsVector *sws_cloneVec(SwsVector *a);

291
/**
292
 * Print with av_log() a textual representation of the vector a
293
 * if log_level <= av_log_level.
294 295 296
 */
void sws_printVec2(SwsVector *a, AVClass *log_ctx, int log_level);

297 298
void sws_freeVec(SwsVector *a);

299
SwsFilter *sws_getDefaultFilter(float lumaGBlur, float chromaGBlur,
300
                                float lumaSharpen, float chromaSharpen,
301 302
                                float chromaHShift, float chromaVShift,
                                int verbose);
303 304
void sws_freeFilter(SwsFilter *filter);

305
/**
306
 * Check if context can be reused, otherwise reallocate a new one.
307
 *
Stefano Sabatini's avatar
Stefano Sabatini committed
308 309 310 311
 * If context is NULL, just calls sws_getContext() to get a new
 * context. Otherwise, checks if the parameters are the ones already
 * saved in context. If that is the case, returns the current
 * context. Otherwise, frees context and gets a new context with
312 313
 * the new parameters.
 *
314
 * Be warned that srcFilter and dstFilter are not checked, they
315
 * are assumed to remain the same.
316
 */
317
struct SwsContext *sws_getCachedContext(struct SwsContext *context,
318 319
                                        int srcW, int srcH, enum AVPixelFormat srcFormat,
                                        int dstW, int dstH, enum AVPixelFormat dstFormat,
320
                                        int flags, SwsFilter *srcFilter,
321
                                        SwsFilter *dstFilter, const double *param);
322

323
/**
324
 * Convert an 8-bit paletted frame into a frame with a color depth of 32 bits.
325 326 327 328 329 330 331 332
 *
 * The output frame will have the same packed format as the palette.
 *
 * @param src        source frame buffer
 * @param dst        destination frame buffer
 * @param num_pixels number of pixels to convert
 * @param palette    array with [256] entries, which must match color arrangement (RGB or BGR) of src
 */
333
void sws_convertPalette8ToPacked32(const uint8_t *src, uint8_t *dst, int num_pixels, const uint8_t *palette);
334 335

/**
336
 * Convert an 8-bit paletted frame into a frame with a color depth of 24 bits.
337 338 339 340 341 342 343 344
 *
 * With the palette format "ABCD", the destination frame ends up with the format "ABC".
 *
 * @param src        source frame buffer
 * @param dst        destination frame buffer
 * @param num_pixels number of pixels to convert
 * @param palette    array with [256] entries, which must match color arrangement (RGB or BGR) of src
 */
345
void sws_convertPalette8ToPacked24(const uint8_t *src, uint8_t *dst, int num_pixels, const uint8_t *palette);
346

347 348 349 350 351 352 353
/**
 * Get the AVClass for swsContext. It can be used in combination with
 * AV_OPT_SEARCH_FAKE_OBJ for examining options.
 *
 * @see av_opt_find().
 */
const AVClass *sws_get_class(void);
354

355 356 357 358
/**
 * @}
 */

359
#endif /* SWSCALE_SWSCALE_H */