git.sesse.net Git - ffmpeg/blob - cmdutils.c

   1 /*
   2  * Various utilities for command line tools
   3  * Copyright (c) 2000-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 #include <string.h>
  23 #include <stdlib.h>
  24 #include <errno.h>
  25 #include <math.h>
  26
  27 /* Include only the enabled headers since some compilers (namely, Sun
  28    Studio) will not omit unused inline functions and create undefined
  29    references to libraries that are not being built. */
  30
  31 #include "config.h"
  32 #include "libavformat/avformat.h"
  33 #include "libavfilter/avfilter.h"
  34 #include "libavdevice/avdevice.h"
  35 #include "libavresample/avresample.h"
  36 #include "libswscale/swscale.h"
  37 #include "libswresample/swresample.h"
  38 #if CONFIG_POSTPROC
  39 #include "libpostproc/postprocess.h"
  40 #endif
  41 #include "libavutil/avstring.h"
  42 #include "libavutil/mathematics.h"
  43 #include "libavutil/parseutils.h"
  44 #include "libavutil/pixdesc.h"
  45 #include "libavutil/eval.h"
  46 #include "libavutil/dict.h"
  47 #include "libavutil/opt.h"
  48 #include "cmdutils.h"
  49 #include "version.h"
  50 #if CONFIG_NETWORK
  51 #include "libavformat/network.h"
  52 #endif
  53 #if HAVE_SYS_RESOURCE_H
  54 #include <sys/resource.h>
  55 #endif
  56
  57 struct SwsContext *sws_opts;
  58 SwrContext *swr_opts;
  59 AVDictionary *format_opts, *codec_opts;
  60
  61 const int this_year = 2012;
  62
  63 static FILE *report_file;
  64
  65 void init_opts(void)
  66 {
  67 #if CONFIG_SWSCALE
  68     sws_opts = sws_getContext(16, 16, 0, 16, 16, 0, SWS_BICUBIC,
  69                               NULL, NULL, NULL);
  70 #endif
  71     swr_opts = swr_alloc();
  72 }
  73
  74 void uninit_opts(void)
  75 {
  76 #if CONFIG_SWSCALE
  77     sws_freeContext(sws_opts);
  78     sws_opts = NULL;
  79 #endif
  80     swr_free(&swr_opts);
  81     av_dict_free(&format_opts);
  82     av_dict_free(&codec_opts);
  83 }
  84
  85 void log_callback_help(void *ptr, int level, const char *fmt, va_list vl)
  86 {
  87     vfprintf(stdout, fmt, vl);
  88 }
  89
  90 static void log_callback_report(void *ptr, int level, const char *fmt, va_list vl)
  91 {
  92     va_list vl2;
  93     char line[1024];
  94     static int print_prefix = 1;
  95
  96     va_copy(vl2, vl);
  97     av_log_default_callback(ptr, level, fmt, vl);
  98     av_log_format_line(ptr, level, fmt, vl2, line, sizeof(line), &print_prefix);
  99     va_end(vl2);
 100     fputs(line, report_file);
 101     fflush(report_file);
 102 }
 103
 104 double parse_number_or_die(const char *context, const char *numstr, int type,
 105                            double min, double max)
 106 {
 107     char *tail;
 108     const char *error;
 109     double d = av_strtod(numstr, &tail);
 110     if (*tail)
 111         error = "Expected number for %s but found: %s\n";
 112     else if (d < min || d > max)
 113         error = "The value for %s was %s which is not within %f - %f\n";
 114     else if (type == OPT_INT64 && (int64_t)d != d)
 115         error = "Expected int64 for %s but found %s\n";
 116     else if (type == OPT_INT && (int)d != d)
 117         error = "Expected int for %s but found %s\n";
 118     else
 119         return d;
 120     av_log(NULL, AV_LOG_FATAL, error, context, numstr, min, max);
 121     exit_program(1);
 122     return 0;
 123 }
 124
 125 int64_t parse_time_or_die(const char *context, const char *timestr,
 126                           int is_duration)
 127 {
 128     int64_t us;
 129     if (av_parse_time(&us, timestr, is_duration) < 0) {
 130         av_log(NULL, AV_LOG_FATAL, "Invalid %s specification for %s: %s\n",
 131                is_duration ? "duration" : "date", context, timestr);
 132         exit_program(1);
 133     }
 134     return us;
 135 }
 136
 137 void show_help_options(const OptionDef *options, const char *msg, int mask,
 138                        int value)
 139 {
 140     const OptionDef *po;
 141     int first;
 142
 143     first = 1;
 144     for (po = options; po->name != NULL; po++) {
 145         char buf[64];
 146         if ((po->flags & mask) == value) {
 147             if (first) {
 148                 printf("%s", msg);
 149                 first = 0;
 150             }
 151             av_strlcpy(buf, po->name, sizeof(buf));
 152             if (po->flags & HAS_ARG) {
 153                 av_strlcat(buf, " ", sizeof(buf));
 154                 av_strlcat(buf, po->argname, sizeof(buf));
 155             }
 156             printf("-%-17s  %s\n", buf, po->help);
 157         }
 158     }
 159 }
 160
 161 void show_help_children(const AVClass *class, int flags)
 162 {
 163     const AVClass *child = NULL;
 164     av_opt_show2(&class, NULL, flags, 0);
 165     printf("\n");
 166
 167     while (child = av_opt_child_class_next(class, child))
 168         show_help_children(child, flags);
 169 }
 170
 171 static const OptionDef *find_option(const OptionDef *po, const char *name)
 172 {
 173     const char *p = strchr(name, ':');
 174     int len = p ? p - name : strlen(name);
 175
 176     while (po->name != NULL) {
 177         if (!strncmp(name, po->name, len) && strlen(po->name) == len)
 178             break;
 179         po++;
 180     }
 181     return po;
 182 }
 183
 184 #if defined(_WIN32) && !defined(__MINGW32CE__)
 185 #include <windows.h>
 186 /* Will be leaked on exit */
 187 static char** win32_argv_utf8 = NULL;
 188 static int win32_argc = 0;
 189
 190 /**
 191  * Prepare command line arguments for executable.
 192  * For Windows - perform wide-char to UTF-8 conversion.
 193  * Input arguments should be main() function arguments.
 194  * @param argc_ptr Arguments number (including executable)
 195  * @param argv_ptr Arguments list.
 196  */
 197 static void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
 198 {
 199     char *argstr_flat;
 200     wchar_t **argv_w;
 201     int i, buffsize = 0, offset = 0;
 202
 203     if (win32_argv_utf8) {
 204         *argc_ptr = win32_argc;
 205         *argv_ptr = win32_argv_utf8;
 206         return;
 207     }
 208
 209     win32_argc = 0;
 210     argv_w = CommandLineToArgvW(GetCommandLineW(), &win32_argc);
 211     if (win32_argc <= 0 || !argv_w)
 212         return;
 213
 214     /* determine the UTF-8 buffer size (including NULL-termination symbols) */
 215     for (i = 0; i < win32_argc; i++)
 216         buffsize += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
 217                                         NULL, 0, NULL, NULL);
 218
 219     win32_argv_utf8 = av_mallocz(sizeof(char *) * (win32_argc + 1) + buffsize);
 220     argstr_flat     = (char *)win32_argv_utf8 + sizeof(char *) * (win32_argc + 1);
 221     if (win32_argv_utf8 == NULL) {
 222         LocalFree(argv_w);
 223         return;
 224     }
 225
 226     for (i = 0; i < win32_argc; i++) {
 227         win32_argv_utf8[i] = &argstr_flat[offset];
 228         offset += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
 229                                       &argstr_flat[offset],
 230                                       buffsize - offset, NULL, NULL);
 231     }
 232     win32_argv_utf8[i] = NULL;
 233     LocalFree(argv_w);
 234
 235     *argc_ptr = win32_argc;
 236     *argv_ptr = win32_argv_utf8;
 237 }
 238 #else
 239 static inline void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
 240 {
 241     /* nothing to do */
 242 }
 243 #endif /* WIN32 && !__MINGW32CE__ */
 244
 245 int parse_option(void *optctx, const char *opt, const char *arg,
 246                  const OptionDef *options)
 247 {
 248     const OptionDef *po;
 249     int bool_val = 1;
 250     int *dstcount;
 251     void *dst;
 252
 253     po = find_option(options, opt);
 254     if (!po->name && opt[0] == 'n' && opt[1] == 'o') {
 255         /* handle 'no' bool option */
 256         po = find_option(options, opt + 2);
 257         if ((po->name && (po->flags & OPT_BOOL)))
 258             bool_val = 0;
 259     }
 260     if (!po->name)
 261         po = find_option(options, "default");
 262     if (!po->name) {
 263         av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
 264         return AVERROR(EINVAL);
 265     }
 266     if (po->flags & HAS_ARG && !arg) {
 267         av_log(NULL, AV_LOG_ERROR, "Missing argument for option '%s'\n", opt);
 268         return AVERROR(EINVAL);
 269     }
 270
 271     /* new-style options contain an offset into optctx, old-style address of
 272      * a global var*/
 273     dst = po->flags & (OPT_OFFSET | OPT_SPEC) ? (uint8_t *)optctx + po->u.off
 274                                               : po->u.dst_ptr;
 275
 276     if (po->flags & OPT_SPEC) {
 277         SpecifierOpt **so = dst;
 278         char *p = strchr(opt, ':');
 279
 280         dstcount = (int *)(so + 1);
 281         *so = grow_array(*so, sizeof(**so), dstcount, *dstcount + 1);
 282         (*so)[*dstcount - 1].specifier = av_strdup(p ? p + 1 : "");
 283         dst = &(*so)[*dstcount - 1].u;
 284     }
 285
 286     if (po->flags & OPT_STRING) {
 287         char *str;
 288         str = av_strdup(arg);
 289         *(char **)dst = str;
 290     } else if (po->flags & OPT_BOOL) {
 291         *(int *)dst = bool_val;
 292     } else if (po->flags & OPT_INT) {
 293         *(int *)dst = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
 294     } else if (po->flags & OPT_INT64) {
 295         *(int64_t *)dst = parse_number_or_die(opt, arg, OPT_INT64, INT64_MIN, INT64_MAX);
 296     } else if (po->flags & OPT_TIME) {
 297         *(int64_t *)dst = parse_time_or_die(opt, arg, 1);
 298     } else if (po->flags & OPT_FLOAT) {
 299         *(float *)dst = parse_number_or_die(opt, arg, OPT_FLOAT, -INFINITY, INFINITY);
 300     } else if (po->flags & OPT_DOUBLE) {
 301         *(double *)dst = parse_number_or_die(opt, arg, OPT_DOUBLE, -INFINITY, INFINITY);
 302     } else if (po->u.func_arg) {
 303         int ret = po->flags & OPT_FUNC2 ? po->u.func2_arg(optctx, opt, arg)
 304                                         : po->u.func_arg(opt, arg);
 305         if (ret < 0) {
 306             av_log(NULL, AV_LOG_ERROR,
 307                    "Failed to set value '%s' for option '%s'\n", arg, opt);
 308             return ret;
 309         }
 310     }
 311     if (po->flags & OPT_EXIT)
 312         exit_program(0);
 313     return !!(po->flags & HAS_ARG);
 314 }
 315
 316 void parse_options(void *optctx, int argc, char **argv, const OptionDef *options,
 317                    void (*parse_arg_function)(void *, const char*))
 318 {
 319     const char *opt;
 320     int optindex, handleoptions = 1, ret;
 321
 322     /* perform system-dependent conversions for arguments list */
 323     prepare_app_arguments(&argc, &argv);
 324
 325     /* parse options */
 326     optindex = 1;
 327     while (optindex < argc) {
 328         opt = argv[optindex++];
 329
 330         if (handleoptions && opt[0] == '-' && opt[1] != '\0') {
 331             if (opt[1] == '-' && opt[2] == '\0') {
 332                 handleoptions = 0;
 333                 continue;
 334             }
 335             opt++;
 336
 337             if ((ret = parse_option(optctx, opt, argv[optindex], options)) < 0)
 338                 exit_program(1);
 339             optindex += ret;
 340         } else {
 341             if (parse_arg_function)
 342                 parse_arg_function(optctx, opt);
 343         }
 344     }
 345 }
 346
 347 int locate_option(int argc, char **argv, const OptionDef *options,
 348                   const char *optname)
 349 {
 350     const OptionDef *po;
 351     int i;
 352
 353     for (i = 1; i < argc; i++) {
 354         const char *cur_opt = argv[i];
 355
 356         if (*cur_opt++ != '-')
 357             continue;
 358
 359         po = find_option(options, cur_opt);
 360         if (!po->name && cur_opt[0] == 'n' && cur_opt[1] == 'o')
 361             po = find_option(options, cur_opt + 2);
 362
 363         if ((!po->name && !strcmp(cur_opt, optname)) ||
 364              (po->name && !strcmp(optname, po->name)))
 365             return i;
 366
 367         if (!po || po->flags & HAS_ARG)
 368             i++;
 369     }
 370     return 0;
 371 }
 372
 373 static void dump_argument(const char *a)
 374 {
 375     const unsigned char *p;
 376
 377     for (p = a; *p; p++)
 378         if (!((*p >= '+' && *p <= ':') || (*p >= '@' && *p <= 'Z') ||
 379               *p == '_' || (*p >= 'a' && *p <= 'z')))
 380             break;
 381     if (!*p) {
 382         fputs(a, report_file);
 383         return;
 384     }
 385     fputc('"', report_file);
 386     for (p = a; *p; p++) {
 387         if (*p == '\\' || *p == '"' || *p == '$' || *p == '`')
 388             fprintf(report_file, "\\%c", *p);
 389         else if (*p < ' ' || *p > '~')
 390             fprintf(report_file, "\\x%02x", *p);
 391         else
 392             fputc(*p, report_file);
 393     }
 394     fputc('"', report_file);
 395 }
 396
 397 void parse_loglevel(int argc, char **argv, const OptionDef *options)
 398 {
 399     int idx = locate_option(argc, argv, options, "loglevel");
 400     if (!idx)
 401         idx = locate_option(argc, argv, options, "v");
 402     if (idx && argv[idx + 1])
 403         opt_loglevel("loglevel", argv[idx + 1]);
 404     idx = locate_option(argc, argv, options, "report");
 405     if (idx || getenv("FFREPORT")) {
 406         opt_report("report");
 407         if (report_file) {
 408             int i;
 409             fprintf(report_file, "Command line:\n");
 410             for (i = 0; i < argc; i++) {
 411                 dump_argument(argv[i]);
 412                 fputc(i < argc - 1 ? ' ' : '\n', report_file);
 413             }
 414             fflush(report_file);
 415         }
 416     }
 417 }
 418
 419 #define FLAGS(o) ((o)->type == AV_OPT_TYPE_FLAGS) ? AV_DICT_APPEND : 0
 420 int opt_default(const char *opt, const char *arg)
 421 {
 422     const AVOption *oc, *of, *os, *oswr = NULL;
 423     char opt_stripped[128];
 424     const char *p;
 425     const AVClass *cc = avcodec_get_class(), *fc = avformat_get_class(), *sc, *swr_class;
 426
 427     if (!(p = strchr(opt, ':')))
 428         p = opt + strlen(opt);
 429     av_strlcpy(opt_stripped, opt, FFMIN(sizeof(opt_stripped), p - opt + 1));
 430
 431     if ((oc = av_opt_find(&cc, opt_stripped, NULL, 0,
 432                          AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)) ||
 433         ((opt[0] == 'v' || opt[0] == 'a' || opt[0] == 's') &&
 434          (oc = av_opt_find(&cc, opt + 1, NULL, 0, AV_OPT_SEARCH_FAKE_OBJ))))
 435         av_dict_set(&codec_opts, opt, arg, FLAGS(oc));
 436     if ((of = av_opt_find(&fc, opt, NULL, 0,
 437                           AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)))
 438         av_dict_set(&format_opts, opt, arg, FLAGS(of));
 439 #if CONFIG_SWSCALE
 440     sc = sws_get_class();
 441     if ((os = av_opt_find(&sc, opt, NULL, 0,
 442                           AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {
 443         // XXX we only support sws_flags, not arbitrary sws options
 444         int ret = av_opt_set(sws_opts, opt, arg, 0);
 445         if (ret < 0) {
 446             av_log(NULL, AV_LOG_ERROR, "Error setting option %s.\n", opt);
 447             return ret;
 448         }
 449     }
 450 #endif
 451     swr_class = swr_get_class();
 452     if (!oc && !of && !os && (oswr = av_opt_find(&swr_class, opt, NULL, 0,
 453                           AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {
 454         int ret = av_opt_set(swr_opts, opt, arg, 0);
 455         if (ret < 0) {
 456             av_log(NULL, AV_LOG_ERROR, "Error setting option %s.\n", opt);
 457             return ret;
 458         }
 459     }
 460
 461     if (oc || of || os || oswr)
 462         return 0;
 463     av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
 464     return AVERROR_OPTION_NOT_FOUND;
 465 }
 466
 467 int opt_loglevel(const char *opt, const char *arg)
 468 {
 469     const struct { const char *name; int level; } log_levels[] = {
 470         { "quiet"  , AV_LOG_QUIET   },
 471         { "panic"  , AV_LOG_PANIC   },
 472         { "fatal"  , AV_LOG_FATAL   },
 473         { "error"  , AV_LOG_ERROR   },
 474         { "warning", AV_LOG_WARNING },
 475         { "info"   , AV_LOG_INFO    },
 476         { "verbose", AV_LOG_VERBOSE },
 477         { "debug"  , AV_LOG_DEBUG   },
 478     };
 479     char *tail;
 480     int level;
 481     int i;
 482
 483     for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
 484         if (!strcmp(log_levels[i].name, arg)) {
 485             av_log_set_level(log_levels[i].level);
 486             return 0;
 487         }
 488     }
 489
 490     level = strtol(arg, &tail, 10);
 491     if (*tail) {
 492         av_log(NULL, AV_LOG_FATAL, "Invalid loglevel \"%s\". "
 493                "Possible levels are numbers or:\n", arg);
 494         for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
 495             av_log(NULL, AV_LOG_FATAL, "\"%s\"\n", log_levels[i].name);
 496         exit_program(1);
 497     }
 498     av_log_set_level(level);
 499     return 0;
 500 }
 501
 502 int opt_report(const char *opt)
 503 {
 504     char filename[64];
 505     time_t now;
 506     struct tm *tm;
 507
 508     if (report_file) /* already opened */
 509         return 0;
 510     time(&now);
 511     tm = localtime(&now);
 512     snprintf(filename, sizeof(filename), "%s-%04d%02d%02d-%02d%02d%02d.log",
 513              program_name,
 514              tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
 515              tm->tm_hour, tm->tm_min, tm->tm_sec);
 516     report_file = fopen(filename, "w");
 517     if (!report_file) {
 518         av_log(NULL, AV_LOG_ERROR, "Failed to open report \"%s\": %s\n",
 519                filename, strerror(errno));
 520         return AVERROR(errno);
 521     }
 522     av_log_set_callback(log_callback_report);
 523     av_log(NULL, AV_LOG_INFO,
 524            "%s started on %04d-%02d-%02d at %02d:%02d:%02d\n"
 525            "Report written to \"%s\"\n",
 526            program_name,
 527            tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
 528            tm->tm_hour, tm->tm_min, tm->tm_sec,
 529            filename);
 530     av_log_set_level(FFMAX(av_log_get_level(), AV_LOG_VERBOSE));
 531     return 0;
 532 }
 533
 534 int opt_max_alloc(const char *opt, const char *arg)
 535 {
 536     char *tail;
 537     size_t max;
 538
 539     max = strtol(arg, &tail, 10);
 540     if (*tail) {
 541         av_log(NULL, AV_LOG_FATAL, "Invalid max_alloc \"%s\".\n", arg);
 542         exit_program(1);
 543     }
 544     av_max_alloc(max);
 545     return 0;
 546 }
 547
 548 int opt_cpuflags(const char *opt, const char *arg)
 549 {
 550     int ret;
 551     unsigned flags = av_get_cpu_flags();
 552
 553     if ((ret = av_parse_cpu_caps(&flags, arg)) < 0)
 554         return ret;
 555
 556     av_force_cpu_flags(flags);
 557     return 0;
 558 }
 559
 560 int opt_codec_debug(const char *opt, const char *arg)
 561 {
 562     av_log_set_level(AV_LOG_DEBUG);
 563     return opt_default(opt, arg);
 564 }
 565
 566 int opt_timelimit(const char *opt, const char *arg)
 567 {
 568 #if HAVE_SETRLIMIT
 569     int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
 570     struct rlimit rl = { lim, lim + 1 };
 571     if (setrlimit(RLIMIT_CPU, &rl))
 572         perror("setrlimit");
 573 #else
 574     av_log(NULL, AV_LOG_WARNING, "-%s not implemented on this OS\n", opt);
 575 #endif
 576     return 0;
 577 }
 578
 579 void print_error(const char *filename, int err)
 580 {
 581     char errbuf[128];
 582     const char *errbuf_ptr = errbuf;
 583
 584     if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
 585         errbuf_ptr = strerror(AVUNERROR(err));
 586     av_log(NULL, AV_LOG_ERROR, "%s: %s\n", filename, errbuf_ptr);
 587 }
 588
 589 static int warned_cfg = 0;
 590
 591 #define INDENT        1
 592 #define SHOW_VERSION  2
 593 #define SHOW_CONFIG   4
 594 #define SHOW_COPYRIGHT 8
 595
 596 #define PRINT_LIB_INFO(libname, LIBNAME, flags, level)                  \
 597     if (CONFIG_##LIBNAME) {                                             \
 598         const char *indent = flags & INDENT? "  " : "";                 \
 599         if (flags & SHOW_VERSION) {                                     \
 600             unsigned int version = libname##_version();                 \
 601             av_log(NULL, level,                                         \
 602                    "%slib%-11s %2d.%3d.%3d / %2d.%3d.%3d\n",            \
 603                    indent, #libname,                                    \
 604                    LIB##LIBNAME##_VERSION_MAJOR,                        \
 605                    LIB##LIBNAME##_VERSION_MINOR,                        \
 606                    LIB##LIBNAME##_VERSION_MICRO,                        \
 607                    version >> 16, version >> 8 & 0xff, version & 0xff); \
 608         }                                                               \
 609         if (flags & SHOW_CONFIG) {                                      \
 610             const char *cfg = libname##_configuration();                \
 611             if (strcmp(FFMPEG_CONFIGURATION, cfg)) {                    \
 612                 if (!warned_cfg) {                                      \
 613                     av_log(NULL, level,                                 \
 614                             "%sWARNING: library configuration mismatch\n", \
 615                             indent);                                    \
 616                     warned_cfg = 1;                                     \
 617                 }                                                       \
 618                 av_log(NULL, level, "%s%-11s configuration: %s\n",      \
 619                         indent, #libname, cfg);                         \
 620             }                                                           \
 621         }                                                               \
 622     }                                                                   \
 623
 624 static void print_all_libs_info(int flags, int level)
 625 {
 626     PRINT_LIB_INFO(avutil,   AVUTIL,   flags, level);
 627     PRINT_LIB_INFO(avcodec,  AVCODEC,  flags, level);
 628     PRINT_LIB_INFO(avformat, AVFORMAT, flags, level);
 629     PRINT_LIB_INFO(avdevice, AVDEVICE, flags, level);
 630     PRINT_LIB_INFO(avfilter, AVFILTER, flags, level);
 631 //    PRINT_LIB_INFO(avresample, AVRESAMPLE, flags, level);
 632     PRINT_LIB_INFO(swscale,  SWSCALE,  flags, level);
 633     PRINT_LIB_INFO(swresample,SWRESAMPLE,  flags, level);
 634 #if CONFIG_POSTPROC
 635     PRINT_LIB_INFO(postproc, POSTPROC, flags, level);
 636 #endif
 637 }
 638
 639 static void print_program_info(int flags, int level)
 640 {
 641     const char *indent = flags & INDENT? "  " : "";
 642
 643     av_log(NULL, level, "%s version " FFMPEG_VERSION, program_name);
 644     if (flags & SHOW_COPYRIGHT)
 645         av_log(NULL, level, " Copyright (c) %d-%d the FFmpeg developers",
 646                program_birth_year, this_year);
 647     av_log(NULL, level, "\n");
 648     av_log(NULL, level, "%sbuilt on %s %s with %s %s\n",
 649            indent, __DATE__, __TIME__, CC_TYPE, CC_VERSION);
 650     av_log(NULL, level, "%sconfiguration: " FFMPEG_CONFIGURATION "\n", indent);
 651 }
 652
 653 void show_banner(int argc, char **argv, const OptionDef *options)
 654 {
 655     int idx = locate_option(argc, argv, options, "version");
 656     if (idx)
 657         return;
 658
 659     print_program_info (INDENT|SHOW_COPYRIGHT, AV_LOG_INFO);
 660     print_all_libs_info(INDENT|SHOW_CONFIG,  AV_LOG_INFO);
 661     print_all_libs_info(INDENT|SHOW_VERSION, AV_LOG_INFO);
 662 }
 663
 664 int opt_version(const char *opt, const char *arg) {
 665     av_log_set_callback(log_callback_help);
 666     print_program_info (0           , AV_LOG_INFO);
 667     print_all_libs_info(SHOW_VERSION, AV_LOG_INFO);
 668     return 0;
 669 }
 670
 671 int opt_license(const char *opt, const char *arg)
 672 {
 673     printf(
 674 #if CONFIG_NONFREE
 675     "This version of %s has nonfree parts compiled in.\n"
 676     "Therefore it is not legally redistributable.\n",
 677     program_name
 678 #elif CONFIG_GPLV3
 679     "%s is free software; you can redistribute it and/or modify\n"
 680     "it under the terms of the GNU General Public License as published by\n"
 681     "the Free Software Foundation; either version 3 of the License, or\n"
 682     "(at your option) any later version.\n"
 683     "\n"
 684     "%s is distributed in the hope that it will be useful,\n"
 685     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 686     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
 687     "GNU General Public License for more details.\n"
 688     "\n"
 689     "You should have received a copy of the GNU General Public License\n"
 690     "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
 691     program_name, program_name, program_name
 692 #elif CONFIG_GPL
 693     "%s is free software; you can redistribute it and/or modify\n"
 694     "it under the terms of the GNU General Public License as published by\n"
 695     "the Free Software Foundation; either version 2 of the License, or\n"
 696     "(at your option) any later version.\n"
 697     "\n"
 698     "%s is distributed in the hope that it will be useful,\n"
 699     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 700     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
 701     "GNU General Public License for more details.\n"
 702     "\n"
 703     "You should have received a copy of the GNU General Public License\n"
 704     "along with %s; if not, write to the Free Software\n"
 705     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
 706     program_name, program_name, program_name
 707 #elif CONFIG_LGPLV3
 708     "%s is free software; you can redistribute it and/or modify\n"
 709     "it under the terms of the GNU Lesser General Public License as published by\n"
 710     "the Free Software Foundation; either version 3 of the License, or\n"
 711     "(at your option) any later version.\n"
 712     "\n"
 713     "%s is distributed in the hope that it will be useful,\n"
 714     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 715     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
 716     "GNU Lesser General Public License for more details.\n"
 717     "\n"
 718     "You should have received a copy of the GNU Lesser General Public License\n"
 719     "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
 720     program_name, program_name, program_name
 721 #else
 722     "%s is free software; you can redistribute it and/or\n"
 723     "modify it under the terms of the GNU Lesser General Public\n"
 724     "License as published by the Free Software Foundation; either\n"
 725     "version 2.1 of the License, or (at your option) any later version.\n"
 726     "\n"
 727     "%s is distributed in the hope that it will be useful,\n"
 728     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 729     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
 730     "Lesser General Public License for more details.\n"
 731     "\n"
 732     "You should have received a copy of the GNU Lesser General Public\n"
 733     "License along with %s; if not, write to the Free Software\n"
 734     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
 735     program_name, program_name, program_name
 736 #endif
 737     );
 738     return 0;
 739 }
 740
 741 int opt_formats(const char *opt, const char *arg)
 742 {
 743     AVInputFormat *ifmt  = NULL;
 744     AVOutputFormat *ofmt = NULL;
 745     const char *last_name;
 746
 747     printf("File formats:\n"
 748            " D. = Demuxing supported\n"
 749            " .E = Muxing supported\n"
 750            " --\n");
 751     last_name = "000";
 752     for (;;) {
 753         int decode = 0;
 754         int encode = 0;
 755         const char *name      = NULL;
 756         const char *long_name = NULL;
 757
 758         while ((ofmt = av_oformat_next(ofmt))) {
 759             if ((name == NULL || strcmp(ofmt->name, name) < 0) &&
 760                 strcmp(ofmt->name, last_name) > 0) {
 761                 name      = ofmt->name;
 762                 long_name = ofmt->long_name;
 763                 encode    = 1;
 764             }
 765         }
 766         while ((ifmt = av_iformat_next(ifmt))) {
 767             if ((name == NULL || strcmp(ifmt->name, name) < 0) &&
 768                 strcmp(ifmt->name, last_name) > 0) {
 769                 name      = ifmt->name;
 770                 long_name = ifmt->long_name;
 771                 encode    = 0;
 772             }
 773             if (name && strcmp(ifmt->name, name) == 0)
 774                 decode = 1;
 775         }
 776         if (name == NULL)
 777             break;
 778         last_name = name;
 779
 780         printf(" %s%s %-15s %s\n",
 781                decode ? "D" : " ",
 782                encode ? "E" : " ",
 783                name,
 784             long_name ? long_name:" ");
 785     }
 786     return 0;
 787 }
 788
 789 static char get_media_type_char(enum AVMediaType type)
 790 {
 791     static const char map[AVMEDIA_TYPE_NB] = {
 792         [AVMEDIA_TYPE_VIDEO]      = 'V',
 793         [AVMEDIA_TYPE_AUDIO]      = 'A',
 794         [AVMEDIA_TYPE_DATA]       = 'D',
 795         [AVMEDIA_TYPE_SUBTITLE]   = 'S',
 796         [AVMEDIA_TYPE_ATTACHMENT] = 'T',
 797     };
 798     return type >= 0 && type < AVMEDIA_TYPE_NB && map[type] ? map[type] : '?';
 799 }
 800
 801 int opt_codecs(const char *opt, const char *arg)
 802 {
 803     AVCodec *p = NULL, *p2;
 804     const char *last_name;
 805     printf("Codecs:\n"
 806            " D..... = Decoding supported\n"
 807            " .E.... = Encoding supported\n"
 808            " ..V... = Video codec\n"
 809            " ..A... = Audio codec\n"
 810            " ..S... = Subtitle codec\n"
 811            " ...S.. = Supports draw_horiz_band\n"
 812            " ....D. = Supports direct rendering method 1\n"
 813            " .....T = Supports weird frame truncation\n"
 814            " ------\n");
 815     last_name= "000";
 816     for (;;) {
 817         int decode = 0;
 818         int encode = 0;
 819         int cap    = 0;
 820
 821         p2 = NULL;
 822         while ((p = av_codec_next(p))) {
 823             if ((p2 == NULL || strcmp(p->name, p2->name) < 0) &&
 824                 strcmp(p->name, last_name) > 0) {
 825                 p2 = p;
 826                 decode = encode = cap = 0;
 827             }
 828             if (p2 && strcmp(p->name, p2->name) == 0) {
 829                 if (av_codec_is_decoder(p))
 830                     decode = 1;
 831                 if (av_codec_is_encoder(p))
 832                     encode = 1;
 833                 cap |= p->capabilities;
 834             }
 835         }
 836         if (p2 == NULL)
 837             break;
 838         last_name = p2->name;
 839
 840         printf(" %s%s%c%s%s%s %-15s %s",
 841                decode ? "D" : (/* p2->decoder ? "d" : */ " "),
 842                encode ? "E" : " ",
 843                get_media_type_char(p2->type),
 844                cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S" : " ",
 845                cap & CODEC_CAP_DR1 ? "D" : " ",
 846                cap & CODEC_CAP_TRUNCATED ? "T" : " ",
 847                p2->name,
 848                p2->long_name ? p2->long_name : "");
 849 #if 0
 850             if (p2->decoder && decode == 0)
 851                 printf(" use %s for decoding", p2->decoder->name);
 852 #endif
 853         printf("\n");
 854     }
 855     printf("\n");
 856     printf("Note, the names of encoders and decoders do not always match, so there are\n"
 857            "several cases where the above table shows encoder only or decoder only entries\n"
 858            "even though both encoding and decoding are supported. For example, the h263\n"
 859            "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
 860            "worse.\n");
 861     return 0;
 862 }
 863
 864 int opt_bsfs(const char *opt, const char *arg)
 865 {
 866     AVBitStreamFilter *bsf = NULL;
 867
 868     printf("Bitstream filters:\n");
 869     while ((bsf = av_bitstream_filter_next(bsf)))
 870         printf("%s\n", bsf->name);
 871     printf("\n");
 872     return 0;
 873 }
 874
 875 int opt_protocols(const char *opt, const char *arg)
 876 {
 877     void *opaque = NULL;
 878     const char *name;
 879
 880     printf("Supported file protocols:\n"
 881            "Input:\n");
 882     while ((name = avio_enum_protocols(&opaque, 0)))
 883         printf("%s\n", name);
 884     printf("Output:\n");
 885     while ((name = avio_enum_protocols(&opaque, 1)))
 886         printf("%s\n", name);
 887     return 0;
 888 }
 889
 890 int opt_filters(const char *opt, const char *arg)
 891 {
 892     AVFilter av_unused(**filter) = NULL;
 893     char descr[64], *descr_cur;
 894     int i, j;
 895     const AVFilterPad *pad;
 896
 897     printf("Filters:\n");
 898 #if CONFIG_AVFILTER
 899     while ((filter = av_filter_next(filter)) && *filter) {
 900         descr_cur = descr;
 901         for (i = 0; i < 2; i++) {
 902             if (i) {
 903                 *(descr_cur++) = '-';
 904                 *(descr_cur++) = '>';
 905             }
 906             pad = i ? (*filter)->outputs : (*filter)->inputs;
 907             for (j = 0; pad[j].name; j++) {
 908                 if (descr_cur >= descr + sizeof(descr) - 4)
 909                     break;
 910                 *(descr_cur++) = get_media_type_char(pad[j].type);
 911             }
 912             if (!j)
 913                 *(descr_cur++) = '|';
 914         }
 915         *descr_cur = 0;
 916         printf("%-16s %-10s %s\n", (*filter)->name, descr, (*filter)->description);
 917     }
 918 #endif
 919     return 0;
 920 }
 921
 922 int opt_pix_fmts(const char *opt, const char *arg)
 923 {
 924     enum PixelFormat pix_fmt;
 925
 926     printf("Pixel formats:\n"
 927            "I.... = Supported Input  format for conversion\n"
 928            ".O... = Supported Output format for conversion\n"
 929            "..H.. = Hardware accelerated format\n"
 930            "...P. = Paletted format\n"
 931            "....B = Bitstream format\n"
 932            "FLAGS NAME            NB_COMPONENTS BITS_PER_PIXEL\n"
 933            "-----\n");
 934
 935 #if !CONFIG_SWSCALE
 936 #   define sws_isSupportedInput(x)  0
 937 #   define sws_isSupportedOutput(x) 0
 938 #endif
 939
 940     for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
 941         const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
 942         if(!pix_desc->name)
 943             continue;
 944         printf("%c%c%c%c%c %-16s       %d            %2d\n",
 945                sws_isSupportedInput (pix_fmt)      ? 'I' : '.',
 946                sws_isSupportedOutput(pix_fmt)      ? 'O' : '.',
 947                pix_desc->flags & PIX_FMT_HWACCEL   ? 'H' : '.',
 948                pix_desc->flags & PIX_FMT_PAL       ? 'P' : '.',
 949                pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
 950                pix_desc->name,
 951                pix_desc->nb_components,
 952                av_get_bits_per_pixel(pix_desc));
 953     }
 954     return 0;
 955 }
 956
 957 int show_sample_fmts(const char *opt, const char *arg)
 958 {
 959     int i;
 960     char fmt_str[128];
 961     for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
 962         printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
 963     return 0;
 964 }
 965
 966 int read_yesno(void)
 967 {
 968     int c = getchar();
 969     int yesno = (toupper(c) == 'Y');
 970
 971     while (c != '\n' && c != EOF)
 972         c = getchar();
 973
 974     return yesno;
 975 }
 976
 977 int cmdutils_read_file(const char *filename, char **bufptr, size_t *size)
 978 {
 979     int ret;
 980     FILE *f = fopen(filename, "rb");
 981
 982     if (!f) {
 983         av_log(NULL, AV_LOG_ERROR, "Cannot read file '%s': %s\n", filename,
 984                strerror(errno));
 985         return AVERROR(errno);
 986     }
 987     fseek(f, 0, SEEK_END);
 988     *size = ftell(f);
 989     fseek(f, 0, SEEK_SET);
 990     *bufptr = av_malloc(*size + 1);
 991     if (!*bufptr) {
 992         av_log(NULL, AV_LOG_ERROR, "Could not allocate file buffer\n");
 993         fclose(f);
 994         return AVERROR(ENOMEM);
 995     }
 996     ret = fread(*bufptr, 1, *size, f);
 997     if (ret < *size) {
 998         av_free(*bufptr);
 999         if (ferror(f)) {
1000             av_log(NULL, AV_LOG_ERROR, "Error while reading file '%s': %s\n",
1001                    filename, strerror(errno));
1002             ret = AVERROR(errno);
1003         } else
1004             ret = AVERROR_EOF;
1005     } else {
1006         ret = 0;
1007         (*bufptr)[*size++] = '\0';
1008     }
1009
1010     fclose(f);
1011     return ret;
1012 }
1013
1014 FILE *get_preset_file(char *filename, size_t filename_size,
1015                       const char *preset_name, int is_path,
1016                       const char *codec_name)
1017 {
1018     FILE *f = NULL;
1019     int i;
1020     const char *base[3] = { getenv("FFMPEG_DATADIR"),
1021                             getenv("HOME"),
1022                             FFMPEG_DATADIR, };
1023
1024     if (is_path) {
1025         av_strlcpy(filename, preset_name, filename_size);
1026         f = fopen(filename, "r");
1027     } else {
1028 #ifdef _WIN32
1029         char datadir[MAX_PATH], *ls;
1030         base[2] = NULL;
1031
1032         if (GetModuleFileNameA(GetModuleHandleA(NULL), datadir, sizeof(datadir) - 1))
1033         {
1034             for (ls = datadir; ls < datadir + strlen(datadir); ls++)
1035                 if (*ls == '\\') *ls = '/';
1036
1037             if (ls = strrchr(datadir, '/'))
1038             {
1039                 *ls = 0;
1040                 strncat(datadir, "/ffpresets",  sizeof(datadir) - 1 - strlen(datadir));
1041                 base[2] = datadir;
1042             }
1043         }
1044 #endif
1045         for (i = 0; i < 3 && !f; i++) {
1046             if (!base[i])
1047                 continue;
1048             snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i],
1049                      i != 1 ? "" : "/.ffmpeg", preset_name);
1050             f = fopen(filename, "r");
1051             if (!f && codec_name) {
1052                 snprintf(filename, filename_size,
1053                          "%s%s/%s-%s.ffpreset",
1054                          base[i], i != 1 ? "" : "/.ffmpeg", codec_name,
1055                          preset_name);
1056                 f = fopen(filename, "r");
1057             }
1058         }
1059     }
1060
1061     return f;
1062 }
1063
1064 int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
1065 {
1066     if (*spec <= '9' && *spec >= '0') /* opt:index */
1067         return strtol(spec, NULL, 0) == st->index;
1068     else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
1069              *spec == 't') { /* opt:[vasdt] */
1070         enum AVMediaType type;
1071
1072         switch (*spec++) {
1073         case 'v': type = AVMEDIA_TYPE_VIDEO;      break;
1074         case 'a': type = AVMEDIA_TYPE_AUDIO;      break;
1075         case 's': type = AVMEDIA_TYPE_SUBTITLE;   break;
1076         case 'd': type = AVMEDIA_TYPE_DATA;       break;
1077         case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
1078         default: abort(); // never reached, silence warning
1079         }
1080         if (type != st->codec->codec_type)
1081             return 0;
1082         if (*spec++ == ':') { /* possibly followed by :index */
1083             int i, index = strtol(spec, NULL, 0);
1084             for (i = 0; i < s->nb_streams; i++)
1085                 if (s->streams[i]->codec->codec_type == type && index-- == 0)
1086                    return i == st->index;
1087             return 0;
1088         }
1089         return 1;
1090     } else if (*spec == 'p' && *(spec + 1) == ':') {
1091         int prog_id, i, j;
1092         char *endptr;
1093         spec += 2;
1094         prog_id = strtol(spec, &endptr, 0);
1095         for (i = 0; i < s->nb_programs; i++) {
1096             if (s->programs[i]->id != prog_id)
1097                 continue;
1098
1099             if (*endptr++ == ':') {
1100                 int stream_idx = strtol(endptr, NULL, 0);
1101                 return stream_idx >= 0 &&
1102                     stream_idx < s->programs[i]->nb_stream_indexes &&
1103                     st->index == s->programs[i]->stream_index[stream_idx];
1104             }
1105
1106             for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
1107                 if (st->index == s->programs[i]->stream_index[j])
1108                     return 1;
1109         }
1110         return 0;
1111     } else if (!*spec) /* empty specifier, matches everything */
1112         return 1;
1113
1114     av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
1115     return AVERROR(EINVAL);
1116 }
1117
1118 AVDictionary *filter_codec_opts(AVDictionary *opts, AVCodec *codec,
1119                                 AVFormatContext *s, AVStream *st)
1120 {
1121     AVDictionary    *ret = NULL;
1122     AVDictionaryEntry *t = NULL;
1123     int            flags = s->oformat ? AV_OPT_FLAG_ENCODING_PARAM
1124                                       : AV_OPT_FLAG_DECODING_PARAM;
1125     char          prefix = 0;
1126     const AVClass    *cc = avcodec_get_class();
1127
1128     if (!codec)
1129         return NULL;
1130
1131     switch (codec->type) {
1132     case AVMEDIA_TYPE_VIDEO:
1133         prefix  = 'v';
1134         flags  |= AV_OPT_FLAG_VIDEO_PARAM;
1135         break;
1136     case AVMEDIA_TYPE_AUDIO:
1137         prefix  = 'a';
1138         flags  |= AV_OPT_FLAG_AUDIO_PARAM;
1139         break;
1140     case AVMEDIA_TYPE_SUBTITLE:
1141         prefix  = 's';
1142         flags  |= AV_OPT_FLAG_SUBTITLE_PARAM;
1143         break;
1144     }
1145
1146     while (t = av_dict_get(opts, "", t, AV_DICT_IGNORE_SUFFIX)) {
1147         char *p = strchr(t->key, ':');
1148
1149         /* check stream specification in opt name */
1150         if (p)
1151             switch (check_stream_specifier(s, st, p + 1)) {
1152             case  1: *p = 0; break;
1153             case  0:         continue;
1154             default:         return NULL;
1155             }
1156
1157         if (av_opt_find(&cc, t->key, NULL, flags, AV_OPT_SEARCH_FAKE_OBJ) ||
1158             (codec && codec->priv_class &&
1159              av_opt_find(&codec->priv_class, t->key, NULL, flags,
1160                          AV_OPT_SEARCH_FAKE_OBJ)))
1161             av_dict_set(&ret, t->key, t->value, 0);
1162         else if (t->key[0] == prefix &&
1163                  av_opt_find(&cc, t->key + 1, NULL, flags,
1164                              AV_OPT_SEARCH_FAKE_OBJ))
1165             av_dict_set(&ret, t->key + 1, t->value, 0);
1166
1167         if (p)
1168             *p = ':';
1169     }
1170     return ret;
1171 }
1172
1173 AVDictionary **setup_find_stream_info_opts(AVFormatContext *s,
1174                                            AVDictionary *codec_opts)
1175 {
1176     int i;
1177     AVDictionary **opts;
1178
1179     if (!s->nb_streams)
1180         return NULL;
1181     opts = av_mallocz(s->nb_streams * sizeof(*opts));
1182     if (!opts) {
1183         av_log(NULL, AV_LOG_ERROR,
1184                "Could not alloc memory for stream options.\n");
1185         return NULL;
1186     }
1187     for (i = 0; i < s->nb_streams; i++)
1188         opts[i] = filter_codec_opts(codec_opts, avcodec_find_decoder(s->streams[i]->codec->codec_id),
1189                                     s, s->streams[i]);
1190     return opts;
1191 }
1192
1193 void *grow_array(void *array, int elem_size, int *size, int new_size)
1194 {
1195     if (new_size >= INT_MAX / elem_size) {
1196         av_log(NULL, AV_LOG_ERROR, "Array too big.\n");
1197         exit_program(1);
1198     }
1199     if (*size < new_size) {
1200         uint8_t *tmp = av_realloc(array, new_size*elem_size);
1201         if (!tmp) {
1202             av_log(NULL, AV_LOG_ERROR, "Could not alloc buffer.\n");
1203             exit_program(1);
1204         }
1205         memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
1206         *size = new_size;
1207         return tmp;
1208     }
1209     return array;
1210 }