FFmpeg: libavcodec/bsf.c Source File

FFmpeg

[フレーム]

libavcodec

bsf.c

Go to the documentation of this file.

1 /*

2 * This file is part of FFmpeg.

3 *

4 * FFmpeg is free software; you can redistribute it and/or

5 * modify it under the terms of the GNU Lesser General Public

6 * License as published by the Free Software Foundation; either

7 * version 2.1 of the License, or (at your option) any later version.

8 *

9 * FFmpeg is distributed in the hope that it will be useful,

10 * but WITHOUT ANY WARRANTY; without even the implied warranty of

11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

12 * Lesser General Public License for more details.

13 *

14 * You should have received a copy of the GNU Lesser General Public

15 * License along with FFmpeg; if not, write to the Free Software

16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

17 */

19 #include <string.h>

21 #include "libavutil/log.h"

22 #include "libavutil/mem.h"

23 #include "libavutil/opt.h"

24 #include "libavutil/avstring.h"

25 #include "libavutil/bprint.h"

27 #include "avcodec.h"

28 #include "bsf.h"

30 struct AVBSFInternal {

31 AVPacket *buffer_pkt;

32 int eof;

33 };

35 void av_bsf_free(AVBSFContext **pctx)

36 {

37 AVBSFContext *ctx;

39 if (!pctx || !*pctx)

40 return;

41 ctx = *pctx;

43 if (ctx->filter->close)

44 ctx->filter->close(ctx);

45 if (ctx->filter->priv_class && ctx->priv_data)

46 av_opt_free(ctx->priv_data);

48 av_opt_free(ctx);

50 av_packet_free(&ctx->internal->buffer_pkt);

51 av_freep(&ctx->internal);

52 av_freep(&ctx->priv_data);

54 avcodec_parameters_free(&ctx->par_in);

55 avcodec_parameters_free(&ctx->par_out);

57 av_freep(pctx);

58 }

60 static void *bsf_child_next(void *obj, void *prev)

61 {

62 AVBSFContext *ctx = obj;

63 if (!prev && ctx->filter->priv_class)

64 return ctx->priv_data;

65 return NULL;

66 }

68 static const AVClass bsf_class = {

69 .class_name = "AVBSFContext",

70 .item_name = av_default_item_name,

71 .version = LIBAVUTIL_VERSION_INT,

72 .child_next = bsf_child_next,

73 .child_class_next = ff_bsf_child_class_next,

74 };

76 const AVClass *av_bsf_get_class(void)

77 {

78 return &bsf_class;

79 }

81 int av_bsf_alloc(const AVBitStreamFilter *filter, AVBSFContext **pctx)

82 {

83 AVBSFContext *ctx;

84 int ret;

86 ctx = av_mallocz(sizeof(*ctx));

87 if (!ctx)

88 return AVERROR(ENOMEM);

90 ctx->av_class = &bsf_class;

91 ctx->filter = filter;

93 ctx->par_in = avcodec_parameters_alloc();

94 ctx->par_out = avcodec_parameters_alloc();

95 if (!ctx->par_in || !ctx->par_out) {

96 ret = AVERROR(ENOMEM);

97 goto fail;

98 }

100 ctx->internal = av_mallocz(sizeof(*ctx->internal));

101 if (!ctx->internal) {

102 ret = AVERROR(ENOMEM);

103 goto fail;

104 }

105

106 ctx->internal->buffer_pkt = av_packet_alloc();

107 if (!ctx->internal->buffer_pkt) {

108 ret = AVERROR(ENOMEM);

109 goto fail;

110 }

111

112 av_opt_set_defaults(ctx);

113

114 /* allocate priv data and init private options */

115 if (filter->priv_data_size) {

116 ctx->priv_data = av_mallocz(filter->priv_data_size);

117 if (!ctx->priv_data) {

118 ret = AVERROR(ENOMEM);

119 goto fail;

120 }

121 if (filter->priv_class) {

122 *(const AVClass **)ctx->priv_data = filter->priv_class;

123 av_opt_set_defaults(ctx->priv_data);

124 }

125 }

126

127 *pctx = ctx;

128 return 0;

129 fail:

130 av_bsf_free(&ctx);

131 return ret;

132 }

133

134 int av_bsf_init(AVBSFContext *ctx)

135 {

136 int ret, i;

137

138 /* check that the codec is supported */

139 if (ctx->filter->codec_ids) {

140 for (i = 0; ctx->filter->codec_ids[i] != AV_CODEC_ID_NONE; i++)

141 if (ctx->par_in->codec_id == ctx->filter->codec_ids[i])

142 break;

143 if (ctx->filter->codec_ids[i] == AV_CODEC_ID_NONE) {

144 const AVCodecDescriptor *desc = avcodec_descriptor_get(ctx->par_in->codec_id);

145 av_log(ctx, AV_LOG_ERROR, "Codec '%s' (%d) is not supported by the "

146 "bitstream filter '%s'. Supported codecs are: ",

147 desc ? desc->name : "unknown", ctx->par_in->codec_id, ctx->filter->name);

148 for (i = 0; ctx->filter->codec_ids[i] != AV_CODEC_ID_NONE; i++) {

149 desc = avcodec_descriptor_get(ctx->filter->codec_ids[i]);

150 av_log(ctx, AV_LOG_ERROR, "%s (%d) ",

151 desc ? desc->name : "unknown", ctx->filter->codec_ids[i]);

152 }

153 av_log(ctx, AV_LOG_ERROR, "\n");

154 return AVERROR(EINVAL);

155 }

156 }

157

158 /* initialize output parameters to be the same as input

159 * init below might overwrite that */

160 ret = avcodec_parameters_copy(ctx->par_out, ctx->par_in);

161 if (ret < 0)

162 return ret;

163

164 ctx->time_base_out = ctx->time_base_in;

165

166 if (ctx->filter->init) {

167 ret = ctx->filter->init(ctx);

168 if (ret < 0)

169 return ret;

170 }

171

172 return 0;

173 }

174

175 int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt)

176 {

177 int ret;

178

179 if (!pkt || (!pkt->data && !pkt->side_data_elems)) {

180 ctx->internal->eof = 1;

181 return 0;

182 }

183

184 if (ctx->internal->eof) {

185 av_log(ctx, AV_LOG_ERROR, "A non-NULL packet sent after an EOF.\n");

186 return AVERROR(EINVAL);

187 }

188

189 if (ctx->internal->buffer_pkt->data ||

190 ctx->internal->buffer_pkt->side_data_elems)

191 return AVERROR(EAGAIN);

192

193 ret = av_packet_make_refcounted(pkt);

194 if (ret < 0)

195 return ret;

196 av_packet_move_ref(ctx->internal->buffer_pkt, pkt);

197

198 return 0;

199 }

200

201 int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt)

202 {

203 return ctx->filter->filter(ctx, pkt);

204 }

205

206 int ff_bsf_get_packet(AVBSFContext *ctx, AVPacket **pkt)

207 {

208 AVBSFInternal *in = ctx->internal;

209 AVPacket *tmp_pkt;

210

211 if (in->eof)

212 return AVERROR_EOF;

213

214 if (!ctx->internal->buffer_pkt->data &&

215 !ctx->internal->buffer_pkt->side_data_elems)

216 return AVERROR(EAGAIN);

217

218 tmp_pkt = av_packet_alloc();

219 if (!tmp_pkt)

220 return AVERROR(ENOMEM);

221

222 *pkt = ctx->internal->buffer_pkt;

223 ctx->internal->buffer_pkt = tmp_pkt;

224

225 return 0;

226 }

227

228 int ff_bsf_get_packet_ref(AVBSFContext *ctx, AVPacket *pkt)

229 {

230 AVBSFInternal *in = ctx->internal;

231

232 if (in->eof)

233 return AVERROR_EOF;

234

235 if (!ctx->internal->buffer_pkt->data &&

236 !ctx->internal->buffer_pkt->side_data_elems)

237 return AVERROR(EAGAIN);

238

239 av_packet_move_ref(pkt, ctx->internal->buffer_pkt);

240

241 return 0;

242 }

243

244 typedef struct BSFListContext {

245 const AVClass *class;

246

247 AVBSFContext **bsfs;

248 int nb_bsfs;

249

250 unsigned idx; // index of currently processed BSF

251 unsigned flushed_idx; // index of BSF being flushed

252

253 char * item_name;

254 } BSFListContext;

255

256

257 static int bsf_list_init(AVBSFContext *bsf)

258 {

259 BSFListContext *lst = bsf->priv_data;

260 int ret, i;

261 const AVCodecParameters *cod_par = bsf->par_in;

262 AVRational tb = bsf->time_base_in;

263

264 for (i = 0; i < lst->nb_bsfs; ++i) {

265 ret = avcodec_parameters_copy(lst->bsfs[i]->par_in, cod_par);

266 if (ret < 0)

267 goto fail;

268

269 lst->bsfs[i]->time_base_in = tb;

270

271 ret = av_bsf_init(lst->bsfs[i]);

272 if (ret < 0)

273 goto fail;

274

275 cod_par = lst->bsfs[i]->par_out;

276 tb = lst->bsfs[i]->time_base_out;

277 }

278

279 bsf->time_base_out = tb;

280 ret = avcodec_parameters_copy(bsf->par_out, cod_par);

281

282 fail:

283 return ret;

284 }

285

286 static int bsf_list_filter(AVBSFContext *bsf, AVPacket *out)

287 {

288 BSFListContext *lst = bsf->priv_data;

289 int ret;

290

291 if (!lst->nb_bsfs)

292 return ff_bsf_get_packet_ref(bsf, out);

293

294 while (1) {

295 if (lst->idx > lst->flushed_idx) {

296 ret = av_bsf_receive_packet(lst->bsfs[lst->idx-1], out);

297 if (ret == AVERROR(EAGAIN)) {

298 /* no more packets from idx-1, try with previous */

299 ret = 0;

300 lst->idx--;

301 continue;

302 } else if (ret == AVERROR_EOF) {

303 /* filter idx-1 is done, continue with idx...nb_bsfs */

304 lst->flushed_idx = lst->idx;

305 continue;

306 }else if (ret < 0) {

307 /* filtering error */

308 break;

309 }

310 } else {

311 ret = ff_bsf_get_packet_ref(bsf, out);

312 if (ret == AVERROR_EOF) {

313 lst->idx = lst->flushed_idx;

314 } else if (ret < 0)

315 break;

316 }

317

318 if (lst->idx < lst->nb_bsfs) {

319 AVPacket *pkt;

320 if (ret == AVERROR_EOF && lst->idx == lst->flushed_idx) {

321 /* ff_bsf_get_packet_ref returned EOF and idx is first

322 * filter of yet not flushed filter chain */

323 pkt = NULL;

324 } else {

325 pkt = out;

326 }

327 ret = av_bsf_send_packet(lst->bsfs[lst->idx], pkt);

328 if (ret < 0)

329 break;

330 lst->idx++;

331 } else {

332 /* The end of filter chain, break to return result */

333 break;

334 }

335 }

336

337 if (ret < 0)

338 av_packet_unref(out);

339

340 return ret;

341 }

342

343 static void bsf_list_close(AVBSFContext *bsf)

344 {

345 BSFListContext *lst = bsf->priv_data;

346 int i;

347

348 for (i = 0; i < lst->nb_bsfs; ++i)

349 av_bsf_free(&lst->bsfs[i]);

350 av_freep(&lst->bsfs);

351 av_freep(&lst->item_name);

352 }

353

354 static const char *bsf_list_item_name(void *ctx)

355 {

356 static const char *null_filter_name = "null";

357 AVBSFContext *bsf_ctx = ctx;

358 BSFListContext *lst = bsf_ctx->priv_data;

359

360 if (!lst->nb_bsfs)

361 return null_filter_name;

362

363 if (!lst->item_name) {

364 int i;

365 AVBPrint bp;

366 av_bprint_init(&bp, 16, 128);

367

368 av_bprintf(&bp, "bsf_list(");

369 for (i = 0; i < lst->nb_bsfs; i++)

370 av_bprintf(&bp, i ? ",%s" : "%s", lst->bsfs[i]->filter->name);

371 av_bprintf(&bp, ")");

372

373 av_bprint_finalize(&bp, &lst->item_name);

374 }

375

376 return lst->item_name;

377 }

378

379 static const AVClass bsf_list_class = {

380 .class_name = "bsf_list",

381 .item_name = bsf_list_item_name,

382 .version = LIBAVUTIL_VERSION_INT,

383 };

384

385 const AVBitStreamFilter ff_list_bsf = {

386 .name = "bsf_list",

387 .priv_data_size = sizeof(BSFListContext),

388 .priv_class = &bsf_list_class,

389 .init = bsf_list_init,

390 .filter = bsf_list_filter,

391 .close = bsf_list_close,

392 };

393

394 struct AVBSFList {

395 AVBSFContext **bsfs;

396 int nb_bsfs;

397 };

398

399 AVBSFList *av_bsf_list_alloc(void)

400 {

401 return av_mallocz(sizeof(AVBSFList));

402 }

403

404 void av_bsf_list_free(AVBSFList **lst)

405 {

406 int i;

407

408 if (!*lst)

409 return;

410

411 for (i = 0; i < (*lst)->nb_bsfs; ++i)

412 av_bsf_free(&(*lst)->bsfs[i]);

413 av_free((*lst)->bsfs);

414 av_freep(lst);

415 }

416

417 int av_bsf_list_append(AVBSFList *lst, AVBSFContext *bsf)

418 {

419 return av_dynarray_add_nofree(&lst->bsfs, &lst->nb_bsfs, bsf);

420 }

421

422 int av_bsf_list_append2(AVBSFList *lst, const char *bsf_name, AVDictionary ** options)

423 {

424 int ret;

425 const AVBitStreamFilter *filter;

426 AVBSFContext *bsf;

427

428 filter = av_bsf_get_by_name(bsf_name);

429 if (!filter)

430 return AVERROR_BSF_NOT_FOUND;

431

432 ret = av_bsf_alloc(filter, &bsf);

433 if (ret < 0)

434 return ret;

435

436 if (options) {

437 ret = av_opt_set_dict2(bsf, options, AV_OPT_SEARCH_CHILDREN);

438 if (ret < 0)

439 goto end;

440 }

441

442 ret = av_bsf_list_append(lst, bsf);

443

444 end:

445 if (ret < 0)

446 av_bsf_free(&bsf);

447

448 return ret;

449 }

450

451 int av_bsf_list_finalize(AVBSFList **lst, AVBSFContext **bsf)

452 {

453 int ret = 0;

454 BSFListContext *ctx;

455

456 if ((*lst)->nb_bsfs == 1) {

457 *bsf = (*lst)->bsfs[0];

458 av_freep(&(*lst)->bsfs);

459 (*lst)->nb_bsfs = 0;

460 goto end;

461 }

462

463 ret = av_bsf_alloc(&ff_list_bsf, bsf);

464 if (ret < 0)

465 return ret;

466

467 ctx = (*bsf)->priv_data;

468

469 ctx->bsfs = (*lst)->bsfs;

470 ctx->nb_bsfs = (*lst)->nb_bsfs;

471

472 end:

473 av_freep(lst);

474 return ret;

475 }

476

477 static int bsf_parse_single(const char *str, AVBSFList *bsf_lst)

478 {

479 char *bsf_name, *bsf_options_str, *buf;

480 AVDictionary *bsf_options = NULL;

481 int ret = 0;

482

483 if (!(buf = av_strdup(str)))

484 return AVERROR(ENOMEM);

485

486 bsf_name = av_strtok(buf, "=", &bsf_options_str);

487 if (!bsf_name) {

488 ret = AVERROR(EINVAL);

489 goto end;

490 }

491

492 if (bsf_options_str) {

493 ret = av_dict_parse_string(&bsf_options, bsf_options_str, "=", ":", 0);

494 if (ret < 0)

495 goto end;

496 }

497

498 ret = av_bsf_list_append2(bsf_lst, bsf_name, &bsf_options);

499

500 av_dict_free(&bsf_options);

501 end:

502 av_free(buf);

503 return ret;

504 }

505

506 int av_bsf_list_parse_str(const char *str, AVBSFContext **bsf_lst)

507 {

508 AVBSFList *lst;

509 char *bsf_str, *buf, *dup, *saveptr;

510 int ret;

511

512 if (!str)

513 return av_bsf_get_null_filter(bsf_lst);

514

515 lst = av_bsf_list_alloc();

516 if (!lst)

517 return AVERROR(ENOMEM);

518

519 if (!(dup = buf = av_strdup(str))) {

520 ret = AVERROR(ENOMEM);

521 goto end;

522 }

523

524 while (1) {

525 bsf_str = av_strtok(buf, ",", &saveptr);

526 if (!bsf_str)

527 break;

528

529 ret = bsf_parse_single(bsf_str, lst);

530 if (ret < 0)

531 goto end;

532

533 buf = NULL;

534 }

535

536 ret = av_bsf_list_finalize(&lst, bsf_lst);

537 end:

538 if (ret < 0)

539 av_bsf_list_free(&lst);

540 av_free(dup);

541 return ret;

542 }

543

544 int av_bsf_get_null_filter(AVBSFContext **bsf)

545 {

546 return av_bsf_alloc(&ff_list_bsf, bsf);

547 }

av_bsf_free

void av_bsf_free(AVBSFContext **pctx)

Free a bitstream filter context and everything associated with it; write NULL into the supplied point...

Definition: bsf.c:35

NULL

#define NULL

Definition: coverity.c:32

BSFListContext::bsfs

AVBSFContext ** bsfs

Definition: bsf.c:247

AVBitStreamFilter::priv_class

const AVClass * priv_class

A class for the private data, used to declare bitstream filter private AVOptions. ...

Definition: avcodec.h:5755

AV_CODEC_ID_NONE

Definition: avcodec.h:216

AVBSFContext::par_out

AVCodecParameters * par_out

Parameters of the output stream.

Definition: avcodec.h:5721

av_bprintf

void av_bprintf(AVBPrint *buf, const char *fmt,...)

Definition: bprint.c:94

bsf_child_next

static void * bsf_child_next(void *obj, void *prev)

Definition: bsf.c:60

LIBAVUTIL_VERSION_INT

#define LIBAVUTIL_VERSION_INT

Definition: version.h:85

mem.h

Memory handling functions.

BSFListContext::idx

unsigned idx

Definition: bsf.c:250

desc

const char * desc

Definition: nvenc.c:65

init

static av_cold int init(AVCodecContext *avctx)

Definition: avrndec.c:35

av_opt_set_defaults

void av_opt_set_defaults(void *s)

Set the values of all AVOption fields to their default values.

Definition: opt.c:1292

AVCodecParameters::codec_id

enum AVCodecID codec_id

Specific type of the encoded data (the codec used).

Definition: avcodec.h:3884

AVBSFContext::filter

const struct AVBitStreamFilter * filter

The bitstream filter this context is an instance of.

Definition: avcodec.h:5696

AVBSFContext

The bitstream filter state.

Definition: avcodec.h:5687

av_default_item_name

const char * av_default_item_name(void *ptr)

Return the context name.

Definition: log.c:191

av_bsf_get_by_name

const AVBitStreamFilter * av_bsf_get_by_name(const char *name)

Definition: bitstream_filters.c:75

AVBSFList

Structure for chain/list of bitstream filters.

Definition: bsf.c:394

av_mallocz

void * av_mallocz(size_t size)

Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...

Definition: mem.c:236

avstring.h

pkt

static AVPacket pkt

Definition: demuxing_decoding.c:54

bsf_class

static const AVClass bsf_class

Definition: bsf.c:68

av_bsf_get_null_filter

int av_bsf_get_null_filter(AVBSFContext **bsf)

Get null/pass-through bitstream filter.

Definition: bsf.c:544

AVBSFContext::priv_data

void * priv_data

Opaque filter-specific private data.

Definition: avcodec.h:5708

BSFListContext

Definition: bsf.c:244

AVCodecParameters

This struct describes the properties of an encoded stream.

Definition: avcodec.h:3876

av_bsf_init

int av_bsf_init(AVBSFContext *ctx)

Prepare the filter for use, after all the parameters and options have been set.

Definition: bsf.c:134

av_bprint_finalize

int av_bprint_finalize(AVBPrint *buf, char **ret_str)

Finalize a print buffer.

Definition: bprint.c:235

av_bsf_list_free

void av_bsf_list_free(AVBSFList **lst)

Free list of bitstream filters.

Definition: bsf.c:404

av_bsf_alloc

int av_bsf_alloc(const AVBitStreamFilter *filter, AVBSFContext **pctx)

Allocate a context for a given bitstream filter.

Definition: bsf.c:81

AVClass::class_name

const char * class_name

The name of the class; usually it is the same name as the context structure type to which the AVClass...

Definition: log.h:72

bsf_list_class

static const AVClass bsf_list_class

Definition: bsf.c:379

av_bsf_receive_packet

int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt)

Retrieve a filtered packet.

Definition: bsf.c:201

filter

static void filter(int16_t *output, ptrdiff_t out_stride, int16_t *low, ptrdiff_t low_stride, int16_t *high, ptrdiff_t high_stride, int len, int clip)

Definition: cfhd.c:114

av_packet_free

void av_packet_free(AVPacket **pkt)

Free the packet, if the packet is reference counted, it will be unreferenced first.

Definition: avpacket.c:62

opt.h

AVOptions.

avcodec_parameters_alloc

AVCodecParameters * avcodec_parameters_alloc(void)

Allocate a new AVCodecParameters and set its fields to default values (unknown/invalid/0).

Definition: utils.c:1982

end

static av_cold int end(AVCodecContext *avctx)

Definition: avrndec.c:90

bsf_parse_single

static int bsf_parse_single(const char *str, AVBSFList *bsf_lst)

Definition: bsf.c:477

AVBitStreamFilter::name

const char * name

Definition: avcodec.h:5737

AVPacket::data

uint8_t * data

Definition: avcodec.h:1430

av_packet_move_ref

void av_packet_move_ref(AVPacket *dst, AVPacket *src)

Move every field in src to dst and reset src.

Definition: avpacket.c:647

bsf.h

AVERROR_EOF

#define AVERROR_EOF

End of file.

Definition: error.h:55

av_dynarray_add_nofree

int av_dynarray_add_nofree(void *tab_ptr, int *nb_ptr, void *elem)

Add an element to a dynamic array.

Definition: mem.c:294

AVBSFInternal

Definition: bsf.c:30

AVBitStreamFilter

Definition: avcodec.h:5736

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:28

AVDictionary

Definition: dict.c:30

avcodec_parameters_copy

int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src)

Copy the contents of src to dst.

Definition: utils.c:2003

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:176

bsf_list_filter

static int bsf_list_filter(AVBSFContext *bsf, AVPacket *out)

Definition: bsf.c:286

AVERROR

#define AVERROR(e)

Definition: error.h:43

AVBitStreamFilter::codec_ids

enum AVCodecID * codec_ids

A list of codec ids supported by the filter, terminated by AV_CODEC_ID_NONE.

Definition: avcodec.h:5744

av_bprint_init

void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)

Definition: bprint.c:69

av_dict_free

void av_dict_free(AVDictionary **pm)

Free all the memory allocated for an AVDictionary struct and all keys and values. ...

Definition: dict.c:203

AVBSFContext::time_base_in

AVRational time_base_in

The timebase used for the timestamps of the input packets.

Definition: avcodec.h:5727

BSFListContext::flushed_idx

unsigned flushed_idx

Definition: bsf.c:251

AVPacket::side_data_elems

int side_data_elems

Definition: avcodec.h:1442

bsf_list_close

static void bsf_list_close(AVBSFContext *bsf)

Definition: bsf.c:343

AVBSFInternal::eof

int eof

Definition: bsf.c:32

AVBitStreamFilter::init

int(* init)(AVBSFContext *ctx)

Definition: avcodec.h:5766

avcodec_parameters_free

void avcodec_parameters_free(AVCodecParameters **par)

Free an AVCodecParameters instance and everything associated with it and write NULL to the supplied p...

Definition: utils.c:1992

fail

#define fail()

Definition: checkasm.h:116

avcodec_descriptor_get

const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)

Definition: codec_desc.c:3135

av_bsf_list_append

int av_bsf_list_append(AVBSFList *lst, AVBSFContext *bsf)

Append bitstream filter to the list of bitstream filters.

Definition: bsf.c:417

ff_bsf_child_class_next

const AVClass * ff_bsf_child_class_next(const AVClass *prev)

Definition: bitstream_filters.c:88

av_bsf_get_class

const AVClass * av_bsf_get_class(void)

Get the AVClass for AVBSFContext.

Definition: bsf.c:76

AV_OPT_SEARCH_CHILDREN

#define AV_OPT_SEARCH_CHILDREN

Search in possible children of the given object first.

Definition: opt.h:555

av_bsf_list_append2

int av_bsf_list_append2(AVBSFList *lst, const char *bsf_name, AVDictionary **options)

Construct new bitstream filter context given it's name and options and append it to the list of bitst...

Definition: bsf.c:422

AVBSFContext::time_base_out

AVRational time_base_out

The timebase used for the timestamps of the output packets.

Definition: avcodec.h:5733

av_packet_make_refcounted

int av_packet_make_refcounted(AVPacket *pkt)

Ensure the data described by a given packet is reference counted.

Definition: avpacket.c:655

av_bsf_send_packet

int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt)

Submit a packet for filtering.

Definition: bsf.c:175

BSFListContext::item_name

char * item_name

Definition: bsf.c:253

ctx

AVFormatContext * ctx

Definition: movenc.c:48

AVBSFContext::av_class

const AVClass * av_class

A class for logging and AVOptions.

Definition: avcodec.h:5691

AVERROR_BSF_NOT_FOUND

#define AVERROR_BSF_NOT_FOUND

Bitstream filter not found.

Definition: error.h:49

AVBitStreamFilter::priv_data_size

int priv_data_size

Definition: avcodec.h:5765

bprint.h

av_opt_set_dict2

int av_opt_set_dict2(void *obj, AVDictionary **options, int search_flags)

Set all the options from a given dictionary on an object.

Definition: opt.c:1565

BSFListContext::nb_bsfs

int nb_bsfs

Definition: bsf.c:248

av_dict_parse_string

int av_dict_parse_string(AVDictionary **pm, const char *str, const char *key_val_sep, const char *pairs_sep, int flags)

Parse the key/value pairs list and add the parsed entries to a dictionary.

Definition: dict.c:180

av_bsf_list_alloc

AVBSFList * av_bsf_list_alloc(void)

Allocate empty list of bitstream filters.

Definition: bsf.c:399

AVBSFList::bsfs

AVBSFContext ** bsfs

Definition: bsf.c:395

av_strdup

char * av_strdup(const char *s)

Duplicate a string.

Definition: mem.c:251

avcodec.h

Libavcodec external API header.

AVBitStreamFilter::close

void(* close)(AVBSFContext *ctx)

Definition: avcodec.h:5768

av_packet_unref

void av_packet_unref(AVPacket *pkt)

Wipe the packet.

Definition: avpacket.c:592

uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31))))#defineSET_CONV_FUNC_GROUP(ofmt, ifmt) staticvoidset_generic_function(AudioConvert *ac){}voidff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, intsample_rate, intapply_map){AudioConvert *ac;intin_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) returnNULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt)>2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);returnNULL;}returnac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);returnac;}intff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){intuse_generic=1;intlen=in->nb_samples;intp;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%dsamples-audio_convert:%sto%s(dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));returnff_convert_dither(ac-> in

Definition: audio_convert.c:194

buf

void * buf

Definition: avisynth_c.h:690

AVClass

Describe the class of an AVClass context structure.

Definition: log.h:67

AVBSFInternal::buffer_pkt

AVPacket * buffer_pkt

Definition: bsf.c:31

AVRational

Rational number (pair of numerator and denominator).