You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

649 lines
23KB

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