1 /* 2 * Copyright (C) 2001-2011 Michael Niedermayer <michaelni@gmx.at> 3 * 4 * This file is part of FFmpeg. 5 * 6 * FFmpeg is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU Lesser General Public 8 * License as published by the Free Software Foundation; either 9 * version 2.1 of the License, or (at your option) any later version. 10 * 11 * FFmpeg is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 * 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 FFmpeg; if not, write to the Free Software 18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 19 */ 20 21 #ifndef SWSCALE_SWSCALE_H 22 #define SWSCALE_SWSCALE_H 23 24 /** 25 * @file 26 * @ingroup libsws 27 * external API header 28 */ 29 30 #include <stdint.h> 31 32 #include "libavutil/avutil.h" 33 #include "libavutil/log.h" 34 #include "libavutil/pixfmt.h" 35 #include "version.h" 36 37 /** 38 * @defgroup libsws libswscale 39 * Color conversion and scaling library. 40 * 41 * @{ 42 * 43 * Return the LIBSWSCALE_VERSION_INT constant. 44 */ 45 unsigned swscale_version(void); 46 47 /** 48 * Return the libswscale build-time configuration. 49 */ 50 const char *swscale_configuration(void); 51 52 /** 53 * Return the libswscale license. 54 */ 55 const char *swscale_license(void); 56 57 /* values for the flags, the stuff on the command line is different */ 58 #define SWS_FAST_BILINEAR 1 59 #define SWS_BILINEAR 2 60 #define SWS_BICUBIC 4 61 #define SWS_X 8 62 #define SWS_POINT 0x10 63 #define SWS_AREA 0x20 64 #define SWS_BICUBLIN 0x40 65 #define SWS_GAUSS 0x80 66 #define SWS_SINC 0x100 67 #define SWS_LANCZOS 0x200 68 #define SWS_SPLINE 0x400 69 70 #define SWS_SRC_V_CHR_DROP_MASK 0x30000 71 #define SWS_SRC_V_CHR_DROP_SHIFT 16 72 73 #define SWS_PARAM_DEFAULT 123456 74 75 #define SWS_PRINT_INFO 0x1000 76 77 //the following 3 flags are not completely implemented 78 //internal chrominance subsampling info 79 #define SWS_FULL_CHR_H_INT 0x2000 80 //input subsampling info 81 #define SWS_FULL_CHR_H_INP 0x4000 82 #define SWS_DIRECT_BGR 0x8000 83 #define SWS_ACCURATE_RND 0x40000 84 #define SWS_BITEXACT 0x80000 85 #define SWS_ERROR_DIFFUSION 0x800000 86 87 #define SWS_MAX_REDUCE_CUTOFF 0.002 88 89 #define SWS_CS_ITU709 1 90 #define SWS_CS_FCC 4 91 #define SWS_CS_ITU601 5 92 #define SWS_CS_ITU624 5 93 #define SWS_CS_SMPTE170M 5 94 #define SWS_CS_SMPTE240M 7 95 #define SWS_CS_DEFAULT 5 96 #define SWS_CS_BT2020 9 97 98 /** 99 * Return a pointer to yuv<->rgb coefficients for the given colorspace 100 * suitable for sws_setColorspaceDetails(). 101 * 102 * @param colorspace One of the SWS_CS_* macros. If invalid, 103 * SWS_CS_DEFAULT is used. 104 */ 105 const int *sws_getCoefficients(int colorspace); 106 107 // when used for filters they must have an odd number of elements 108 // coeffs cannot be shared between vectors 109 typedef struct SwsVector { 110 double *coeff; ///< pointer to the list of coefficients 111 int length; ///< number of coefficients in the vector 112 } SwsVector; 113 114 // vectors can be shared 115 typedef struct SwsFilter { 116 SwsVector *lumH; 117 SwsVector *lumV; 118 SwsVector *chrH; 119 SwsVector *chrV; 120 } SwsFilter; 121 122 struct SwsContext; 123 124 /** 125 * Return a positive value if pix_fmt is a supported input format, 0 126 * otherwise. 127 */ 128 int sws_isSupportedInput(enum AVPixelFormat pix_fmt); 129 130 /** 131 * Return a positive value if pix_fmt is a supported output format, 0 132 * otherwise. 133 */ 134 int sws_isSupportedOutput(enum AVPixelFormat pix_fmt); 135 136 /** 137 * @param[in] pix_fmt the pixel format 138 * @return a positive value if an endianness conversion for pix_fmt is 139 * supported, 0 otherwise. 140 */ 141 int sws_isSupportedEndiannessConversion(enum AVPixelFormat pix_fmt); 142 143 /** 144 * Allocate an empty SwsContext. This must be filled and passed to 145 * sws_init_context(). For filling see AVOptions, options.c and 146 * sws_setColorspaceDetails(). 147 */ 148 struct SwsContext *sws_alloc_context(void); 149 150 /** 151 * Initialize the swscaler context sws_context. 152 * 153 * @return zero or positive value on success, a negative value on 154 * error 155 */ 156 av_warn_unused_result 157 int sws_init_context(struct SwsContext *sws_context, SwsFilter *srcFilter, SwsFilter *dstFilter); 158 159 /** 160 * Free the swscaler context swsContext. 161 * If swsContext is NULL, then does nothing. 162 */ 163 void sws_freeContext(struct SwsContext *swsContext); 164 165 /** 166 * Allocate and return an SwsContext. You need it to perform 167 * scaling/conversion operations using sws_scale(). 168 * 169 * @param srcW the width of the source image 170 * @param srcH the height of the source image 171 * @param srcFormat the source image format 172 * @param dstW the width of the destination image 173 * @param dstH the height of the destination image 174 * @param dstFormat the destination image format 175 * @param flags specify which algorithm and options to use for rescaling 176 * @param param extra parameters to tune the used scaler 177 * For SWS_BICUBIC param[0] and [1] tune the shape of the basis 178 * function, param[0] tunes f(1) and param[1] f´(1) 179 * For SWS_GAUSS param[0] tunes the exponent and thus cutoff 180 * frequency 181 * For SWS_LANCZOS param[0] tunes the width of the window function 182 * @return a pointer to an allocated context, or NULL in case of error 183 * @note this function is to be removed after a saner alternative is 184 * written 185 */ 186 struct SwsContext *sws_getContext(int srcW, int srcH, enum AVPixelFormat srcFormat, 187 int dstW, int dstH, enum AVPixelFormat dstFormat, 188 int flags, SwsFilter *srcFilter, 189 SwsFilter *dstFilter, const double *param); 190 191 /** 192 * Scale the image slice in srcSlice and put the resulting scaled 193 * slice in the image in dst. A slice is a sequence of consecutive 194 * rows in an image. 195 * 196 * Slices have to be provided in sequential order, either in 197 * top-bottom or bottom-top order. If slices are provided in 198 * non-sequential order the behavior of the function is undefined. 199 * 200 * @param c the scaling context previously created with 201 * sws_getContext() 202 * @param srcSlice the array containing the pointers to the planes of 203 * the source slice 204 * @param srcStride the array containing the strides for each plane of 205 * the source image 206 * @param srcSliceY the position in the source image of the slice to 207 * process, that is the number (counted starting from 208 * zero) in the image of the first row of the slice 209 * @param srcSliceH the height of the source slice, that is the number 210 * of rows in the slice 211 * @param dst the array containing the pointers to the planes of 212 * the destination image 213 * @param dstStride the array containing the strides for each plane of 214 * the destination image 215 * @return the height of the output slice 216 */ 217 int sws_scale(struct SwsContext *c, const uint8_t *const srcSlice[], 218 const int srcStride[], int srcSliceY, int srcSliceH, 219 uint8_t *const dst[], const int dstStride[]); 220 221 /** 222 * @param dstRange flag indicating the while-black range of the output (1=jpeg / 0=mpeg) 223 * @param srcRange flag indicating the while-black range of the input (1=jpeg / 0=mpeg) 224 * @param table the yuv2rgb coefficients describing the output yuv space, normally ff_yuv2rgb_coeffs[x] 225 * @param inv_table the yuv2rgb coefficients describing the input yuv space, normally ff_yuv2rgb_coeffs[x] 226 * @param brightness 16.16 fixed point brightness correction 227 * @param contrast 16.16 fixed point contrast correction 228 * @param saturation 16.16 fixed point saturation correction 229 * @return -1 if not supported 230 */ 231 int sws_setColorspaceDetails(struct SwsContext *c, const int inv_table[4], 232 int srcRange, const int table[4], int dstRange, 233 int brightness, int contrast, int saturation); 234 235 /** 236 * @return -1 if not supported 237 */ 238 int sws_getColorspaceDetails(struct SwsContext *c, int **inv_table, 239 int *srcRange, int **table, int *dstRange, 240 int *brightness, int *contrast, int *saturation); 241 242 /** 243 * Allocate and return an uninitialized vector with length coefficients. 244 */ 245 SwsVector *sws_allocVec(int length); 246 247 /** 248 * Return a normalized Gaussian curve used to filter stuff 249 * quality = 3 is high quality, lower is lower quality. 250 */ 251 SwsVector *sws_getGaussianVec(double variance, double quality); 252 253 /** 254 * Scale all the coefficients of a by the scalar value. 255 */ 256 void sws_scaleVec(SwsVector *a, double scalar); 257 258 /** 259 * Scale all the coefficients of a so that their sum equals height. 260 */ 261 void sws_normalizeVec(SwsVector *a, double height); 262 263 #if FF_API_SWS_VECTOR 264 attribute_deprecated SwsVector *sws_getConstVec(double c, int length); 265 attribute_deprecated SwsVector *sws_getIdentityVec(void); 266 attribute_deprecated void sws_convVec(SwsVector *a, SwsVector *b); 267 attribute_deprecated void sws_addVec(SwsVector *a, SwsVector *b); 268 attribute_deprecated void sws_subVec(SwsVector *a, SwsVector *b); 269 attribute_deprecated void sws_shiftVec(SwsVector *a, int shift); 270 attribute_deprecated SwsVector *sws_cloneVec(SwsVector *a); 271 attribute_deprecated void sws_printVec2(SwsVector *a, AVClass *log_ctx, int log_level); 272 #endif 273 274 void sws_freeVec(SwsVector *a); 275 276 SwsFilter *sws_getDefaultFilter(float lumaGBlur, float chromaGBlur, 277 float lumaSharpen, float chromaSharpen, 278 float chromaHShift, float chromaVShift, 279 int verbose); 280 void sws_freeFilter(SwsFilter *filter); 281 282 /** 283 * Check if context can be reused, otherwise reallocate a new one. 284 * 285 * If context is NULL, just calls sws_getContext() to get a new 286 * context. Otherwise, checks if the parameters are the ones already 287 * saved in context. If that is the case, returns the current 288 * context. Otherwise, frees context and gets a new context with 289 * the new parameters. 290 * 291 * Be warned that srcFilter and dstFilter are not checked, they 292 * are assumed to remain the same. 293 */ 294 struct SwsContext *sws_getCachedContext(struct SwsContext *context, 295 int srcW, int srcH, enum AVPixelFormat srcFormat, 296 int dstW, int dstH, enum AVPixelFormat dstFormat, 297 int flags, SwsFilter *srcFilter, 298 SwsFilter *dstFilter, const double *param); 299 300 /** 301 * Convert an 8-bit paletted frame into a frame with a color depth of 32 bits. 302 * 303 * The output frame will have the same packed format as the palette. 304 * 305 * @param src source frame buffer 306 * @param dst destination frame buffer 307 * @param num_pixels number of pixels to convert 308 * @param palette array with [256] entries, which must match color arrangement (RGB or BGR) of src 309 */ 310 void sws_convertPalette8ToPacked32(const uint8_t *src, uint8_t *dst, int num_pixels, const uint8_t *palette); 311 312 /** 313 * Convert an 8-bit paletted frame into a frame with a color depth of 24 bits. 314 * 315 * With the palette format "ABCD", the destination frame ends up with the format "ABC". 316 * 317 * @param src source frame buffer 318 * @param dst destination frame buffer 319 * @param num_pixels number of pixels to convert 320 * @param palette array with [256] entries, which must match color arrangement (RGB or BGR) of src 321 */ 322 void sws_convertPalette8ToPacked24(const uint8_t *src, uint8_t *dst, int num_pixels, const uint8_t *palette); 323 324 /** 325 * Get the AVClass for swsContext. It can be used in combination with 326 * AV_OPT_SEARCH_FAKE_OBJ for examining options. 327 * 328 * @see av_opt_find(). 329 */ 330 const AVClass *sws_get_class(void); 331 332 /** 333 * @} 334 */ 335 336 #endif /* SWSCALE_SWSCALE_H */ 337