FFmpeg: libavfilter/formats.c Source File

FFmpeg

[フレーム]

libavfilter

formats.c

Go to the documentation of this file.

1 /*

2 * Filter layer - format negotiation

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

22 #include "libavutil/avassert.h"

23 #include "libavutil/channel_layout.h"

24 #include "libavutil/common.h"

25 #include "libavutil/eval.h"

26 #include "libavutil/pixdesc.h"

27 #include "libavutil/parseutils.h"

28 #include "avfilter.h"

29 #include "internal.h"

30 #include "formats.h"

32 #define KNOWN(l) (!FF_LAYOUT2COUNT(l)) /* for readability */

34 /**

35 * Add all refs from a to ret and destroy a.

36 */

37 #define MERGE_REF(ret, a, fmts, type, fail) \

38 do { \

39 type ***tmp; \

40 int i; \

41 \

42 if (!(tmp = av_realloc_array(ret->refs, ret->refcount + a->refcount, \

43 sizeof(*tmp)))) \

44 goto fail; \

45 ret->refs = tmp; \

46 \

47 for (i = 0; i < a->refcount; i ++) { \

48 ret->refs[ret->refcount] = a->refs[i]; \

49 *ret->refs[ret->refcount++] = ret; \

50 } \

51 \

52 av_freep(&a->refs); \

53 av_freep(&a->fmts); \

54 av_freep(&a); \

55 } while (0)

57 /**

58 * Add all formats common for a and b to ret, copy the refs and destroy

59 * a and b.

60 */

61 #define MERGE_FORMATS(ret, a, b, fmts, nb, type, fail) \

62 do { \

63 int i, j, k = 0, count = FFMIN(a->nb, b->nb); \

64 \

65 if (!(ret = av_mallocz(sizeof(*ret)))) \

66 goto fail; \

67 \

68 if (count) { \

69 if (!(ret->fmts = av_malloc_array(count, sizeof(*ret->fmts)))) \

70 goto fail; \

71 for (i = 0; i < a->nb; i++) \

72 for (j = 0; j < b->nb; j++) \

73 if (a->fmts[i] == b->fmts[j]) { \

74 if(k >= FFMIN(a->nb, b->nb)){ \

75 av_log(NULL, AV_LOG_ERROR, "Duplicate formats in avfilter_merge_formats() detected\n"); \

76 av_free(ret->fmts); \

77 av_free(ret); \

78 return NULL; \

79 } \

80 ret->fmts[k++] = a->fmts[i]; \

81 } \

82 } \

83 ret->nb = k; \

84 /* check that there was at least one common format */ \

85 if (!ret->nb) \

86 goto fail; \

87 \

88 MERGE_REF(ret, a, fmts, type, fail); \

89 MERGE_REF(ret, b, fmts, type, fail); \

90 } while (0)

92 AVFilterFormats *ff_merge_formats(AVFilterFormats *a, AVFilterFormats *b,

93 enum AVMediaType type)

94 {

95 AVFilterFormats *ret = NULL;

96 int i, j;

97 int alpha1=0, alpha2=0;

98 int chroma1=0, chroma2=0;

100 if (a == b)

101 return a;

102

103 /* Do not lose chroma or alpha in merging.

104 It happens if both lists have formats with chroma (resp. alpha), but

105 the only formats in common do not have it (e.g. YUV+gray vs.

106 RGB+gray): in that case, the merging would select the gray format,

107 possibly causing a lossy conversion elsewhere in the graph.

108 To avoid that, pretend that there are no common formats to force the

109 insertion of a conversion filter. */

110 if (type == AVMEDIA_TYPE_VIDEO)

111 for (i = 0; i < a->nb_formats; i++)

112 for (j = 0; j < b->nb_formats; j++) {

113 const AVPixFmtDescriptor *adesc = av_pix_fmt_desc_get(a->formats[i]);

114 const AVPixFmtDescriptor *bdesc = av_pix_fmt_desc_get(b->formats[j]);

115 alpha2 |= adesc->flags & bdesc->flags & AV_PIX_FMT_FLAG_ALPHA;

116 chroma2|= adesc->nb_components > 1 && bdesc->nb_components > 1;

117 if (a->formats[i] == b->formats[j]) {

118 alpha1 |= adesc->flags & AV_PIX_FMT_FLAG_ALPHA;

119 chroma1|= adesc->nb_components > 1;

120 }

121 }

122

123 // If chroma or alpha can be lost through merging then do not merge

124 if (alpha2 > alpha1 || chroma2 > chroma1)

125 return NULL;

126

127 MERGE_FORMATS(ret, a, b, formats, nb_formats, AVFilterFormats, fail);

128

129 return ret;

130 fail:

131 if (ret) {

132 av_freep(&ret->refs);

133 av_freep(&ret->formats);

134 }

135 av_freep(&ret);

136 return NULL;

137 }

138

139 AVFilterFormats *ff_merge_samplerates(AVFilterFormats *a,

140 AVFilterFormats *b)

141 {

142 AVFilterFormats *ret = NULL;

143

144 if (a == b) return a;

145

146 if (a->nb_formats && b->nb_formats) {

147 MERGE_FORMATS(ret, a, b, formats, nb_formats, AVFilterFormats, fail);

148 } else if (a->nb_formats) {

149 MERGE_REF(a, b, formats, AVFilterFormats, fail);

150 ret = a;

151 } else {

152 MERGE_REF(b, a, formats, AVFilterFormats, fail);

153 ret = b;

154 }

155

156 return ret;

157 fail:

158 if (ret) {

159 av_freep(&ret->refs);

160 av_freep(&ret->formats);

161 }

162 av_freep(&ret);

163 return NULL;

164 }

165

166 AVFilterChannelLayouts *ff_merge_channel_layouts(AVFilterChannelLayouts *a,

167 AVFilterChannelLayouts *b)

168 {

169 AVFilterChannelLayouts *ret = NULL;

170 unsigned a_all = a->all_layouts + a->all_counts;

171 unsigned b_all = b->all_layouts + b->all_counts;

172 int ret_max, ret_nb = 0, i, j, round;

173

174 if (a == b) return a;

175

176 /* Put the most generic set in a, to avoid doing everything twice */

177 if (a_all < b_all) {

178 FFSWAP(AVFilterChannelLayouts *, a, b);

179 FFSWAP(unsigned, a_all, b_all);

180 }

181 if (a_all) {

182 if (a_all == 1 && !b_all) {

183 /* keep only known layouts in b; works also for b_all = 1 */

184 for (i = j = 0; i < b->nb_channel_layouts; i++)

185 if (KNOWN(b->channel_layouts[i]))

186 b->channel_layouts[j++] = b->channel_layouts[i];

187 /* Not optimal: the unknown layouts of b may become known after

188 another merge. */

189 if (!j)

190 return NULL;

191 b->nb_channel_layouts = j;

192 }

193 MERGE_REF(b, a, channel_layouts, AVFilterChannelLayouts, fail);

194 return b;

195 }

196

197 ret_max = a->nb_channel_layouts + b->nb_channel_layouts;

198 if (!(ret = av_mallocz(sizeof(*ret))) ||

199 !(ret->channel_layouts = av_malloc_array(ret_max,

200 sizeof(*ret->channel_layouts))))

201 goto fail;

202

203 /* a[known] intersect b[known] */

204 for (i = 0; i < a->nb_channel_layouts; i++) {

205 if (!KNOWN(a->channel_layouts[i]))

206 continue;

207 for (j = 0; j < b->nb_channel_layouts; j++) {

208 if (a->channel_layouts[i] == b->channel_layouts[j]) {

209 ret->channel_layouts[ret_nb++] = a->channel_layouts[i];

210 a->channel_layouts[i] = b->channel_layouts[j] = 0;

211 }

212 }

213 }

214 /* 1st round: a[known] intersect b[generic]

215 2nd round: a[generic] intersect b[known] */

216 for (round = 0; round < 2; round++) {

217 for (i = 0; i < a->nb_channel_layouts; i++) {

218 uint64_t fmt = a->channel_layouts[i], bfmt;

219 if (!fmt || !KNOWN(fmt))

220 continue;

221 bfmt = FF_COUNT2LAYOUT(av_get_channel_layout_nb_channels(fmt));

222 for (j = 0; j < b->nb_channel_layouts; j++)

223 if (b->channel_layouts[j] == bfmt)

224 ret->channel_layouts[ret_nb++] = a->channel_layouts[i];

225 }

226 /* 1st round: swap to prepare 2nd round; 2nd round: put it back */

227 FFSWAP(AVFilterChannelLayouts *, a, b);

228 }

229 /* a[generic] intersect b[generic] */

230 for (i = 0; i < a->nb_channel_layouts; i++) {

231 if (KNOWN(a->channel_layouts[i]))

232 continue;

233 for (j = 0; j < b->nb_channel_layouts; j++)

234 if (a->channel_layouts[i] == b->channel_layouts[j])

235 ret->channel_layouts[ret_nb++] = a->channel_layouts[i];

236 }

237

238 ret->nb_channel_layouts = ret_nb;

239 if (!ret->nb_channel_layouts)

240 goto fail;

241 MERGE_REF(ret, a, channel_layouts, AVFilterChannelLayouts, fail);

242 MERGE_REF(ret, b, channel_layouts, AVFilterChannelLayouts, fail);

243 return ret;

244

245 fail:

246 if (ret) {

247 av_freep(&ret->refs);

248 av_freep(&ret->channel_layouts);

249 }

250 av_freep(&ret);

251 return NULL;

252 }

253

254 int ff_fmt_is_in(int fmt, const int *fmts)

255 {

256 const int *p;

257

258 for (p = fmts; *p != -1; p++) {

259 if (fmt == *p)

260 return 1;

261 }

262 return 0;

263 }

264

265 #define COPY_INT_LIST(list_copy, list, type) { \

266 int count = 0; \

267 if (list) \

268 for (count = 0; list[count] != -1; count++) \

269 ; \

270 list_copy = av_calloc(count+1, sizeof(type)); \

271 if (list_copy) { \

272 memcpy(list_copy, list, sizeof(type) * count); \

273 list_copy[count] = -1; \

274 } \

275 }

276

277 #define MAKE_FORMAT_LIST(type, field, count_field) \

278 type *formats; \

279 int count = 0; \

280 if (fmts) \

281 for (count = 0; fmts[count] != -1; count++) \

282 ; \

283 formats = av_mallocz(sizeof(*formats)); \

284 if (!formats) return NULL; \

285 formats->count_field = count; \

286 if (count) { \

287 formats->field = av_malloc_array(count, sizeof(*formats->field)); \

288 if (!formats->field) { \

289 av_free(formats); \

290 return NULL; \

291 } \

292 }

293

294 AVFilterFormats *ff_make_format_list(const int *fmts)

295 {

296 MAKE_FORMAT_LIST(AVFilterFormats, formats, nb_formats);

297 while (count--)

298 formats->formats[count] = fmts[count];

299

300 return formats;

301 }

302

303 AVFilterChannelLayouts *avfilter_make_format64_list(const int64_t *fmts)

304 {

305 MAKE_FORMAT_LIST(AVFilterChannelLayouts,

306 channel_layouts, nb_channel_layouts);

307 if (count)

308 memcpy(formats->channel_layouts, fmts,

309 sizeof(*formats->channel_layouts) * count);

310

311 return formats;

312 }

313

314 #define ADD_FORMAT(f, fmt, type, list, nb) \

315 do { \

316 type *fmts; \

317 void *oldf = *f; \

318 \

319 if (!(*f) && !(*f = av_mallocz(sizeof(**f)))) \

320 return AVERROR(ENOMEM); \

321 \

322 fmts = av_realloc((*f)->list, \

323 sizeof(*(*f)->list) * ((*f)->nb + 1));\

324 if (!fmts) { \

325 if (!oldf) \

326 av_freep(f); \

327 return AVERROR(ENOMEM); \

328 } \

329 \

330 (*f)->list = fmts; \

331 (*f)->list[(*f)->nb++] = fmt; \

332 } while (0)

333

334 int ff_add_format(AVFilterFormats **avff, int64_t fmt)

335 {

336 ADD_FORMAT(avff, fmt, int, formats, nb_formats);

337 return 0;

338 }

339

340 int ff_add_channel_layout(AVFilterChannelLayouts **l, uint64_t channel_layout)

341 {

342 av_assert1(!(*l && (*l)->all_layouts));

343 ADD_FORMAT(l, channel_layout, uint64_t, channel_layouts, nb_channel_layouts);

344 return 0;

345 }

346

347 AVFilterFormats *ff_all_formats(enum AVMediaType type)

348 {

349 AVFilterFormats *ret = NULL;

350

351 if (type == AVMEDIA_TYPE_VIDEO) {

352 const AVPixFmtDescriptor *desc = NULL;

353 while ((desc = av_pix_fmt_desc_next(desc))) {

354 if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL))

355 ff_add_format(&ret, av_pix_fmt_desc_get_id(desc));

356 }

357 } else if (type == AVMEDIA_TYPE_AUDIO) {

358 enum AVSampleFormat fmt = 0;

359 while (av_get_sample_fmt_name(fmt)) {

360 ff_add_format(&ret, fmt);

361 fmt++;

362 }

363 }

364

365 return ret;

366 }

367

368 const int64_t avfilter_all_channel_layouts[] = {

369 #include "all_channel_layouts.inc"

370 -1

371 };

372

373 // AVFilterFormats *avfilter_make_all_channel_layouts(void)

374 // {

375 // return avfilter_make_format64_list(avfilter_all_channel_layouts);

376 // }

377

378 AVFilterFormats *ff_planar_sample_fmts(void)

379 {

380 AVFilterFormats *ret = NULL;

381 int fmt;

382

383 for (fmt = 0; av_get_bytes_per_sample(fmt)>0; fmt++)

384 if (av_sample_fmt_is_planar(fmt))

385 ff_add_format(&ret, fmt);

386

387 return ret;

388 }

389

390 AVFilterFormats *ff_all_samplerates(void)

391 {

392 AVFilterFormats *ret = av_mallocz(sizeof(*ret));

393 return ret;

394 }

395

396 AVFilterChannelLayouts *ff_all_channel_layouts(void)

397 {

398 AVFilterChannelLayouts *ret = av_mallocz(sizeof(*ret));

399 if (!ret)

400 return NULL;

401 ret->all_layouts = 1;

402 return ret;

403 }

404

405 AVFilterChannelLayouts *ff_all_channel_counts(void)

406 {

407 AVFilterChannelLayouts *ret = av_mallocz(sizeof(*ret));

408 if (!ret)

409 return NULL;

410 ret->all_layouts = ret->all_counts = 1;

411 return ret;

412 }

413

414 #define FORMATS_REF(f, ref) \

415 do { \

416 *ref = f; \

417 f->refs = av_realloc(f->refs, sizeof(*f->refs) * ++f->refcount); \

418 f->refs[f->refcount-1] = ref; \

419 } while (0)

420

421 void ff_channel_layouts_ref(AVFilterChannelLayouts *f, AVFilterChannelLayouts **ref)

422 {

423 FORMATS_REF(f, ref);

424 }

425

426 void ff_formats_ref(AVFilterFormats *f, AVFilterFormats **ref)

427 {

428 FORMATS_REF(f, ref);

429 }

430

431 #define FIND_REF_INDEX(ref, idx) \

432 do { \

433 int i; \

434 for (i = 0; i < (*ref)->refcount; i ++) \

435 if((*ref)->refs[i] == ref) { \

436 idx = i; \

437 break; \

438 } \

439 } while (0)

440

441 #define FORMATS_UNREF(ref, list) \

442 do { \

443 int idx = -1; \

444 \

445 if (!*ref) \

446 return; \

447 \

448 FIND_REF_INDEX(ref, idx); \

449 \

450 if (idx >= 0) \

451 memmove((*ref)->refs + idx, (*ref)->refs + idx + 1, \

452 sizeof(*(*ref)->refs) * ((*ref)->refcount - idx - 1)); \

453 \

454 if(!--(*ref)->refcount) { \

455 av_free((*ref)->list); \

456 av_free((*ref)->refs); \

457 av_free(*ref); \

458 } \

459 *ref = NULL; \

460 } while (0)

461

462 void ff_formats_unref(AVFilterFormats **ref)

463 {

464 FORMATS_UNREF(ref, formats);

465 }

466

467 void ff_channel_layouts_unref(AVFilterChannelLayouts **ref)

468 {

469 FORMATS_UNREF(ref, channel_layouts);

470 }

471

472 #define FORMATS_CHANGEREF(oldref, newref) \

473 do { \

474 int idx = -1; \

475 \

476 FIND_REF_INDEX(oldref, idx); \

477 \

478 if (idx >= 0) { \

479 (*oldref)->refs[idx] = newref; \

480 *newref = *oldref; \

481 *oldref = NULL; \

482 } \

483 } while (0)

484

485 void ff_channel_layouts_changeref(AVFilterChannelLayouts **oldref,

486 AVFilterChannelLayouts **newref)

487 {

488 FORMATS_CHANGEREF(oldref, newref);

489 }

490

491 void ff_formats_changeref(AVFilterFormats **oldref, AVFilterFormats **newref)

492 {

493 FORMATS_CHANGEREF(oldref, newref);

494 }

495

496 #define SET_COMMON_FORMATS(ctx, fmts, in_fmts, out_fmts, ref, list) \

497 if (fmts) { \

498 int count = 0, i; \

499 \

500 for (i = 0; i < ctx->nb_inputs; i++) { \

501 if (ctx->inputs[i] && !ctx->inputs[i]->out_fmts) { \

502 ref(fmts, &ctx->inputs[i]->out_fmts); \

503 count++; \

504 } \

505 } \

506 for (i = 0; i < ctx->nb_outputs; i++) { \

507 if (ctx->outputs[i] && !ctx->outputs[i]->in_fmts) { \

508 ref(fmts, &ctx->outputs[i]->in_fmts); \

509 count++; \

510 } \

511 } \

512 \

513 if (!count) { \

514 av_freep(&fmts->list); \

515 av_freep(&fmts->refs); \

516 av_freep(&fmts); \

517 } \

518 }

519

520 void ff_set_common_channel_layouts(AVFilterContext *ctx,

521 AVFilterChannelLayouts *layouts)

522 {

523 SET_COMMON_FORMATS(ctx, layouts, in_channel_layouts, out_channel_layouts,

524 ff_channel_layouts_ref, channel_layouts);

525 }

526

527 void ff_set_common_samplerates(AVFilterContext *ctx,

528 AVFilterFormats *samplerates)

529 {

530 SET_COMMON_FORMATS(ctx, samplerates, in_samplerates, out_samplerates,

531 ff_formats_ref, formats);

532 }

533

534 /**

535 * A helper for query_formats() which sets all links to the same list of

536 * formats. If there are no links hooked to this filter, the list of formats is

537 * freed.

538 */

539 void ff_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats)

540 {

541 SET_COMMON_FORMATS(ctx, formats, in_formats, out_formats,

542 ff_formats_ref, formats);

543 }

544

545 static int default_query_formats_common(AVFilterContext *ctx,

546 AVFilterChannelLayouts *(layouts)(void))

547 {

548 enum AVMediaType type = ctx->inputs && ctx->inputs [0] ? ctx->inputs [0]->type :

549 ctx->outputs && ctx->outputs[0] ? ctx->outputs[0]->type :

550 AVMEDIA_TYPE_VIDEO;

551

552 ff_set_common_formats(ctx, ff_all_formats(type));

553 if (type == AVMEDIA_TYPE_AUDIO) {

554 ff_set_common_channel_layouts(ctx, layouts());

555 ff_set_common_samplerates(ctx, ff_all_samplerates());

556 }

557

558 return 0;

559 }

560

561 int ff_default_query_formats(AVFilterContext *ctx)

562 {

563 return default_query_formats_common(ctx, ff_all_channel_layouts);

564 }

565

566 int ff_query_formats_all(AVFilterContext *ctx)

567 {

568 return default_query_formats_common(ctx, ff_all_channel_counts);

569 }

570

571 /* internal functions for parsing audio format arguments */

572

573 int ff_parse_pixel_format(enum AVPixelFormat *ret, const char *arg, void *log_ctx)

574 {

575 char *tail;

576 int pix_fmt = av_get_pix_fmt(arg);

577 if (pix_fmt == AV_PIX_FMT_NONE) {

578 pix_fmt = strtol(arg, &tail, 0);

579 if (*tail || !av_pix_fmt_desc_get(pix_fmt)) {

580 av_log(log_ctx, AV_LOG_ERROR, "Invalid pixel format '%s'\n", arg);

581 return AVERROR(EINVAL);

582 }

583 }

584 *ret = pix_fmt;

585 return 0;

586 }

587

588 int ff_parse_sample_format(int *ret, const char *arg, void *log_ctx)

589 {

590 char *tail;

591 int sfmt = av_get_sample_fmt(arg);

592 if (sfmt == AV_SAMPLE_FMT_NONE) {

593 sfmt = strtol(arg, &tail, 0);

594 if (*tail || av_get_bytes_per_sample(sfmt)<=0) {

595 av_log(log_ctx, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);

596 return AVERROR(EINVAL);

597 }

598 }

599 *ret = sfmt;

600 return 0;

601 }

602

603 int ff_parse_time_base(AVRational *ret, const char *arg, void *log_ctx)

604 {

605 AVRational r;

606 if(av_parse_ratio(&r, arg, INT_MAX, 0, log_ctx) < 0 ||r.num<=0 ||r.den<=0) {

607 av_log(log_ctx, AV_LOG_ERROR, "Invalid time base '%s'\n", arg);

608 return AVERROR(EINVAL);

609 }

610 *ret = r;

611 return 0;

612 }

613

614 int ff_parse_sample_rate(int *ret, const char *arg, void *log_ctx)

615 {

616 char *tail;

617 double srate = av_strtod(arg, &tail);

618 if (*tail || srate < 1 || (int)srate != srate || srate > INT_MAX) {

619 av_log(log_ctx, AV_LOG_ERROR, "Invalid sample rate '%s'\n", arg);

620 return AVERROR(EINVAL);

621 }

622 *ret = srate;

623 return 0;

624 }

625

626 int ff_parse_channel_layout(int64_t *ret, int *nret, const char *arg,

627 void *log_ctx)

628 {

629 char *tail;

630 int64_t chlayout, count;

631

632 if (nret) {

633 count = strtol(arg, &tail, 10);

634 if (*tail == 'c' && !tail[1] && count > 0 && count < 63) {

635 *nret = count;

636 *ret = 0;

637 return 0;

638 }

639 }

640 chlayout = av_get_channel_layout(arg);

641 if (chlayout == 0) {

642 chlayout = strtol(arg, &tail, 10);

643 if (*tail || chlayout == 0) {

644 av_log(log_ctx, AV_LOG_ERROR, "Invalid channel layout '%s'\n", arg);

645 return AVERROR(EINVAL);

646 }

647 }

648 *ret = chlayout;

649 if (nret)

650 *nret = av_get_channel_layout_nb_channels(chlayout);

651 return 0;

652 }

653

654 #ifdef TEST

655

656 #undef printf

657

658 int main(void)

659 {

660 const int64_t *cl;

661 char buf[512];

662

663 for (cl = avfilter_all_channel_layouts; *cl != -1; cl++) {

664 av_get_channel_layout_string(buf, sizeof(buf), -1, *cl);

665 printf("%s\n", buf);

666 }

667

668 return 0;

669 }

670

671 #endif

672

Generated on Sun Mar 8 2015 02:35:06 for FFmpeg by doxygen 1.8.2