virtualenv/FFmpeg
1
0
Fork 0
mirror of https://github.com/FFmpeg/FFmpeg.git synced 2024-11-21 10:55:51 +02:00
Code Issues Releases Activity

doxygen: Consistently use '@' instead of '\' for Doxygen markup.

Browse Source 
Signed-off-by: Diego Biurrun <diego@biurrun.de>
This commit is contained in:
Diego Biurrun 2011-06-23 22:41:54 +02:00
parent 9abbe8cc13
commit adbfc605f6
38 changed files with 259 additions and 259 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

74
libavcodec/acelp_pitch_delay.h
View File

@ -30,11 +30,11 @@
#define PITCH_DELAY_MAX 143
/**
* \brief Decode pitch delay of the first subframe encoded by 8 bits with 1/3
* @brief Decode pitch delay of the first subframe encoded by 8 bits with 1/3
* resolution.
* \param ac_index adaptive codebook index (8 bits)
* @param ac_index adaptive codebook index (8 bits)
*
* \return pitch delay in 1/3 units
* @return pitch delay in 1/3 units
*
* Pitch delay is coded:
* with 1/3 resolution, 19 < pitch_delay < 85
@ -43,18 +43,18 @@
int ff_acelp_decode_8bit_to_1st_delay3(int ac_index);
/**
* \brief Decode pitch delay of the second subframe encoded by 5 or 6 bits
* @brief Decode pitch delay of the second subframe encoded by 5 or 6 bits
* with 1/3 precision.
* \param ac_index adaptive codebook index (5 or 6 bits)
* \param pitch_delay_min lower bound (integer) of pitch delay interval
* @param ac_index adaptive codebook index (5 or 6 bits)
* @param pitch_delay_min lower bound (integer) of pitch delay interval
* for second subframe
*
* \return pitch delay in 1/3 units
* @return pitch delay in 1/3 units
*
* Pitch delay is coded:
* with 1/3 resolution, -6 < pitch_delay - int(prev_pitch_delay) < 5
*
* \remark The routine is used in G.729 @@8k, AMR @@10.2k, AMR @@7.95k,
* @remark The routine is used in G.729 @@8k, AMR @@10.2k, AMR @@7.95k,
* AMR @@7.4k for the second subframe.
*/
int ff_acelp_decode_5_6_bit_to_2nd_delay3(
@ -62,19 +62,19 @@ int ff_acelp_decode_5_6_bit_to_2nd_delay3(
int pitch_delay_min);
/**
* \brief Decode pitch delay with 1/3 precision.
* \param ac_index adaptive codebook index (4 bits)
* \param pitch_delay_min lower bound (integer) of pitch delay interval for
* @brief Decode pitch delay with 1/3 precision.
* @param ac_index adaptive codebook index (4 bits)
* @param pitch_delay_min lower bound (integer) of pitch delay interval for
* second subframe
*
* \return pitch delay in 1/3 units
* @return pitch delay in 1/3 units
*
* Pitch delay is coded:
* integers only, -6 < pitch_delay - int(prev_pitch_delay) <= -2
* with 1/3 resolution, -2 < pitch_delay - int(prev_pitch_delay) < 1
* integers only, 1 <= pitch_delay - int(prev_pitch_delay) < 5
*
* \remark The routine is used in G.729 @@6.4k, AMR @@6.7k, AMR @@5.9k,
* @remark The routine is used in G.729 @@6.4k, AMR @@6.7k, AMR @@5.9k,
* AMR @@5.15k, AMR @@4.75k for the second subframe.
*/
int ff_acelp_decode_4bit_to_2nd_delay3(
@ -82,44 +82,44 @@ int ff_acelp_decode_4bit_to_2nd_delay3(
int pitch_delay_min);
/**
* \brief Decode pitch delay of the first subframe encoded by 9 bits
* @brief Decode pitch delay of the first subframe encoded by 9 bits
* with 1/6 precision.
* \param ac_index adaptive codebook index (9 bits)
* @param ac_index adaptive codebook index (9 bits)
*
* \return pitch delay in 1/6 units
* @return pitch delay in 1/6 units
*
* Pitch delay is coded:
* with 1/6 resolution, 17 < pitch_delay < 95
* integers only, 95 <= pitch_delay <= 143
*
* \remark The routine is used in AMR @@12.2k for the first and third subframes.
* @remark The routine is used in AMR @@12.2k for the first and third subframes.
*/
int ff_acelp_decode_9bit_to_1st_delay6(int ac_index);
/**
* \brief Decode pitch delay of the second subframe encoded by 6 bits
* @brief Decode pitch delay of the second subframe encoded by 6 bits
* with 1/6 precision.
* \param ac_index adaptive codebook index (6 bits)
* \param pitch_delay_min lower bound (integer) of pitch delay interval for
* @param ac_index adaptive codebook index (6 bits)
* @param pitch_delay_min lower bound (integer) of pitch delay interval for
* second subframe
*
* \return pitch delay in 1/6 units
* @return pitch delay in 1/6 units
*
* Pitch delay is coded:
* with 1/6 resolution, -6 < pitch_delay - int(prev_pitch_delay) < 5
*
* \remark The routine is used in AMR @@12.2k for the second and fourth subframes.
* @remark The routine is used in AMR @@12.2k for the second and fourth subframes.
*/
int ff_acelp_decode_6bit_to_2nd_delay6(
int ac_index,
int pitch_delay_min);
/**
* \brief Update past quantized energies
* \param[in,out] quant_energy past quantized energies (5.10)
* \param gain_corr_factor gain correction factor
* \param log2_ma_pred_order log2() of MA prediction order
* \param erasure frame erasure flag
* @brief Update past quantized energies
* @param[in,out] quant_energy past quantized energies (5.10)
* @param gain_corr_factor gain correction factor
* @param log2_ma_pred_order log2() of MA prediction order
* @param erasure frame erasure flag
*
* If frame erasure flag is not equal to zero, memory is updated with
* averaged energy, attenuated by 4dB:
@ -128,7 +128,7 @@ int ff_acelp_decode_6bit_to_2nd_delay6(
* In normal mode memory is updated with
* Er - Ep = 20 * log10(gain_corr_factor)
*
* \remark The routine is used in G.729 and AMR (all modes).
* @remark The routine is used in G.729 and AMR (all modes).
*/
void ff_acelp_update_past_gain(
int16_t* quant_energy,
@ -137,16 +137,16 @@ void ff_acelp_update_past_gain(
int erasure);
/**
* \brief Decode the adaptive codebook gain and add
* @brief Decode the adaptive codebook gain and add
* correction (4.1.5 and 3.9.1 of G.729).
* \param dsp initialized dsputil context
* \param gain_corr_factor gain correction factor (2.13)
* \param fc_v fixed-codebook vector (2.13)
* \param mr_energy mean innovation energy and fixed-point correction (7.13)
* \param[in,out] quant_energy past quantized energies (5.10)
* \param subframe_size length of subframe
* @param dsp initialized dsputil context
* @param gain_corr_factor gain correction factor (2.13)
* @param fc_v fixed-codebook vector (2.13)
* @param mr_energy mean innovation energy and fixed-point correction (7.13)
* @param[in,out] quant_energy past quantized energies (5.10)
* @param subframe_size length of subframe
*
* \return quantized fixed-codebook gain (14.1)
* @return quantized fixed-codebook gain (14.1)
*
* The routine implements equations 69, 66 and 71 of the G.729 specification (3.9.1)
*
@ -205,7 +205,7 @@ void ff_acelp_update_past_gain(
*
* mr_energy = Em + 10log(N) + 10log(2^26)
*
* \remark The routine is used in G.729 and AMR (all modes).
* @remark The routine is used in G.729 and AMR (all modes).
*/
int16_t ff_acelp_decode_gain_code(
DSPContext *dsp,

6
libavcodec/avcodec.h
View File

@ -3255,7 +3255,7 @@ void av_resample_close(struct AVResampleContext *c);
/**
* Allocate memory for a picture. Call avpicture_free() to free it.
*
* \see avpicture_fill()
* @see avpicture_fill()
*
* @param picture the picture to be filled in
* @param pix_fmt the format of the picture
@ -3302,7 +3302,7 @@ int avpicture_fill(AVPicture *picture, uint8_t *ptr,
* The data is stored compactly, without any gaps for alignment or padding
* which may be applied by avpicture_fill().
*
* \see avpicture_get_size()
* @see avpicture_get_size()
*
* @param[in] src AVPicture containing image data
* @param[in] pix_fmt The format in which the picture data is stored.
@ -3896,7 +3896,7 @@ typedef struct AVCodecParserContext {
int64_t offset; ///< byte offset from starting packet start
int64_t cur_frame_end[AV_PARSER_PTS_NB];
/*!
/**
* Set by parser to 1 for key frames and 0 for non-key frames.
* It is initialized to -1, so if the parser doesn't set this flag,
* old-style fallback using AV_PICTURE_TYPE_I picture type as key frames

2
libavcodec/celp_filters.h
View File

@ -34,7 +34,7 @@
*
* fc_out[n] = sum(i,0,len-1){ fc_in[i] * filter[(len + n - i)%len] }
*
* \note fc_in and fc_out should not overlap!
* @note fc_in and fc_out should not overlap!
*/
void ff_celp_convolve_circ(int16_t *fc_out, const int16_t *fc_in,
const int16_t *filter, int len);

2
libavcodec/fft.h
View File

@ -119,7 +119,7 @@ extern COSTABLE_CONST FFTSample* const FFT_NAME(ff_cos_tabs)[17];
/**
* Initialize the cosine table in ff_cos_tabs[index]
* \param index index in ff_cos_tabs array of the table to initialize
* @param index index in ff_cos_tabs array of the table to initialize
*/
void ff_init_ff_cos_tabs(int index);

2
libavcodec/g729dec.c
View File

@ -116,7 +116,7 @@ static const G729FormatDescription format_g729d_6k4 = {
};
/**
* \brief pseudo random number generator
* @brief pseudo random number generator
*/
static inline uint16_t g729_prng(uint16_t value)
{

2
libavcodec/h264_parser.c
View File

@ -97,7 +97,7 @@ found:
return i-(state&5);
}
/*!
/**
* Parse NAL units of found picture and decode some basic information.
*
* @param s parser context.

26
libavcodec/lagarith.c
View File

@ -32,25 +32,25 @@
#include "lagarithrac.h"
enum LagarithFrameType {
FRAME_RAW = 1, /*!< uncompressed */
FRAME_U_RGB24 = 2, /*!< unaligned RGB24 */
FRAME_ARITH_YUY2 = 3, /*!< arithmetic coded YUY2 */
FRAME_ARITH_RGB24 = 4, /*!< arithmetic coded RGB24 */
FRAME_SOLID_GRAY = 5, /*!< solid grayscale color frame */
FRAME_SOLID_COLOR = 6, /*!< solid non-grayscale color frame */
FRAME_OLD_ARITH_RGB = 7, /*!< obsolete arithmetic coded RGB (no longer encoded by upstream since version 1.1.0) */
FRAME_ARITH_RGBA = 8, /*!< arithmetic coded RGBA */
FRAME_SOLID_RGBA = 9, /*!< solid RGBA color frame */
FRAME_ARITH_YV12 = 10, /*!< arithmetic coded YV12 */
FRAME_REDUCED_RES = 11, /*!< reduced resolution YV12 frame */
FRAME_RAW = 1, /**< uncompressed */
FRAME_U_RGB24 = 2, /**< unaligned RGB24 */
FRAME_ARITH_YUY2 = 3, /**< arithmetic coded YUY2 */
FRAME_ARITH_RGB24 = 4, /**< arithmetic coded RGB24 */
FRAME_SOLID_GRAY = 5, /**< solid grayscale color frame */
FRAME_SOLID_COLOR = 6, /**< solid non-grayscale color frame */
FRAME_OLD_ARITH_RGB = 7, /**< obsolete arithmetic coded RGB (no longer encoded by upstream since version 1.1.0) */
FRAME_ARITH_RGBA = 8, /**< arithmetic coded RGBA */
FRAME_SOLID_RGBA = 9, /**< solid RGBA color frame */
FRAME_ARITH_YV12 = 10, /**< arithmetic coded YV12 */
FRAME_REDUCED_RES = 11, /**< reduced resolution YV12 frame */
};
typedef struct LagarithContext {
AVCodecContext *avctx;
AVFrame picture;
DSPContext dsp;
int zeros; /*!< number of consecutive zero bytes encountered */
int zeros_rem; /*!< number of zero bytes remaining to output */
int zeros; /**< number of consecutive zero bytes encountered */
int zeros_rem; /**< number of zero bytes remaining to output */
} LagarithContext;
/**

14
libavcodec/lagarithrac.h
View File

@ -40,15 +40,15 @@ typedef struct lag_rac {
AVCodecContext *avctx;
unsigned low;
unsigned range;
unsigned scale; /*!< Number of bits of precision in range. */
unsigned hash_shift; /*!< Number of bits to shift to calculate hash for radix search. */
unsigned scale; /**< Number of bits of precision in range. */
unsigned hash_shift; /**< Number of bits to shift to calculate hash for radix search. */
const uint8_t *bytestream_start; /*!< Start of input bytestream. */
const uint8_t *bytestream; /*!< Current position in input bytestream. */
const uint8_t *bytestream_end; /*!< End position of input bytestream. */
const uint8_t *bytestream_start; /**< Start of input bytestream. */
const uint8_t *bytestream; /**< Current position in input bytestream. */
const uint8_t *bytestream_end; /**< End position of input bytestream. */
uint32_t prob[258]; /*!< Table of cumulative probability for each symbol. */
uint8_t range_hash[256]; /*!< Hash table mapping upper byte to approximate symbol. */
uint32_t prob[258]; /**< Table of cumulative probability for each symbol. */
uint8_t range_hash[256]; /**< Hash table mapping upper byte to approximate symbol. */
} lag_rac;
void lag_rac_init(lag_rac *l, GetBitContext *gb, int length);

14
libavcodec/lcldec.c
View File

@ -73,8 +73,8 @@ typedef struct LclDecContext {
/**
* \param srcptr compressed source buffer, must be padded with at least 5 extra bytes
* \param destptr must be padded sufficiently for av_memcpy_backptr
* @param srcptr compressed source buffer, must be padded with at least 5 extra bytes
* @param destptr must be padded sufficiently for av_memcpy_backptr
*/
static unsigned int mszh_decomp(const unsigned char * srcptr, int srclen, unsigned char * destptr, unsigned int destsize)
{
@ -119,11 +119,11 @@ static unsigned int mszh_decomp(const unsigned char * srcptr, int srclen, unsign
#if CONFIG_ZLIB_DECODER
/**
* \brief decompress a zlib-compressed data block into decomp_buf
* \param src compressed input buffer
* \param src_len data length in input buffer
* \param offset offset in decomp_buf
* \param expected expected decompressed length
* @brief decompress a zlib-compressed data block into decomp_buf
* @param src compressed input buffer
* @param src_len data length in input buffer
* @param offset offset in decomp_buf
* @param expected expected decompressed length
*/
static int zlib_decomp(AVCodecContext *avctx, const uint8_t *src, int src_len, int offset, int expected)
{

6
libavcodec/lsp.c
View File

@ -74,9 +74,9 @@ void ff_acelp_lsf2lspd(double *lsp, const float *lsf, int lp_order)
}
/**
* \brief decodes polynomial coefficients from LSP
* \param f [out] decoded polynomial coefficients (-0x20000000 <= (3.22) <= 0x1fffffff)
* \param lsp LSP coefficients (-0x8000 <= (0.15) <= 0x7fff)
* @brief decodes polynomial coefficients from LSP
* @param f [out] decoded polynomial coefficients (-0x20000000 <= (3.22) <= 0x1fffffff)
* @param lsp LSP coefficients (-0x8000 <= (0.15) <= 0x7fff)
*/
static void lsp2poly(int* f, const int16_t* lsp, int lp_half_order)
{

42
libavcodec/lsp.h
View File

@ -30,12 +30,12 @@
*/
/**
* \brief ensure a minimum distance between LSFs
* \param[in,out] lsfq LSF to check and adjust
* \param lsfq_min_distance minimum distance between LSFs
* \param lsfq_min minimum allowed LSF value
* \param lsfq_max maximum allowed LSF value
* \param lp_order LP filter order
* @brief ensure a minimum distance between LSFs
* @param[in,out] lsfq LSF to check and adjust
* @param lsfq_min_distance minimum distance between LSFs
* @param lsfq_min minimum allowed LSF value
* @param lsfq_max maximum allowed LSF value
* @param lp_order LP filter order
*/
void ff_acelp_reorder_lsf(int16_t* lsfq, int lsfq_min_distance, int lsfq_min, int lsfq_max, int lp_order);
@ -53,12 +53,12 @@ void ff_acelp_reorder_lsf(int16_t* lsfq, int lsfq_min_distance, int lsfq_min, in
void ff_set_min_dist_lsf(float *lsf, double min_spacing, int size);
/**
* \brief Convert LSF to LSP
* \param[out] lsp LSP coefficients (-0x8000 <= (0.15) < 0x8000)
* \param lsf normalized LSF coefficients (0 <= (2.13) < 0x2000 * PI)
* \param lp_order LP filter order
* @brief Convert LSF to LSP
* @param[out] lsp LSP coefficients (-0x8000 <= (0.15) < 0x8000)
* @param lsf normalized LSF coefficients (0 <= (2.13) < 0x2000 * PI)
* @param lp_order LP filter order
*
* \remark It is safe to pass the same array into the lsf and lsp parameters.
* @remark It is safe to pass the same array into the lsf and lsp parameters.
*/
void ff_acelp_lsf2lsp(int16_t *lsp, const int16_t *lsf, int lp_order);
@ -68,10 +68,10 @@ void ff_acelp_lsf2lsp(int16_t *lsp, const int16_t *lsf, int lp_order);
void ff_acelp_lsf2lspd(double *lsp, const float *lsf, int lp_order);
/**
* \brief LSP to LP conversion (3.2.6 of G.729)
* \param[out] lp decoded LP coefficients (-0x8000 <= (3.12) < 0x8000)
* \param lsp LSP coefficients (-0x8000 <= (0.15) < 0x8000)
* \param lp_half_order LP filter order, divided by 2
* @brief LSP to LP conversion (3.2.6 of G.729)
* @param[out] lp decoded LP coefficients (-0x8000 <= (3.12) < 0x8000)
* @param lsp LSP coefficients (-0x8000 <= (0.15) < 0x8000)
* @param lp_half_order LP filter order, divided by 2
*/
void ff_acelp_lsp2lpc(int16_t* lp, const int16_t* lsp, int lp_half_order);
@ -81,12 +81,12 @@ void ff_acelp_lsp2lpc(int16_t* lp, const int16_t* lsp, int lp_half_order);
void ff_amrwb_lsp2lpc(const double *lsp, float *lp, int lp_order);
/**
* \brief Interpolate LSP for the first subframe and convert LSP -> LP for both subframes (3.2.5 and 3.2.6 of G.729)
* \param[out] lp_1st decoded LP coefficients for first subframe (-0x8000 <= (3.12) < 0x8000)
* \param[out] lp_2nd decoded LP coefficients for second subframe (-0x8000 <= (3.12) < 0x8000)
* \param lsp_2nd LSP coefficients of the second subframe (-0x8000 <= (0.15) < 0x8000)
* \param lsp_prev LSP coefficients from the second subframe of the previous frame (-0x8000 <= (0.15) < 0x8000)
* \param lp_order LP filter order
* @brief Interpolate LSP for the first subframe and convert LSP -> LP for both subframes (3.2.5 and 3.2.6 of G.729)
* @param[out] lp_1st decoded LP coefficients for first subframe (-0x8000 <= (3.12) < 0x8000)
* @param[out] lp_2nd decoded LP coefficients for second subframe (-0x8000 <= (3.12) < 0x8000)
* @param lsp_2nd LSP coefficients of the second subframe (-0x8000 <= (0.15) < 0x8000)
* @param lsp_prev LSP coefficients from the second subframe of the previous frame (-0x8000 <= (0.15) < 0x8000)
* @param lp_order LP filter order
*/
void ff_acelp_lp_decode(int16_t* lp_1st, int16_t* lp_2nd, const int16_t* lsp_2nd, const int16_t* lsp_prev, int lp_order);

2
libavcodec/motion_est.c
View File

@ -248,7 +248,7 @@ static int cmp_internal(MpegEncContext *s, const int x, const int y, const int s
}
}
/*! \brief compares a block (either a full macroblock or a partition thereof)
/** @brief compares a block (either a full macroblock or a partition thereof)
against a proposed motion-compensated prediction of that block
*/
static av_always_inline int cmp(MpegEncContext *s, const int x, const int y, const int subx, const int suby,

8
libavcodec/motion_est_template.c
View File

@ -990,8 +990,8 @@ static av_always_inline int diamond_search(MpegEncContext * s, int *best, int dm
return var_diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
}
/*!
\param P[10][2] a list of candidate mvs to check before starting the
/**
@param P[10][2] a list of candidate mvs to check before starting the
iterative search. If one of the candidates is close to the optimal mv, then
it takes fewer iterations. And it increases the chance that we find the
optimal mv.
@ -1001,12 +1001,12 @@ static av_always_inline int epzs_motion_search_internal(MpegEncContext * s, int
int ref_mv_scale, int flags, int size, int h)
{
MotionEstContext * const c= &s->me;
int best[2]={0, 0}; /*!< x and y coordinates of the best motion vector.
int best[2]={0, 0}; /**< x and y coordinates of the best motion vector.
i.e. the difference between the position of the
block currently being encoded and the position of
the block chosen to predict it from. */
int d; ///< the score (cmp + penalty) of any given mv
int dmin; /*!< the best value of d, i.e. the score
int dmin; /**< the best value of d, i.e. the score
corresponding to the mv stored in best[]. */
int map_generation;
int penalty_factor;

2
libavcodec/mpegvideo.h
View File

@ -154,7 +154,7 @@ typedef struct MotionEstContext{
uint32_t *score_map; ///< map to store the scores
int map_generation;
int pre_penalty_factor;
int penalty_factor; /*!< an estimate of the bits required to
int penalty_factor; /**< an estimate of the bits required to
code a given mv value, e.g. (1,0) takes
more bits than (0,0). We have to
estimate whether any reduction in

14
libavcodec/nuv.c
View File

@ -63,11 +63,11 @@ static const uint8_t fallback_cquant[] = {
};
/**
* \brief copy frame data from buffer to AVFrame, handling stride.
* \param f destination AVFrame
* \param src source buffer, does not use any line-stride
* \param width width of the video frame
* \param height height of the video frame
* @brief copy frame data from buffer to AVFrame, handling stride.
* @param f destination AVFrame
* @param src source buffer, does not use any line-stride
* @param width width of the video frame
* @param height height of the video frame
*/
static void copy_frame(AVFrame *f, const uint8_t *src,
int width, int height) {
@ -77,7 +77,7 @@ static void copy_frame(AVFrame *f, const uint8_t *src,
}
/**
* \brief extract quantization tables from codec data into our context
* @brief extract quantization tables from codec data into our context
*/
static int get_quant(AVCodecContext *avctx, NuvContext *c,
const uint8_t *buf, int size) {
@ -94,7 +94,7 @@ static int get_quant(AVCodecContext *avctx, NuvContext *c,
}
/**
* \brief set quantization tables from a quality value
* @brief set quantization tables from a quality value
*/
static void get_quant_quality(NuvContext *c, int quality) {
int i;

6
libavcodec/qcelpdata.h
View File

@ -74,9 +74,9 @@ typedef struct {
static const float qcelp_hammsinc_table[4] = { -0.006822, 0.041249, -0.143459, 0.588863};
typedef struct {
uint8_t index; /*!< index into the QCELPContext structure */
uint8_t bitpos; /*!< position of the lowest bit in the value's byte */
uint8_t bitlen; /*!< number of bits to read */
uint8_t index; /**< index into the QCELPContext structure */
uint8_t bitpos; /**< position of the lowest bit in the value's byte */
uint8_t bitlen; /**< number of bits to read */
} QCELPBitmap;
#define QCELP_OF(variable, bit, len) {offsetof(QCELPFrame, variable), bit, len}

8
libavcodec/qcelpdec.c
View File

@ -46,7 +46,7 @@
typedef enum
{
I_F_Q = -1, /*!< insufficient frame quality */
I_F_Q = -1, /**< insufficient frame quality */
SILENCE,
RATE_OCTAVE,
RATE_QUARTER,
@ -58,12 +58,12 @@ typedef struct
{
GetBitContext gb;
qcelp_packet_rate bitrate;
QCELPFrame frame; /*!< unpacked data frame */
QCELPFrame frame; /**< unpacked data frame */
uint8_t erasure_count;
uint8_t octave_count; /*!< count the consecutive RATE_OCTAVE frames */
uint8_t octave_count; /**< count the consecutive RATE_OCTAVE frames */
float prev_lspf[10];
float predictor_lspf[10];/*!< LSP predictor for RATE_OCTAVE and I_F_Q */
float predictor_lspf[10];/**< LSP predictor for RATE_OCTAVE and I_F_Q */
float pitch_synthesis_filter_mem[303];
float pitch_pre_filter_mem[303];
float rnd_fir_filter_mem[180];

38
libavcodec/rtjpeg.c
View File

@ -33,12 +33,12 @@
if (n) {skip_bits(gb, n);}
/**
* \brief read one block from stream
* \param gb contains stream data
* \param block where data is written to
* \param scan array containing the mapping stream address -> block position
* \param quant quantization factors
* \return 0 means the block is not coded, < 0 means an error occurred.
* @brief read one block from stream
* @param gb contains stream data
* @param block where data is written to
* @param scan array containing the mapping stream address -> block position
* @param quant quantization factors
* @return 0 means the block is not coded, < 0 means an error occurred.
*
* Note: GetBitContext is used to make the code simpler, since all data is
* aligned this could be done faster in a different way, e.g. as it is done
@ -96,13 +96,13 @@ static inline int get_block(GetBitContext *gb, DCTELEM *block, const uint8_t *sc
}
/**
* \brief decode one rtjpeg YUV420 frame
* \param c context, must be initialized via rtjpeg_decode_init
* \param f AVFrame to place decoded frame into. If parts of the frame
* @brief decode one rtjpeg YUV420 frame
* @param c context, must be initialized via rtjpeg_decode_init
* @param f AVFrame to place decoded frame into. If parts of the frame
* are not coded they are left unchanged, so consider initializing it
* \param buf buffer containing input data
* \param buf_size length of input data in bytes
* \return number of bytes consumed from the input buffer
* @param buf buffer containing input data
* @param buf_size length of input data in bytes
* @return number of bytes consumed from the input buffer
*/
int rtjpeg_decode_frame_yuv420(RTJpegContext *c, AVFrame *f,
const uint8_t *buf, int buf_size) {
@ -143,15 +143,15 @@ int rtjpeg_decode_frame_yuv420(RTJpegContext *c, AVFrame *f,
}
/**
* \brief initialize an RTJpegContext, may be called multiple times
* \param c context to initialize
* \param dsp specifies the idct to use for decoding
* \param width width of image, will be rounded down to the nearest multiple
* @brief initialize an RTJpegContext, may be called multiple times
* @param c context to initialize
* @param dsp specifies the idct to use for decoding
* @param width width of image, will be rounded down to the nearest multiple
* of 16 for decoding
* \param height height of image, will be rounded down to the nearest multiple
* @param height height of image, will be rounded down to the nearest multiple
* of 16 for decoding
* \param lquant luma quantization table to use
* \param cquant chroma quantization table to use
* @param lquant luma quantization table to use
* @param cquant chroma quantization table to use
*/
void rtjpeg_decode_init(RTJpegContext *c, DSPContext *dsp,
int width, int height,

2
libavcodec/tableprint.h
View File

@ -56,7 +56,7 @@ void write_##type##_2d_array(const void *arg, int len, int len2)\
}
/**
* \defgroup printfuncs Predefined functions for printing tables
* @defgroup printfuncs Predefined functions for printing tables
*
* \{
*/

8
libavcodec/twinvq.c
View File

@ -411,7 +411,7 @@ static inline float mulawinv(float y, float clip, float mu)
* a*b == 200 and the nearest integer is ill-defined, use a table to emulate
* the following broken float-based implementation used by the binary decoder:
*
* \code
* @code
* static int very_broken_op(int a, int b)
* {
* static float test; // Ugh, force gcc to do the division first...
@ -419,7 +419,7 @@ static inline float mulawinv(float y, float clip, float mu)
* test = a/400.;
* return b * test + 0.5;
* }
* \endcode
* @endcode
*
* @note if this function is replaced by just ROUNDED_DIV(a*b,400.), the stddev
* between the original file (before encoding with Yamaha encoder) and the
@ -938,14 +938,14 @@ static void permutate_in_line(int16_t *tab, int num_vect, int num_blocks,
/**
* Interpret the input data as in the following table:
*
* \verbatim
* @verbatim
*
* abcdefgh
* ijklmnop
* qrstuvw
* x123456
*
* \endverbatim
* @endverbatim
*
* and transpose it, giving the output
* aiqxbjr1cks2dlt3emu4fvn5gow6hp

2
libavcodec/vaapi.c
View File

@ -24,7 +24,7 @@
#include "vaapi_internal.h"
/**
* \addtogroup VAAPI_Decoding
* @addtogroup VAAPI_Decoding
*
* @{
*/

4
libavcodec/vaapi.h
View File

@ -27,8 +27,8 @@
#include <stdint.h>
/**
* \defgroup VAAPI_Decoding VA API Decoding
* \ingroup Decoder
* @defgroup VAAPI_Decoding VA API Decoding
* @ingroup Decoder
* @{
*/

2
libavcodec/vaapi_internal.h
View File

@ -30,7 +30,7 @@
#include "mpegvideo.h"
/**
* \addtogroup VAAPI_Decoding
* @addtogroup VAAPI_Decoding
*
* @{
*/

2
libavcodec/vdpau.c
View File

@ -33,7 +33,7 @@
#include "vdpau_internal.h"
/**
* \addtogroup VDPAU_Decoding
* @addtogroup VDPAU_Decoding
*
* @{
*/

12
libavcodec/vdpau.h
View File

@ -25,7 +25,7 @@
#define AVCODEC_VDPAU_H
/**
* \defgroup Decoder VDPAU Decoder and Renderer
* @defgroup Decoder VDPAU Decoder and Renderer
*
* VDPAU hardware acceleration has two modules
* - VDPAU decoding
@ -38,25 +38,25 @@
* and rendering (API calls) are done as part of the VDPAU
* presentation (vo_vdpau.c) module.
*
* \defgroup VDPAU_Decoding VDPAU Decoding
* \ingroup Decoder
* @defgroup VDPAU_Decoding VDPAU Decoding
* @ingroup Decoder
* @{
*/
#include <vdpau/vdpau.h>
#include <vdpau/vdpau_x11.h>
/** \brief The videoSurface is used for rendering. */
/** @brief The videoSurface is used for rendering. */
#define FF_VDPAU_STATE_USED_FOR_RENDER 1
/**
* \brief The videoSurface is needed for reference/prediction.
* @brief The videoSurface is needed for reference/prediction.
* The codec manipulates this.
*/
#define FF_VDPAU_STATE_USED_FOR_REFERENCE 2
/**
* \brief This structure is used as a callback between the Libav
* @brief This structure is used as a callback between the Libav
* decoder (vd_) and presentation (vo_) module.
* This is used for defining a video frame containing surface,
* picture parameter, bitstream information etc which are passed

2
libavcodec/x86/idct_sse2_xvid.c
View File

@ -43,7 +43,7 @@
#include "idct_xvid.h"
#include "dsputil_mmx.h"
/*!
/**
* @file
* @brief SSE2 idct compatible with xvidmmx
*/

2
libavcodec/x86/idct_xvid.h
View File

@ -18,7 +18,7 @@
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
/*!
/**
* @file
* header for Xvid IDCT functions
*/

4
libavcodec/xsubenc.c
View File

@ -36,8 +36,8 @@
/**
* Encode a single color run. At most 16 bits will be used.
* \param len length of the run, values > 255 mean "until end of line", may not be < 0.
* \param color color to encode, only the lowest two bits are used and all others must be 0.
* @param len length of the run, values > 255 mean "until end of line", may not be < 0.
* @param color color to encode, only the lowest two bits are used and all others must be 0.
*/
static void put_xsub_rle(PutBitContext *pb, int len, int color)
{

36
libavformat/asfcrypt.c
View File

@ -28,9 +28,9 @@
#include "asfcrypt.h"
/**
* \brief find multiplicative inverse modulo 2 ^ 32
* \param v number to invert, must be odd!
* \return number so that result * v = 1 (mod 2^32)
* @brief find multiplicative inverse modulo 2 ^ 32
* @param v number to invert, must be odd!
* @return number so that result * v = 1 (mod 2^32)
*/
static uint32_t inverse(uint32_t v) {
// v ^ 3 gives the inverse (mod 16), could also be implemented
@ -45,9 +45,9 @@ static uint32_t inverse(uint32_t v) {
}
/**
* \brief read keys from keybuf into keys
* \param keybuf buffer containing the keys
* \param keys output key array containing the keys for encryption in
* @brief read keys from keybuf into keys
* @param keybuf buffer containing the keys
* @param keys output key array containing the keys for encryption in
* native endianness
*/
static void multiswap_init(const uint8_t keybuf[48], uint32_t keys[12]) {
@ -57,9 +57,9 @@ static void multiswap_init(const uint8_t keybuf[48], uint32_t keys[12]) {
}
/**
* \brief invert the keys so that encryption become decryption keys and
* @brief invert the keys so that encryption become decryption keys and
* the other way round.
* \param keys key array of ints to invert
* @param keys key array of ints to invert
*/
static void multiswap_invert_keys(uint32_t keys[12]) {
int i;
@ -92,12 +92,12 @@ static uint32_t multiswap_inv_step(const uint32_t keys[12], uint32_t v) {
}
/**
* \brief "MultiSwap" encryption
* \param keys 32 bit numbers in machine endianness,
* @brief "MultiSwap" encryption
* @param keys 32 bit numbers in machine endianness,
* 0-4 and 6-10 must be inverted from decryption
* \param key another key, this one must be the same for the decryption
* \param data data to encrypt
* \return encrypted data
* @param key another key, this one must be the same for the decryption
* @param data data to encrypt
* @return encrypted data
*/
static uint64_t multiswap_enc(const uint32_t keys[12], uint64_t key, uint64_t data) {
uint32_t a = data;
@ -114,12 +114,12 @@ static uint64_t multiswap_enc(const uint32_t keys[12], uint64_t key, uint64_t da
}
/**
* \brief "MultiSwap" decryption
* \param keys 32 bit numbers in machine endianness,
* @brief "MultiSwap" decryption
* @param keys 32 bit numbers in machine endianness,
* 0-4 and 6-10 must be inverted from encryption
* \param key another key, this one must be the same as for the encryption
* \param data data to decrypt
* \return decrypted data
* @param key another key, this one must be the same as for the encryption
* @param data data to decrypt
* @return decrypted data
*/
static uint64_t multiswap_dec(const uint32_t keys[12], uint64_t key, uint64_t data) {
uint32_t a;

54
libavformat/gxf.c
View File

@ -32,11 +32,11 @@ struct gxf_stream_info {
};
/**
* \brief parses a packet header, extracting type and length
* \param pb AVIOContext to read header from
* \param type detected packet type is stored here
* \param length detected packet length, excluding header is stored here
* \return 0 if header not found or contains invalid data, 1 otherwise
* @brief parses a packet header, extracting type and length
* @param pb AVIOContext to read header from
* @param type detected packet type is stored here
* @param length detected packet length, excluding header is stored here
* @return 0 if header not found or contains invalid data, 1 otherwise
*/
static int parse_packet_header(AVIOContext *pb, GXFPktType *type, int *length) {
if (avio_rb32(pb))
@ -58,7 +58,7 @@ static int parse_packet_header(AVIOContext *pb, GXFPktType *type, int *length) {
}
/**
* \brief check if file starts with a PKT_MAP header
* @brief check if file starts with a PKT_MAP header
*/
static int gxf_probe(AVProbeData *p) {
static const uint8_t startcode[] = {0, 0, 0, 0, 1, 0xbc}; // start with map packet
@ -70,10 +70,10 @@ static int gxf_probe(AVProbeData *p) {
}
/**
* \brief gets the stream index for the track with the specified id, creates new
* @brief gets the stream index for the track with the specified id, creates new
* stream if not found
* \param id id of stream to find / add
* \param format stream format identifier
* @param id id of stream to find / add
* @param format stream format identifier
*/
static int get_sindex(AVFormatContext *s, int id, int format) {
int i;
@ -153,9 +153,9 @@ static int get_sindex(AVFormatContext *s, int id, int format) {
}
/**
* \brief filters out interesting tags from material information.
* \param len length of tag section, will be adjusted to contain remaining bytes
* \param si struct to store collected information into
* @brief filters out interesting tags from material information.
* @param len length of tag section, will be adjusted to contain remaining bytes
* @param si struct to store collected information into
*/
static void gxf_material_tags(AVIOContext *pb, int *len, struct gxf_stream_info *si) {
si->first_field = AV_NOPTS_VALUE;
@ -179,9 +179,9 @@ static void gxf_material_tags(AVIOContext *pb, int *len, struct gxf_stream_info
}
/**
* \brief convert fps tag value to AVRational fps
* \param fps fps value from tag
* \return fps as AVRational, or 0 / 0 if unknown
* @brief convert fps tag value to AVRational fps
* @param fps fps value from tag
* @return fps as AVRational, or 0 / 0 if unknown
*/
static AVRational fps_tag2avr(int32_t fps) {
extern const AVRational ff_frame_rate_tab[];
@ -190,9 +190,9 @@ static AVRational fps_tag2avr(int32_t fps) {
}
/**
* \brief convert UMF attributes flags to AVRational fps
* \param flags UMF flags to convert
* \return fps as AVRational, or 0 / 0 if unknown
* @brief convert UMF attributes flags to AVRational fps
* @param flags UMF flags to convert
* @return fps as AVRational, or 0 / 0 if unknown
*/
static AVRational fps_umf2avr(uint32_t flags) {
static const AVRational map[] = {{50, 1}, {60000, 1001}, {24, 1},
@ -202,9 +202,9 @@ static AVRational fps_umf2avr(uint32_t flags) {
}
/**
* \brief filters out interesting tags from track information.
* \param len length of tag section, will be adjusted to contain remaining bytes
* \param si struct to store collected information into
* @brief filters out interesting tags from track information.
* @param len length of tag section, will be adjusted to contain remaining bytes
* @param si struct to store collected information into
*/
static void gxf_track_tags(AVIOContext *pb, int *len, struct gxf_stream_info *si) {
si->frames_per_second = (AVRational){0, 0};
@ -228,7 +228,7 @@ static void gxf_track_tags(AVIOContext *pb, int *len, struct gxf_stream_info *si
}
/**
* \brief read index from FLT packet into stream 0 av_index
* @brief read index from FLT packet into stream 0 av_index
*/
static void gxf_read_index(AVFormatContext *s, int pkt_len) {
AVIOContext *pb = s->pb;
@ -374,11 +374,11 @@ static int gxf_header(AVFormatContext *s, AVFormatParameters *ap) {
}
/**
* \brief resync the stream on the next media packet with specified properties
* \param max_interval how many bytes to search for matching packet at most
* \param track track id the media packet must belong to, -1 for any
* \param timestamp minimum timestamp (== field number) the packet must have, -1 for any
* \return timestamp of packet found
* @brief resync the stream on the next media packet with specified properties
* @param max_interval how many bytes to search for matching packet at most
* @param track track id the media packet must belong to, -1 for any
* @param timestamp minimum timestamp (== field number) the packet must have, -1 for any
* @return timestamp of packet found
*/
static int64_t gxf_resync_media(AVFormatContext *s, uint64_t max_interval, int track, int timestamp) {
uint32_t tmp;

8
libavformat/mpegts.c
View File

@ -221,11 +221,11 @@ static void add_pid_to_pmt(MpegTSContext *ts, unsigned int programid, unsigned i
}
/**
* \brief discard_pid() decides if the pid is to be discarded according
* @brief discard_pid() decides if the pid is to be discarded according
* to caller's programs selection
* \param ts : - TS context
* \param pid : - pid
* \return 1 if the pid is only comprised in programs that have .discard=AVDISCARD_ALL
* @param ts : - TS context
* @param pid : - pid
* @return 1 if the pid is only comprised in programs that have .discard=AVDISCARD_ALL
* 0 otherwise
*/
static int discard_pid(MpegTSContext *ts, unsigned int pid)

10
libavformat/nuv.c
View File

@ -49,11 +49,11 @@ static int nuv_probe(AVProbeData *p) {
#define PKTSIZE(s) (s & 0xffffff)
/**
* \brief read until we found all data needed for decoding
* \param vst video stream of which to change parameters
* \param ast video stream of which to change parameters
* \param myth set if this is a MythTVVideo format file
* \return 1 if all required codec data was found
* @brief read until we found all data needed for decoding
* @param vst video stream of which to change parameters
* @param ast video stream of which to change parameters
* @param myth set if this is a MythTVVideo format file
* @return 1 if all required codec data was found
*/
static int get_codec_data(AVIOContext *pb, AVStream *vst,
AVStream *ast, int myth) {

20
libavutil/common.h
View File

@ -268,16 +268,16 @@ static av_always_inline av_const int av_popcount_c(uint32_t x)
}\
}\
/*!
* \def PUT_UTF8(val, tmp, PUT_BYTE)
/**
* @def PUT_UTF8(val, tmp, PUT_BYTE)
* Convert a 32-bit Unicode character to its UTF-8 encoded form (up to 4 bytes long).
* \param val is an input-only argument and should be of type uint32_t. It holds
* @param val is an input-only argument and should be of type uint32_t. It holds
* a UCS-4 encoded Unicode character that is to be converted to UTF-8. If
* val is given as a function it is executed only once.
* \param tmp is a temporary variable and should be of type uint8_t. It
* @param tmp is a temporary variable and should be of type uint8_t. It
* represents an intermediate value during conversion that is to be
* output by PUT_BYTE.
* \param PUT_BYTE writes the converted UTF-8 bytes to any proper destination.
* @param PUT_BYTE writes the converted UTF-8 bytes to any proper destination.
* It could be a function or a statement, and uses tmp as the input byte.
* For example, PUT_BYTE could be "*output++ = tmp;" PUT_BYTE will be
* executed up to 4 times for values in the valid UTF-8 range and up to
@ -304,16 +304,16 @@ static av_always_inline av_const int av_popcount_c(uint32_t x)
}\
}
/*!
* \def PUT_UTF16(val, tmp, PUT_16BIT)
/**
* @def PUT_UTF16(val, tmp, PUT_16BIT)
* Convert a 32-bit Unicode character to its UTF-16 encoded form (2 or 4 bytes).
* \param val is an input-only argument and should be of type uint32_t. It holds
* @param val is an input-only argument and should be of type uint32_t. It holds
* a UCS-4 encoded Unicode character that is to be converted to UTF-16. If
* val is given as a function it is executed only once.
* \param tmp is a temporary variable and should be of type uint16_t. It
* @param tmp is a temporary variable and should be of type uint16_t. It
* represents an intermediate value during conversion that is to be
* output by PUT_16BIT.
* \param PUT_16BIT writes the converted UTF-16 data to any proper destination
* @param PUT_16BIT writes the converted UTF-16 data to any proper destination
* in desired endianness. It could be a function or a statement, and uses tmp
* as the input byte. For example, PUT_BYTE could be "*output++ = tmp;"
* PUT_BYTE will be executed 1 or 2 times depending on input character.

2
libavutil/des.c
View File

@ -240,7 +240,7 @@ static uint32_t f_func(uint32_t r, uint64_t k) {
}
/**
* \brief rotate the two halves of the expanded 56 bit key each 1 bit left
* @brief rotate the two halves of the expanded 56 bit key each 1 bit left
*
* Note: the specification calls this "shift", so I kept it although
* it is confusing.

18
libavutil/des.h
View File

@ -30,22 +30,22 @@ struct AVDES {
};
/**
* \brief Initializes an AVDES context.
* @brief Initializes an AVDES context.
*
* \param key_bits must be 64 or 192
* \param decrypt 0 for encryption, 1 for decryption
* @param key_bits must be 64 or 192
* @param decrypt 0 for encryption, 1 for decryption
*/
int av_des_init(struct AVDES *d, const uint8_t *key, int key_bits, int decrypt);
/**
* \brief Encrypts / decrypts using the DES algorithm.
* @brief Encrypts / decrypts using the DES algorithm.
*
* \param count number of 8 byte blocks
* \param dst destination array, can be equal to src, must be 8-byte aligned
* \param src source array, can be equal to dst, must be 8-byte aligned, may be NULL
* \param iv initialization vector for CBC mode, if NULL then ECB will be used,
* @param count number of 8 byte blocks
* @param dst destination array, can be equal to src, must be 8-byte aligned
* @param src source array, can be equal to dst, must be 8-byte aligned, may be NULL
* @param iv initialization vector for CBC mode, if NULL then ECB will be used,
* must be 8-byte aligned
* \param decrypt 0 for encryption, 1 for decryption
* @param decrypt 0 for encryption, 1 for decryption
*/
void av_des_crypt(struct AVDES *d, uint8_t *dst, const uint8_t *src, int count, uint8_t *iv, int decrypt);

22
libavutil/lzo.c
View File

@ -37,8 +37,8 @@ typedef struct LZOContext {
} LZOContext;
/**
* \brief Reads one byte from the input buffer, avoiding an overrun.
* \return byte read
* @brief Reads one byte from the input buffer, avoiding an overrun.
* @return byte read
*/
static inline int get_byte(LZOContext *c) {
if (c->in < c->in_end)
@ -54,10 +54,10 @@ static inline int get_byte(LZOContext *c) {
#endif
/**
* \brief Decodes a length value in the coding used by lzo.
* \param x previous byte value
* \param mask bits used from x
* \return decoded length value
* @brief Decodes a length value in the coding used by lzo.
* @param x previous byte value
* @param mask bits used from x
* @return decoded length value
*/
static inline int get_len(LZOContext *c, int x, int mask) {
int cnt = x & mask;
@ -82,8 +82,8 @@ static inline int get_len(LZOContext *c, int x, int mask) {
#endif
/**
* \brief Copies bytes from input to output buffer with checking.
* \param cnt number of bytes to copy, must be >= 0
* @brief Copies bytes from input to output buffer with checking.
* @param cnt number of bytes to copy, must be >= 0
*/
static inline void copy(LZOContext *c, int cnt) {
register const uint8_t *src = c->in;
@ -111,9 +111,9 @@ static inline void copy(LZOContext *c, int cnt) {
static inline void memcpy_backptr(uint8_t *dst, int back, int cnt);
/**
* \brief Copies previously decoded bytes to current position.
* \param back how many bytes back we start
* \param cnt number of bytes to copy, must be >= 0
* @brief Copies previously decoded bytes to current position.
* @param back how many bytes back we start
* @param cnt number of bytes to copy, must be >= 0
*
* cnt > back is valid, this will copy the bytes we just copied,
* thus creating a repeating pattern with a period length of back.

22
libavutil/lzo.h
View File

@ -24,7 +24,7 @@
#include <stdint.h>
/** \defgroup errflags Error flags returned by av_lzo1x_decode
/** @defgroup errflags Error flags returned by av_lzo1x_decode
* \{ */
//! end of the input buffer reached before decoding finished
#define AV_LZO_INPUT_DEPLETED 1
@ -40,12 +40,12 @@
#define AV_LZO_OUTPUT_PADDING 12
/**
* \brief Decodes LZO 1x compressed data.
* \param out output buffer
* \param outlen size of output buffer, number of bytes left are returned here
* \param in input buffer
* \param inlen size of input buffer, number of bytes left are returned here
* \return 0 on success, otherwise a combination of the error flags above
* @brief Decodes LZO 1x compressed data.
* @param out output buffer
* @param outlen size of output buffer, number of bytes left are returned here
* @param in input buffer
* @param inlen size of input buffer, number of bytes left are returned here
* @return 0 on success, otherwise a combination of the error flags above
*
* Make sure all buffers are appropriately padded, in must provide
* AV_LZO_INPUT_PADDING, out must provide AV_LZO_OUTPUT_PADDING additional bytes.
@ -53,10 +53,10 @@
int av_lzo1x_decode(void *out, int *outlen, const void *in, int *inlen);
/**
* \brief deliberately overlapping memcpy implementation
* \param dst destination buffer; must be padded with 12 additional bytes
* \param back how many bytes back we start (the initial size of the overlapping window)
* \param cnt number of bytes to copy, must be >= 0
* @brief deliberately overlapping memcpy implementation
* @param dst destination buffer; must be padded with 12 additional bytes
* @param back how many bytes back we start (the initial size of the overlapping window)
* @param cnt number of bytes to copy, must be >= 0
*
* cnt > back is valid, this will copy the bytes we just copied,
* thus creating a repeating pattern with a period length of back.

18
libavutil/rc4.h
View File

@ -29,21 +29,21 @@ struct AVRC4 {
};
/**
* \brief Initializes an AVRC4 context.
* @brief Initializes an AVRC4 context.
*
* \param key_bits must be a multiple of 8
* \param decrypt 0 for encryption, 1 for decryption, currently has no effect
* @param key_bits must be a multiple of 8
* @param decrypt 0 for encryption, 1 for decryption, currently has no effect
*/
int av_rc4_init(struct AVRC4 *d, const uint8_t *key, int key_bits, int decrypt);
/**
* \brief Encrypts / decrypts using the RC4 algorithm.
* @brief Encrypts / decrypts using the RC4 algorithm.
*
* \param count number of bytes
* \param dst destination array, can be equal to src
* \param src source array, can be equal to dst, may be NULL
* \param iv not (yet) used for RC4, should be NULL
* \param decrypt 0 for encryption, 1 for decryption, not (yet) used
* @param count number of bytes
* @param dst destination array, can be equal to src
* @param src source array, can be equal to dst, may be NULL
* @param iv not (yet) used for RC4, should be NULL
* @param decrypt 0 for encryption, 1 for decryption, not (yet) used
*/
void av_rc4_crypt(struct AVRC4 *d, uint8_t *dst, const uint8_t *src, int count, uint8_t *iv, int decrypt);