FFmpeg: libavformat/gxf.c Source File

FFmpeg

[フレーム]

libavformat

gxf.c

Go to the documentation of this file.

1 /*

2 * GXF demuxer.

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 <inttypes.h>

24 #include "libavutil/channel_layout.h"

25 #include "libavutil/common.h"

26 #include "avformat.h"

27 #include "demux.h"

28 #include "internal.h"

29 #include "gxf.h"

31 struct gxf_stream_info {

32 int64_t first_field;

33 int64_t last_field;

34 AVRational frames_per_second;

35 int32_t fields_per_frame;

36 int64_t track_aux_data;

37 };

39 /**

40 * @brief parse gxf timecode and add it to metadata

41 */

42 static int add_timecode_metadata(AVDictionary **pm, const char *key, uint32_t timecode, int fields_per_frame)

43 {

44 char tmp[128];

45 int field = timecode & 0xff;

46 int frame = fields_per_frame ? field / fields_per_frame : field;

47 int second = (timecode >> 8) & 0xff;

48 int minute = (timecode >> 16) & 0xff;

49 int hour = (timecode >> 24) & 0x1f;

50 int drop = (timecode >> 29) & 1;

51 // bit 30: color_frame, unused

52 // ignore invalid time code

53 if (timecode >> 31)

54 return 0;

55 snprintf(tmp, sizeof(tmp), "%02d:%02d:%02d%c%02d",

56 hour, minute, second, drop ? ';' : ':', frame);

57 return av_dict_set(pm, key, tmp, 0);

58 }

60 /**

61 * @brief parses a packet header, extracting type and length

62 * @param pb AVIOContext to read header from

63 * @param type detected packet type is stored here

64 * @param length detected packet length, excluding header is stored here

65 * @return 0 if header not found or contains invalid data, 1 otherwise

66 */

67 static int parse_packet_header(AVIOContext *pb, GXFPktType *type, int *length) {

68 if (avio_rb32(pb))

69 return 0;

70 if (avio_r8(pb) != 1)

71 return 0;

72 *type = avio_r8(pb);

73 *length = avio_rb32(pb);

74 if ((*length >> 24) || *length < 16)

75 return 0;

76 *length -= 16;

77 if (avio_rb32(pb))

78 return 0;

79 if (avio_r8(pb) != 0xe1)

80 return 0;

81 if (avio_r8(pb) != 0xe2)

82 return 0;

83 return 1;

84 }

86 /**

87 * @brief check if file starts with a PKT_MAP header

88 */

89 static int gxf_probe(const AVProbeData *p) {

90 static const uint8_t startcode[] = {0, 0, 0, 0, 1, 0xbc}; // start with map packet

91 static const uint8_t endcode[] = {0, 0, 0, 0, 0xe1, 0xe2};

92 if (!memcmp(p->buf, startcode, sizeof(startcode)) &&

93 !memcmp(&p->buf[16 - sizeof(endcode)], endcode, sizeof(endcode)))

94 return AVPROBE_SCORE_MAX;

95 return 0;

96 }

98 /**

99 * @brief gets the stream index for the track with the specified id, creates new

100 * stream if not found

101 * @param id id of stream to find / add

102 * @param format stream format identifier

103 */

104 static int get_sindex(AVFormatContext *s, int id, int format) {

105 int i;

106 AVStream *st = NULL;

107 FFStream *sti;

108 i = ff_find_stream_index(s, id);

109 if (i >= 0)

110 return i;

111 st = avformat_new_stream(s, NULL);

112 if (!st)

113 return AVERROR(ENOMEM);

114 sti = ffstream(st);

115 st->id = id;

116 switch (format) {

117 case 3:

118 case 4:

119 st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;

120 st->codecpar->codec_id = AV_CODEC_ID_MJPEG;

121 break;

122 case 13:

123 case 14:

124 case 15:

125 case 16:

126 case 25:

127 st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;

128 st->codecpar->codec_id = AV_CODEC_ID_DVVIDEO;

129 break;

130 case 11:

131 case 12:

132 case 20:

133 st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;

134 st->codecpar->codec_id = AV_CODEC_ID_MPEG2VIDEO;

135 sti->need_parsing = AVSTREAM_PARSE_HEADERS; //get keyframe flag etc.

136 break;

137 case 22:

138 case 23:

139 st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;

140 st->codecpar->codec_id = AV_CODEC_ID_MPEG1VIDEO;

141 sti->need_parsing = AVSTREAM_PARSE_HEADERS; //get keyframe flag etc.

142 break;

143 case 9:

144 st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;

145 st->codecpar->codec_id = AV_CODEC_ID_PCM_S24LE;

146 st->codecpar->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_MONO;

147 st->codecpar->sample_rate = 48000;

148 st->codecpar->bit_rate = 3 * 1 * 48000 * 8;

149 st->codecpar->block_align = 3 * 1;

150 st->codecpar->bits_per_coded_sample = 24;

151 break;

152 case 10:

153 st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;

154 st->codecpar->codec_id = AV_CODEC_ID_PCM_S16LE;

155 st->codecpar->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_MONO;

156 st->codecpar->sample_rate = 48000;

157 st->codecpar->bit_rate = 2 * 1 * 48000 * 8;

158 st->codecpar->block_align = 2 * 1;

159 st->codecpar->bits_per_coded_sample = 16;

160 break;

161 case 17:

162 st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;

163 st->codecpar->codec_id = AV_CODEC_ID_AC3;

164 st->codecpar->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_STEREO;

165 st->codecpar->sample_rate = 48000;

166 break;

167 case 26: /* AVCi50 / AVCi100 (AVC Intra) */

168 case 29: /* AVCHD */

169 st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;

170 st->codecpar->codec_id = AV_CODEC_ID_H264;

171 sti->need_parsing = AVSTREAM_PARSE_HEADERS;

172 break;

173 // timecode tracks:

174 case 7:

175 case 8:

176 case 24:

177 st->codecpar->codec_type = AVMEDIA_TYPE_DATA;

178 st->codecpar->codec_id = AV_CODEC_ID_NONE;

179 break;

180 case 30:

181 st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;

182 st->codecpar->codec_id = AV_CODEC_ID_DNXHD;

183 break;

184 default:

185 st->codecpar->codec_type = AVMEDIA_TYPE_UNKNOWN;

186 st->codecpar->codec_id = AV_CODEC_ID_NONE;

187 break;

188 }

189 return s->nb_streams - 1;

190 }

191

192 /**

193 * @brief filters out interesting tags from material information.

194 * @param len length of tag section, will be adjusted to contain remaining bytes

195 * @param si struct to store collected information into

196 */

197 static void gxf_material_tags(AVIOContext *pb, int *len, struct gxf_stream_info *si) {

198 si->first_field = AV_NOPTS_VALUE;

199 si->last_field = AV_NOPTS_VALUE;

200 while (*len >= 2) {

201 GXFMatTag tag = avio_r8(pb);

202 int tlen = avio_r8(pb);

203 *len -= 2;

204 if (tlen > *len)

205 return;

206 *len -= tlen;

207 if (tlen == 4) {

208 uint32_t value = avio_rb32(pb);

209 if (tag == MAT_FIRST_FIELD)

210 si->first_field = value;

211 else if (tag == MAT_LAST_FIELD)

212 si->last_field = value;

213 } else

214 avio_skip(pb, tlen);

215 }

216 }

217

218 static const AVRational frame_rate_tab[] = {

219 { 60, 1},

220 {60000, 1001},

221 { 50, 1},

222 { 30, 1},

223 {30000, 1001},

224 { 25, 1},

225 { 24, 1},

226 {24000, 1001},

227 { 0, 0},

228 };

229

230 /**

231 * @brief convert fps tag value to AVRational fps

232 * @param fps fps value from tag

233 * @return fps as AVRational, or 0 / 0 if unknown

234 */

235 static AVRational fps_tag2avr(int32_t fps) {

236 if (fps < 1 || fps > 9) fps = 9;

237 return frame_rate_tab[fps - 1];

238 }

239

240 /**

241 * @brief convert UMF attributes flags to AVRational fps

242 * @param flags UMF flags to convert

243 * @return fps as AVRational, or 0 / 0 if unknown

244 */

245 static AVRational fps_umf2avr(uint32_t flags) {

246 static const AVRational map[] = {{50, 1}, {60000, 1001}, {24, 1},

247 {25, 1}, {30000, 1001}};

248 int idx = av_log2((flags & 0x7c0) >> 6);

249 return map[idx];

250 }

251

252 /**

253 * @brief filters out interesting tags from track information.

254 * @param len length of tag section, will be adjusted to contain remaining bytes

255 * @param si struct to store collected information into

256 */

257 static void gxf_track_tags(AVIOContext *pb, int *len, struct gxf_stream_info *si) {

258 si->frames_per_second = (AVRational){0, 0};

259 si->fields_per_frame = 0;

260 si->track_aux_data = 0x80000000;

261 while (*len >= 2) {

262 GXFTrackTag tag = avio_r8(pb);

263 int tlen = avio_r8(pb);

264 *len -= 2;

265 if (tlen > *len)

266 return;

267 *len -= tlen;

268 if (tlen == 4) {

269 uint32_t value = avio_rb32(pb);

270 if (tag == TRACK_FPS)

271 si->frames_per_second = fps_tag2avr(value);

272 else if (tag == TRACK_FPF && (value == 1 || value == 2))

273 si->fields_per_frame = value;

274 } else if (tlen == 8 && tag == TRACK_AUX)

275 si->track_aux_data = avio_rl64(pb);

276 else

277 avio_skip(pb, tlen);

278 }

279 }

280

281 /**

282 * @brief read index from FLT packet into stream 0 av_index

283 */

284 static void gxf_read_index(AVFormatContext *s, int pkt_len) {

285 AVIOContext *pb = s->pb;

286 AVStream *st;

287 uint32_t fields_per_map, map_cnt;

288 int i;

289 if (pkt_len < 8)

290 return;

291 fields_per_map = avio_rl32(pb);

292 map_cnt = avio_rl32(pb);

293 pkt_len -= 8;

294 if ((s->flags & AVFMT_FLAG_IGNIDX) || !s->streams) {

295 avio_skip(pb, pkt_len);

296 return;

297 }

298 st = s->streams[0];

299 if (map_cnt > 1000) {

300 av_log(s, AV_LOG_ERROR,

301 "too many index entries %"PRIu32" (%"PRIx32")\n",

302 map_cnt, map_cnt);

303 map_cnt = 1000;

304 }

305 if (pkt_len < 4 * map_cnt) {

306 av_log(s, AV_LOG_ERROR, "invalid index length\n");

307 avio_skip(pb, pkt_len);

308 return;

309 }

310 pkt_len -= 4 * map_cnt;

311 av_add_index_entry(st, 0, 0, 0, 0, 0);

312 for (i = 0; i < map_cnt; i++)

313 av_add_index_entry(st, (uint64_t)avio_rl32(pb) * 1024,

314 i * (uint64_t)fields_per_map + 1, 0, 0, 0);

315 avio_skip(pb, pkt_len);

316 }

317

318 static int gxf_header(AVFormatContext *s) {

319 AVIOContext *pb = s->pb;

320 GXFPktType pkt_type;

321 int map_len;

322 int len;

323 AVRational main_timebase = {0, 0};

324 struct gxf_stream_info *si = s->priv_data;

325 int i;

326 if (!parse_packet_header(pb, &pkt_type, &map_len) || pkt_type != PKT_MAP) {

327 av_log(s, AV_LOG_ERROR, "map packet not found\n");

328 return 0;

329 }

330 map_len -= 2;

331 if (avio_r8(pb) != 0x0e0 || avio_r8(pb) != 0xff) {

332 av_log(s, AV_LOG_ERROR, "unknown version or invalid map preamble\n");

333 return 0;

334 }

335 map_len -= 2;

336 len = avio_rb16(pb); // length of material data section

337 if (len > map_len) {

338 av_log(s, AV_LOG_ERROR, "material data longer than map data\n");

339 return 0;

340 }

341 map_len -= len;

342 gxf_material_tags(pb, &len, si);

343 avio_skip(pb, len);

344 map_len -= 2;

345 len = avio_rb16(pb); // length of track description

346 if (len > map_len) {

347 av_log(s, AV_LOG_ERROR, "track description longer than map data\n");

348 return 0;

349 }

350 map_len -= len;

351 while (len > 0) {

352 int track_type, track_id, track_len;

353 AVStream *st;

354 int idx;

355 len -= 4;

356 track_type = avio_r8(pb);

357 track_id = avio_r8(pb);

358 track_len = avio_rb16(pb);

359 len -= track_len;

360 if (!(track_type & 0x80)) {

361 av_log(s, AV_LOG_ERROR, "invalid track type %x\n", track_type);

362 continue;

363 }

364 track_type &= 0x7f;

365 if ((track_id & 0xc0) != 0xc0) {

366 av_log(s, AV_LOG_ERROR, "invalid track id %x\n", track_id);

367 continue;

368 }

369 track_id &= 0x3f;

370 gxf_track_tags(pb, &track_len, si);

371 // check for timecode tracks

372 if (track_type == 7 || track_type == 8 || track_type == 24) {

373 add_timecode_metadata(&s->metadata, "timecode",

374 si->track_aux_data & 0xffffffff,

375 si->fields_per_frame);

376

377 }

378 avio_skip(pb, track_len);

379

380 idx = get_sindex(s, track_id, track_type);

381 if (idx < 0) continue;

382 st = s->streams[idx];

383 if (!main_timebase.num || !main_timebase.den) {

384 main_timebase.num = si->frames_per_second.den;

385 main_timebase.den = si->frames_per_second.num * 2;

386 }

387 st->start_time = si->first_field;

388 if (si->first_field != AV_NOPTS_VALUE && si->last_field != AV_NOPTS_VALUE)

389 st->duration = si->last_field - si->first_field;

390 }

391 if (len < 0)

392 av_log(s, AV_LOG_ERROR, "invalid track description length specified\n");

393 if (map_len)

394 avio_skip(pb, map_len);

395 if (!parse_packet_header(pb, &pkt_type, &len)) {

396 av_log(s, AV_LOG_ERROR, "sync lost in header\n");

397 return -1;

398 }

399 if (pkt_type == PKT_FLT) {

400 gxf_read_index(s, len);

401 if (!parse_packet_header(pb, &pkt_type, &len)) {

402 av_log(s, AV_LOG_ERROR, "sync lost in header\n");

403 return -1;

404 }

405 }

406 if (pkt_type == PKT_UMF) {

407 if (len >= 0x39) {

408 AVRational fps;

409 len -= 0x39;

410 avio_skip(pb, 5); // preamble

411 avio_skip(pb, 0x30); // payload description

412 fps = fps_umf2avr(avio_rl32(pb));

413 if (!main_timebase.num || !main_timebase.den) {

414 av_log(s, AV_LOG_WARNING, "No FPS track tag, using UMF fps tag."

415 " This might give wrong results.\n");

416 // this may not always be correct, but simply the best we can get

417 main_timebase.num = fps.den;

418 main_timebase.den = fps.num * 2;

419 }

420

421 if (len >= 0x18) {

422 len -= 0x18;

423 avio_skip(pb, 0x10);

424 add_timecode_metadata(&s->metadata, "timecode_at_mark_in",

425 avio_rl32(pb), si->fields_per_frame);

426 add_timecode_metadata(&s->metadata, "timecode_at_mark_out",

427 avio_rl32(pb), si->fields_per_frame);

428 }

429 } else

430 av_log(s, AV_LOG_INFO, "UMF packet too short\n");

431 } else

432 av_log(s, AV_LOG_INFO, "UMF packet missing\n");

433 avio_skip(pb, len);

434 // set a fallback value, 60000/1001 is specified for audio-only files

435 // so use that regardless of why we do not know the video frame rate.

436 if (!main_timebase.num || !main_timebase.den)

437 main_timebase = (AVRational){1001, 60000};

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

439 AVStream *st = s->streams[i];

440 avpriv_set_pts_info(st, 32, main_timebase.num, main_timebase.den);

441 }

442 return 0;

443 }

444

445 #define READ_ONE() \

446 { \

447 if (!max_interval-- || avio_feof(pb)) \

448 goto out; \

449 tmp = tmp << 8 | avio_r8(pb); \

450 }

451

452 /**

453 * @brief resync the stream on the next media packet with specified properties

454 * @param max_interval how many bytes to search for matching packet at most

455 * @param track track id the media packet must belong to, -1 for any

456 * @param timestamp minimum timestamp (== field number) the packet must have, -1 for any

457 * @return timestamp of packet found

458 */

459 static int64_t gxf_resync_media(AVFormatContext *s, uint64_t max_interval, int track, int timestamp) {

460 uint32_t tmp;

461 uint64_t last_pos;

462 uint64_t last_found_pos = 0;

463 int cur_track;

464 int64_t cur_timestamp = AV_NOPTS_VALUE;

465 int len;

466 AVIOContext *pb = s->pb;

467 GXFPktType type;

468 tmp = avio_rb32(pb);

469 start:

470 while (tmp)

471 READ_ONE();

472 READ_ONE();

473 if (tmp != 1)

474 goto start;

475 last_pos = avio_tell(pb);

476 if (avio_seek(pb, -5, SEEK_CUR) < 0)

477 goto out;

478 if (!parse_packet_header(pb, &type, &len) || type != PKT_MEDIA) {

479 if (avio_seek(pb, last_pos, SEEK_SET) < 0)

480 goto out;

481 goto start;

482 }

483 avio_r8(pb);

484 cur_track = avio_r8(pb);

485 cur_timestamp = avio_rb32(pb);

486 last_found_pos = avio_tell(pb) - 16 - 6;

487 if ((track >= 0 && track != cur_track) || (timestamp >= 0 && timestamp > cur_timestamp)) {

488 if (avio_seek(pb, last_pos, SEEK_SET) >= 0)

489 goto start;

490 }

491 out:

492 if (last_found_pos)

493 avio_seek(pb, last_found_pos, SEEK_SET);

494 return cur_timestamp;

495 }

496

497 static int gxf_packet(AVFormatContext *s, AVPacket *pkt) {

498 AVIOContext *pb = s->pb;

499 GXFPktType pkt_type;

500 int pkt_len;

501 struct gxf_stream_info *si = s->priv_data;

502

503 while (!pb->eof_reached) {

504 AVStream *st;

505 int track_type, track_id, ret;

506 int field_nr, field_info, skip = 0;

507 int stream_index;

508 if (!parse_packet_header(pb, &pkt_type, &pkt_len)) {

509 if (!avio_feof(pb))

510 av_log(s, AV_LOG_ERROR, "sync lost\n");

511 return -1;

512 }

513 if (pkt_type == PKT_FLT) {

514 gxf_read_index(s, pkt_len);

515 continue;

516 }

517 if (pkt_type != PKT_MEDIA) {

518 avio_skip(pb, pkt_len);

519 continue;

520 }

521 if (pkt_len < 16) {

522 av_log(s, AV_LOG_ERROR, "invalid media packet length\n");

523 continue;

524 }

525 pkt_len -= 16;

526 track_type = avio_r8(pb);

527 track_id = avio_r8(pb);

528 stream_index = get_sindex(s, track_id, track_type);

529 if (stream_index < 0)

530 return stream_index;

531 st = s->streams[stream_index];

532 field_nr = avio_rb32(pb);

533 field_info = avio_rb32(pb);

534 avio_rb32(pb); // "timeline" field number

535 avio_r8(pb); // flags

536 avio_r8(pb); // reserved

537 if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S24LE ||

538 st->codecpar->codec_id == AV_CODEC_ID_PCM_S16LE) {

539 int first = field_info >> 16;

540 int last = field_info & 0xffff; // last is exclusive

541 int bps = av_get_bits_per_sample(st->codecpar->codec_id)>>3;

542 if (first <= last && last*bps <= pkt_len) {

543 avio_skip(pb, first*bps);

544 skip = pkt_len - last*bps;

545 pkt_len = (last-first)*bps;

546 } else

547 av_log(s, AV_LOG_ERROR, "invalid first and last sample values\n");

548 }

549 ret = av_get_packet(pb, pkt, pkt_len);

550 if (skip)

551 avio_skip(pb, skip);

552 pkt->stream_index = stream_index;

553 pkt->dts = field_nr;

554

555 //set duration manually for DV or else lavf misdetects the frame rate

556 if (st->codecpar->codec_id == AV_CODEC_ID_DVVIDEO)

557 pkt->duration = si->fields_per_frame;

558

559 return ret;

560 }

561 return AVERROR_EOF;

562 }

563

564 static int gxf_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags) {

565 int64_t res = 0;

566 uint64_t pos;

567 uint64_t maxlen = 100 * 1024 * 1024;

568 AVStream *st = s->streams[0];

569 FFStream *const sti = ffstream(st);

570 int64_t start_time = s->streams[stream_index]->start_time;

571 int64_t found;

572 int idx;

573 if (timestamp < start_time) timestamp = start_time;

574 idx = av_index_search_timestamp(st, timestamp - start_time,

575 AVSEEK_FLAG_ANY | AVSEEK_FLAG_BACKWARD);

576 if (idx < 0)

577 return -1;

578 pos = sti->index_entries[idx].pos;

579 if (idx < sti->nb_index_entries - 2)

580 maxlen = sti->index_entries[idx + 2].pos - pos;

581 maxlen = FFMAX(maxlen, 200 * 1024);

582 res = avio_seek(s->pb, pos, SEEK_SET);

583 if (res < 0)

584 return res;

585 found = gxf_resync_media(s, maxlen, -1, timestamp);

586 if (FFABS(found - timestamp) > 4)

587 return -1;

588 return 0;

589 }

590

591 static int64_t gxf_read_timestamp(AVFormatContext *s, int stream_index,

592 int64_t *pos, int64_t pos_limit) {

593 AVIOContext *pb = s->pb;

594 int64_t res;

595 if (avio_seek(pb, *pos, SEEK_SET) < 0)

596 return AV_NOPTS_VALUE;

597 res = gxf_resync_media(s, pos_limit - *pos, -1, -1);

598 *pos = avio_tell(pb);

599 return res;

600 }

601

602 const FFInputFormat ff_gxf_demuxer = {

603 .p.name = "gxf",

604 .p.long_name = NULL_IF_CONFIG_SMALL("GXF (General eXchange Format)"),

605 .priv_data_size = sizeof(struct gxf_stream_info),

606 .read_probe = gxf_probe,

607 .read_header = gxf_header,

608 .read_packet = gxf_packet,

609 .read_seek = gxf_seek,

610 .read_timestamp = gxf_read_timestamp,

611 };

AV_CODEC_ID_PCM_S16LE

@ AV_CODEC_ID_PCM_S16LE

Definition: codec_id.h:328

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:186

AV_CODEC_ID_AC3

@ AV_CODEC_ID_AC3

Definition: codec_id.h:443

gxf_stream_info::track_aux_data

int64_t track_aux_data

Definition: gxf.c:36

AVERROR

Filter the word "frame" indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions

AVCodecParameters::codec_type

enum AVMediaType codec_type

General type of the encoded data.

Definition: codec_par.h:51

out

FILE * out

Definition: movenc.c:54

AV_CHANNEL_LAYOUT_STEREO

#define AV_CHANNEL_LAYOUT_STEREO

Definition: channel_layout.h:379

AVFMT_FLAG_IGNIDX

#define AVFMT_FLAG_IGNIDX

Ignore index.

Definition: avformat.h:1408

READ_ONE

#define READ_ONE()

Definition: gxf.c:445

avformat_new_stream

AVStream * avformat_new_stream(AVFormatContext *s, const struct AVCodec *c)

Add a new stream to a media file.

frame_rate_tab

static const AVRational frame_rate_tab[]

Definition: gxf.c:218

AVERROR_EOF

#define AVERROR_EOF

End of file.

Definition: error.h:57

TRACK_FPF

@ TRACK_FPF

Definition: gxf.h:49

int64_t

long long int64_t

Definition: coverity.c:34

tmp

static uint8_t tmp[11]

Definition: aes_ctr.c:28

TRACK_FPS

@ TRACK_FPS

Definition: gxf.h:47

AVPacket::duration

int64_t duration

Duration of this packet in AVStream->time_base units, 0 if unknown.

Definition: packet.h:540

gxf_stream_info::fields_per_frame

int32_t fields_per_frame

Definition: gxf.c:35

AVDictionary

Definition: dict.c:34

FFMAX

#define FFMAX(a, b)

Definition: macros.h:47

fps_umf2avr

static AVRational fps_umf2avr(uint32_t flags)

convert UMF attributes flags to AVRational fps

Definition: gxf.c:245

AVPROBE_SCORE_MAX

#define AVPROBE_SCORE_MAX

maximum score

Definition: avformat.h:463

gxf_probe

static int gxf_probe(const AVProbeData *p)

check if file starts with a PKT_MAP header

Definition: gxf.c:89

avpriv_set_pts_info

void avpriv_set_pts_info(AVStream *st, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)

Set the time base and wrapping info for a given stream.

Definition: avformat.c:853

ff_gxf_demuxer

const FFInputFormat ff_gxf_demuxer

Definition: gxf.c:602

ffstream

static av_always_inline FFStream * ffstream(AVStream *st)

Definition: internal.h:417

AVSEEK_FLAG_ANY

#define AVSEEK_FLAG_ANY

seek to any frame, even non-keyframes

Definition: avformat.h:2435

av_add_index_entry

int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp, int size, int distance, int flags)

Add an index entry into a sorted list.

Definition: seek.c:120

avio_tell

static av_always_inline int64_t avio_tell(AVIOContext *s)

ftell() equivalent for AVIOContext.

Definition: avio.h:494

PKT_MAP

@ PKT_MAP

Definition: gxf.h:26

type

it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type

Definition: writing_filters.txt:86

TRACK_AUX

@ TRACK_AUX

Definition: gxf.h:44

AVStream::duration

int64_t duration

Decoding: duration of the stream, in stream time base.

Definition: avformat.h:802

AVRational::num

int num

Numerator.

Definition: rational.h:59

av_get_bits_per_sample

int av_get_bits_per_sample(enum AVCodecID codec_id)

Return codec bits per sample.

Definition: utils.c:550

first

trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But first

Definition: rate_distortion.txt:12

PKT_UMF

@ PKT_UMF

Definition: gxf.h:30

avio_rb32

unsigned int avio_rb32(AVIOContext *s)

Definition: aviobuf.c:760

pkt

AVPacket * pkt

Definition: movenc.c:59

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

parse_packet_header

static int parse_packet_header(AVIOContext *pb, GXFPktType *type, int *length)

parses a packet header, extracting type and length

Definition: gxf.c:67

#define s(width, name)

Definition: cbs_vp9.c:198

format

AVInputFormat::name

const char * name

A comma separated list of short names for the format.

Definition: avformat.h:553

AVProbeData::buf

unsigned char * buf

Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.

Definition: avformat.h:453

AVMEDIA_TYPE_AUDIO

@ AVMEDIA_TYPE_AUDIO

Definition: avutil.h:202

field

it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this field

Definition: writing_filters.txt:78

key

const char * key

Definition: hwcontext_opencl.c:189

AVMEDIA_TYPE_DATA

@ AVMEDIA_TYPE_DATA

Opaque data information usually continuous.

Definition: avutil.h:203

AV_CODEC_ID_H264

@ AV_CODEC_ID_H264

Definition: codec_id.h:79

frame

static AVFrame * frame

Definition: demux_decode.c:54

MAT_FIRST_FIELD

@ MAT_FIRST_FIELD

Definition: gxf.h:35

FFABS

#define FFABS(a)

Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...

Definition: common.h:72

FFStream::need_parsing

enum AVStreamParseType need_parsing

Definition: internal.h:386

gxf_stream_info

Definition: gxf.c:31

AVFormatContext

Format I/O context.

Definition: avformat.h:1255

internal.h

AVStream::codecpar

AVCodecParameters * codecpar

Codec parameters associated with this stream.

Definition: avformat.h:766

AVSEEK_FLAG_BACKWARD

#define AVSEEK_FLAG_BACKWARD

Definition: avformat.h:2433

gxf_packet

static int gxf_packet(AVFormatContext *s, AVPacket *pkt)

Definition: gxf.c:497

NULL

#define NULL

Definition: coverity.c:32

AVRational

Rational number (pair of numerator and denominator).

Definition: rational.h:58

AVProbeData

This structure contains the data a format has to probe a file.

Definition: avformat.h:451

MAT_LAST_FIELD

@ MAT_LAST_FIELD

Definition: gxf.h:36

fps_tag2avr

static AVRational fps_tag2avr(int32_t fps)

convert fps tag value to AVRational fps

Definition: gxf.c:235

AVCodecParameters::ch_layout

AVChannelLayout ch_layout

Audio only.

Definition: codec_par.h:180

gxf_track_tags

static void gxf_track_tags(AVIOContext *pb, int *len, struct gxf_stream_info *si)

filters out interesting tags from track information.

Definition: gxf.c:257

AVCodecParameters::sample_rate

int sample_rate

Audio only.

Definition: codec_par.h:184

AV_CODEC_ID_MPEG1VIDEO

@ AV_CODEC_ID_MPEG1VIDEO

Definition: codec_id.h:53

gxf_seek

static int gxf_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)

Definition: gxf.c:564

avio_rl32

unsigned int avio_rl32(AVIOContext *s)

Definition: aviobuf.c:729

AVIOContext

Bytestream IO Context.

Definition: avio.h:160

AV_CODEC_ID_PCM_S24LE

@ AV_CODEC_ID_PCM_S24LE

Definition: codec_id.h:340

NULL_IF_CONFIG_SMALL

#define NULL_IF_CONFIG_SMALL(x)

Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.

Definition: internal.h:106

GXFMatTag

Definition: gxf.h:33

AVChannelLayout

An AVChannelLayout holds information about the channel layout of audio data.

Definition: channel_layout.h:303

FFStream

Definition: internal.h:193

start_time

static int64_t start_time

Definition: ffplay.c:329

bps

unsigned bps

Definition: movenc.c:1792

AV_NOPTS_VALUE

#define AV_NOPTS_VALUE

Undefined timestamp value.

Definition: avutil.h:248

AVMEDIA_TYPE_UNKNOWN

@ AVMEDIA_TYPE_UNKNOWN

Usually treated as AVMEDIA_TYPE_DATA.

Definition: avutil.h:200

ff_find_stream_index

int ff_find_stream_index(const AVFormatContext *s, int id)

Find stream index based on format-specific stream ID.

Definition: demux_utils.c:351

FFInputFormat::p

AVInputFormat p

The public AVInputFormat.

Definition: demux.h:41

AVPacket::dts

int64_t dts

Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.

Definition: packet.h:521

avio_r8

int avio_r8(AVIOContext *s)

Definition: aviobuf.c:602

gxf.h

PKT_FLT

@ PKT_FLT

Definition: gxf.h:29

AV_LOG_INFO

#define AV_LOG_INFO

Standard information.

Definition: log.h:191

gxf_stream_info::first_field

int64_t first_field

Definition: gxf.c:32

AV_CODEC_ID_MJPEG

@ AV_CODEC_ID_MJPEG

Definition: codec_id.h:59

AV_CODEC_ID_NONE

@ AV_CODEC_ID_NONE

Definition: codec_id.h:50

#define i(width, name, range_min, range_max)

Definition: cbs_h2645.c:255

gxf_material_tags

static void gxf_material_tags(AVIOContext *pb, int *len, struct gxf_stream_info *si)

filters out interesting tags from material information.

Definition: gxf.c:197

AVCodecParameters::block_align

int block_align

Audio only.

Definition: codec_par.h:191

GXFTrackTag

Definition: gxf.h:42

common.h

value

it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default value

Definition: writing_filters.txt:86

AV_CODEC_ID_DVVIDEO

@ AV_CODEC_ID_DVVIDEO

Definition: codec_id.h:76

gxf_read_timestamp

static int64_t gxf_read_timestamp(AVFormatContext *s, int stream_index, int64_t *pos, int64_t pos_limit)

Definition: gxf.c:591

demux.h

gxf_read_index

static void gxf_read_index(AVFormatContext *s, int pkt_len)

read index from FLT packet into stream 0 av_index

Definition: gxf.c:284

len

int len

Definition: vorbis_enc_data.h:426

gxf_header

static int gxf_header(AVFormatContext *s)

Definition: gxf.c:318

get_sindex

static int get_sindex(AVFormatContext *s, int id, int format)

gets the stream index for the track with the specified id, creates new stream if not found

Definition: gxf.c:104

av_get_packet

int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)

Allocate and read the payload of a packet and initialize its fields with default values.

Definition: utils.c:103

add_timecode_metadata

static int add_timecode_metadata(AVDictionary **pm, const char *key, uint32_t timecode, int fields_per_frame)

parse gxf timecode and add it to metadata

Definition: gxf.c:42

tag

uint32_t tag

Definition: movenc.c:1791

AVStream::id

int id

Format-specific stream ID.

Definition: avformat.h:755

ret

Definition: filter_design.txt:187

AVStream

Stream structure.

Definition: avformat.h:743

avio_seek

int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)

fseek() equivalent for AVIOContext.

Definition: aviobuf.c:230

avio_rb16

unsigned int avio_rb16(AVIOContext *s)

Definition: aviobuf.c:745

AVSTREAM_PARSE_HEADERS

@ AVSTREAM_PARSE_HEADERS

Only parse headers, do not repack.

Definition: avformat.h:594

pos

unsigned int pos

Definition: spdifenc.c:413

avformat.h

enum AVCodecID id

Definition: dts2pts.c:364

channel_layout.h

AVRational::den

int den

Denominator.

Definition: rational.h:60

PKT_MEDIA

@ PKT_MEDIA

Definition: gxf.h:27

AVIndexEntry::pos

int64_t pos

Definition: avformat.h:603

AVIOContext::eof_reached

int eof_reached

true if was unable to read due to error or eof

Definition: avio.h:238

AVPacket::stream_index

int stream_index

Definition: packet.h:524

avio_skip

int64_t avio_skip(AVIOContext *s, int64_t offset)

Skip given number of bytes forward.

Definition: aviobuf.c:317

gxf_stream_info::frames_per_second

AVRational frames_per_second

Definition: gxf.c:34

FFStream::index_entries

AVIndexEntry * index_entries

Only used if the format does not support seeking natively.

Definition: internal.h:249

AVMEDIA_TYPE_VIDEO

@ AVMEDIA_TYPE_VIDEO

Definition: avutil.h:201

read_probe

static int read_probe(const AVProbeData *p)

Definition: cdg.c:30

AVCodecParameters::bits_per_coded_sample

int bits_per_coded_sample

The number of bits per sample in the codedwords.

Definition: codec_par.h:110

map

const VDPAUPixFmtMap * map

Definition: hwcontext_vdpau.c:71

AV_CHANNEL_LAYOUT_MONO

#define AV_CHANNEL_LAYOUT_MONO

Definition: channel_layout.h:378

AVCodecParameters::codec_id

enum AVCodecID codec_id

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

Definition: codec_par.h:55

AVPacket

This structure stores compressed data.

Definition: packet.h:499

av_dict_set

int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)

Set the given entry in *pm, overwriting an existing entry.

Definition: dict.c:88

FFInputFormat

Definition: demux.h:37

avio_rl64

uint64_t avio_rl64(AVIOContext *s)

Definition: aviobuf.c:737

int32_t

Definition: audioconvert.c:56

GXFPktType

Definition: gxf.h:25

flags

#define flags(name, subs,...)

Definition: cbs_av1.c:482

AVCodecParameters::bit_rate

int64_t bit_rate

The average bitrate of the encoded data (in bits per second).

Definition: codec_par.h:97

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:27

AVStream::start_time

int64_t start_time

Decoding: pts of the first frame of the stream in presentation order, in stream time base.

Definition: avformat.h:792

AV_CODEC_ID_MPEG2VIDEO

@ AV_CODEC_ID_MPEG2VIDEO

preferred ID for MPEG-1/2 video decoding

Definition: codec_id.h:54

snprintf

#define snprintf

Definition: snprintf.h:34

av_log2

int av_log2(unsigned v)

Definition: intmath.c:26

skip

static void BS_FUNC() skip(BSCTX *bc, unsigned int n)

Skip n bits in the buffer.

Definition: bitstream_template.h:375

gxf_resync_media

static int64_t gxf_resync_media(AVFormatContext *s, uint64_t max_interval, int track, int timestamp)

resync the stream on the next media packet with specified properties

Definition: gxf.c:459

AV_CODEC_ID_DNXHD

@ AV_CODEC_ID_DNXHD

Definition: codec_id.h:151

gxf_stream_info::last_field

int64_t last_field

Definition: gxf.c:33

av_index_search_timestamp

int av_index_search_timestamp(AVStream *st, int64_t timestamp, int flags)

Get the index for a specific timestamp.

Definition: seek.c:243

avio_feof

int avio_feof(AVIOContext *s)

Similar to feof() but also returns nonzero on read errors.

Definition: aviobuf.c:345

Generated on Thu Sep 26 2024 23:15:45 for FFmpeg by doxygen 1.8.17