swscale.h 12 KB
Newer Older
1
/*
2 3
 * Copyright (C) 2001-2003 Michael Niedermayer <michaelni@gmx.at>
 *
4
 * This file is part of Libav.
5
 *
6
 * Libav is free software; you can redistribute it and/or
7 8 9
 * 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
 * Libav is distributed in the hope that it will be useful,
12
 * 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
 * You should have received a copy of the GNU Lesser General Public
17
 * License along with Libav; 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
 * @brief
27 28 29
 *     external api for the swscale stuff
 */

30
#include "libavutil/avutil.h"
31
#include "libavutil/log.h"
32
#include "libavutil/pixfmt.h"
33

34
#define LIBSWSCALE_VERSION_MAJOR 2
35
#define LIBSWSCALE_VERSION_MINOR 1
36
#define LIBSWSCALE_VERSION_MICRO 0
37

38 39 40 41 42 43
#define LIBSWSCALE_VERSION_INT  AV_VERSION_INT(LIBSWSCALE_VERSION_MAJOR, \
                                               LIBSWSCALE_VERSION_MINOR, \
                                               LIBSWSCALE_VERSION_MICRO)
#define LIBSWSCALE_VERSION      AV_VERSION(LIBSWSCALE_VERSION_MAJOR, \
                                           LIBSWSCALE_VERSION_MINOR, \
                                           LIBSWSCALE_VERSION_MICRO)
44 45 46 47
#define LIBSWSCALE_BUILD        LIBSWSCALE_VERSION_INT

#define LIBSWSCALE_IDENT        "SwS" AV_STRINGIFY(LIBSWSCALE_VERSION)

48 49 50 51 52
/**
 * Those FF_API_* defines are not part of public API.
 * They may change, break or disappear at any time.
 */
#ifndef FF_API_SWS_GETCONTEXT
53
#define FF_API_SWS_GETCONTEXT  (LIBSWSCALE_VERSION_MAJOR < 3)
54
#endif
55
#ifndef FF_API_SWS_CPU_CAPS
56
#define FF_API_SWS_CPU_CAPS    (LIBSWSCALE_VERSION_MAJOR < 3)
57
#endif
58

59
/**
60
 * Return the LIBSWSCALE_VERSION_INT constant.
61 62 63
 */
unsigned swscale_version(void);

64
/**
65
 * Return the libswscale build-time configuration.
66
 */
67
const char *swscale_configuration(void);
68 69

/**
70
 * Return the libswscale license.
71
 */
72
const char *swscale_license(void);
73

74
/* values for the flags, the stuff on the command line is different */
75 76 77 78 79 80 81 82 83 84 85
#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
86

87 88
#define SWS_SRC_V_CHR_DROP_MASK     0x30000
#define SWS_SRC_V_CHR_DROP_SHIFT    16
89

90
#define SWS_PARAM_DEFAULT           123456
Michael Niedermayer's avatar
Michael Niedermayer committed
91

92
#define SWS_PRINT_INFO              0x1000
Michael Niedermayer's avatar
Michael Niedermayer committed
93

Diego Biurrun's avatar
Diego Biurrun committed
94 95
//the following 3 flags are not completely implemented
//internal chrominace subsampling info
96
#define SWS_FULL_CHR_H_INT    0x2000
97
//input subsampling info
98 99 100
#define SWS_FULL_CHR_H_INP    0x4000
#define SWS_DIRECT_BGR        0x8000
#define SWS_ACCURATE_RND      0x40000
Michael Niedermayer's avatar
Michael Niedermayer committed
101
#define SWS_BITEXACT          0x80000
102

103 104 105 106 107 108 109 110 111 112 113 114 115
#if FF_API_SWS_CPU_CAPS
/**
 * CPU caps are autodetected now, those flags
 * are only provided for API compatibility.
 */
#define SWS_CPU_CAPS_MMX      0x80000000
#define SWS_CPU_CAPS_MMX2     0x20000000
#define SWS_CPU_CAPS_3DNOW    0x40000000
#define SWS_CPU_CAPS_ALTIVEC  0x10000000
#define SWS_CPU_CAPS_BFIN     0x01000000
#define SWS_CPU_CAPS_SSE2     0x02000000
#endif

116
#define SWS_MAX_REDUCE_CUTOFF 0.002
117

118 119 120 121 122 123 124
#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
125

126
/**
127
 * Return a pointer to yuv<->rgb coefficients for the given colorspace
128 129 130 131
 * suitable for sws_setColorspaceDetails().
 *
 * @param colorspace One of the SWS_CS_* macros. If invalid,
 * SWS_CS_DEFAULT is used.
132
 */
133
const int *sws_getCoefficients(int colorspace);
Michael Niedermayer's avatar
Michael Niedermayer committed
134

135 136
// when used for filters they must have an odd number of elements
// coeffs cannot be shared between vectors
137
typedef struct {
138 139
    double *coeff;              ///< pointer to the list of coefficients
    int length;                 ///< number of coefficients in the vector
140 141 142 143
} SwsVector;

// vectors can be shared
typedef struct {
144 145 146 147
    SwsVector *lumH;
    SwsVector *lumV;
    SwsVector *chrH;
    SwsVector *chrV;
148 149
} SwsFilter;

150
struct SwsContext;
151

152
/**
153
 * Return a positive value if pix_fmt is a supported input format, 0
154 155 156 157 158
 * otherwise.
 */
int sws_isSupportedInput(enum PixelFormat pix_fmt);

/**
159
 * Return a positive value if pix_fmt is a supported output format, 0
160 161 162 163
 * otherwise.
 */
int sws_isSupportedOutput(enum PixelFormat pix_fmt);

164
/**
165
 * Allocate an empty SwsContext. This must be filled and passed to
Ramiro Polla's avatar
Ramiro Polla committed
166 167
 * sws_init_context(). For filling see AVOptions, options.c and
 * sws_setColorspaceDetails().
168 169 170 171
 */
struct SwsContext *sws_alloc_context(void);

/**
172
 * Initialize the swscaler context sws_context.
173 174 175
 *
 * @return zero or positive value on success, a negative value on
 * error
176 177 178
 */
int sws_init_context(struct SwsContext *sws_context, SwsFilter *srcFilter, SwsFilter *dstFilter);

179
/**
180
 * Free the swscaler context swsContext.
Stefano Sabatini's avatar
Stefano Sabatini committed
181
 * If swsContext is NULL, then does nothing.
182
 */
183
void sws_freeContext(struct SwsContext *swsContext);
184

185
#if FF_API_SWS_GETCONTEXT
186
/**
187
 * Allocate and return an SwsContext. You need it to perform
188 189 190 191 192 193 194 195 196 197
 * 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
198 199
 * @note this function is to be removed after a saner alternative is
 *       written
200
 * @deprecated Use sws_getCachedContext() instead.
201
 */
202 203 204
struct SwsContext *sws_getContext(int srcW, int srcH, enum PixelFormat srcFormat,
                                  int dstW, int dstH, enum PixelFormat dstFormat,
                                  int flags, SwsFilter *srcFilter,
205
                                  SwsFilter *dstFilter, const double *param);
206
#endif
Stefano Sabatini's avatar
Stefano Sabatini committed
207 208

/**
209
 * Scale the image slice in srcSlice and put the resulting scaled
210
 * slice in the image in dst. A slice is a sequence of consecutive
211 212 213 214 215
 * 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
216
 *
217
 * @param c         the scaling context previously created with
Stefano Sabatini's avatar
Stefano Sabatini committed
218
 *                  sws_getContext()
219
 * @param srcSlice  the array containing the pointers to the planes of
Stefano Sabatini's avatar
Stefano Sabatini committed
220 221 222 223 224 225 226 227 228 229 230 231 232 233
 *                  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
 */
234
int sws_scale(struct SwsContext *c, const uint8_t *const srcSlice[],
235
              const int srcStride[], int srcSliceY, int srcSliceH,
236
              uint8_t *const dst[], const int dstStride[]);
237

238 239 240 241
/**
 * @param inv_table the yuv2rgb coefficients, normally ff_yuv2rgb_coeffs[x]
 * @return -1 if not supported
 */
242 243 244
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);
245 246 247 248

/**
 * @return -1 if not supported
 */
249 250 251
int sws_getColorspaceDetails(struct SwsContext *c, int **inv_table,
                             int *srcRange, int **table, int *dstRange,
                             int *brightness, int *contrast, int *saturation);
252

253
/**
254
 * Allocate and return an uninitialized vector with length coefficients.
255 256 257
 */
SwsVector *sws_allocVec(int length);

258
/**
259 260
 * Return a normalized Gaussian curve used to filter stuff
 * quality = 3 is high quality, lower is lower quality.
261
 */
262
SwsVector *sws_getGaussianVec(double variance, double quality);
263 264

/**
265
 * Allocate and return a vector with length coefficients, all
266
 * with the same value c.
267
 */
268
SwsVector *sws_getConstVec(double c, int length);
269 270

/**
271
 * Allocate and return a vector with just one coefficient, with
272 273
 * value 1.0.
 */
274
SwsVector *sws_getIdentityVec(void);
275 276

/**
277
 * Scale all the coefficients of a by the scalar value.
278
 */
279
void sws_scaleVec(SwsVector *a, double scalar);
280 281

/**
282
 * Scale all the coefficients of a so that their sum equals height.
283
 */
284 285 286 287 288
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);
289 290

/**
291
 * Allocate and return a clone of the vector a, that is a vector
292
 * with the same coefficients as a.
293
 */
294 295
SwsVector *sws_cloneVec(SwsVector *a);

296
/**
297
 * Print with av_log() a textual representation of the vector a
298
 * if log_level <= av_log_level.
299 300 301
 */
void sws_printVec2(SwsVector *a, AVClass *log_ctx, int log_level);

302 303
void sws_freeVec(SwsVector *a);

304
SwsFilter *sws_getDefaultFilter(float lumaGBlur, float chromaGBlur,
305
                                float lumaSharpen, float chromaSharpen,
306 307
                                float chromaHShift, float chromaVShift,
                                int verbose);
308 309
void sws_freeFilter(SwsFilter *filter);

310
/**
311
 * Check if context can be reused, otherwise reallocate a new one.
312
 *
Stefano Sabatini's avatar
Stefano Sabatini committed
313 314 315 316
 * 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
317 318
 * the new parameters.
 *
319
 * Be warned that srcFilter and dstFilter are not checked, they
320
 * are assumed to remain the same.
321
 */
322
struct SwsContext *sws_getCachedContext(struct SwsContext *context,
323
                                        int srcW, int srcH, enum PixelFormat srcFormat,
324 325
                                        int dstW, int dstH, enum PixelFormat dstFormat,
                                        int flags, SwsFilter *srcFilter,
326
                                        SwsFilter *dstFilter, const double *param);
327

328
/**
329
 * Convert an 8-bit paletted frame into a frame with a color depth of 32 bits.
330 331 332 333 334 335 336 337
 *
 * 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
 */
338
void sws_convertPalette8ToPacked32(const uint8_t *src, uint8_t *dst, int num_pixels, const uint8_t *palette);
339 340

/**
341
 * Convert an 8-bit paletted frame into a frame with a color depth of 24 bits.
342 343 344 345 346 347 348 349
 *
 * 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
 */
350
void sws_convertPalette8ToPacked24(const uint8_t *src, uint8_t *dst, int num_pixels, const uint8_t *palette);
351

352 353 354 355 356 357 358
/**
 * 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);
359

360
#endif /* SWSCALE_SWSCALE_H */