~siretart/libav/merge.raring.libav-0.8.6 : revision 30

1

/*

2

* Various utilities for command line tools

3

4

*

5

* This file is part of Libav.

6

*

7

* Libav 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

* Libav 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 Libav; 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 "libswscale/swscale.h"

36

#if CONFIG_POSTPROC

37

#include "libpostproc/postprocess.h"

38

#endif

39

#include "libavutil/avstring.h"

40

#include "libavutil/mathematics.h"

41

#include "libavutil/parseutils.h"

42

#include "libavutil/pixdesc.h"

43

#include "libavutil/eval.h"

44

#include "libavutil/dict.h"

45

#include "libavutil/opt.h"

46

#include "cmdutils.h"

47

#include "version.h"

48

#if CONFIG_NETWORK

49

#include "libavformat/network.h"

50

#endif

51

#if HAVE_SYS_RESOURCE_H

52

#include <sys/resource.h>

53

#endif

54

55

struct SwsContext *sws_opts;

56

AVDictionary *format_opts, *codec_opts;

57

58

static const int this_year = 2012;

59

60

void init_opts(void)

61

{

62

#if CONFIG_SWSCALE

63

sws_opts = sws_getContext(16, 16, 0, 16, 16, 0, SWS_BICUBIC,

64

NULL, NULL, NULL);

65

#endif

66

}

67

68

void uninit_opts(void)

69

{

70

#if CONFIG_SWSCALE

71

sws_freeContext(sws_opts);

72

sws_opts = NULL;

73

#endif

74

av_dict_free(&format_opts);

75

av_dict_free(&codec_opts);

76

}

77

78

void log_callback_help(void *ptr, int level, const char *fmt, va_list vl)

79

{

80

vfprintf(stdout, fmt, vl);

81

}

82

83

double parse_number_or_die(const char *context, const char *numstr, int type,

84

double min, double max)

85

{

86

char *tail;

87

const char *error;

88

double d = av_strtod(numstr, &tail);

89

if (*tail)

90

error = "Expected number for %s but found: %s\n";

91

else if (d < min || d > max)

92

error = "The value for %s was %s which is not within %f - %f\n";

93

else if (type == OPT_INT64 && (int64_t)d != d)

94

error = "Expected int64 for %s but found %s\n";

95

else if (type == OPT_INT && (int)d != d)

96

error = "Expected int for %s but found %s\n";

97

else

98

return d;

99

av_log(NULL, AV_LOG_FATAL, error, context, numstr, min, max);

100

exit_program(1);

101

return 0;

102

}

103

104

int64_t parse_time_or_die(const char *context, const char *timestr,

105

int is_duration)

106

{

107

int64_t us;

108

if (av_parse_time(&us, timestr, is_duration) < 0) {

109

av_log(NULL, AV_LOG_FATAL, "Invalid %s specification for %s: %s\n",

110

is_duration ? "duration" : "date", context, timestr);

111

exit_program(1);

112

}

113

return us;

114

}

115

116

void show_help_options(const OptionDef *options, const char *msg, int mask,

117

int value)

118

{

119

const OptionDef *po;

120

int first;

121

122

first = 1;

123

for (po = options; po->name != NULL; po++) {

124

char buf[64];

125

if ((po->flags & mask) == value) {

126

if (first) {

127

printf("%s", msg);

128

first = 0;

129

}

130

av_strlcpy(buf, po->name, sizeof(buf));

131

if (po->flags & HAS_ARG) {

132

av_strlcat(buf, " ", sizeof(buf));

133

av_strlcat(buf, po->argname, sizeof(buf));

134

}

135

printf("-%-17s %s\n", buf, po->help);

136

}

137

}

138

}

139

140

void show_help_children(const AVClass *class, int flags)

141

{

142

const AVClass *child = NULL;

143

av_opt_show2(&class, NULL, flags, 0);

144

printf("\n");

145

146

while (child = av_opt_child_class_next(class, child))

147

show_help_children(child, flags);

148

}

149

150

static const OptionDef *find_option(const OptionDef *po, const char *name)

151

{

152

const char *p = strchr(name, ':');

153

int len = p ? p - name : strlen(name);

154

155

while (po->name != NULL) {

156

if (!strncmp(name, po->name, len) && strlen(po->name) == len)

157

break;

158

po++;

159

}

160

return po;

161

}

162

163

#if defined(_WIN32) && !defined(__MINGW32CE__)

164

#include <windows.h>

165

/* Will be leaked on exit */

166

static char** win32_argv_utf8 = NULL;

167

static int win32_argc = 0;

168

169

/**

170

* Prepare command line arguments for executable.

171

* For Windows - perform wide-char to UTF-8 conversion.

172

* Input arguments should be main() function arguments.

173

* @param argc_ptr Arguments number (including executable)

174

* @param argv_ptr Arguments list.

175

*/

176

static void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)

177

{

178

char *argstr_flat;

179

wchar_t **argv_w;

180

int i, buffsize = 0, offset = 0;

181

182

if (win32_argv_utf8) {

183

*argc_ptr = win32_argc;

184

*argv_ptr = win32_argv_utf8;

185

return;

186

}

187

188

win32_argc = 0;

189

argv_w = CommandLineToArgvW(GetCommandLineW(), &win32_argc);

190

if (win32_argc <= 0 || !argv_w)

191

return;

192

193

/* determine the UTF-8 buffer size (including NULL-termination symbols) */

194

for (i = 0; i < win32_argc; i++)

195

buffsize += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,

196

NULL, 0, NULL, NULL);

197

198

win32_argv_utf8 = av_mallocz(sizeof(char *) * (win32_argc + 1) + buffsize);

199

argstr_flat = (char *)win32_argv_utf8 + sizeof(char *) * (win32_argc + 1);

200

if (win32_argv_utf8 == NULL) {

201

LocalFree(argv_w);

202

return;

203

}

204

205

for (i = 0; i < win32_argc; i++) {

206

win32_argv_utf8[i] = &argstr_flat[offset];

207

offset += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,

208

&argstr_flat[offset],

209

buffsize - offset, NULL, NULL);

210

}

211

win32_argv_utf8[i] = NULL;

212

LocalFree(argv_w);

213

214

*argc_ptr = win32_argc;

215

*argv_ptr = win32_argv_utf8;

216

}

217

#else

218

static inline void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)

219

{

220

/* nothing to do */

221

}

222

#endif /* WIN32 && !__MINGW32CE__ */

223

224

int parse_option(void *optctx, const char *opt, const char *arg,

225

const OptionDef *options)

226

{

227

const OptionDef *po;

228

int bool_val = 1;

229

int *dstcount;

230

void *dst;

231

232

po = find_option(options, opt);

233

if (!po->name && opt[0] == 'n' && opt[1] == 'o') {

234

/* handle 'no' bool option */

235

po = find_option(options, opt + 2);

236

if (!(po->name && (po->flags & OPT_BOOL)))

237

goto unknown_opt;

238

bool_val = 0;

239

}

240

if (!po->name)

241

po = find_option(options, "default");

242

if (!po->name) {

243

unknown_opt:

244

av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);

245

return AVERROR(EINVAL);

246

}

247

if (po->flags & HAS_ARG && !arg) {

248

av_log(NULL, AV_LOG_ERROR, "Missing argument for option '%s'\n", opt);

249

return AVERROR(EINVAL);

250

}

251

252

/* new-style options contain an offset into optctx, old-style address of

253

* a global var*/

254

dst = po->flags & (OPT_OFFSET | OPT_SPEC) ? (uint8_t *)optctx + po->u.off

255

: po->u.dst_ptr;

256

257

if (po->flags & OPT_SPEC) {

258

SpecifierOpt **so = dst;

259

char *p = strchr(opt, ':');

260

261

dstcount = (int *)(so + 1);

262

*so = grow_array(*so, sizeof(**so), dstcount, *dstcount + 1);

263

(*so)[*dstcount - 1].specifier = av_strdup(p ? p + 1 : "");

264

dst = &(*so)[*dstcount - 1].u;

265

}

266

267

if (po->flags & OPT_STRING) {

268

char *str;

269

str = av_strdup(arg);

270

*(char **)dst = str;

271

} else if (po->flags & OPT_BOOL) {

272

*(int *)dst = bool_val;

273

} else if (po->flags & OPT_INT) {

274

*(int *)dst = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);

275

} else if (po->flags & OPT_INT64) {

276

*(int64_t *)dst = parse_number_or_die(opt, arg, OPT_INT64, INT64_MIN, INT64_MAX);

277

} else if (po->flags & OPT_TIME) {

278

*(int64_t *)dst = parse_time_or_die(opt, arg, 1);

279

} else if (po->flags & OPT_FLOAT) {

280

*(float *)dst = parse_number_or_die(opt, arg, OPT_FLOAT, -INFINITY, INFINITY);

281

} else if (po->flags & OPT_DOUBLE) {

282

*(double *)dst = parse_number_or_die(opt, arg, OPT_DOUBLE, -INFINITY, INFINITY);

283

} else if (po->u.func_arg) {

284

int ret = po->flags & OPT_FUNC2 ? po->u.func2_arg(optctx, opt, arg)

285

: po->u.func_arg(opt, arg);

286

if (ret < 0) {

287

av_log(NULL, AV_LOG_ERROR,

288

"Failed to set value '%s' for option '%s'\n", arg, opt);

289

return ret;

290

}

291

}

292

if (po->flags & OPT_EXIT)

293

exit_program(0);

294

return !!(po->flags & HAS_ARG);

295

}

296

297

void parse_options(void *optctx, int argc, char **argv, const OptionDef *options,

298

void (*parse_arg_function)(void *, const char*))

299

{

300

const char *opt;

301

int optindex, handleoptions = 1, ret;

302

303

/* perform system-dependent conversions for arguments list */

304

prepare_app_arguments(&argc, &argv);

305

306

/* parse options */

307

optindex = 1;

308

while (optindex < argc) {

309

opt = argv[optindex++];

310

311

if (handleoptions && opt[0] == '-' && opt[1] != '\0') {

312

if (opt[1] == '-' && opt[2] == '\0') {

313

handleoptions = 0;

314

continue;

315

}

316

opt++;

317

318

if ((ret = parse_option(optctx, opt, argv[optindex], options)) < 0)

319

exit_program(1);

320

optindex += ret;

321

} else {

322

if (parse_arg_function)

323

parse_arg_function(optctx, opt);

324

}

325

}

326

}

327

328

/*

329

* Return index of option opt in argv or 0 if not found.

330

*/

331

static int locate_option(int argc, char **argv, const OptionDef *options,

332

const char *optname)

333

{

334

const OptionDef *po;

335

int i;

336

337

for (i = 1; i < argc; i++) {

338

const char *cur_opt = argv[i];

339

340

if (*cur_opt++ != '-')

341

continue;

342

343

po = find_option(options, cur_opt);

344

if (!po->name && cur_opt[0] == 'n' && cur_opt[1] == 'o')

345

po = find_option(options, cur_opt + 2);

346

347

if ((!po->name && !strcmp(cur_opt, optname)) ||

348

(po->name && !strcmp(optname, po->name)))

349

return i;

350

351

if (!po || po->flags & HAS_ARG)

352

i++;

353

}

354

return 0;

355

}

356

357

void parse_loglevel(int argc, char **argv, const OptionDef *options)

358

{

359

int idx = locate_option(argc, argv, options, "loglevel");

360

if (!idx)

361

idx = locate_option(argc, argv, options, "v");

362

if (idx && argv[idx + 1])

363

opt_loglevel("loglevel", argv[idx + 1]);

364

}

365

366

#define FLAGS (o->type == AV_OPT_TYPE_FLAGS) ? AV_DICT_APPEND : 0

367

int opt_default(const char *opt, const char *arg)

368

{

369

const AVOption *o;

370

char opt_stripped[128];

371

const char *p;

372

const AVClass *cc = avcodec_get_class(), *fc = avformat_get_class(), *sc = sws_get_class();

373

374

if (!(p = strchr(opt, ':')))

375

p = opt + strlen(opt);

376

av_strlcpy(opt_stripped, opt, FFMIN(sizeof(opt_stripped), p - opt + 1));

377

378

if ((o = av_opt_find(&cc, opt_stripped, NULL, 0,

379

AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)) ||

380

((opt[0] == 'v' || opt[0] == 'a' || opt[0] == 's') &&

381

(o = av_opt_find(&cc, opt + 1, NULL, 0, AV_OPT_SEARCH_FAKE_OBJ))))

382

av_dict_set(&codec_opts, opt, arg, FLAGS);

383

else if ((o = av_opt_find(&fc, opt, NULL, 0,

384

AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)))

385

av_dict_set(&format_opts, opt, arg, FLAGS);

386

else if ((o = av_opt_find(&sc, opt, NULL, 0,

387

AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {

388

// XXX we only support sws_flags, not arbitrary sws options

389

int ret = av_opt_set(sws_opts, opt, arg, 0);

390

if (ret < 0) {

391

av_log(NULL, AV_LOG_ERROR, "Error setting option %s.\n", opt);

392

return ret;

393

}

394

}

395

396

if (o)

397

return 0;

398

av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);

399

return AVERROR_OPTION_NOT_FOUND;

400

}

401

402

int opt_loglevel(const char *opt, const char *arg)

403

{

404

const struct { const char *name; int level; } log_levels[] = {

405

{ "quiet" , AV_LOG_QUIET },

406

{ "panic" , AV_LOG_PANIC },

407

{ "fatal" , AV_LOG_FATAL },

408

{ "error" , AV_LOG_ERROR },

409

{ "warning", AV_LOG_WARNING },

410

{ "info" , AV_LOG_INFO },

411

{ "verbose", AV_LOG_VERBOSE },

412

{ "debug" , AV_LOG_DEBUG },

413

};

414

char *tail;

415

int level;

416

int i;

417

418

for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {

419

if (!strcmp(log_levels[i].name, arg)) {

420

av_log_set_level(log_levels[i].level);

421

return 0;

422

}

423

}

424

425

level = strtol(arg, &tail, 10);

426

if (*tail) {

427

av_log(NULL, AV_LOG_FATAL, "Invalid loglevel \"%s\". "

428

"Possible levels are numbers or:\n", arg);

429

for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)

430

av_log(NULL, AV_LOG_FATAL, "\"%s\"\n", log_levels[i].name);

431

exit_program(1);

432

}

433

av_log_set_level(level);

434

return 0;

435

}

436

437

int opt_timelimit(const char *opt, const char *arg)

438

{

439

#if HAVE_SETRLIMIT

440

int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);

441

struct rlimit rl = { lim, lim + 1 };

442

if (setrlimit(RLIMIT_CPU, &rl))

443

perror("setrlimit");

444

#else

445

av_log(NULL, AV_LOG_WARNING, "-%s not implemented on this OS\n", opt);

446

#endif

447

return 0;

448

}

449

450

void print_error(const char *filename, int err)

451

{

452

char errbuf[128];

453

const char *errbuf_ptr = errbuf;

454

455

if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)

456

errbuf_ptr = strerror(AVUNERROR(err));

457

av_log(NULL, AV_LOG_ERROR, "%s: %s\n", filename, errbuf_ptr);

458

}

459

460

static int warned_cfg = 0;

461

462

#define INDENT 1

463

#define SHOW_VERSION 2

464

#define SHOW_CONFIG 4

465

466

#define PRINT_LIB_INFO(libname, LIBNAME, flags, level) \

467

if (CONFIG_##LIBNAME) { \

468

const char *indent = flags & INDENT? " " : ""; \

469

if (flags & SHOW_VERSION) { \

470

unsigned int version = libname##_version(); \

471

av_log(NULL, level, "%slib%-9s %2d.%3d.%2d / %2d.%3d.%2d\n",\

472

indent, #libname, \

473

LIB##LIBNAME##_VERSION_MAJOR, \

474

LIB##LIBNAME##_VERSION_MINOR, \

475

LIB##LIBNAME##_VERSION_MICRO, \

476

version >> 16, version >> 8 & 0xff, version & 0xff); \

477

} \

478

if (flags & SHOW_CONFIG) { \

479

const char *cfg = libname##_configuration(); \

480

if (strcmp(LIBAV_CONFIGURATION, cfg)) { \

481

if (!warned_cfg) { \

482

av_log(NULL, level, \

483

"%sWARNING: library configuration mismatch\n", \

484

indent); \

485

warned_cfg = 1; \

486

} \

487

av_log(NULL, level, "%s%-11s configuration: %s\n", \

488

indent, #libname, cfg); \

489

} \

490

} \

491

} \

492

493

static void print_all_libs_info(int flags, int level)

494

{

495

PRINT_LIB_INFO(avutil, AVUTIL, flags, level);

496

PRINT_LIB_INFO(avcodec, AVCODEC, flags, level);

497

PRINT_LIB_INFO(avformat, AVFORMAT, flags, level);

498

PRINT_LIB_INFO(avdevice, AVDEVICE, flags, level);

499

PRINT_LIB_INFO(avfilter, AVFILTER, flags, level);

500

PRINT_LIB_INFO(swscale, SWSCALE, flags, level);

501

#if CONFIG_POSTPROC

502

PRINT_LIB_INFO(postproc, POSTPROC, flags, level);

503

#endif

504

}

505

506

void show_banner(void)

507

{

508

av_log(NULL, AV_LOG_INFO,

509

"%s version " LIBAV_VERSION ", Copyright (c) %d-%d the Libav developers\n",

510

program_name, program_birth_year, this_year);

511

av_log(NULL, AV_LOG_INFO, " built on %s %s with %s %s\n",

512

__DATE__, __TIME__, CC_TYPE, CC_VERSION);

513

av_log(NULL, AV_LOG_VERBOSE, " configuration: " LIBAV_CONFIGURATION "\n");

514

print_all_libs_info(INDENT|SHOW_CONFIG, AV_LOG_VERBOSE);

515

print_all_libs_info(INDENT|SHOW_VERSION, AV_LOG_VERBOSE);

516

}

517

518

void show_version(void) {

519

av_log_set_callback(log_callback_help);

520

printf("%s " LIBAV_VERSION "\n", program_name);

521

print_all_libs_info(SHOW_VERSION, AV_LOG_INFO);

522

}

523

524

void show_license(void)

525

{

526

printf(

527

#if CONFIG_NONFREE

528

"This version of %s has nonfree parts compiled in.\n"

529

"Therefore it is not legally redistributable.\n",

530

program_name

531

#elif CONFIG_GPLV3

532

"%s is free software; you can redistribute it and/or modify\n"

533

"it under the terms of the GNU General Public License as published by\n"

534

"the Free Software Foundation; either version 3 of the License, or\n"

535

"(at your option) any later version.\n"

536

"\n"

537

"%s is distributed in the hope that it will be useful,\n"

538

"but WITHOUT ANY WARRANTY; without even the implied warranty of\n"

539

"MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"

540

"GNU General Public License for more details.\n"

541

"\n"

542

"You should have received a copy of the GNU General Public License\n"

543

"along with %s. If not, see <http://www.gnu.org/licenses/>.\n",

544

program_name, program_name, program_name

545

#elif CONFIG_GPL

546

"%s is free software; you can redistribute it and/or modify\n"

547

"it under the terms of the GNU General Public License as published by\n"

548

"the Free Software Foundation; either version 2 of the License, or\n"

549

"(at your option) any later version.\n"

550

"\n"

551

"%s is distributed in the hope that it will be useful,\n"

552

"but WITHOUT ANY WARRANTY; without even the implied warranty of\n"

553

"MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"

554

"GNU General Public License for more details.\n"

555

"\n"

556

"You should have received a copy of the GNU General Public License\n"

557

"along with %s; if not, write to the Free Software\n"

558

"Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",

559

program_name, program_name, program_name

560

#elif CONFIG_LGPLV3

561

"%s is free software; you can redistribute it and/or modify\n"

562

"it under the terms of the GNU Lesser General Public License as published by\n"

563

"the Free Software Foundation; either version 3 of the License, or\n"

564

"(at your option) any later version.\n"

565

"\n"

566

"%s is distributed in the hope that it will be useful,\n"

567

"but WITHOUT ANY WARRANTY; without even the implied warranty of\n"

568

"MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"

569

"GNU Lesser General Public License for more details.\n"

570

"\n"

571

"You should have received a copy of the GNU Lesser General Public License\n"

572

"along with %s. If not, see <http://www.gnu.org/licenses/>.\n",

573

program_name, program_name, program_name

574

#else

575

"%s is free software; you can redistribute it and/or\n"

576

"modify it under the terms of the GNU Lesser General Public\n"

577

"License as published by the Free Software Foundation; either\n"

578

"version 2.1 of the License, or (at your option) any later version.\n"

579

"\n"

580

"%s is distributed in the hope that it will be useful,\n"

581

"but WITHOUT ANY WARRANTY; without even the implied warranty of\n"

582

"MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"

583

"Lesser General Public License for more details.\n"

584

"\n"

585

"You should have received a copy of the GNU Lesser General Public\n"

586

"License along with %s; if not, write to the Free Software\n"

587

"Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",

588

program_name, program_name, program_name

589

#endif

590

);

591

}

592

593

void show_formats(void)

594

{

595

AVInputFormat *ifmt = NULL;

596

AVOutputFormat *ofmt = NULL;

597

const char *last_name;

598

599

printf("File formats:\n"

600

" D. = Demuxing supported\n"

601

" .E = Muxing supported\n"

602

" --\n");

603

last_name = "000";

604

for (;;) {

605

int decode = 0;

606

int encode = 0;

607

const char *name = NULL;

608

const char *long_name = NULL;

609

610

while ((ofmt = av_oformat_next(ofmt))) {

611

if ((name == NULL || strcmp(ofmt->name, name) < 0) &&

612

strcmp(ofmt->name, last_name) > 0) {

613

name = ofmt->name;

614

long_name = ofmt->long_name;

615

encode = 1;

616

}

617

}

618

while ((ifmt = av_iformat_next(ifmt))) {

619

if ((name == NULL || strcmp(ifmt->name, name) < 0) &&

620

strcmp(ifmt->name, last_name) > 0) {

621

name = ifmt->name;

622

long_name = ifmt->long_name;

623

encode = 0;

624

}

625

if (name && strcmp(ifmt->name, name) == 0)

626

decode = 1;

627

}

628

if (name == NULL)

629

break;

630

last_name = name;

631

632

printf(" %s%s %-15s %s\n",

633

decode ? "D" : " ",

634

encode ? "E" : " ",

635

name,

636

long_name ? long_name:" ");

637

}

638

}

639

640

void show_codecs(void)

641

{

642

AVCodec *p = NULL, *p2;

643

const char *last_name;

644

printf("Codecs:\n"

645

" D..... = Decoding supported\n"

646

" .E.... = Encoding supported\n"

647

" ..V... = Video codec\n"

648

" ..A... = Audio codec\n"

649

" ..S... = Subtitle codec\n"

650

" ...S.. = Supports draw_horiz_band\n"

651

" ....D. = Supports direct rendering method 1\n"

652

" .....T = Supports weird frame truncation\n"

653

" ------\n");

654

last_name= "000";

655

for (;;) {

656

int decode = 0;

657

int encode = 0;

658

int cap = 0;

659

const char *type_str;

660

661

p2 = NULL;

662

while ((p = av_codec_next(p))) {

663

if ((p2 == NULL || strcmp(p->name, p2->name) < 0) &&

664

strcmp(p->name, last_name) > 0) {

665

p2 = p;

666

decode = encode = cap = 0;

667

}

668

if (p2 && strcmp(p->name, p2->name) == 0) {

669

if (p->decode)

670

decode = 1;

671

if (p->encode)

672

encode = 1;

673

cap |= p->capabilities;

674

}

675

}

676

if (p2 == NULL)

677

break;

678

last_name = p2->name;

679

680

switch (p2->type) {

681

case AVMEDIA_TYPE_VIDEO:

682

type_str = "V";

683

break;

684

case AVMEDIA_TYPE_AUDIO:

685

type_str = "A";

686

break;

687

case AVMEDIA_TYPE_SUBTITLE:

688

type_str = "S";

689

break;

690

default:

691

type_str = "?";

692

break;

693

}

694

printf(" %s%s%s%s%s%s %-15s %s",

695

decode ? "D" : (/* p2->decoder ? "d" : */ " "),

696

encode ? "E" : " ",

697

type_str,

698

cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S" : " ",

699

cap & CODEC_CAP_DR1 ? "D" : " ",

700

cap & CODEC_CAP_TRUNCATED ? "T" : " ",

701

p2->name,

702

p2->long_name ? p2->long_name : "");

703

#if 0

704

if (p2->decoder && decode == 0)

705

printf(" use %s for decoding", p2->decoder->name);

706

#endif

707

printf("\n");

708

}

709

printf("\n");

710

printf("Note, the names of encoders and decoders do not always match, so there are\n"

711

"several cases where the above table shows encoder only or decoder only entries\n"

712

"even though both encoding and decoding are supported. For example, the h263\n"

713

"decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"

714

"worse.\n");

715

}

716

717

void show_bsfs(void)

718

{

719

AVBitStreamFilter *bsf = NULL;

720

721

printf("Bitstream filters:\n");

722

while ((bsf = av_bitstream_filter_next(bsf)))

723

printf("%s\n", bsf->name);

724

printf("\n");

725

}

726

727

void show_protocols(void)

728

{

729

void *opaque = NULL;

730

const char *name;

731

732

printf("Supported file protocols:\n"

733

"Input:\n");

734

while ((name = avio_enum_protocols(&opaque, 0)))

735

printf("%s\n", name);

736

printf("Output:\n");

737

while ((name = avio_enum_protocols(&opaque, 1)))

738

printf("%s\n", name);

739

}

740

741

void show_filters(void)

742

{

743

AVFilter av_unused(**filter) = NULL;

744

745

printf("Filters:\n");

746

#if CONFIG_AVFILTER

747

while ((filter = av_filter_next(filter)) && *filter)

748

printf("%-16s %s\n", (*filter)->name, (*filter)->description);

749

#endif

750

}

751

752

void show_pix_fmts(void)

753

{

754

enum PixelFormat pix_fmt;

755

756

printf("Pixel formats:\n"

757

"I.... = Supported Input format for conversion\n"

758

".O... = Supported Output format for conversion\n"

759

"..H.. = Hardware accelerated format\n"

760

"...P. = Paletted format\n"

761

"....B = Bitstream format\n"

762

"FLAGS NAME NB_COMPONENTS BITS_PER_PIXEL\n"

763

"-----\n");

764

765

#if !CONFIG_SWSCALE

766

# define sws_isSupportedInput(x) 0

767

# define sws_isSupportedOutput(x) 0

768

#endif

769

770

for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {

771

const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];

772

printf("%c%c%c%c%c %-16s %d %2d\n",

773

sws_isSupportedInput (pix_fmt) ? 'I' : '.',

774

sws_isSupportedOutput(pix_fmt) ? 'O' : '.',

775

pix_desc->flags & PIX_FMT_HWACCEL ? 'H' : '.',

776

pix_desc->flags & PIX_FMT_PAL ? 'P' : '.',

777

pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',

778

pix_desc->name,

779

pix_desc->nb_components,

780

av_get_bits_per_pixel(pix_desc));

781

}

782

}

783

784

int show_sample_fmts(const char *opt, const char *arg)

785

{

786

int i;

787

char fmt_str[128];

788

for (i = -1; i < AV_SAMPLE_FMT_NB; i++)

789

printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));

790

return 0;

791

}

792

793

int read_yesno(void)

794

{

795

int c = getchar();

796

int yesno = (toupper(c) == 'Y');

797

798

while (c != '\n' && c != EOF)

799

c = getchar();

800

801

return yesno;

802

}

803

804

int cmdutils_read_file(const char *filename, char **bufptr, size_t *size)

805

{

806

int ret;

807

FILE *f = fopen(filename, "rb");

808

809

if (!f) {

810

av_log(NULL, AV_LOG_ERROR, "Cannot read file '%s': %s\n", filename,

811

strerror(errno));

812

return AVERROR(errno);

813

}

814

fseek(f, 0, SEEK_END);

815

*size = ftell(f);

816

fseek(f, 0, SEEK_SET);

817

*bufptr = av_malloc(*size + 1);

818

if (!*bufptr) {

819

av_log(NULL, AV_LOG_ERROR, "Could not allocate file buffer\n");

820

fclose(f);

821

return AVERROR(ENOMEM);

822

}

823

ret = fread(*bufptr, 1, *size, f);

824

if (ret < *size) {

825

av_free(*bufptr);

826

if (ferror(f)) {

827

av_log(NULL, AV_LOG_ERROR, "Error while reading file '%s': %s\n",

828

filename, strerror(errno));

829

ret = AVERROR(errno);

830

} else

831

ret = AVERROR_EOF;

832

} else {

833

ret = 0;

834

(*bufptr)[*size++] = '\0';

835

}

836

837

fclose(f);

838

return ret;

839

}

840

841

void init_pts_correction(PtsCorrectionContext *ctx)

842

{

843

ctx->num_faulty_pts = ctx->num_faulty_dts = 0;

844

ctx->last_pts = ctx->last_dts = INT64_MIN;

845

}

846

847

int64_t guess_correct_pts(PtsCorrectionContext *ctx, int64_t reordered_pts,

848

int64_t dts)

849

{

850

int64_t pts = AV_NOPTS_VALUE;

851

852

if (dts != AV_NOPTS_VALUE) {

853

ctx->num_faulty_dts += dts <= ctx->last_dts;

854

ctx->last_dts = dts;

855

}

856

if (reordered_pts != AV_NOPTS_VALUE) {

857

ctx->num_faulty_pts += reordered_pts <= ctx->last_pts;

858

ctx->last_pts = reordered_pts;

859

}

860

if ((ctx->num_faulty_pts<=ctx->num_faulty_dts || dts == AV_NOPTS_VALUE)

861

&& reordered_pts != AV_NOPTS_VALUE)

862

pts = reordered_pts;

863

else

864

pts = dts;

865

866

return pts;

867

}

868

869

FILE *get_preset_file(char *filename, size_t filename_size,

870

const char *preset_name, int is_path,

871

const char *codec_name)

872

{

873

FILE *f = NULL;

874

int i;

875

const char *base[3] = { getenv("AVCONV_DATADIR"),

876

getenv("HOME"),

877

AVCONV_DATADIR, };

878

879

if (is_path) {

880

av_strlcpy(filename, preset_name, filename_size);

881

f = fopen(filename, "r");

882

} else {

883

for (i = 0; i < 3 && !f; i++) {

884

if (!base[i])

885

continue;

886

snprintf(filename, filename_size, "%s%s/%s.avpreset", base[i],

887

i != 1 ? "" : "/.avconv", preset_name);

888

f = fopen(filename, "r");

889

if (!f && codec_name) {

890

snprintf(filename, filename_size,

891

"%s%s/%s-%s.avpreset",

892

base[i], i != 1 ? "" : "/.avconv", codec_name,

893

preset_name);

894

f = fopen(filename, "r");

895

}

896

}

897

}

898

899

return f;

900

}

901

902

int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)

903

{

904

if (*spec <= '9' && *spec >= '0') /* opt:index */

905

return strtol(spec, NULL, 0) == st->index;

906

else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||

907

*spec == 't') { /* opt:[vasdt] */

908

enum AVMediaType type;

909

910

switch (*spec++) {

911

case 'v': type = AVMEDIA_TYPE_VIDEO; break;

912

case 'a': type = AVMEDIA_TYPE_AUDIO; break;

913

case 's': type = AVMEDIA_TYPE_SUBTITLE; break;

914

case 'd': type = AVMEDIA_TYPE_DATA; break;

915

case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;

916

}

917

if (type != st->codec->codec_type)

918

return 0;

919

if (*spec++ == ':') { /* possibly followed by :index */

920

int i, index = strtol(spec, NULL, 0);

921

for (i = 0; i < s->nb_streams; i++)

922

if (s->streams[i]->codec->codec_type == type && index-- == 0)

923

return i == st->index;

924

return 0;

925

}

926

return 1;

927

} else if (*spec == 'p' && *(spec + 1) == ':') {

928

int prog_id, i, j;

929

char *endptr;

930

spec += 2;

931

prog_id = strtol(spec, &endptr, 0);

932

for (i = 0; i < s->nb_programs; i++) {

933

if (s->programs[i]->id != prog_id)

934

continue;

935

936

if (*endptr++ == ':') {

937

int stream_idx = strtol(endptr, NULL, 0);

938

return stream_idx >= 0 &&

939

stream_idx < s->programs[i]->nb_stream_indexes &&

940

st->index == s->programs[i]->stream_index[stream_idx];

941

}

942

943

for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)

944

if (st->index == s->programs[i]->stream_index[j])

945

return 1;

946

}

947

return 0;

948

} else if (!*spec) /* empty specifier, matches everything */

949

return 1;

950

951

av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);

952

return AVERROR(EINVAL);

953

}

954

955

AVDictionary *filter_codec_opts(AVDictionary *opts, enum CodecID codec_id,

956

AVFormatContext *s, AVStream *st)

957

{

958

AVDictionary *ret = NULL;

959

AVDictionaryEntry *t = NULL;

960

AVCodec *codec = s->oformat ? avcodec_find_encoder(codec_id)

961

: avcodec_find_decoder(codec_id);

962

int flags = s->oformat ? AV_OPT_FLAG_ENCODING_PARAM

963

: AV_OPT_FLAG_DECODING_PARAM;

964

char prefix = 0;

965

const AVClass *cc = avcodec_get_class();

966

967

if (!codec)

968

return NULL;

969

970

switch (codec->type) {

971

case AVMEDIA_TYPE_VIDEO:

972

prefix = 'v';

973

flags |= AV_OPT_FLAG_VIDEO_PARAM;

974

break;

975

case AVMEDIA_TYPE_AUDIO:

976

prefix = 'a';

977

flags |= AV_OPT_FLAG_AUDIO_PARAM;

978

break;

979

case AVMEDIA_TYPE_SUBTITLE:

980

prefix = 's';

981

flags |= AV_OPT_FLAG_SUBTITLE_PARAM;

982

break;

983

}

984

985

while (t = av_dict_get(opts, "", t, AV_DICT_IGNORE_SUFFIX)) {

986

char *p = strchr(t->key, ':');

987

988

/* check stream specification in opt name */

989

if (p)

990

switch (check_stream_specifier(s, st, p + 1)) {

991

case 1: *p = 0; break;

992

case 0: continue;

993

default: return NULL;

994

}

995

996

if (av_opt_find(&cc, t->key, NULL, flags, AV_OPT_SEARCH_FAKE_OBJ) ||

997

(codec && codec->priv_class &&

998

av_opt_find(&codec->priv_class, t->key, NULL, flags,

999

AV_OPT_SEARCH_FAKE_OBJ)))

1000

av_dict_set(&ret, t->key, t->value, 0);

1001

else if (t->key[0] == prefix &&

1002

av_opt_find(&cc, t->key + 1, NULL, flags,

1003

AV_OPT_SEARCH_FAKE_OBJ))

1004

av_dict_set(&ret, t->key + 1, t->value, 0);

1005

1006

if (p)

1007

*p = ':';

1008

}

1009

return ret;

1010

}

1011

1012

AVDictionary **setup_find_stream_info_opts(AVFormatContext *s,

1013

AVDictionary *codec_opts)

1014

{

1015

int i;

1016

AVDictionary **opts;

1017

1018

if (!s->nb_streams)

1019

return NULL;

1020

opts = av_mallocz(s->nb_streams * sizeof(*opts));

1021

if (!opts) {

1022

av_log(NULL, AV_LOG_ERROR,

1023

"Could not alloc memory for stream options.\n");

1024

return NULL;

1025

}

1026

for (i = 0; i < s->nb_streams; i++)

1027

opts[i] = filter_codec_opts(codec_opts, s->streams[i]->codec->codec_id,

1028

s, s->streams[i]);

1029

return opts;

1030

}

1031

1032

#if CONFIG_AVFILTER

1033

1034

static int avsink_init(AVFilterContext *ctx, const char *args, void *opaque)

1035

{

1036

AVSinkContext *priv = ctx->priv;

1037

1038

if (!opaque)

1039

return AVERROR(EINVAL);

1040

*priv = *(AVSinkContext *)opaque;

1041

1042

return 0;

1043

}

1044

1045

static void null_end_frame(AVFilterLink *inlink) { }

1046

1047

static int avsink_query_formats(AVFilterContext *ctx)

1048

{

1049

AVSinkContext *priv = ctx->priv;

1050

enum PixelFormat pix_fmts[] = { priv->pix_fmt, PIX_FMT_NONE };

1051

1052

avfilter_set_common_formats(ctx, avfilter_make_format_list(pix_fmts));

1053

return 0;

1054

}

1055

1056

AVFilter avsink = {

1057

.name = "avsink",

1058

.priv_size = sizeof(AVSinkContext),

1059

.init = avsink_init,

1060

1061

.query_formats = avsink_query_formats,

1062

1063

.inputs = (AVFilterPad[]) {{ .name = "default",

1064

.type = AVMEDIA_TYPE_VIDEO,

1065

.end_frame = null_end_frame,

1066

.min_perms = AV_PERM_READ, },

1067

{ .name = NULL }},

1068

.outputs = (AVFilterPad[]) {{ .name = NULL }},

1069

};

1070

1071

int get_filtered_video_frame(AVFilterContext *ctx, AVFrame *frame,

1072

AVFilterBufferRef **picref_ptr, AVRational *tb)

1073

{

1074

int ret;

1075

AVFilterBufferRef *picref;

1076

1077

if ((ret = avfilter_request_frame(ctx->inputs[0])) < 0)

1078

return ret;

1079

if (!(picref = ctx->inputs[0]->cur_buf))

1080

return AVERROR(ENOENT);

1081

*picref_ptr = picref;

1082

ctx->inputs[0]->cur_buf = NULL;

1083

*tb = ctx->inputs[0]->time_base;

1084

1085

memcpy(frame->data, picref->data, sizeof(frame->data));

1086

memcpy(frame->linesize, picref->linesize, sizeof(frame->linesize));

1087

frame->interlaced_frame = picref->video->interlaced;

1088

frame->top_field_first = picref->video->top_field_first;

1089

frame->key_frame = picref->video->key_frame;

1090

frame->pict_type = picref->video->pict_type;

1091

frame->sample_aspect_ratio = picref->video->pixel_aspect;

1092

1093

return 1;

1094

}

1095

1096

#endif /* CONFIG_AVFILTER */

1097

1098

void *grow_array(void *array, int elem_size, int *size, int new_size)

1099

{

1100

if (new_size >= INT_MAX / elem_size) {

1101

av_log(NULL, AV_LOG_ERROR, "Array too big.\n");

1102

exit_program(1);

1103

}

1104

if (*size < new_size) {

1105

uint8_t *tmp = av_realloc(array, new_size*elem_size);

1106

if (!tmp) {

1107

av_log(NULL, AV_LOG_ERROR, "Could not alloc buffer.\n");

1108

exit_program(1);

1109

}

1110

memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);

1111

*size = new_size;

1112

return tmp;

1113

}

1114

return array;

1115

}