Go to most recent revision | Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
4349 | Serge | 1 | /* |
2 | * Various utilities for command line tools |
||
3 | * copyright (c) 2003 Fabrice Bellard |
||
4 | * |
||
5 | * This file is part of FFmpeg. |
||
6 | * |
||
7 | * FFmpeg is free software; you can redistribute it and/or |
||
8 | * modify it under the terms of the GNU Lesser General Public |
||
9 | * License as published by the Free Software Foundation; either |
||
10 | * version 2.1 of the License, or (at your option) any later version. |
||
11 | * |
||
12 | * FFmpeg is distributed in the hope that it will be useful, |
||
13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
||
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
||
15 | * Lesser General Public License for more details. |
||
16 | * |
||
17 | * You should have received a copy of the GNU Lesser General Public |
||
18 | * License along with FFmpeg; if not, write to the Free Software |
||
19 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
||
20 | */ |
||
21 | |||
22 | #ifndef FFMPEG_CMDUTILS_H |
||
23 | #define FFMPEG_CMDUTILS_H |
||
24 | |||
25 | #include |
||
26 | |||
27 | #include "libavcodec/avcodec.h" |
||
28 | #include "libavfilter/avfilter.h" |
||
29 | #include "libavformat/avformat.h" |
||
30 | #include "libswscale/swscale.h" |
||
31 | |||
32 | #ifdef __MINGW32__ |
||
33 | #undef main /* We don't want SDL to override our main() */ |
||
34 | #endif |
||
35 | |||
36 | /** |
||
37 | * program name, defined by the program for show_version(). |
||
38 | */ |
||
39 | extern const char program_name[]; |
||
40 | |||
41 | /** |
||
42 | * program birth year, defined by the program for show_banner() |
||
43 | */ |
||
44 | extern const int program_birth_year; |
||
45 | |||
46 | /** |
||
47 | * this year, defined by the program for show_banner() |
||
48 | */ |
||
49 | extern const int this_year; |
||
50 | |||
51 | extern AVCodecContext *avcodec_opts[AVMEDIA_TYPE_NB]; |
||
52 | extern AVFormatContext *avformat_opts; |
||
53 | extern struct SwsContext *sws_opts; |
||
54 | extern AVDictionary *swr_opts; |
||
55 | extern AVDictionary *format_opts, *codec_opts, *resample_opts; |
||
56 | |||
57 | /** |
||
58 | * Register a program-specific cleanup routine. |
||
59 | */ |
||
60 | void register_exit(void (*cb)(int ret)); |
||
61 | |||
62 | /** |
||
63 | * Wraps exit with a program-specific cleanup routine. |
||
64 | */ |
||
65 | void exit_program(int ret); |
||
66 | |||
67 | /** |
||
68 | * Initialize the cmdutils option system, in particular |
||
69 | * allocate the *_opts contexts. |
||
70 | */ |
||
71 | void init_opts(void); |
||
72 | /** |
||
73 | * Uninitialize the cmdutils option system, in particular |
||
74 | * free the *_opts contexts and their contents. |
||
75 | */ |
||
76 | void uninit_opts(void); |
||
77 | |||
78 | /** |
||
79 | * Trivial log callback. |
||
80 | * Only suitable for opt_help and similar since it lacks prefix handling. |
||
81 | */ |
||
82 | void log_callback_help(void* ptr, int level, const char* fmt, va_list vl); |
||
83 | |||
84 | /** |
||
85 | * Override the cpuflags. |
||
86 | */ |
||
87 | int opt_cpuflags(void *optctx, const char *opt, const char *arg); |
||
88 | |||
89 | /** |
||
90 | * Fallback for options that are not explicitly handled, these will be |
||
91 | * parsed through AVOptions. |
||
92 | */ |
||
93 | int opt_default(void *optctx, const char *opt, const char *arg); |
||
94 | |||
95 | /** |
||
96 | * Set the libav* libraries log level. |
||
97 | */ |
||
98 | int opt_loglevel(void *optctx, const char *opt, const char *arg); |
||
99 | |||
100 | int opt_report(const char *opt); |
||
101 | |||
102 | int opt_max_alloc(void *optctx, const char *opt, const char *arg); |
||
103 | |||
104 | int opt_codec_debug(void *optctx, const char *opt, const char *arg); |
||
105 | |||
106 | int opt_opencl(void *optctx, const char *opt, const char *arg); |
||
107 | |||
108 | /** |
||
109 | * Limit the execution time. |
||
110 | */ |
||
111 | int opt_timelimit(void *optctx, const char *opt, const char *arg); |
||
112 | |||
113 | /** |
||
114 | * Parse a string and return its corresponding value as a double. |
||
115 | * Exit from the application if the string cannot be correctly |
||
116 | * parsed or the corresponding value is invalid. |
||
117 | * |
||
118 | * @param context the context of the value to be set (e.g. the |
||
119 | * corresponding command line option name) |
||
120 | * @param numstr the string to be parsed |
||
121 | * @param type the type (OPT_INT64 or OPT_FLOAT) as which the |
||
122 | * string should be parsed |
||
123 | * @param min the minimum valid accepted value |
||
124 | * @param max the maximum valid accepted value |
||
125 | */ |
||
126 | double parse_number_or_die(const char *context, const char *numstr, int type, |
||
127 | double min, double max); |
||
128 | |||
129 | /** |
||
130 | * Parse a string specifying a time and return its corresponding |
||
131 | * value as a number of microseconds. Exit from the application if |
||
132 | * the string cannot be correctly parsed. |
||
133 | * |
||
134 | * @param context the context of the value to be set (e.g. the |
||
135 | * corresponding command line option name) |
||
136 | * @param timestr the string to be parsed |
||
137 | * @param is_duration a flag which tells how to interpret timestr, if |
||
138 | * not zero timestr is interpreted as a duration, otherwise as a |
||
139 | * date |
||
140 | * |
||
141 | * @see av_parse_time() |
||
142 | */ |
||
143 | int64_t parse_time_or_die(const char *context, const char *timestr, |
||
144 | int is_duration); |
||
145 | |||
146 | typedef struct SpecifierOpt { |
||
147 | char *specifier; /**< stream/chapter/program/... specifier */ |
||
148 | union { |
||
149 | uint8_t *str; |
||
150 | int i; |
||
151 | int64_t i64; |
||
152 | float f; |
||
153 | double dbl; |
||
154 | } u; |
||
155 | } SpecifierOpt; |
||
156 | |||
157 | typedef struct OptionDef { |
||
158 | const char *name; |
||
159 | int flags; |
||
160 | #define HAS_ARG 0x0001 |
||
161 | #define OPT_BOOL 0x0002 |
||
162 | #define OPT_EXPERT 0x0004 |
||
163 | #define OPT_STRING 0x0008 |
||
164 | #define OPT_VIDEO 0x0010 |
||
165 | #define OPT_AUDIO 0x0020 |
||
166 | #define OPT_INT 0x0080 |
||
167 | #define OPT_FLOAT 0x0100 |
||
168 | #define OPT_SUBTITLE 0x0200 |
||
169 | #define OPT_INT64 0x0400 |
||
170 | #define OPT_EXIT 0x0800 |
||
171 | #define OPT_DATA 0x1000 |
||
172 | #define OPT_PERFILE 0x2000 /* the option is per-file (currently ffmpeg-only). |
||
173 | implied by OPT_OFFSET or OPT_SPEC */ |
||
174 | #define OPT_OFFSET 0x4000 /* option is specified as an offset in a passed optctx */ |
||
175 | #define OPT_SPEC 0x8000 /* option is to be stored in an array of SpecifierOpt. |
||
176 | Implies OPT_OFFSET. Next element after the offset is |
||
177 | an int containing element count in the array. */ |
||
178 | #define OPT_TIME 0x10000 |
||
179 | #define OPT_DOUBLE 0x20000 |
||
180 | #define OPT_INPUT 0x40000 |
||
181 | #define OPT_OUTPUT 0x80000 |
||
182 | union { |
||
183 | void *dst_ptr; |
||
184 | int (*func_arg)(void *, const char *, const char *); |
||
185 | size_t off; |
||
186 | } u; |
||
187 | const char *help; |
||
188 | const char *argname; |
||
189 | } OptionDef; |
||
190 | |||
191 | /** |
||
192 | * Print help for all options matching specified flags. |
||
193 | * |
||
194 | * @param options a list of options |
||
195 | * @param msg title of this group. Only printed if at least one option matches. |
||
196 | * @param req_flags print only options which have all those flags set. |
||
197 | * @param rej_flags don't print options which have any of those flags set. |
||
198 | * @param alt_flags print only options that have at least one of those flags set |
||
199 | */ |
||
200 | void show_help_options(const OptionDef *options, const char *msg, int req_flags, |
||
201 | int rej_flags, int alt_flags); |
||
202 | |||
203 | /** |
||
204 | * Show help for all options with given flags in class and all its |
||
205 | * children. |
||
206 | */ |
||
207 | void show_help_children(const AVClass *class, int flags); |
||
208 | |||
209 | /** |
||
210 | * Per-fftool specific help handler. Implemented in each |
||
211 | * fftool, called by show_help(). |
||
212 | */ |
||
213 | void show_help_default(const char *opt, const char *arg); |
||
214 | |||
215 | /** |
||
216 | * Generic -h handler common to all fftools. |
||
217 | */ |
||
218 | int show_help(void *optctx, const char *opt, const char *arg); |
||
219 | |||
220 | /** |
||
221 | * Parse the command line arguments. |
||
222 | * |
||
223 | * @param optctx an opaque options context |
||
224 | * @param argc number of command line arguments |
||
225 | * @param argv values of command line arguments |
||
226 | * @param options Array with the definitions required to interpret every |
||
227 | * option of the form: -option_name [argument] |
||
228 | * @param parse_arg_function Name of the function called to process every |
||
229 | * argument without a leading option name flag. NULL if such arguments do |
||
230 | * not have to be processed. |
||
231 | */ |
||
232 | void parse_options(void *optctx, int argc, char **argv, const OptionDef *options, |
||
233 | void (* parse_arg_function)(void *optctx, const char*)); |
||
234 | |||
235 | /** |
||
236 | * Parse one given option. |
||
237 | * |
||
238 | * @return on success 1 if arg was consumed, 0 otherwise; negative number on error |
||
239 | */ |
||
240 | int parse_option(void *optctx, const char *opt, const char *arg, |
||
241 | const OptionDef *options); |
||
242 | |||
243 | /** |
||
244 | * An option extracted from the commandline. |
||
245 | * Cannot use AVDictionary because of options like -map which can be |
||
246 | * used multiple times. |
||
247 | */ |
||
248 | typedef struct Option { |
||
249 | const OptionDef *opt; |
||
250 | const char *key; |
||
251 | const char *val; |
||
252 | } Option; |
||
253 | |||
254 | typedef struct OptionGroupDef { |
||
255 | /**< group name */ |
||
256 | const char *name; |
||
257 | /** |
||
258 | * Option to be used as group separator. Can be NULL for groups which |
||
259 | * are terminated by a non-option argument (e.g. ffmpeg output files) |
||
260 | */ |
||
261 | const char *sep; |
||
262 | /** |
||
263 | * Option flags that must be set on each option that is |
||
264 | * applied to this group |
||
265 | */ |
||
266 | int flags; |
||
267 | } OptionGroupDef; |
||
268 | |||
269 | typedef struct OptionGroup { |
||
270 | const OptionGroupDef *group_def; |
||
271 | const char *arg; |
||
272 | |||
273 | Option *opts; |
||
274 | int nb_opts; |
||
275 | |||
276 | AVDictionary *codec_opts; |
||
277 | AVDictionary *format_opts; |
||
278 | AVDictionary *resample_opts; |
||
279 | struct SwsContext *sws_opts; |
||
280 | AVDictionary *swr_opts; |
||
281 | } OptionGroup; |
||
282 | |||
283 | /** |
||
284 | * A list of option groups that all have the same group type |
||
285 | * (e.g. input files or output files) |
||
286 | */ |
||
287 | typedef struct OptionGroupList { |
||
288 | const OptionGroupDef *group_def; |
||
289 | |||
290 | OptionGroup *groups; |
||
291 | int nb_groups; |
||
292 | } OptionGroupList; |
||
293 | |||
294 | typedef struct OptionParseContext { |
||
295 | OptionGroup global_opts; |
||
296 | |||
297 | OptionGroupList *groups; |
||
298 | int nb_groups; |
||
299 | |||
300 | /* parsing state */ |
||
301 | OptionGroup cur_group; |
||
302 | } OptionParseContext; |
||
303 | |||
304 | /** |
||
305 | * Parse an options group and write results into optctx. |
||
306 | * |
||
307 | * @param optctx an app-specific options context. NULL for global options group |
||
308 | */ |
||
309 | int parse_optgroup(void *optctx, OptionGroup *g); |
||
310 | |||
311 | /** |
||
312 | * Split the commandline into an intermediate form convenient for further |
||
313 | * processing. |
||
314 | * |
||
315 | * The commandline is assumed to be composed of options which either belong to a |
||
316 | * group (those with OPT_SPEC, OPT_OFFSET or OPT_PERFILE) or are global |
||
317 | * (everything else). |
||
318 | * |
||
319 | * A group (defined by an OptionGroupDef struct) is a sequence of options |
||
320 | * terminated by either a group separator option (e.g. -i) or a parameter that |
||
321 | * is not an option (doesn't start with -). A group without a separator option |
||
322 | * must always be first in the supplied groups list. |
||
323 | * |
||
324 | * All options within the same group are stored in one OptionGroup struct in an |
||
325 | * OptionGroupList, all groups with the same group definition are stored in one |
||
326 | * OptionGroupList in OptionParseContext.groups. The order of group lists is the |
||
327 | * same as the order of group definitions. |
||
328 | */ |
||
329 | int split_commandline(OptionParseContext *octx, int argc, char *argv[], |
||
330 | const OptionDef *options, |
||
331 | const OptionGroupDef *groups, int nb_groups); |
||
332 | |||
333 | /** |
||
334 | * Free all allocated memory in an OptionParseContext. |
||
335 | */ |
||
336 | void uninit_parse_context(OptionParseContext *octx); |
||
337 | |||
338 | /** |
||
339 | * Find the '-loglevel' option in the command line args and apply it. |
||
340 | */ |
||
341 | void parse_loglevel(int argc, char **argv, const OptionDef *options); |
||
342 | |||
343 | /** |
||
344 | * Return index of option opt in argv or 0 if not found. |
||
345 | */ |
||
346 | int locate_option(int argc, char **argv, const OptionDef *options, |
||
347 | const char *optname); |
||
348 | |||
349 | /** |
||
350 | * Check if the given stream matches a stream specifier. |
||
351 | * |
||
352 | * @param s Corresponding format context. |
||
353 | * @param st Stream from s to be checked. |
||
354 | * @param spec A stream specifier of the [v|a|s|d]:[\ |
||
355 | * |
||
356 | * @return 1 if the stream matches, 0 if it doesn't, <0 on error |
||
357 | */ |
||
358 | int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec); |
||
359 | |||
360 | /** |
||
361 | * Filter out options for given codec. |
||
362 | * |
||
363 | * Create a new options dictionary containing only the options from |
||
364 | * opts which apply to the codec with ID codec_id. |
||
365 | * |
||
366 | * @param opts dictionary to place options in |
||
367 | * @param codec_id ID of the codec that should be filtered for |
||
368 | * @param s Corresponding format context. |
||
369 | * @param st A stream from s for which the options should be filtered. |
||
370 | * @param codec The particular codec for which the options should be filtered. |
||
371 | * If null, the default one is looked up according to the codec id. |
||
372 | * @return a pointer to the created dictionary |
||
373 | */ |
||
374 | AVDictionary *filter_codec_opts(AVDictionary *opts, enum AVCodecID codec_id, |
||
375 | AVFormatContext *s, AVStream *st, AVCodec *codec); |
||
376 | |||
377 | /** |
||
378 | * Setup AVCodecContext options for avformat_find_stream_info(). |
||
379 | * |
||
380 | * Create an array of dictionaries, one dictionary for each stream |
||
381 | * contained in s. |
||
382 | * Each dictionary will contain the options from codec_opts which can |
||
383 | * be applied to the corresponding stream codec context. |
||
384 | * |
||
385 | * @return pointer to the created array of dictionaries, NULL if it |
||
386 | * cannot be created |
||
387 | */ |
||
388 | AVDictionary **setup_find_stream_info_opts(AVFormatContext *s, |
||
389 | AVDictionary *codec_opts); |
||
390 | |||
391 | /** |
||
392 | * Print an error message to stderr, indicating filename and a human |
||
393 | * readable description of the error code err. |
||
394 | * |
||
395 | * If strerror_r() is not available the use of this function in a |
||
396 | * multithreaded application may be unsafe. |
||
397 | * |
||
398 | * @see av_strerror() |
||
399 | */ |
||
400 | void print_error(const char *filename, int err); |
||
401 | |||
402 | /** |
||
403 | * Print the program banner to stderr. The banner contents depend on the |
||
404 | * current version of the repository and of the libav* libraries used by |
||
405 | * the program. |
||
406 | */ |
||
407 | void show_banner(int argc, char **argv, const OptionDef *options); |
||
408 | |||
409 | /** |
||
410 | * Print the version of the program to stdout. The version message |
||
411 | * depends on the current versions of the repository and of the libav* |
||
412 | * libraries. |
||
413 | * This option processing function does not utilize the arguments. |
||
414 | */ |
||
415 | int show_version(void *optctx, const char *opt, const char *arg); |
||
416 | |||
417 | /** |
||
418 | * Print the license of the program to stdout. The license depends on |
||
419 | * the license of the libraries compiled into the program. |
||
420 | * This option processing function does not utilize the arguments. |
||
421 | */ |
||
422 | int show_license(void *optctx, const char *opt, const char *arg); |
||
423 | |||
424 | /** |
||
425 | * Print a listing containing all the formats supported by the |
||
426 | * program. |
||
427 | * This option processing function does not utilize the arguments. |
||
428 | */ |
||
429 | int show_formats(void *optctx, const char *opt, const char *arg); |
||
430 | |||
431 | /** |
||
432 | * Print a listing containing all the codecs supported by the |
||
433 | * program. |
||
434 | * This option processing function does not utilize the arguments. |
||
435 | */ |
||
436 | int show_codecs(void *optctx, const char *opt, const char *arg); |
||
437 | |||
438 | /** |
||
439 | * Print a listing containing all the decoders supported by the |
||
440 | * program. |
||
441 | */ |
||
442 | int show_decoders(void *optctx, const char *opt, const char *arg); |
||
443 | |||
444 | /** |
||
445 | * Print a listing containing all the encoders supported by the |
||
446 | * program. |
||
447 | */ |
||
448 | int show_encoders(void *optctx, const char *opt, const char *arg); |
||
449 | |||
450 | /** |
||
451 | * Print a listing containing all the filters supported by the |
||
452 | * program. |
||
453 | * This option processing function does not utilize the arguments. |
||
454 | */ |
||
455 | int show_filters(void *optctx, const char *opt, const char *arg); |
||
456 | |||
457 | /** |
||
458 | * Print a listing containing all the bit stream filters supported by the |
||
459 | * program. |
||
460 | * This option processing function does not utilize the arguments. |
||
461 | */ |
||
462 | int show_bsfs(void *optctx, const char *opt, const char *arg); |
||
463 | |||
464 | /** |
||
465 | * Print a listing containing all the protocols supported by the |
||
466 | * program. |
||
467 | * This option processing function does not utilize the arguments. |
||
468 | */ |
||
469 | int show_protocols(void *optctx, const char *opt, const char *arg); |
||
470 | |||
471 | /** |
||
472 | * Print a listing containing all the pixel formats supported by the |
||
473 | * program. |
||
474 | * This option processing function does not utilize the arguments. |
||
475 | */ |
||
476 | int show_pix_fmts(void *optctx, const char *opt, const char *arg); |
||
477 | |||
478 | /** |
||
479 | * Print a listing containing all the standard channel layouts supported by |
||
480 | * the program. |
||
481 | * This option processing function does not utilize the arguments. |
||
482 | */ |
||
483 | int show_layouts(void *optctx, const char *opt, const char *arg); |
||
484 | |||
485 | /** |
||
486 | * Print a listing containing all the sample formats supported by the |
||
487 | * program. |
||
488 | */ |
||
489 | int show_sample_fmts(void *optctx, const char *opt, const char *arg); |
||
490 | |||
491 | /** |
||
492 | * Print a listing containing all the color names and values recognized |
||
493 | * by the program. |
||
494 | */ |
||
495 | void show_colors(void *optctx, const char *opt, const char *arg); |
||
496 | |||
497 | /** |
||
498 | * Return a positive value if a line read from standard input |
||
499 | * starts with [yY], otherwise return 0. |
||
500 | */ |
||
501 | int read_yesno(void); |
||
502 | |||
503 | /** |
||
504 | * Read the file with name filename, and put its content in a newly |
||
505 | * allocated 0-terminated buffer. |
||
506 | * |
||
507 | * @param filename file to read from |
||
508 | * @param bufptr location where pointer to buffer is returned |
||
509 | * @param size location where size of buffer is returned |
||
510 | * @return >= 0 in case of success, a negative value corresponding to an |
||
511 | * AVERROR error code in case of failure. |
||
512 | */ |
||
513 | int cmdutils_read_file(const char *filename, char **bufptr, size_t *size); |
||
514 | |||
515 | /** |
||
516 | * Get a file corresponding to a preset file. |
||
517 | * |
||
518 | * If is_path is non-zero, look for the file in the path preset_name. |
||
519 | * Otherwise search for a file named arg.ffpreset in the directories |
||
520 | * $FFMPEG_DATADIR (if set), $HOME/.ffmpeg, and in the datadir defined |
||
521 | * at configuration time or in a "ffpresets" folder along the executable |
||
522 | * on win32, in that order. If no such file is found and |
||
523 | * codec_name is defined, then search for a file named |
||
524 | * codec_name-preset_name.avpreset in the above-mentioned directories. |
||
525 | * |
||
526 | * @param filename buffer where the name of the found filename is written |
||
527 | * @param filename_size size in bytes of the filename buffer |
||
528 | * @param preset_name name of the preset to search |
||
529 | * @param is_path tell if preset_name is a filename path |
||
530 | * @param codec_name name of the codec for which to look for the |
||
531 | * preset, may be NULL |
||
532 | */ |
||
533 | FILE *get_preset_file(char *filename, size_t filename_size, |
||
534 | const char *preset_name, int is_path, const char *codec_name); |
||
535 | |||
536 | /** |
||
537 | * Realloc array to hold new_size elements of elem_size. |
||
538 | * Calls exit() on failure. |
||
539 | * |
||
540 | * @param array array to reallocate |
||
541 | * @param elem_size size in bytes of each element |
||
542 | * @param size new element count will be written here |
||
543 | * @param new_size number of elements to place in reallocated array |
||
544 | * @return reallocated array |
||
545 | */ |
||
546 | void *grow_array(void *array, int elem_size, int *size, int new_size); |
||
547 | |||
548 | #define media_type_string av_get_media_type_string |
||
549 | |||
550 | #define GROW_ARRAY(array, nb_elems)\ |
||
551 | array = grow_array(array, sizeof(*array), &nb_elems, nb_elems + 1) |
||
552 | |||
553 | #define GET_PIX_FMT_NAME(pix_fmt)\ |
||
554 | const char *name = av_get_pix_fmt_name(pix_fmt); |
||
555 | |||
556 | #define GET_SAMPLE_FMT_NAME(sample_fmt)\ |
||
557 | const char *name = av_get_sample_fmt_name(sample_fmt) |
||
558 | |||
559 | #define GET_SAMPLE_RATE_NAME(rate)\ |
||
560 | char name[16];\ |
||
561 | snprintf(name, sizeof(name), "%d", rate); |
||
562 | |||
563 | #define GET_CH_LAYOUT_NAME(ch_layout)\ |
||
564 | char name[16];\ |
||
565 | snprintf(name, sizeof(name), "0x%"PRIx64, ch_layout); |
||
566 | |||
567 | #define GET_CH_LAYOUT_DESC(ch_layout)\ |
||
568 | char name[128];\ |
||
569 | av_get_channel_layout_string(name, sizeof(name), 0, ch_layout); |
||
570 | |||
571 | #endif /* CMDUTILS_H */0>>> |