3 * Copyright (c) 2006 Reimar Doeffinger
5 * This file is part of FFmpeg.
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.
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.
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
24 #include "libavutil/channel_layout.h"
25 #include "libavutil/common.h"
29 #include "libavcodec/mpeg12data.h"
31 struct gxf_stream_info
{
34 AVRational frames_per_second
;
35 int32_t fields_per_frame
;
36 int64_t track_aux_data
;
40 * @brief parse gxf timecode and add it to metadata
42 static int add_timecode_metadata(AVDictionary
**pm
, const char *key
, uint32_t timecode
, int fields_per_frame
)
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
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);
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
67 static int parse_packet_header(AVIOContext
*pb
, GXFPktType
*type
, int *length
) {
73 *length
= avio_rb32(pb
);
74 if ((*length
>> 24) || *length
< 16)
79 if (avio_r8(pb
) != 0xe1)
81 if (avio_r8(pb
) != 0xe2)
87 * @brief check if file starts with a PKT_MAP header
89 static int gxf_probe(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
;
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
104 static int get_sindex(AVFormatContext
*s
, int id
, int format
) {
107 i
= ff_find_stream_index(s
, id
);
110 st
= avformat_new_stream(s
, NULL
);
112 return AVERROR(ENOMEM
);
117 st
->codec
->codec_type
= AVMEDIA_TYPE_VIDEO
;
118 st
->codec
->codec_id
= AV_CODEC_ID_MJPEG
;
125 st
->codec
->codec_type
= AVMEDIA_TYPE_VIDEO
;
126 st
->codec
->codec_id
= AV_CODEC_ID_DVVIDEO
;
131 st
->codec
->codec_type
= AVMEDIA_TYPE_VIDEO
;
132 st
->codec
->codec_id
= AV_CODEC_ID_MPEG2VIDEO
;
133 st
->need_parsing
= AVSTREAM_PARSE_HEADERS
; //get keyframe flag etc.
137 st
->codec
->codec_type
= AVMEDIA_TYPE_VIDEO
;
138 st
->codec
->codec_id
= AV_CODEC_ID_MPEG1VIDEO
;
139 st
->need_parsing
= AVSTREAM_PARSE_HEADERS
; //get keyframe flag etc.
142 st
->codec
->codec_type
= AVMEDIA_TYPE_AUDIO
;
143 st
->codec
->codec_id
= AV_CODEC_ID_PCM_S24LE
;
144 st
->codec
->channels
= 1;
145 st
->codec
->channel_layout
= AV_CH_LAYOUT_MONO
;
146 st
->codec
->sample_rate
= 48000;
147 st
->codec
->bit_rate
= 3 * 1 * 48000 * 8;
148 st
->codec
->block_align
= 3 * 1;
149 st
->codec
->bits_per_coded_sample
= 24;
152 st
->codec
->codec_type
= AVMEDIA_TYPE_AUDIO
;
153 st
->codec
->codec_id
= AV_CODEC_ID_PCM_S16LE
;
154 st
->codec
->channels
= 1;
155 st
->codec
->channel_layout
= AV_CH_LAYOUT_MONO
;
156 st
->codec
->sample_rate
= 48000;
157 st
->codec
->bit_rate
= 2 * 1 * 48000 * 8;
158 st
->codec
->block_align
= 2 * 1;
159 st
->codec
->bits_per_coded_sample
= 16;
162 st
->codec
->codec_type
= AVMEDIA_TYPE_AUDIO
;
163 st
->codec
->codec_id
= AV_CODEC_ID_AC3
;
164 st
->codec
->channels
= 2;
165 st
->codec
->channel_layout
= AV_CH_LAYOUT_STEREO
;
166 st
->codec
->sample_rate
= 48000;
168 case 26: /* AVCi50 / AVCi100 (AVC Intra) */
170 st
->codec
->codec_type
= AVMEDIA_TYPE_VIDEO
;
171 st
->codec
->codec_id
= AV_CODEC_ID_H264
;
172 st
->need_parsing
= AVSTREAM_PARSE_HEADERS
;
178 st
->codec
->codec_type
= AVMEDIA_TYPE_DATA
;
179 st
->codec
->codec_id
= AV_CODEC_ID_NONE
;
182 st
->codec
->codec_type
= AVMEDIA_TYPE_VIDEO
;
183 st
->codec
->codec_id
= AV_CODEC_ID_DNXHD
;
186 st
->codec
->codec_type
= AVMEDIA_TYPE_UNKNOWN
;
187 st
->codec
->codec_id
= AV_CODEC_ID_NONE
;
190 return s
->nb_streams
- 1;
194 * @brief filters out interesting tags from material information.
195 * @param len length of tag section, will be adjusted to contain remaining bytes
196 * @param si struct to store collected information into
198 static void gxf_material_tags(AVIOContext
*pb
, int *len
, struct gxf_stream_info
*si
) {
199 si
->first_field
= AV_NOPTS_VALUE
;
200 si
->last_field
= AV_NOPTS_VALUE
;
202 GXFMatTag tag
= avio_r8(pb
);
203 int tlen
= avio_r8(pb
);
209 uint32_t value
= avio_rb32(pb
);
210 if (tag
== MAT_FIRST_FIELD
)
211 si
->first_field
= value
;
212 else if (tag
== MAT_LAST_FIELD
)
213 si
->last_field
= value
;
219 static const AVRational frame_rate_tab
[] = {
232 * @brief convert fps tag value to AVRational fps
233 * @param fps fps value from tag
234 * @return fps as AVRational, or 0 / 0 if unknown
236 static AVRational
fps_tag2avr(int32_t fps
) {
237 if (fps
< 1 || fps
> 9) fps
= 9;
238 return frame_rate_tab
[fps
- 1];
242 * @brief convert UMF attributes flags to AVRational fps
243 * @param flags UMF flags to convert
244 * @return fps as AVRational, or 0 / 0 if unknown
246 static AVRational
fps_umf2avr(uint32_t flags
) {
247 static const AVRational map
[] = {{50, 1}, {60000, 1001}, {24, 1},
248 {25, 1}, {30000, 1001}};
249 int idx
= av_log2((flags
& 0x7c0) >> 6);
254 * @brief filters out interesting tags from track information.
255 * @param len length of tag section, will be adjusted to contain remaining bytes
256 * @param si struct to store collected information into
258 static void gxf_track_tags(AVIOContext
*pb
, int *len
, struct gxf_stream_info
*si
) {
259 si
->frames_per_second
= (AVRational
){0, 0};
260 si
->fields_per_frame
= 0;
261 si
->track_aux_data
= 0x80000000;
263 GXFTrackTag tag
= avio_r8(pb
);
264 int tlen
= avio_r8(pb
);
270 uint32_t value
= avio_rb32(pb
);
271 if (tag
== TRACK_FPS
)
272 si
->frames_per_second
= fps_tag2avr(value
);
273 else if (tag
== TRACK_FPF
&& (value
== 1 || value
== 2))
274 si
->fields_per_frame
= value
;
275 } else if (tlen
== 8 && tag
== TRACK_AUX
)
276 si
->track_aux_data
= avio_rl64(pb
);
283 * @brief read index from FLT packet into stream 0 av_index
285 static void gxf_read_index(AVFormatContext
*s
, int pkt_len
) {
286 AVIOContext
*pb
= s
->pb
;
288 uint32_t fields_per_map
= avio_rl32(pb
);
289 uint32_t map_cnt
= avio_rl32(pb
);
292 if ((s
->flags
& AVFMT_FLAG_IGNIDX
) || !s
->streams
) {
293 avio_skip(pb
, pkt_len
);
297 if (map_cnt
> 1000) {
298 av_log(s
, AV_LOG_ERROR
,
299 "too many index entries %"PRIu32
" (%"PRIx32
")\n",
303 if (pkt_len
< 4 * map_cnt
) {
304 av_log(s
, AV_LOG_ERROR
, "invalid index length\n");
305 avio_skip(pb
, pkt_len
);
308 pkt_len
-= 4 * map_cnt
;
309 av_add_index_entry(st
, 0, 0, 0, 0, 0);
310 for (i
= 0; i
< map_cnt
; i
++)
311 av_add_index_entry(st
, (uint64_t)avio_rl32(pb
) * 1024,
312 i
* (uint64_t)fields_per_map
+ 1, 0, 0, 0);
313 avio_skip(pb
, pkt_len
);
316 static int gxf_header(AVFormatContext
*s
) {
317 AVIOContext
*pb
= s
->pb
;
321 AVRational main_timebase
= {0, 0};
322 struct gxf_stream_info
*si
= s
->priv_data
;
324 if (!parse_packet_header(pb
, &pkt_type
, &map_len
) || pkt_type
!= PKT_MAP
) {
325 av_log(s
, AV_LOG_ERROR
, "map packet not found\n");
329 if (avio_r8(pb
) != 0x0e0 || avio_r8(pb
) != 0xff) {
330 av_log(s
, AV_LOG_ERROR
, "unknown version or invalid map preamble\n");
334 len
= avio_rb16(pb
); // length of material data section
336 av_log(s
, AV_LOG_ERROR
, "material data longer than map data\n");
340 gxf_material_tags(pb
, &len
, si
);
343 len
= avio_rb16(pb
); // length of track description
345 av_log(s
, AV_LOG_ERROR
, "track description longer than map data\n");
350 int track_type
, track_id
, track_len
;
354 track_type
= avio_r8(pb
);
355 track_id
= avio_r8(pb
);
356 track_len
= avio_rb16(pb
);
358 if (!(track_type
& 0x80)) {
359 av_log(s
, AV_LOG_ERROR
, "invalid track type %x\n", track_type
);
363 if ((track_id
& 0xc0) != 0xc0) {
364 av_log(s
, AV_LOG_ERROR
, "invalid track id %x\n", track_id
);
368 gxf_track_tags(pb
, &track_len
, si
);
369 // check for timecode tracks
370 if (track_type
== 7 || track_type
== 8 || track_type
== 24) {
371 add_timecode_metadata(&s
->metadata
, "timecode",
372 si
->track_aux_data
& 0xffffffff,
373 si
->fields_per_frame
);
376 avio_skip(pb
, track_len
);
378 idx
= get_sindex(s
, track_id
, track_type
);
379 if (idx
< 0) continue;
380 st
= s
->streams
[idx
];
381 if (!main_timebase
.num
|| !main_timebase
.den
) {
382 main_timebase
.num
= si
->frames_per_second
.den
;
383 main_timebase
.den
= si
->frames_per_second
.num
* 2;
385 st
->start_time
= si
->first_field
;
386 if (si
->first_field
!= AV_NOPTS_VALUE
&& si
->last_field
!= AV_NOPTS_VALUE
)
387 st
->duration
= si
->last_field
- si
->first_field
;
390 av_log(s
, AV_LOG_ERROR
, "invalid track description length specified\n");
392 avio_skip(pb
, map_len
);
393 if (!parse_packet_header(pb
, &pkt_type
, &len
)) {
394 av_log(s
, AV_LOG_ERROR
, "sync lost in header\n");
397 if (pkt_type
== PKT_FLT
) {
398 gxf_read_index(s
, len
);
399 if (!parse_packet_header(pb
, &pkt_type
, &len
)) {
400 av_log(s
, AV_LOG_ERROR
, "sync lost in header\n");
404 if (pkt_type
== PKT_UMF
) {
408 avio_skip(pb
, 5); // preamble
409 avio_skip(pb
, 0x30); // payload description
410 fps
= fps_umf2avr(avio_rl32(pb
));
411 if (!main_timebase
.num
|| !main_timebase
.den
) {
412 av_log(s
, AV_LOG_WARNING
, "No FPS track tag, using UMF fps tag."
413 " This might give wrong results.\n");
414 // this may not always be correct, but simply the best we can get
415 main_timebase
.num
= fps
.den
;
416 main_timebase
.den
= fps
.num
* 2;
422 add_timecode_metadata(&s
->metadata
, "timecode_at_mark_in",
423 avio_rl32(pb
), si
->fields_per_frame
);
424 add_timecode_metadata(&s
->metadata
, "timecode_at_mark_out",
425 avio_rl32(pb
), si
->fields_per_frame
);
428 av_log(s
, AV_LOG_INFO
, "UMF packet too short\n");
430 av_log(s
, AV_LOG_INFO
, "UMF packet missing\n");
432 // set a fallback value, 60000/1001 is specified for audio-only files
433 // so use that regardless of why we do not know the video frame rate.
434 if (!main_timebase
.num
|| !main_timebase
.den
)
435 main_timebase
= (AVRational
){1001, 60000};
436 for (i
= 0; i
< s
->nb_streams
; i
++) {
437 AVStream
*st
= s
->streams
[i
];
438 avpriv_set_pts_info(st
, 32, main_timebase
.num
, main_timebase
.den
);
445 if (!max_interval-- || avio_feof(pb)) \
447 tmp = tmp << 8 | avio_r8(pb); \
451 * @brief resync the stream on the next media packet with specified properties
452 * @param max_interval how many bytes to search for matching packet at most
453 * @param track track id the media packet must belong to, -1 for any
454 * @param timestamp minimum timestamp (== field number) the packet must have, -1 for any
455 * @return timestamp of packet found
457 static int64_t gxf_resync_media(AVFormatContext
*s
, uint64_t max_interval
, int track
, int timestamp
) {
460 uint64_t last_found_pos
= 0;
462 int64_t cur_timestamp
= AV_NOPTS_VALUE
;
464 AVIOContext
*pb
= s
->pb
;
473 last_pos
= avio_tell(pb
);
474 if (avio_seek(pb
, -5, SEEK_CUR
) < 0)
476 if (!parse_packet_header(pb
, &type
, &len
) || type
!= PKT_MEDIA
) {
477 if (avio_seek(pb
, last_pos
, SEEK_SET
) < 0)
482 cur_track
= avio_r8(pb
);
483 cur_timestamp
= avio_rb32(pb
);
484 last_found_pos
= avio_tell(pb
) - 16 - 6;
485 if ((track
>= 0 && track
!= cur_track
) || (timestamp
>= 0 && timestamp
> cur_timestamp
)) {
486 if (avio_seek(pb
, last_pos
, SEEK_SET
) >= 0)
491 avio_seek(pb
, last_found_pos
, SEEK_SET
);
492 return cur_timestamp
;
495 static int gxf_packet(AVFormatContext
*s
, AVPacket
*pkt
) {
496 AVIOContext
*pb
= s
->pb
;
499 struct gxf_stream_info
*si
= s
->priv_data
;
501 while (!pb
->eof_reached
) {
503 int track_type
, track_id
, ret
;
504 int field_nr
, field_info
, skip
= 0;
506 if (!parse_packet_header(pb
, &pkt_type
, &pkt_len
)) {
508 av_log(s
, AV_LOG_ERROR
, "sync lost\n");
511 if (pkt_type
== PKT_FLT
) {
512 gxf_read_index(s
, pkt_len
);
515 if (pkt_type
!= PKT_MEDIA
) {
516 avio_skip(pb
, pkt_len
);
520 av_log(s
, AV_LOG_ERROR
, "invalid media packet length\n");
524 track_type
= avio_r8(pb
);
525 track_id
= avio_r8(pb
);
526 stream_index
= get_sindex(s
, track_id
, track_type
);
527 if (stream_index
< 0)
529 st
= s
->streams
[stream_index
];
530 field_nr
= avio_rb32(pb
);
531 field_info
= avio_rb32(pb
);
532 avio_rb32(pb
); // "timeline" field number
533 avio_r8(pb
); // flags
534 avio_r8(pb
); // reserved
535 if (st
->codec
->codec_id
== AV_CODEC_ID_PCM_S24LE
||
536 st
->codec
->codec_id
== AV_CODEC_ID_PCM_S16LE
) {
537 int first
= field_info
>> 16;
538 int last
= field_info
& 0xffff; // last is exclusive
539 int bps
= av_get_bits_per_sample(st
->codec
->codec_id
)>>3;
540 if (first
<= last
&& last
*bps
<= pkt_len
) {
541 avio_skip(pb
, first
*bps
);
542 skip
= pkt_len
- last
*bps
;
543 pkt_len
= (last
-first
)*bps
;
545 av_log(s
, AV_LOG_ERROR
, "invalid first and last sample values\n");
547 ret
= av_get_packet(pb
, pkt
, pkt_len
);
550 pkt
->stream_index
= stream_index
;
553 //set duration manually for DV or else lavf misdetects the frame rate
554 if (st
->codec
->codec_id
== AV_CODEC_ID_DVVIDEO
)
555 pkt
->duration
= si
->fields_per_frame
;
562 static int gxf_seek(AVFormatContext
*s
, int stream_index
, int64_t timestamp
, int flags
) {
565 uint64_t maxlen
= 100 * 1024 * 1024;
566 AVStream
*st
= s
->streams
[0];
567 int64_t start_time
= s
->streams
[stream_index
]->start_time
;
570 if (timestamp
< start_time
) timestamp
= start_time
;
571 idx
= av_index_search_timestamp(st
, timestamp
- start_time
,
572 AVSEEK_FLAG_ANY
| AVSEEK_FLAG_BACKWARD
);
575 pos
= st
->index_entries
[idx
].pos
;
576 if (idx
< st
->nb_index_entries
- 2)
577 maxlen
= st
->index_entries
[idx
+ 2].pos
- pos
;
578 maxlen
= FFMAX(maxlen
, 200 * 1024);
579 res
= avio_seek(s
->pb
, pos
, SEEK_SET
);
582 found
= gxf_resync_media(s
, maxlen
, -1, timestamp
);
583 if (FFABS(found
- timestamp
) > 4)
588 static int64_t gxf_read_timestamp(AVFormatContext
*s
, int stream_index
,
589 int64_t *pos
, int64_t pos_limit
) {
590 AVIOContext
*pb
= s
->pb
;
592 if (avio_seek(pb
, *pos
, SEEK_SET
) < 0)
593 return AV_NOPTS_VALUE
;
594 res
= gxf_resync_media(s
, pos_limit
- *pos
, -1, -1);
595 *pos
= avio_tell(pb
);
599 AVInputFormat ff_gxf_demuxer
= {
601 .long_name
= NULL_IF_CONFIG_SMALL("GXF (General eXchange Format)"),
602 .priv_data_size
= sizeof(struct gxf_stream_info
),
603 .read_probe
= gxf_probe
,
604 .read_header
= gxf_header
,
605 .read_packet
= gxf_packet
,
606 .read_seek
= gxf_seek
,
607 .read_timestamp
= gxf_read_timestamp
,