Revision bf7e799c

View differences:

cmdutils.h
73 73
 * @param context the context of the value to be set (e.g. the
74 74
 * corresponding commandline option name)
75 75
 * @param timestr the string to be parsed
76
 * @param is_duration a flag which tells how to interpret \p timestr, if
77
 * not zero \p timestr is interpreted as a duration, otherwise as a
76
 * @param is_duration a flag which tells how to interpret timestr, if
77
 * not zero timestr is interpreted as a duration, otherwise as a
78 78
 * date
79 79
 *
80 80
 * @see parse_date()
libavcodec/ac3.h
132 132

  
133 133
/**
134 134
 * Calculates the masking curve.
135
 * First, the excitation is calculated using parameters in \p s and the signal
135
 * First, the excitation is calculated using parameters in s and the signal
136 136
 * power in each critical band.  The excitation is compared with a predefined
137 137
 * hearing threshold table to produce the masking curve.  If delta bit
138 138
 * allocation information is provided, it is used for adjusting the masking
......
161 161
/**
162 162
 * Calculates bit allocation pointers.
163 163
 * The SNR is the difference between the masking curve and the signal.  AC-3
164
 * uses this value for each frequency bin to allocate bits.  The \p snroffset
164
 * uses this value for each frequency bin to allocate bits.  The snroffset
165 165
 * parameter is a global adjustment to the SNR for all bins.
166 166
 *
167 167
 * @param[in]  mask       masking curve
libavcodec/avcodec.h
2544 2544
    const AVRational *supported_framerates; ///< array of supported framerates, or NULL if any, array is terminated by {0,0}
2545 2545
    const enum PixelFormat *pix_fmts;       ///< array of supported pixel formats, or NULL if unknown, array is terminated by -1
2546 2546
    /**
2547
     * Descriptive name for the codec, meant to be more human readable than \p name.
2548
     * You \e should use the NULL_IF_CONFIG_SMALL() macro to define it.
2547
     * Descriptive name for the codec, meant to be more human readable than name.
2548
     * You should use the NULL_IF_CONFIG_SMALL() macro to define it.
2549 2549
     */
2550 2550
    const char *long_name;
2551 2551
    const int *supported_samplerates;       ///< array of supported audio samplerates, or NULL if unknown, array is terminated by 0
......
2599 2599
     * Meaningful frame information (codec specific) is guaranteed to
2600 2600
     * be parsed at this point. This function is mandatory.
2601 2601
     *
2602
     * Note that \p buf can be NULL along with \p buf_size set to 0.
2602
     * Note that buf can be NULL along with buf_size set to 0.
2603 2603
     * Otherwise, this means the whole frame is available at this point.
2604 2604
     *
2605 2605
     * @param avctx the codec context
......
2915 2915
void avcodec_set_dimensions(AVCodecContext *s, int width, int height);
2916 2916

  
2917 2917
/**
2918
 * Returns the pixel format corresponding to the name \p name.
2918
 * Returns the pixel format corresponding to the name name.
2919 2919
 *
2920
 * If there is no pixel format with name \p name, then looks for a
2920
 * If there is no pixel format with name name, then looks for a
2921 2921
 * pixel format with the name corresponding to the native endian
2922
 * format of \p name.
2922
 * format of name.
2923 2923
 * For example in a little-endian system, first looks for "gray16",
2924 2924
 * then for "gray16le".
2925 2925
 *
2926
 * Finally if no pixel format has been found, returns \c PIX_FMT_NONE.
2926
 * Finally if no pixel format has been found, returns PIX_FMT_NONE.
2927 2927
 */
2928 2928
enum PixelFormat avcodec_get_pix_fmt(const char* name);
2929 2929
unsigned int avcodec_pix_fmt_to_codec_tag(enum PixelFormat p);
......
2963 2963
 * some formats to other formats. avcodec_find_best_pix_fmt() searches which of
2964 2964
 * the given pixel formats should be used to suffer the least amount of loss.
2965 2965
 * The pixel formats from which it chooses one, are determined by the
2966
 * \p pix_fmt_mask parameter.
2966
 * pix_fmt_mask parameter.
2967 2967
 *
2968 2968
 * @code
2969 2969
 * src_pix_fmt = PIX_FMT_YUV420P;
......
3025 3025
/**
3026 3026
 * Initializes libavcodec.
3027 3027
 *
3028
 * @warning This function \e must be called before any other libavcodec
3028
 * @warning This function must be called before any other libavcodec
3029 3029
 * function.
3030 3030
 */
3031 3031
void avcodec_init(void);
......
3038 3038
#endif
3039 3039

  
3040 3040
/**
3041
 * Register the codec \p codec and initialize libavcodec.
3041
 * Register the codec codec and initialize libavcodec.
3042 3042
 *
3043 3043
 * @see avcodec_init()
3044 3044
 */
......
3170 3170

  
3171 3171
#if LIBAVCODEC_VERSION_MAJOR < 53
3172 3172
/**
3173
 * Decodes an audio frame from \p buf into \p samples.
3173
 * Decodes an audio frame from buf into samples.
3174 3174
 * Wrapper function which calls avcodec_decode_audio3.
3175 3175
 *
3176 3176
 * @deprecated Use avcodec_decode_audio3 instead.
......
3192 3192
 * Some decoders may support multiple frames in a single AVPacket, such
3193 3193
 * decoders would then just decode the first frame.
3194 3194
 * If no frame
3195
 * could be decompressed, \p frame_size_ptr is zero. Otherwise, it is the
3196
 * decompressed frame size in \e bytes.
3195
 * could be decompressed, frame_size_ptr is zero. Otherwise, it is the
3196
 * decompressed frame size in bytes.
3197 3197
 *
3198
 * @warning You \e must set \p frame_size_ptr to the allocated size of the
3198
 * @warning You must set frame_size_ptr to the allocated size of the
3199 3199
 * output buffer before calling avcodec_decode_audio3().
3200 3200
 *
3201
 * @warning The input buffer must be \c FF_INPUT_BUFFER_PADDING_SIZE larger than
3201
 * @warning The input buffer must be FF_INPUT_BUFFER_PADDING_SIZE larger than
3202 3202
 * the actual read bytes because some optimized bitstream readers read 32 or 64
3203 3203
 * bits at once and could read over the end.
3204 3204
 *
3205
 * @warning The end of the input buffer \p avpkt->data should be set to 0 to ensure that
3205
 * @warning The end of the input buffer avpkt->data should be set to 0 to ensure that
3206 3206
 * no overreading happens for damaged MPEG streams.
3207 3207
 *
3208
 * @note You might have to align the input buffer \p avpkt->data and output buffer \p
3208
 * @note You might have to align the input buffer avpkt->data and output buffer
3209 3209
 * samples. The alignment requirements depend on the CPU: On some CPUs it isn't
3210 3210
 * necessary at all, on others it won't work at all if not aligned and on others
3211 3211
 * it will work but it will have an impact on performance. In practice, the
......
3230 3230

  
3231 3231
#if LIBAVCODEC_VERSION_MAJOR < 53
3232 3232
/**
3233
 * Decodes a video frame from \p buf into \p picture.
3233
 * Decodes a video frame from buf into picture.
3234 3234
 * Wrapper function which calls avcodec_decode_video2.
3235 3235
 *
3236 3236
 * @deprecated Use avcodec_decode_video2 instead.
......
3252 3252
 * Some decoders may support multiple frames in a single AVPacket, such
3253 3253
 * decoders would then just decode the first frame.
3254 3254
 *
3255
 * @warning The input buffer must be \c FF_INPUT_BUFFER_PADDING_SIZE larger than
3255
 * @warning The input buffer must be FF_INPUT_BUFFER_PADDING_SIZE larger than
3256 3256
 * the actual read bytes because some optimized bitstream readers read 32 or 64
3257 3257
 * bits at once and could read over the end.
3258 3258
 *
3259
 * @warning The end of the input buffer \p buf should be set to 0 to ensure that
3259
 * @warning The end of the input buffer buf should be set to 0 to ensure that
3260 3260
 * no overreading happens for damaged MPEG streams.
3261 3261
 *
3262
 * @note You might have to align the input buffer \p avpkt->data and output buffer \p
3262
 * @note You might have to align the input buffer avpkt->data and output buffer
3263 3263
 * samples. The alignment requirements depend on the CPU: on some CPUs it isn't
3264 3264
 * necessary at all, on others it won't work at all if not aligned and on others
3265 3265
 * it will work but it will have an impact on performance. In practice, the
......
3298 3298
/**
3299 3299
 * Decodes a subtitle message.
3300 3300
 * Returns a negative value on error, otherwise returns the number of bytes used.
3301
 * If no subtitle could be decompressed, \p got_sub_ptr is zero.
3302
 * Otherwise, the subtitle is stored in \p *sub.
3301
 * If no subtitle could be decompressed, got_sub_ptr is zero.
3302
 * Otherwise, the subtitle is stored in *sub.
3303 3303
 *
3304 3304
 * @param avctx the codec context
3305 3305
 * @param[out] sub The AVSubtitle in which the decoded subtitle will be stored.
......
3314 3314
                        uint8_t *buf, int buf_size);
3315 3315

  
3316 3316
/**
3317
 * Encodes an audio frame from \p samples into \p buf.
3317
 * Encodes an audio frame from samples into buf.
3318 3318
 *
3319
 * @note The output buffer should be at least \c FF_MIN_BUFFER_SIZE bytes large.
3319
 * @note The output buffer should be at least FF_MIN_BUFFER_SIZE bytes large.
3320 3320
 * However, for PCM audio the user will know how much space is needed
3321
 * because it depends on the value passed in \p buf_size as described
3321
 * because it depends on the value passed in buf_size as described
3322 3322
 * below. In that case a lower value can be used.
3323 3323
 *
3324 3324
 * @param avctx the codec context
......
3326 3326
 * @param[in] buf_size the output buffer size
3327 3327
 * @param[in] samples the input buffer containing the samples
3328 3328
 * The number of samples read from this buffer is frame_size*channels,
3329
 * both of which are defined in \p avctx.
3330
 * For PCM audio the number of samples read from \p samples is equal to
3331
 * \p buf_size * input_sample_size / output_sample_size.
3329
 * both of which are defined in avctx.
3330
 * For PCM audio the number of samples read from samples is equal to
3331
 * buf_size * input_sample_size / output_sample_size.
3332 3332
 * @return On error a negative value is returned, on success zero or the number
3333 3333
 * of bytes used to encode the data read from the input buffer.
3334 3334
 */
......
3336 3336
                         const short *samples);
3337 3337

  
3338 3338
/**
3339
 * Encodes a video frame from \p pict into \p buf.
3339
 * Encodes a video frame from pict into buf.
3340 3340
 * The input picture should be
3341
 * stored using a specific format, namely \c avctx.pix_fmt.
3341
 * stored using a specific format, namely avctx.pix_fmt.
3342 3342
 *
3343 3343
 * @param avctx the codec context
3344 3344
 * @param[out] buf the output buffer for the bitstream of encoded frame
......
3376 3376
/* misc useful functions */
3377 3377

  
3378 3378
/**
3379
 * Returns a single letter to describe the given picture type \p pict_type.
3379
 * Returns a single letter to describe the given picture type pict_type.
3380 3380
 *
3381 3381
 * @param[in] pict_type the picture type
3382 3382
 * @return A single character representing the picture type.
......
3666 3666
unsigned int av_xiphlacing(unsigned char *s, unsigned int v);
3667 3667

  
3668 3668
/**
3669
 * Parses \p str and put in \p width_ptr and \p height_ptr the detected values.
3669
 * Parses str and put in width_ptr and height_ptr the detected values.
3670 3670
 *
3671 3671
 * @return 0 in case of a successful parsing, a negative value otherwise
3672 3672
 * @param[in] str the string to parse: it has to be a string in the format
......
3679 3679
int av_parse_video_frame_size(int *width_ptr, int *height_ptr, const char *str);
3680 3680

  
3681 3681
/**
3682
 * Parses \p str and put in \p frame_rate the detected values.
3682
 * Parses str and put in frame_rate the detected values.
3683 3683
 *
3684 3684
 * @return 0 in case of a successful parsing, a negative value otherwise
3685 3685
 * @param[in] str the string to parse: it has to be a string in the format
......
3710 3710
#define AVERROR_PATCHWELCOME    -MKTAG('P','A','W','E') /**< Not yet implemented in FFmpeg. Patches welcome. */
3711 3711

  
3712 3712
/**
3713
 * Registers the hardware accelerator \p hwaccel.
3713
 * Registers the hardware accelerator hwaccel.
3714 3714
 */
3715 3715
void av_register_hwaccel(AVHWAccel *hwaccel);
3716 3716

  
......
3734 3734

  
3735 3735
/**
3736 3736
 * Register a user provided lock manager supporting the operations
3737
 * specified by AVLockOp. \p mutex points to a (void *) where the
3737
 * specified by AVLockOp. mutex points to a (void *) where the
3738 3738
 * lockmgr should store/get a pointer to a user allocated mutex. It's
3739 3739
 * NULL upon AV_LOCK_CREATE and != NULL for all other ops.
3740 3740
 *
libavcodec/internal.h
33 33
 * a pointer to an AVClass struct
34 34
 * @param[in] feature string containing the name of the missing feature
35 35
 * @param[in] want_sample indicates if samples are wanted which exhibit this feature.
36
 * If \p want_sample is non-zero, additional verbage will be added to the log
36
 * If want_sample is non-zero, additional verbage will be added to the log
37 37
 * message which tells the user how to report samples to the development
38 38
 * mailing list.
39 39
 */
......
48 48
void ff_log_ask_for_sample(void *avc, const char *msg);
49 49

  
50 50
/**
51
 * Determines whether \p pix_fmt is a hardware accelerated format.
51
 * Determines whether pix_fmt is a hardware accelerated format.
52 52
 */
53 53
int ff_is_hwaccel_pix_fmt(enum PixelFormat pix_fmt);
54 54

  
55 55
/**
56
 * Returns the hardware accelerated codec for codec \p codec_id and
57
 * pixel format \p pix_fmt.
56
 * Returns the hardware accelerated codec for codec codec_id and
57
 * pixel format pix_fmt.
58 58
 *
59 59
 * @param codec_id the codec to match
60 60
 * @param pix_fmt the pixel format to match
libavcodec/opt.h
87 87

  
88 88

  
89 89
/**
90
 * Looks for an option in \p obj. Looks only for the options which
91
 * have the flags set as specified in \p mask and \p flags (that is,
90
 * Looks for an option in obj. Looks only for the options which
91
 * have the flags set as specified in mask and flags (that is,
92 92
 * for which it is the case that opt->flags & mask == flags).
93 93
 *
94 94
 * @param[in] obj a pointer to a struct whose first element is a
......
108 108

  
109 109
/**
110 110
 * @return a pointer to the AVOption corresponding to the field set or
111
 * NULL if no matching AVOption exists, or if the value \p val is not
111
 * NULL if no matching AVOption exists, or if the value val is not
112 112
 * valid
113 113
 * @see av_set_string3()
114 114
 */
libavcodec/pixdesc.h
86 86
extern const AVPixFmtDescriptor av_pix_fmt_descriptors[];
87 87

  
88 88
/**
89
 * Reads a line from an image, and writes to \p dst the values of the
90
 * pixel format component \p c.
89
 * Reads a line from an image, and writes to dst the values of the
90
 * pixel format component c.
91 91
 *
92 92
 * @param data the array containing the pointers to the planes of the image
93 93
 * @param linesizes the array containing the linesizes of the image
......
95 95
 * @param x the horizontal coordinate of the first pixel to read
96 96
 * @param y the vertical coordinate of the first pixel to read
97 97
 * @param w the width of the line to read, that is the number of
98
 * values to write to \p dst
98
 * values to write to dst
99 99
 * @param read_pal_component if not zero and the format is a paletted
100
 * format writes to \p dst the values corresponding to the palette
101
 * component \p c in data[1], rather than the palette indexes in
100
 * format writes to dst the values corresponding to the palette
101
 * component c in data[1], rather than the palette indexes in
102 102
 * data[0]. The behavior is undefined if the format is not paletted.
103 103
 */
104 104
static inline void read_line(uint16_t *dst, const uint8_t *data[4], const int linesize[4],
libavcodec/put_bits.h
52 52
} PutBitContext;
53 53

  
54 54
/**
55
 * Initializes the PutBitContext \p s.
55
 * Initializes the PutBitContext s.
56 56
 *
57 57
 * @param buffer the buffer where to put bits
58
 * @param buffer_size the size in bytes of \p buffer
58
 * @param buffer_size the size in bytes of buffer
59 59
 */
60 60
static inline void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
61 61
{
......
123 123
void align_put_bits(PutBitContext *s);
124 124

  
125 125
/**
126
 * Puts the string \p s in the bitstream.
126
 * Puts the string s in the bitstream.
127 127
 *
128 128
 * @param terminate_string 0-terminates the written string if value is 1
129 129
 */
130 130
void ff_put_string(PutBitContext * pbc, const char *s, int terminate_string);
131 131

  
132 132
/**
133
 * Copies the content of \p src to the bitstream.
133
 * Copies the content of src to the bitstream.
134 134
 *
135
 * @param length the number of bits of \p src to copy
135
 * @param length the number of bits of src to copy
136 136
 */
137 137
void ff_copy_bits(PutBitContext *pb, const uint8_t *src, int length);
138 138

  
......
290 290
/**
291 291
 * Skips the given number of bits.
292 292
 * Must only be used if the actual values in the bitstream do not matter.
293
 * If \p n is 0 the behavior is undefined.
293
 * If n is 0 the behavior is undefined.
294 294
 */
295 295
static inline void skip_put_bits(PutBitContext *s, int n){
296 296
#ifdef ALT_BITSTREAM_WRITER
libavformat/rm.h
64 64
 * @param flags pointer to an integer containing the packet flags, may be
65 65
                updated
66 66
 * @param ts pointer to timestamp, may be updated
67
 * @return <0 on error, 0 if a packet was placed in the \p pkt pointer. A
68
 *         value >0 means that no data was placed in \p pkt, but that cached
67
 * @return <0 on error, 0 if a packet was placed in the pkt pointer. A
68
 *         value >0 means that no data was placed in pkt, but that cached
69 69
 *         data is available by calling ff_rm_retrieve_cache().
70 70
 */
71 71
int ff_rm_parse_packet (AVFormatContext *s, ByteIOContext *pb,
libavformat/rtsp.h
207 207

  
208 208
    /** timestamp of the last RTSP command that we sent to the RTSP server.
209 209
     * This is used to calculate when to send dummy commands to keep the
210
     * connection alive, in conjunction with \p timeout. */
210
     * connection alive, in conjunction with timeout. */
211 211
    int64_t last_cmd_time;
212 212

  
213 213
    /** the negotiated data/packet transport protocol; e.g. RTP or RDT */
libavutil/base64.h
24 24
#include <stdint.h>
25 25

  
26 26
/**
27
 * Decodes the base64-encoded string in \p in and puts the decoded
28
 * data in \p out.
27
 * Decodes the base64-encoded string in in and puts the decoded
28
 * data in out.
29 29
 *
30
 * @param out_size size in bytes of the \p out buffer, it should be at
31
 * least 3/4 of the length of \p in
30
 * @param out_size size in bytes of the out buffer, it should be at
31
 * least 3/4 of the length of in
32 32
 * @return the number of bytes written, or a negative value in case of
33 33
 * error
34 34
 */
35 35
int av_base64_decode(uint8_t *out, const char *in, int out_size);
36 36

  
37 37
/**
38
 * Encodes in base64 the data in \p in and puts the resulting string
39
 * in \p out.
38
 * Encodes in base64 the data in in and puts the resulting string
39
 * in out.
40 40
 *
41
 * @param out_size size in bytes of the \p out string, it should be at
42
 * least ((\p in_size + 2) / 3) * 4 + 1
43
 * @param in_size size in bytes of the \p in buffer
41
 * @param out_size size in bytes of the out string, it should be at
42
 * least ((in_size + 2) / 3) * 4 + 1
43
 * @param in_size size in bytes of the in buffer
44 44
 * @return the string containing the encoded data, or NULL in case of
45 45
 * error
46 46
 */
libavutil/log.h
39 39

  
40 40
    /**
41 41
     * A pointer to a function which returns the name of a context
42
     * instance \p ctx associated with the class.
42
     * instance ctx associated with the class.
43 43
     */
44 44
    const char* (*item_name)(void* ctx);
45 45

  
libavutil/mem.h
41 41
#endif
42 42

  
43 43
/**
44
 * Allocates a block of \p size bytes with alignment suitable for all
44
 * Allocates a block of size bytes with alignment suitable for all
45 45
 * memory accesses (including vectors if available on the CPU).
46 46
 * @param size Size in bytes for the memory block to be allocated.
47 47
 * @return Pointer to the allocated block, NULL if the block cannot
......
52 52

  
53 53
/**
54 54
 * Allocates or reallocates a block of memory.
55
 * If \p ptr is NULL and \p size > 0, allocates a new block. If \p
56
 * size is zero, frees the memory block pointed to by \p ptr.
55
 * If ptr is NULL and size > 0, allocates a new block. If \p
56
 * size is zero, frees the memory block pointed to by ptr.
57 57
 * @param size Size in bytes for the memory block to be allocated or
58 58
 * reallocated.
59 59
 * @param ptr Pointer to a memory block already allocated with
......
75 75
void av_free(void *ptr);
76 76

  
77 77
/**
78
 * Allocates a block of \p size bytes with alignment suitable for all
78
 * Allocates a block of size bytes with alignment suitable for all
79 79
 * memory accesses (including vectors if available on the CPU) and
80 80
 * zeroes all the bytes of the block.
81 81
 * @param size Size in bytes for the memory block to be allocated.
......
85 85
void *av_mallocz(unsigned int size) av_malloc_attrib av_alloc_size(1);
86 86

  
87 87
/**
88
 * Duplicates the string \p s.
88
 * Duplicates the string s.
89 89
 * @param s string to be duplicated
90 90
 * @return Pointer to a newly allocated string containing a
91
 * copy of \p s or NULL if the string cannot be allocated.
91
 * copy of s or NULL if the string cannot be allocated.
92 92
 */
93 93
char *av_strdup(const char *s) av_malloc_attrib;
94 94

  
libavutil/rational.h
114 114
AVRational av_d2q(double d, int max) av_const;
115 115

  
116 116
/**
117
 * @return 1 if \q1 is nearer to \p q than \p q2, -1 if \p q2 is nearer
118
 * than \p q1, 0 if they have the same distance.
117
 * @return 1 if q1 is nearer to q than q2, -1 if q2 is nearer
118
 * than q1, 0 if they have the same distance.
119 119
 */
120 120
int av_nearer_q(AVRational q, AVRational q1, AVRational q2);
121 121

  
122 122
/**
123
 * Finds the nearest value in \p q_list to \p q.
123
 * Finds the nearest value in q_list to q.
124 124
 * @param q_list an array of rationals terminated by {0, 0}
125 125
 * @return the index of the nearest value found in the array
126 126
 */

Also available in: Unified diff