swscale.h 9.67 KB
Newer Older
1
/*
2 3 4 5
 * Copyright (C) 2001-2003 Michael Niedermayer <michaelni@gmx.at>
 *
 * 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 libswscale/swscale.h
26
 * @brief
27 28 29
 *     external api for the swscale stuff
 */

30
#include "libavutil/avutil.h"
31

32
#define LIBSWSCALE_VERSION_MAJOR 0
33
#define LIBSWSCALE_VERSION_MINOR 7
34
#define LIBSWSCALE_VERSION_MICRO 1
35

36 37 38 39 40 41
#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)
42 43 44 45
#define LIBSWSCALE_BUILD        LIBSWSCALE_VERSION_INT

#define LIBSWSCALE_IDENT        "SwS" AV_STRINGIFY(LIBSWSCALE_VERSION)

46 47 48 49 50
/**
 * Returns the LIBSWSCALE_VERSION_INT constant.
 */
unsigned swscale_version(void);

51 52 53 54 55 56 57 58 59 60
/**
 * Returns the libswscale build-time configuration.
 */
const char * swscale_configuration(void);

/**
 * Returns the libswscale license.
 */
const char * swscale_license(void);

61
/* values for the flags, the stuff on the command line is different */
62 63 64 65 66 67 68 69 70 71 72
#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
73

74 75
#define SWS_SRC_V_CHR_DROP_MASK     0x30000
#define SWS_SRC_V_CHR_DROP_SHIFT    16
76

77
#define SWS_PARAM_DEFAULT           123456
Michael Niedermayer's avatar
Michael Niedermayer committed
78

79
#define SWS_PRINT_INFO              0x1000
Michael Niedermayer's avatar
Michael Niedermayer committed
80

Diego Biurrun's avatar
Diego Biurrun committed
81 82
//the following 3 flags are not completely implemented
//internal chrominace subsampling info
83
#define SWS_FULL_CHR_H_INT    0x2000
84
//input subsampling info
85 86 87
#define SWS_FULL_CHR_H_INP    0x4000
#define SWS_DIRECT_BGR        0x8000
#define SWS_ACCURATE_RND      0x40000
Michael Niedermayer's avatar
Michael Niedermayer committed
88
#define SWS_BITEXACT          0x80000
89

90 91 92 93
#define SWS_CPU_CAPS_MMX      0x80000000
#define SWS_CPU_CAPS_MMX2     0x20000000
#define SWS_CPU_CAPS_3DNOW    0x40000000
#define SWS_CPU_CAPS_ALTIVEC  0x10000000
94
#define SWS_CPU_CAPS_BFIN     0x01000000
95

96
#define SWS_MAX_REDUCE_CUTOFF 0.002
97

98 99 100 101 102 103 104
#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
105

Michael Niedermayer's avatar
Michael Niedermayer committed
106

107

108 109
// when used for filters they must have an odd number of elements
// coeffs cannot be shared between vectors
110
typedef struct {
111 112
    double *coeff;              ///< pointer to the list of coefficients
    int length;                 ///< number of coefficients in the vector
113 114 115 116
} SwsVector;

// vectors can be shared
typedef struct {
117 118 119 120
    SwsVector *lumH;
    SwsVector *lumV;
    SwsVector *chrH;
    SwsVector *chrV;
121 122
} SwsFilter;

123
struct SwsContext;
124

125 126 127 128
/**
 * Frees the swscaler context swsContext.
 * If swsContext is NULL, then does nothing.
 */
129
void sws_freeContext(struct SwsContext *swsContext);
130

131 132 133 134 135 136 137 138 139 140 141 142 143
/**
 * Allocates and returns a SwsContext. You need it to perform
 * 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
 */
144 145 146
struct SwsContext *sws_getContext(int srcW, int srcH, enum PixelFormat srcFormat,
                                  int dstW, int dstH, enum PixelFormat dstFormat,
                                  int flags, SwsFilter *srcFilter,
147
                                  SwsFilter *dstFilter, const double *param);
Stefano Sabatini's avatar
Stefano Sabatini committed
148 149

/**
150 151
 * Scales the image slice in srcSlice and puts the resulting scaled
 * slice in the image in dst. A slice is a sequence of consecutive
152 153 154 155 156
 * 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
157 158 159
 *
 * @param context   the scaling context previously created with
 *                  sws_getContext()
160
 * @param srcSlice  the array containing the pointers to the planes of
Stefano Sabatini's avatar
Stefano Sabatini committed
161 162 163 164 165 166 167 168 169 170 171 172 173 174
 *                  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
 */
175 176
int sws_scale(struct SwsContext *context, uint8_t* srcSlice[], int srcStride[],
              int srcSliceY, int srcSliceH, uint8_t* dst[], int dstStride[]);
177
#if LIBSWSCALE_VERSION_MAJOR < 1
178 179 180
/**
 * @deprecated Use sws_scale() instead.
 */
181 182 183
int sws_scale_ordered(struct SwsContext *context, uint8_t* src[],
                      int srcStride[], int srcSliceY, int srcSliceH,
                      uint8_t* dst[], int dstStride[]) attribute_deprecated;
184
#endif
185

186 187 188 189 190
/**
 * @param inv_table the yuv2rgb coefficients, normally ff_yuv2rgb_coeffs[x]
 * @param fullRange if 1 then the luma range is 0..255 if 0 it is 16..235
 * @return -1 if not supported
 */
191 192 193
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);
194 195 196 197

/**
 * @return -1 if not supported
 */
198 199 200
int sws_getColorspaceDetails(struct SwsContext *c, int **inv_table,
                             int *srcRange, int **table, int *dstRange,
                             int *brightness, int *contrast, int *saturation);
201

202 203 204 205 206
/**
 * Allocates and returns an uninitialized vector with length coefficients.
 */
SwsVector *sws_allocVec(int length);

207 208 209 210
/**
 * Returns a normalized Gaussian curve used to filter stuff
 * quality=3 is high quality, lower is lower quality.
 */
211
SwsVector *sws_getGaussianVec(double variance, double quality);
212 213

/**
214 215
 * Allocates and returns a vector with length coefficients, all
 * with the same value c.
216
 */
217
SwsVector *sws_getConstVec(double c, int length);
218 219 220 221 222

/**
 * Allocates and returns a vector with just one coefficient, with
 * value 1.0.
 */
223
SwsVector *sws_getIdentityVec(void);
224 225

/**
226
 * Scales all the coefficients of a by the scalar value.
227
 */
228
void sws_scaleVec(SwsVector *a, double scalar);
229 230

/**
231
 * Scales all the coefficients of a so that their sum equals height.
232
 */
233 234 235 236 237
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);
238 239

/**
240 241
 * Allocates and returns a clone of the vector a, that is a vector
 * with the same coefficients as a.
242
 */
243 244
SwsVector *sws_cloneVec(SwsVector *a);

245 246 247 248 249 250 251 252
#if LIBSWSCALE_VERSION_MAJOR < 1
/**
 * @deprecated Use sws_printVec2() instead.
 */
attribute_deprecated void sws_printVec(SwsVector *a);
#endif

/**
253 254
 * Prints with av_log() a textual representation of the vector a
 * if log_level <= av_log_level.
255 256 257
 */
void sws_printVec2(SwsVector *a, AVClass *log_ctx, int log_level);

258 259
void sws_freeVec(SwsVector *a);

260
SwsFilter *sws_getDefaultFilter(float lumaGBlur, float chromaGBlur,
261
                                float lumaSharpen, float chromaSharpen,
262 263
                                float chromaHShift, float chromaVShift,
                                int verbose);
264 265
void sws_freeFilter(SwsFilter *filter);

266
/**
267
 * Checks if context can be reused, otherwise reallocates a new
268
 * one.
269
 *
270
 * If context is NULL, just calls sws_getContext() to get a new
271
 * context. Otherwise, checks if the parameters are the ones already
272 273
 * saved in context. If that is the case, returns the current
 * context. Otherwise, frees context and gets a new context with
274 275
 * the new parameters.
 *
276
 * Be warned that srcFilter and dstFilter are not checked, they
277
 * are assumed to remain the same.
278
 */
279
struct SwsContext *sws_getCachedContext(struct SwsContext *context,
280
                                        int srcW, int srcH, enum PixelFormat srcFormat,
281 282
                                        int dstW, int dstH, enum PixelFormat dstFormat,
                                        int flags, SwsFilter *srcFilter,
283
                                        SwsFilter *dstFilter, const double *param);
284

285
#endif /* SWSCALE_SWSCALE_H */