avresample.h 21 KB
Newer Older
Justin Ruggles's avatar
Justin Ruggles committed
1 2 3
/*
 * Copyright (c) 2012 Justin Ruggles <justin.ruggles@gmail.com>
 *
4
 * This file is part of FFmpeg.
Justin Ruggles's avatar
Justin Ruggles committed
5
 *
6
 * FFmpeg is free software; you can redistribute it and/or
Justin Ruggles's avatar
Justin Ruggles committed
7 8 9 10
 * 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.
 *
11
 * FFmpeg is distributed in the hope that it will be useful,
Justin Ruggles's avatar
Justin Ruggles committed
12 13 14 15 16
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
17
 * License along with FFmpeg; if not, write to the Free Software
Justin Ruggles's avatar
Justin Ruggles committed
18 19 20 21 22 23 24 25
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#ifndef AVRESAMPLE_AVRESAMPLE_H
#define AVRESAMPLE_AVRESAMPLE_H

/**
 * @file
26
 * @ingroup lavr
Justin Ruggles's avatar
Justin Ruggles committed
27 28 29
 * external API header
 */

30
/**
31
 * @defgroup lavr libavresample
32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51
 * @{
 *
 * Libavresample (lavr) is a library that handles audio resampling, sample
 * format conversion and mixing.
 *
 * Interaction with lavr is done through AVAudioResampleContext, which is
 * allocated with avresample_alloc_context(). It is opaque, so all parameters
 * must be set with the @ref avoptions API.
 *
 * For example the following code will setup conversion from planar float sample
 * format to interleaved signed 16-bit integer, downsampling from 48kHz to
 * 44.1kHz and downmixing from 5.1 channels to stereo (using the default mixing
 * matrix):
 * @code
 * AVAudioResampleContext *avr = avresample_alloc_context();
 * av_opt_set_int(avr, "in_channel_layout",  AV_CH_LAYOUT_5POINT1, 0);
 * av_opt_set_int(avr, "out_channel_layout", AV_CH_LAYOUT_STEREO,  0);
 * av_opt_set_int(avr, "in_sample_rate",     48000,                0);
 * av_opt_set_int(avr, "out_sample_rate",    44100,                0);
 * av_opt_set_int(avr, "in_sample_fmt",      AV_SAMPLE_FMT_FLTP,   0);
52
 * av_opt_set_int(avr, "out_sample_fmt",     AV_SAMPLE_FMT_S16,    0);
53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78
 * @endcode
 *
 * Once the context is initialized, it must be opened with avresample_open(). If
 * you need to change the conversion parameters, you must close the context with
 * avresample_close(), change the parameters as described above, then reopen it
 * again.
 *
 * The conversion itself is done by repeatedly calling avresample_convert().
 * Note that the samples may get buffered in two places in lavr. The first one
 * is the output FIFO, where the samples end up if the output buffer is not
 * large enough. The data stored in there may be retrieved at any time with
 * avresample_read(). The second place is the resampling delay buffer,
 * applicable only when resampling is done. The samples in it require more input
 * before they can be processed. Their current amount is returned by
 * avresample_get_delay(). At the end of conversion the resampling buffer can be
 * flushed by calling avresample_convert() with NULL input.
 *
 * The following code demonstrates the conversion loop assuming the parameters
 * from above and caller-defined functions get_input() and handle_output():
 * @code
 * uint8_t **input;
 * int in_linesize, in_samples;
 *
 * while (get_input(&input, &in_linesize, &in_samples)) {
 *     uint8_t *output
 *     int out_linesize;
79 80
 *     int out_samples = avresample_get_out_samples(avr, in_samples);
 *
81 82 83 84 85 86 87 88 89 90 91 92 93 94
 *     av_samples_alloc(&output, &out_linesize, 2, out_samples,
 *                      AV_SAMPLE_FMT_S16, 0);
 *     out_samples = avresample_convert(avr, &output, out_linesize, out_samples,
 *                                      input, in_linesize, in_samples);
 *     handle_output(output, out_linesize, out_samples);
 *     av_freep(&output);
 *  }
 *  @endcode
 *
 *  When the conversion is finished and the FIFOs are flushed if required, the
 *  conversion context and everything associated with it must be freed with
 *  avresample_free().
 */

Justin Ruggles's avatar
Justin Ruggles committed
95
#include "libavutil/avutil.h"
96
#include "libavutil/channel_layout.h"
Justin Ruggles's avatar
Justin Ruggles committed
97
#include "libavutil/dict.h"
98
#include "libavutil/frame.h"
Justin Ruggles's avatar
Justin Ruggles committed
99
#include "libavutil/log.h"
100
#include "libavutil/mathematics.h"
Justin Ruggles's avatar
Justin Ruggles committed
101 102 103 104 105

#include "libavresample/version.h"

#define AVRESAMPLE_MAX_CHANNELS 32

106
typedef struct AVAudioResampleContext AVAudioResampleContext;
Justin Ruggles's avatar
Justin Ruggles committed
107

108 109 110 111 112
/**
 * @deprecated use libswresample
 *
 * Mixing Coefficient Types */
enum attribute_deprecated AVMixCoeffType {
113
    AV_MIX_COEFF_TYPE_Q8,   /** 16-bit 8.8 fixed-point                      */
Justin Ruggles's avatar
Justin Ruggles committed
114 115 116 117 118
    AV_MIX_COEFF_TYPE_Q15,  /** 32-bit 17.15 fixed-point                    */
    AV_MIX_COEFF_TYPE_FLT,  /** floating-point                              */
    AV_MIX_COEFF_TYPE_NB,   /** Number of coeff types. Not part of ABI      */
};

119 120 121 122 123
/**
 * @deprecated use libswresample
 *
 * Resampling Filter Types */
enum attribute_deprecated AVResampleFilterType {
124 125 126 127 128
    AV_RESAMPLE_FILTER_TYPE_CUBIC,              /**< Cubic */
    AV_RESAMPLE_FILTER_TYPE_BLACKMAN_NUTTALL,   /**< Blackman Nuttall Windowed Sinc */
    AV_RESAMPLE_FILTER_TYPE_KAISER,             /**< Kaiser Windowed Sinc */
};

129 130 131 132
/**
 * @deprecated use libswresample
 */
enum attribute_deprecated AVResampleDitherMethod {
133 134 135 136 137 138 139 140
    AV_RESAMPLE_DITHER_NONE,            /**< Do not use dithering */
    AV_RESAMPLE_DITHER_RECTANGULAR,     /**< Rectangular Dither */
    AV_RESAMPLE_DITHER_TRIANGULAR,      /**< Triangular Dither*/
    AV_RESAMPLE_DITHER_TRIANGULAR_HP,   /**< Triangular Dither with High Pass */
    AV_RESAMPLE_DITHER_TRIANGULAR_NS,   /**< Triangular Dither with Noise Shaping */
    AV_RESAMPLE_DITHER_NB,              /**< Number of dither types. Not part of ABI. */
};

Justin Ruggles's avatar
Justin Ruggles committed
141
/**
142 143 144
 *
 * @deprecated use libswresample
 *
Justin Ruggles's avatar
Justin Ruggles committed
145 146
 * Return the LIBAVRESAMPLE_VERSION_INT constant.
 */
147
attribute_deprecated
Justin Ruggles's avatar
Justin Ruggles committed
148 149 150
unsigned avresample_version(void);

/**
151 152 153
 *
 * @deprecated use libswresample
 *
Justin Ruggles's avatar
Justin Ruggles committed
154 155 156
 * Return the libavresample build-time configuration.
 * @return  configure string
 */
157
attribute_deprecated
Justin Ruggles's avatar
Justin Ruggles committed
158 159 160
const char *avresample_configuration(void);

/**
161 162 163
 *
 * @deprecated use libswresample
 *
Justin Ruggles's avatar
Justin Ruggles committed
164 165
 * Return the libavresample license.
 */
166
attribute_deprecated
Justin Ruggles's avatar
Justin Ruggles committed
167 168 169
const char *avresample_license(void);

/**
170 171 172
 *
 * @deprecated use libswresample
 *
Justin Ruggles's avatar
Justin Ruggles committed
173 174 175 176 177 178 179 180 181
 * Get the AVClass for AVAudioResampleContext.
 *
 * Can be used in combination with AV_OPT_SEARCH_FAKE_OBJ for examining options
 * without allocating a context.
 *
 * @see av_opt_find().
 *
 * @return AVClass for AVAudioResampleContext
 */
182
attribute_deprecated
Justin Ruggles's avatar
Justin Ruggles committed
183 184 185
const AVClass *avresample_get_class(void);

/**
186 187 188
 *
 * @deprecated use libswresample
 *
Justin Ruggles's avatar
Justin Ruggles committed
189 190 191 192
 * Allocate AVAudioResampleContext and set options.
 *
 * @return  allocated audio resample context, or NULL on failure
 */
193
attribute_deprecated
Justin Ruggles's avatar
Justin Ruggles committed
194 195 196
AVAudioResampleContext *avresample_alloc_context(void);

/**
197 198 199
 *
 * @deprecated use libswresample
 *
Justin Ruggles's avatar
Justin Ruggles committed
200
 * Initialize AVAudioResampleContext.
201
 * @note The context must be configured using the AVOption API.
202 203 204
 * @note The fields "in_channel_layout", "out_channel_layout",
 *       "in_sample_rate", "out_sample_rate", "in_sample_fmt",
 *       "out_sample_fmt" must be set.
205 206 207
 *
 * @see av_opt_set_int()
 * @see av_opt_set_dict()
208
 * @see av_get_default_channel_layout()
Justin Ruggles's avatar
Justin Ruggles committed
209 210 211 212
 *
 * @param avr  audio resample context
 * @return     0 on success, negative AVERROR code on failure
 */
213
attribute_deprecated
Justin Ruggles's avatar
Justin Ruggles committed
214 215
int avresample_open(AVAudioResampleContext *avr);

216
/**
217 218 219
 *
 * @deprecated use libswresample
 *
220 221 222 223 224
 * Check whether an AVAudioResampleContext is open or closed.
 *
 * @param avr AVAudioResampleContext to check
 * @return 1 if avr is open, 0 if avr is closed.
 */
225
attribute_deprecated
226 227
int avresample_is_open(AVAudioResampleContext *avr);

Justin Ruggles's avatar
Justin Ruggles committed
228
/**
229 230 231
 *
 * @deprecated use libswresample
 *
Justin Ruggles's avatar
Justin Ruggles committed
232 233 234 235 236 237 238 239 240 241 242 243
 * Close AVAudioResampleContext.
 *
 * This closes the context, but it does not change the parameters. The context
 * can be reopened with avresample_open(). It does, however, clear the output
 * FIFO and any remaining leftover samples in the resampling delay buffer. If
 * there was a custom matrix being used, that is also cleared.
 *
 * @see avresample_convert()
 * @see avresample_set_matrix()
 *
 * @param avr  audio resample context
 */
244
attribute_deprecated
Justin Ruggles's avatar
Justin Ruggles committed
245 246 247
void avresample_close(AVAudioResampleContext *avr);

/**
248 249 250
 *
 * @deprecated use libswresample
 *
Justin Ruggles's avatar
Justin Ruggles committed
251 252 253 254 255 256
 * Free AVAudioResampleContext and associated AVOption values.
 *
 * This also calls avresample_close() before freeing.
 *
 * @param avr  audio resample context
 */
257
attribute_deprecated
Justin Ruggles's avatar
Justin Ruggles committed
258 259 260
void avresample_free(AVAudioResampleContext **avr);

/**
261 262 263
 *
 * @deprecated use libswresample
 *
Justin Ruggles's avatar
Justin Ruggles committed
264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281
 * Generate a channel mixing matrix.
 *
 * This function is the one used internally by libavresample for building the
 * default mixing matrix. It is made public just as a utility function for
 * building custom matrices.
 *
 * @param in_layout           input channel layout
 * @param out_layout          output channel layout
 * @param center_mix_level    mix level for the center channel
 * @param surround_mix_level  mix level for the surround channel(s)
 * @param lfe_mix_level       mix level for the low-frequency effects channel
 * @param normalize           if 1, coefficients will be normalized to prevent
 *                            overflow. if 0, coefficients will not be
 *                            normalized.
 * @param[out] matrix         mixing coefficients; matrix[i + stride * o] is
 *                            the weight of input channel i in output channel o.
 * @param stride              distance between adjacent input channels in the
 *                            matrix array
282
 * @param matrix_encoding     matrixed stereo downmix mode (e.g. dplii)
Justin Ruggles's avatar
Justin Ruggles committed
283 284
 * @return                    0 on success, negative AVERROR code on failure
 */
285
attribute_deprecated
Justin Ruggles's avatar
Justin Ruggles committed
286 287 288
int avresample_build_matrix(uint64_t in_layout, uint64_t out_layout,
                            double center_mix_level, double surround_mix_level,
                            double lfe_mix_level, int normalize, double *matrix,
289
                            int stride, enum AVMatrixEncoding matrix_encoding);
Justin Ruggles's avatar
Justin Ruggles committed
290 291

/**
292 293 294
 *
 * @deprecated use libswresample
 *
Justin Ruggles's avatar
Justin Ruggles committed
295 296
 * Get the current channel mixing matrix.
 *
297 298 299
 * If no custom matrix has been previously set or the AVAudioResampleContext is
 * not open, an error is returned.
 *
Justin Ruggles's avatar
Justin Ruggles committed
300 301 302 303 304 305
 * @param avr     audio resample context
 * @param matrix  mixing coefficients; matrix[i + stride * o] is the weight of
 *                input channel i in output channel o.
 * @param stride  distance between adjacent input channels in the matrix array
 * @return        0 on success, negative AVERROR code on failure
 */
306
attribute_deprecated
Justin Ruggles's avatar
Justin Ruggles committed
307 308 309 310
int avresample_get_matrix(AVAudioResampleContext *avr, double *matrix,
                          int stride);

/**
311 312 313
 *
 * @deprecated use libswresample
 *
Justin Ruggles's avatar
Justin Ruggles committed
314 315 316 317 318
 * Set channel mixing matrix.
 *
 * Allows for setting a custom mixing matrix, overriding the default matrix
 * generated internally during avresample_open(). This function can be called
 * anytime on an allocated context, either before or after calling
319 320
 * avresample_open(), as long as the channel layouts have been set.
 * avresample_convert() always uses the current matrix.
Justin Ruggles's avatar
Justin Ruggles committed
321 322 323 324 325 326 327 328 329 330
 * Calling avresample_close() on the context will clear the current matrix.
 *
 * @see avresample_close()
 *
 * @param avr     audio resample context
 * @param matrix  mixing coefficients; matrix[i + stride * o] is the weight of
 *                input channel i in output channel o.
 * @param stride  distance between adjacent input channels in the matrix array
 * @return        0 on success, negative AVERROR code on failure
 */
331
attribute_deprecated
Justin Ruggles's avatar
Justin Ruggles committed
332 333 334
int avresample_set_matrix(AVAudioResampleContext *avr, const double *matrix,
                          int stride);

335
/**
336 337 338
 *
 * @deprecated use libswresample
 *
339 340 341 342 343 344 345 346 347 348 349 350 351
 * Set a customized input channel mapping.
 *
 * This function can only be called when the allocated context is not open.
 * Also, the input channel layout must have already been set.
 *
 * Calling avresample_close() on the context will clear the channel mapping.
 *
 * The map for each input channel specifies the channel index in the source to
 * use for that particular channel, or -1 to mute the channel. Source channels
 * can be duplicated by using the same index for multiple input channels.
 *
 * Examples:
 *
352
 * Reordering 5.1 AAC order (C,L,R,Ls,Rs,LFE) to FFmpeg order (L,R,C,LFE,Ls,Rs):
353 354 355 356 357 358 359 360 361 362 363 364
 * { 1, 2, 0, 5, 3, 4 }
 *
 * Muting the 3rd channel in 4-channel input:
 * { 0, 1, -1, 3 }
 *
 * Duplicating the left channel of stereo input:
 * { 0, 0 }
 *
 * @param avr         audio resample context
 * @param channel_map customized input channel mapping
 * @return            0 on success, negative AVERROR code on failure
 */
365
attribute_deprecated
366 367 368
int avresample_set_channel_mapping(AVAudioResampleContext *avr,
                                   const int *channel_map);

Justin Ruggles's avatar
Justin Ruggles committed
369
/**
370 371 372
 *
 * @deprecated use libswresample
 *
Justin Ruggles's avatar
Justin Ruggles committed
373 374
 * Set compensation for resampling.
 *
375 376 377 378
 * This can be called anytime after avresample_open(). If resampling is not
 * automatically enabled because of a sample rate conversion, the
 * "force_resampling" option must have been set to 1 when opening the context
 * in order to use resampling compensation.
Justin Ruggles's avatar
Justin Ruggles committed
379 380 381 382 383 384
 *
 * @param avr                    audio resample context
 * @param sample_delta           compensation delta, in samples
 * @param compensation_distance  compensation distance, in samples
 * @return                       0 on success, negative AVERROR code on failure
 */
385
attribute_deprecated
Justin Ruggles's avatar
Justin Ruggles committed
386 387 388
int avresample_set_compensation(AVAudioResampleContext *avr, int sample_delta,
                                int compensation_distance);

389
/**
390 391 392
 *
 * @deprecated use libswresample
 *
393 394 395 396 397 398 399 400 401
 * Provide the upper bound on the number of samples the configured
 * conversion would output.
 *
 * @param avr           audio resample context
 * @param in_nb_samples number of input samples
 *
 * @return              number of samples or AVERROR(EINVAL) if the value
 *                      would exceed INT_MAX
 */
402
attribute_deprecated
403 404
int avresample_get_out_samples(AVAudioResampleContext *avr, int in_nb_samples);

Justin Ruggles's avatar
Justin Ruggles committed
405
/**
406 407 408
 *
 * @deprecated use libswresample
 *
Justin Ruggles's avatar
Justin Ruggles committed
409 410
 * Convert input samples and write them to the output FIFO.
 *
411 412
 * The upper bound on the number of output samples can be obtained through
 * avresample_get_out_samples().
413
 *
Justin Ruggles's avatar
Justin Ruggles committed
414 415 416 417 418 419 420 421 422 423 424 425 426 427 428
 * The output data can be NULL or have fewer allocated samples than required.
 * In this case, any remaining samples not written to the output will be added
 * to an internal FIFO buffer, to be returned at the next call to this function
 * or to avresample_read().
 *
 * If converting sample rate, there may be data remaining in the internal
 * resampling delay buffer. avresample_get_delay() tells the number of remaining
 * samples. To get this data as output, call avresample_convert() with NULL
 * input.
 *
 * At the end of the conversion process, there may be data remaining in the
 * internal FIFO buffer. avresample_available() tells the number of remaining
 * samples. To get this data as output, either call avresample_convert() with
 * NULL input or call avresample_read().
 *
429
 * @see avresample_get_out_samples()
Justin Ruggles's avatar
Justin Ruggles committed
430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449
 * @see avresample_read()
 * @see avresample_get_delay()
 *
 * @param avr             audio resample context
 * @param output          output data pointers
 * @param out_plane_size  output plane size, in bytes.
 *                        This can be 0 if unknown, but that will lead to
 *                        optimized functions not being used directly on the
 *                        output, which could slow down some conversions.
 * @param out_samples     maximum number of samples that the output buffer can hold
 * @param input           input data pointers
 * @param in_plane_size   input plane size, in bytes
 *                        This can be 0 if unknown, but that will lead to
 *                        optimized functions not being used directly on the
 *                        input, which could slow down some conversions.
 * @param in_samples      number of input samples to convert
 * @return                number of samples written to the output buffer,
 *                        not including converted samples added to the internal
 *                        output FIFO
 */
450
attribute_deprecated
451
int avresample_convert(AVAudioResampleContext *avr, uint8_t **output,
452 453 454
                       int out_plane_size, int out_samples,
                       uint8_t * const *input, int in_plane_size,
                       int in_samples);
Justin Ruggles's avatar
Justin Ruggles committed
455 456

/**
457 458 459
 *
 * @deprecated use libswresample
 *
Justin Ruggles's avatar
Justin Ruggles committed
460 461 462 463 464 465 466 467 468 469 470 471
 * Return the number of samples currently in the resampling delay buffer.
 *
 * When resampling, there may be a delay between the input and output. Any
 * unconverted samples in each call are stored internally in a delay buffer.
 * This function allows the user to determine the current number of samples in
 * the delay buffer, which can be useful for synchronization.
 *
 * @see avresample_convert()
 *
 * @param avr  audio resample context
 * @return     number of samples currently in the resampling delay buffer
 */
472
attribute_deprecated
Justin Ruggles's avatar
Justin Ruggles committed
473 474 475
int avresample_get_delay(AVAudioResampleContext *avr);

/**
476 477 478
 *
 * @deprecated use libswresample
 *
Justin Ruggles's avatar
Justin Ruggles committed
479 480 481 482 483 484 485 486 487 488 489 490 491 492
 * Return the number of available samples in the output FIFO.
 *
 * During conversion, if the user does not specify an output buffer or
 * specifies an output buffer that is smaller than what is needed, remaining
 * samples that are not written to the output are stored to an internal FIFO
 * buffer. The samples in the FIFO can be read with avresample_read() or
 * avresample_convert().
 *
 * @see avresample_read()
 * @see avresample_convert()
 *
 * @param avr  audio resample context
 * @return     number of samples available for reading
 */
493
attribute_deprecated
Justin Ruggles's avatar
Justin Ruggles committed
494 495 496
int avresample_available(AVAudioResampleContext *avr);

/**
497 498 499
 *
 * @deprecated use libswresample
 *
Justin Ruggles's avatar
Justin Ruggles committed
500 501 502 503 504 505 506 507 508 509 510
 * Read samples from the output FIFO.
 *
 * During conversion, if the user does not specify an output buffer or
 * specifies an output buffer that is smaller than what is needed, remaining
 * samples that are not written to the output are stored to an internal FIFO
 * buffer. This function can be used to read samples from that internal FIFO.
 *
 * @see avresample_available()
 * @see avresample_convert()
 *
 * @param avr         audio resample context
511 512
 * @param output      output data pointers. May be NULL, in which case
 *                    nb_samples of data is discarded from output FIFO.
Justin Ruggles's avatar
Justin Ruggles committed
513 514 515
 * @param nb_samples  number of samples to read from the FIFO
 * @return            the number of samples written to output
 */
516
attribute_deprecated
517
int avresample_read(AVAudioResampleContext *avr, uint8_t **output, int nb_samples);
Justin Ruggles's avatar
Justin Ruggles committed
518

519
/**
520 521 522
 *
 * @deprecated use libswresample
 *
523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565
 * Convert the samples in the input AVFrame and write them to the output AVFrame.
 *
 * Input and output AVFrames must have channel_layout, sample_rate and format set.
 *
 * The upper bound on the number of output samples is obtained through
 * avresample_get_out_samples().
 *
 * If the output AVFrame does not have the data pointers allocated the nb_samples
 * field will be set using avresample_get_out_samples() and av_frame_get_buffer()
 * is called to allocate the frame.
 *
 * The output AVFrame can be NULL or have fewer allocated samples than required.
 * In this case, any remaining samples not written to the output will be added
 * to an internal FIFO buffer, to be returned at the next call to this function
 * or to avresample_convert() or to avresample_read().
 *
 * If converting sample rate, there may be data remaining in the internal
 * resampling delay buffer. avresample_get_delay() tells the number of
 * remaining samples. To get this data as output, call this function or
 * avresample_convert() with NULL input.
 *
 * At the end of the conversion process, there may be data remaining in the
 * internal FIFO buffer. avresample_available() tells the number of remaining
 * samples. To get this data as output, either call this function or
 * avresample_convert() with NULL input or call avresample_read().
 *
 * If the AVAudioResampleContext configuration does not match the output and
 * input AVFrame settings the conversion does not take place and depending on
 * which AVFrame is not matching AVERROR_OUTPUT_CHANGED, AVERROR_INPUT_CHANGED
 * or AVERROR_OUTPUT_CHANGED|AVERROR_INPUT_CHANGED is returned.
 *
 * @see avresample_get_out_samples()
 * @see avresample_available()
 * @see avresample_convert()
 * @see avresample_read()
 * @see avresample_get_delay()
 *
 * @param avr             audio resample context
 * @param output          output AVFrame
 * @param input           input AVFrame
 * @return                0 on success, AVERROR on failure or nonmatching
 *                        configuration.
 */
566
attribute_deprecated
567 568 569 570
int avresample_convert_frame(AVAudioResampleContext *avr,
                             AVFrame *output, AVFrame *input);

/**
571 572 573
 *
 * @deprecated use libswresample
 *
574 575 576 577 578 579 580 581 582 583
 * Configure or reconfigure the AVAudioResampleContext using the information
 * provided by the AVFrames.
 *
 * The original resampling context is reset even on failure.
 * The function calls avresample_close() internally if the context is open.
 *
 * @see avresample_open();
 * @see avresample_close();
 *
 * @param avr             audio resample context
584 585
 * @param out             output AVFrame
 * @param in              input AVFrame
586 587
 * @return                0 on success, AVERROR on failure.
 */
588
attribute_deprecated
589 590
int avresample_config(AVAudioResampleContext *avr, AVFrame *out, AVFrame *in);

591 592 593 594
/**
 * @}
 */

Justin Ruggles's avatar
Justin Ruggles committed
595
#endif /* AVRESAMPLE_AVRESAMPLE_H */