0286439c44dd1884c352d4e9d90f2d46b7ff2bea
[ffmpeg.git] / libavformat / gxf.c
1 /*
2  * GXF demuxer.
3  * Copyright (c) 2006 Reimar Doeffinger
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  */
21
22 #include "libavutil/common.h"
23 #include "avformat.h"
24 #include "internal.h"
25 #include "gxf.h"
26 #include "libavcodec/mpeg12data.h"
27
28 struct gxf_stream_info {
29     int64_t first_field;
30     int64_t last_field;
31     AVRational frames_per_second;
32     int32_t fields_per_frame;
33     int64_t track_aux_data;
34 };
35
36 /**
37  * @brief parse gxf timecode and add it to metadata
38  */
39 static int add_timecode_metadata(AVDictionary **pm, const char *key, uint32_t timecode, int fields_per_frame)
40 {
41    char tmp[128];
42    int field  = timecode & 0xff;
43    int frame  = fields_per_frame ? field / fields_per_frame : field;
44    int second = (timecode >>  8) & 0xff;
45    int minute = (timecode >> 16) & 0xff;
46    int hour   = (timecode >> 24) & 0x1f;
47    int drop   = (timecode >> 29) & 1;
48    // bit 30: color_frame, unused
49    // ignore invalid time code
50    if (timecode >> 31)
51        return 0;
52    snprintf(tmp, sizeof(tmp), "%02d:%02d:%02d%c%02d",
53        hour, minute, second, drop ? ';' : ':', frame);
54    return av_dict_set(pm, key, tmp, 0);
55 }
56
57 /**
58  * @brief parses a packet header, extracting type and length
59  * @param pb AVIOContext to read header from
60  * @param type detected packet type is stored here
61  * @param length detected packet length, excluding header is stored here
62  * @return 0 if header not found or contains invalid data, 1 otherwise
63  */
64 static int parse_packet_header(AVIOContext *pb, GXFPktType *type, int *length) {
65     if (avio_rb32(pb))
66         return 0;
67     if (avio_r8(pb) != 1)
68         return 0;
69     *type = avio_r8(pb);
70     *length = avio_rb32(pb);
71     if ((*length >> 24) || *length < 16)
72         return 0;
73     *length -= 16;
74     if (avio_rb32(pb))
75         return 0;
76     if (avio_r8(pb) != 0xe1)
77         return 0;
78     if (avio_r8(pb) != 0xe2)
79         return 0;
80     return 1;
81 }
82
83 /**
84  * @brief check if file starts with a PKT_MAP header
85  */
86 static int gxf_probe(AVProbeData *p) {
87     static const uint8_t startcode[] = {0, 0, 0, 0, 1, 0xbc}; // start with map packet
88     static const uint8_t endcode[] = {0, 0, 0, 0, 0xe1, 0xe2};
89     if (!memcmp(p->buf, startcode, sizeof(startcode)) &&
90         !memcmp(&p->buf[16 - sizeof(endcode)], endcode, sizeof(endcode)))
91         return AVPROBE_SCORE_MAX;
92     return 0;
93 }
94
95 /**
96  * @brief gets the stream index for the track with the specified id, creates new
97  *        stream if not found
98  * @param id     id of stream to find / add
99  * @param format stream format identifier
100  */
101 static int get_sindex(AVFormatContext *s, int id, int format) {
102     int i;
103     AVStream *st = NULL;
104     i = ff_find_stream_index(s, id);
105     if (i >= 0)
106         return i;
107     st = avformat_new_stream(s, NULL);
108     if (!st)
109         return AVERROR(ENOMEM);
110     st->id = id;
111     switch (format) {
112         case 3:
113         case 4:
114             st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
115             st->codec->codec_id = AV_CODEC_ID_MJPEG;
116             break;
117         case 13:
118         case 15:
119             st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
120             st->codec->codec_id = AV_CODEC_ID_DVVIDEO;
121             break;
122         case 14:
123         case 16:
124             st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
125             st->codec->codec_id = AV_CODEC_ID_DVVIDEO;
126             break;
127         case 11:
128         case 12:
129         case 20:
130             st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
131             st->codec->codec_id = AV_CODEC_ID_MPEG2VIDEO;
132             st->need_parsing = AVSTREAM_PARSE_HEADERS; //get keyframe flag etc.
133             break;
134         case 22:
135         case 23:
136             st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
137             st->codec->codec_id = AV_CODEC_ID_MPEG1VIDEO;
138             st->need_parsing = AVSTREAM_PARSE_HEADERS; //get keyframe flag etc.
139             break;
140         case 9:
141             st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
142             st->codec->codec_id = AV_CODEC_ID_PCM_S24LE;
143             st->codec->channels = 1;
144             st->codec->sample_rate = 48000;
145             st->codec->bit_rate = 3 * 1 * 48000 * 8;
146             st->codec->block_align = 3 * 1;
147             st->codec->bits_per_coded_sample = 24;
148             break;
149         case 10:
150             st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
151             st->codec->codec_id = AV_CODEC_ID_PCM_S16LE;
152             st->codec->channels = 1;
153             st->codec->sample_rate = 48000;
154             st->codec->bit_rate = 2 * 1 * 48000 * 8;
155             st->codec->block_align = 2 * 1;
156             st->codec->bits_per_coded_sample = 16;
157             break;
158         case 17:
159             st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
160             st->codec->codec_id = AV_CODEC_ID_AC3;
161             st->codec->channels = 2;
162             st->codec->sample_rate = 48000;
163             break;
164         // timecode tracks:
165         case 7:
166         case 8:
167         case 24:
168             st->codec->codec_type = AVMEDIA_TYPE_DATA;
169             st->codec->codec_id = AV_CODEC_ID_NONE;
170             break;
171         default:
172             st->codec->codec_type = AVMEDIA_TYPE_UNKNOWN;
173             st->codec->codec_id = AV_CODEC_ID_NONE;
174             break;
175     }
176     return s->nb_streams - 1;
177 }
178
179 /**
180  * @brief filters out interesting tags from material information.
181  * @param len length of tag section, will be adjusted to contain remaining bytes
182  * @param si struct to store collected information into
183  */
184 static void gxf_material_tags(AVIOContext *pb, int *len, struct gxf_stream_info *si) {
185     si->first_field = AV_NOPTS_VALUE;
186     si->last_field = AV_NOPTS_VALUE;
187     while (*len >= 2) {
188         GXFMatTag tag = avio_r8(pb);
189         int tlen = avio_r8(pb);
190         *len -= 2;
191         if (tlen > *len)
192             return;
193         *len -= tlen;
194         if (tlen == 4) {
195             uint32_t value = avio_rb32(pb);
196             if (tag == MAT_FIRST_FIELD)
197                 si->first_field = value;
198             else if (tag == MAT_LAST_FIELD)
199                 si->last_field = value;
200         } else
201             avio_skip(pb, tlen);
202     }
203 }
204
205 static const AVRational frame_rate_tab[] = {
206     {   60,    1},
207     {60000, 1001},
208     {   50,    1},
209     {   30,    1},
210     {30000, 1001},
211     {   25,    1},
212     {   24,    1},
213     {24000, 1001},
214     {    0,    0},
215 };
216
217 /**
218  * @brief convert fps tag value to AVRational fps
219  * @param fps fps value from tag
220  * @return fps as AVRational, or 0 / 0 if unknown
221  */
222 static AVRational fps_tag2avr(int32_t fps) {
223     if (fps < 1 || fps > 9) fps = 9;
224     return frame_rate_tab[fps - 1];
225 }
226
227 /**
228  * @brief convert UMF attributes flags to AVRational fps
229  * @param flags UMF flags to convert
230  * @return fps as AVRational, or 0 / 0 if unknown
231  */
232 static AVRational fps_umf2avr(uint32_t flags) {
233     static const AVRational map[] = {{50, 1}, {60000, 1001}, {24, 1},
234         {25, 1}, {30000, 1001}};
235     int idx =  av_log2((flags & 0x7c0) >> 6);
236     return map[idx];
237 }
238
239 /**
240  * @brief filters out interesting tags from track information.
241  * @param len length of tag section, will be adjusted to contain remaining bytes
242  * @param si struct to store collected information into
243  */
244 static void gxf_track_tags(AVIOContext *pb, int *len, struct gxf_stream_info *si) {
245     si->frames_per_second = (AVRational){0, 0};
246     si->fields_per_frame = 0;
247     si->track_aux_data = 0x80000000;
248     while (*len >= 2) {
249         GXFTrackTag tag = avio_r8(pb);
250         int tlen = avio_r8(pb);
251         *len -= 2;
252         if (tlen > *len)
253             return;
254         *len -= tlen;
255         if (tlen == 4) {
256             uint32_t value = avio_rb32(pb);
257             if (tag == TRACK_FPS)
258                 si->frames_per_second = fps_tag2avr(value);
259             else if (tag == TRACK_FPF && (value == 1 || value == 2))
260                 si->fields_per_frame = value;
261         } else if (tlen == 8 && tag == TRACK_AUX)
262             si->track_aux_data = avio_rl64(pb);
263         else
264             avio_skip(pb, tlen);
265     }
266 }
267
268 /**
269  * @brief read index from FLT packet into stream 0 av_index
270  */
271 static void gxf_read_index(AVFormatContext *s, int pkt_len) {
272     AVIOContext *pb = s->pb;
273     AVStream *st = s->streams[0];
274     uint32_t fields_per_map = avio_rl32(pb);
275     uint32_t map_cnt = avio_rl32(pb);
276     int i;
277     pkt_len -= 8;
278     if (s->flags & AVFMT_FLAG_IGNIDX) {
279         avio_skip(pb, pkt_len);
280         return;
281     }
282     if (map_cnt > 1000) {
283         av_log(s, AV_LOG_ERROR, "too many index entries %u (%x)\n", map_cnt, map_cnt);
284         map_cnt = 1000;
285     }
286     if (pkt_len < 4 * map_cnt) {
287         av_log(s, AV_LOG_ERROR, "invalid index length\n");
288         avio_skip(pb, pkt_len);
289         return;
290     }
291     pkt_len -= 4 * map_cnt;
292     av_add_index_entry(st, 0, 0, 0, 0, 0);
293     for (i = 0; i < map_cnt; i++)
294         av_add_index_entry(st, (uint64_t)avio_rl32(pb) * 1024,
295                            i * (uint64_t)fields_per_map + 1, 0, 0, 0);
296     avio_skip(pb, pkt_len);
297 }
298
299 static int gxf_header(AVFormatContext *s) {
300     AVIOContext *pb = s->pb;
301     GXFPktType pkt_type;
302     int map_len;
303     int len;
304     AVRational main_timebase = {0, 0};
305     struct gxf_stream_info *si = s->priv_data;
306     int i;
307     if (!parse_packet_header(pb, &pkt_type, &map_len) || pkt_type != PKT_MAP) {
308         av_log(s, AV_LOG_ERROR, "map packet not found\n");
309         return 0;
310     }
311     map_len -= 2;
312     if (avio_r8(pb) != 0x0e0 || avio_r8(pb) != 0xff) {
313         av_log(s, AV_LOG_ERROR, "unknown version or invalid map preamble\n");
314         return 0;
315     }
316     map_len -= 2;
317     len = avio_rb16(pb); // length of material data section
318     if (len > map_len) {
319         av_log(s, AV_LOG_ERROR, "material data longer than map data\n");
320         return 0;
321     }
322     map_len -= len;
323     gxf_material_tags(pb, &len, si);
324     avio_skip(pb, len);
325     map_len -= 2;
326     len = avio_rb16(pb); // length of track description
327     if (len > map_len) {
328         av_log(s, AV_LOG_ERROR, "track description longer than map data\n");
329         return 0;
330     }
331     map_len -= len;
332     while (len > 0) {
333         int track_type, track_id, track_len;
334         AVStream *st;
335         int idx;
336         len -= 4;
337         track_type = avio_r8(pb);
338         track_id = avio_r8(pb);
339         track_len = avio_rb16(pb);
340         len -= track_len;
341         if (!(track_type & 0x80)) {
342            av_log(s, AV_LOG_ERROR, "invalid track type %x\n", track_type);
343            continue;
344         }
345         track_type &= 0x7f;
346         if ((track_id & 0xc0) != 0xc0) {
347            av_log(s, AV_LOG_ERROR, "invalid track id %x\n", track_id);
348            continue;
349         }
350         track_id &= 0x3f;
351         gxf_track_tags(pb, &track_len, si);
352         // check for timecode tracks
353         if (track_type == 7 || track_type == 8 || track_type == 24) {
354             add_timecode_metadata(&s->metadata, "timecode",
355                                   si->track_aux_data & 0xffffffff,
356                                   si->fields_per_frame);
357
358         }
359         avio_skip(pb, track_len);
360
361         idx = get_sindex(s, track_id, track_type);
362         if (idx < 0) continue;
363         st = s->streams[idx];
364         if (!main_timebase.num || !main_timebase.den) {
365             main_timebase.num = si->frames_per_second.den;
366             main_timebase.den = si->frames_per_second.num * 2;
367         }
368         st->start_time = si->first_field;
369         if (si->first_field != AV_NOPTS_VALUE && si->last_field != AV_NOPTS_VALUE)
370             st->duration = si->last_field - si->first_field;
371     }
372     if (len < 0)
373         av_log(s, AV_LOG_ERROR, "invalid track description length specified\n");
374     if (map_len)
375         avio_skip(pb, map_len);
376     if (!parse_packet_header(pb, &pkt_type, &len)) {
377         av_log(s, AV_LOG_ERROR, "sync lost in header\n");
378         return -1;
379     }
380     if (pkt_type == PKT_FLT) {
381         gxf_read_index(s, len);
382         if (!parse_packet_header(pb, &pkt_type, &len)) {
383             av_log(s, AV_LOG_ERROR, "sync lost in header\n");
384             return -1;
385         }
386     }
387     if (pkt_type == PKT_UMF) {
388         if (len >= 0x39) {
389             AVRational fps;
390             len -= 0x39;
391             avio_skip(pb, 5); // preamble
392             avio_skip(pb, 0x30); // payload description
393             fps = fps_umf2avr(avio_rl32(pb));
394             if (!main_timebase.num || !main_timebase.den) {
395                 av_log(s, AV_LOG_WARNING, "No FPS track tag, using UMF fps tag."
396                                           " This might give wrong results.\n");
397                 // this may not always be correct, but simply the best we can get
398                 main_timebase.num = fps.den;
399                 main_timebase.den = fps.num * 2;
400             }
401
402             if (len >= 0x18) {
403                 len -= 0x18;
404                 avio_skip(pb, 0x10);
405                 add_timecode_metadata(&s->metadata, "timecode_at_mark_in",
406                                       avio_rl32(pb), si->fields_per_frame);
407                 add_timecode_metadata(&s->metadata, "timecode_at_mark_out",
408                                       avio_rl32(pb), si->fields_per_frame);
409             }
410         } else
411             av_log(s, AV_LOG_INFO, "UMF packet too short\n");
412     } else
413         av_log(s, AV_LOG_INFO, "UMF packet missing\n");
414     avio_skip(pb, len);
415     // set a fallback value, 60000/1001 is specified for audio-only files
416     // so use that regardless of why we do not know the video frame rate.
417     if (!main_timebase.num || !main_timebase.den)
418         main_timebase = (AVRational){1001, 60000};
419     for (i = 0; i < s->nb_streams; i++) {
420         AVStream *st = s->streams[i];
421         avpriv_set_pts_info(st, 32, main_timebase.num, main_timebase.den);
422     }
423     return 0;
424 }
425
426 #define READ_ONE() \
427     { \
428         if (!max_interval-- || url_feof(pb)) \
429             goto out; \
430         tmp = tmp << 8 | avio_r8(pb); \
431     }
432
433 /**
434  * @brief resync the stream on the next media packet with specified properties
435  * @param max_interval how many bytes to search for matching packet at most
436  * @param track track id the media packet must belong to, -1 for any
437  * @param timestamp minimum timestamp (== field number) the packet must have, -1 for any
438  * @return timestamp of packet found
439  */
440 static int64_t gxf_resync_media(AVFormatContext *s, uint64_t max_interval, int track, int timestamp) {
441     uint32_t tmp;
442     uint64_t last_pos;
443     uint64_t last_found_pos = 0;
444     int cur_track;
445     int64_t cur_timestamp = AV_NOPTS_VALUE;
446     int len;
447     AVIOContext *pb = s->pb;
448     GXFPktType type;
449     tmp = avio_rb32(pb);
450 start:
451     while (tmp)
452         READ_ONE();
453     READ_ONE();
454     if (tmp != 1)
455         goto start;
456     last_pos = avio_tell(pb);
457     if (avio_seek(pb, -5, SEEK_CUR) < 0)
458         goto out;
459     if (!parse_packet_header(pb, &type, &len) || type != PKT_MEDIA) {
460         if (avio_seek(pb, last_pos, SEEK_SET) < 0)
461             goto out;
462         goto start;
463     }
464     avio_r8(pb);
465     cur_track = avio_r8(pb);
466     cur_timestamp = avio_rb32(pb);
467     last_found_pos = avio_tell(pb) - 16 - 6;
468     if ((track >= 0 && track != cur_track) || (timestamp >= 0 && timestamp > cur_timestamp)) {
469         if (avio_seek(pb, last_pos, SEEK_SET) >= 0)
470             goto start;
471     }
472 out:
473     if (last_found_pos)
474         avio_seek(pb, last_found_pos, SEEK_SET);
475     return cur_timestamp;
476 }
477
478 static int gxf_packet(AVFormatContext *s, AVPacket *pkt) {
479     AVIOContext *pb = s->pb;
480     GXFPktType pkt_type;
481     int pkt_len;
482     struct gxf_stream_info *si = s->priv_data;
483
484     while (!pb->eof_reached) {
485         AVStream *st;
486         int track_type, track_id, ret;
487         int field_nr, field_info, skip = 0;
488         int stream_index;
489         if (!parse_packet_header(pb, &pkt_type, &pkt_len)) {
490             if (!url_feof(pb))
491                 av_log(s, AV_LOG_ERROR, "sync lost\n");
492             return -1;
493         }
494         if (pkt_type == PKT_FLT) {
495             gxf_read_index(s, pkt_len);
496             continue;
497         }
498         if (pkt_type != PKT_MEDIA) {
499             avio_skip(pb, pkt_len);
500             continue;
501         }
502         if (pkt_len < 16) {
503             av_log(s, AV_LOG_ERROR, "invalid media packet length\n");
504             continue;
505         }
506         pkt_len -= 16;
507         track_type = avio_r8(pb);
508         track_id = avio_r8(pb);
509         stream_index = get_sindex(s, track_id, track_type);
510         if (stream_index < 0)
511             return stream_index;
512         st = s->streams[stream_index];
513         field_nr = avio_rb32(pb);
514         field_info = avio_rb32(pb);
515         avio_rb32(pb); // "timeline" field number
516         avio_r8(pb); // flags
517         avio_r8(pb); // reserved
518         if (st->codec->codec_id == AV_CODEC_ID_PCM_S24LE ||
519             st->codec->codec_id == AV_CODEC_ID_PCM_S16LE) {
520             int first = field_info >> 16;
521             int last  = field_info & 0xffff; // last is exclusive
522             int bps = av_get_bits_per_sample(st->codec->codec_id)>>3;
523             if (first <= last && last*bps <= pkt_len) {
524                 avio_skip(pb, first*bps);
525                 skip = pkt_len - last*bps;
526                 pkt_len = (last-first)*bps;
527             } else
528                 av_log(s, AV_LOG_ERROR, "invalid first and last sample values\n");
529         }
530         ret = av_get_packet(pb, pkt, pkt_len);
531         if (skip)
532             avio_skip(pb, skip);
533         pkt->stream_index = stream_index;
534         pkt->dts = field_nr;
535
536         //set duration manually for DV or else lavf misdetects the frame rate
537         if (st->codec->codec_id == AV_CODEC_ID_DVVIDEO)
538             pkt->duration = si->fields_per_frame;
539
540         return ret;
541     }
542     return AVERROR_EOF;
543 }
544
545 static int gxf_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags) {
546     int res = 0;
547     uint64_t pos;
548     uint64_t maxlen = 100 * 1024 * 1024;
549     AVStream *st = s->streams[0];
550     int64_t start_time = s->streams[stream_index]->start_time;
551     int64_t found;
552     int idx;
553     if (timestamp < start_time) timestamp = start_time;
554     idx = av_index_search_timestamp(st, timestamp - start_time,
555                                     AVSEEK_FLAG_ANY | AVSEEK_FLAG_BACKWARD);
556     if (idx < 0)
557         return -1;
558     pos = st->index_entries[idx].pos;
559     if (idx < st->nb_index_entries - 2)
560         maxlen = st->index_entries[idx + 2].pos - pos;
561     maxlen = FFMAX(maxlen, 200 * 1024);
562     res = avio_seek(s->pb, pos, SEEK_SET);
563     if (res < 0)
564         return res;
565     found = gxf_resync_media(s, maxlen, -1, timestamp);
566     if (FFABS(found - timestamp) > 4)
567         return -1;
568     return 0;
569 }
570
571 static int64_t gxf_read_timestamp(AVFormatContext *s, int stream_index,
572                                   int64_t *pos, int64_t pos_limit) {
573     AVIOContext *pb = s->pb;
574     int64_t res;
575     if (avio_seek(pb, *pos, SEEK_SET) < 0)
576         return AV_NOPTS_VALUE;
577     res = gxf_resync_media(s, pos_limit - *pos, -1, -1);
578     *pos = avio_tell(pb);
579     return res;
580 }
581
582 AVInputFormat ff_gxf_demuxer = {
583     .name           = "gxf",
584     .long_name      = NULL_IF_CONFIG_SMALL("GXF (General eXchange Format)"),
585     .priv_data_size = sizeof(struct gxf_stream_info),
586     .read_probe     = gxf_probe,
587     .read_header    = gxf_header,
588     .read_packet    = gxf_packet,
589     .read_seek      = gxf_seek,
590     .read_timestamp = gxf_read_timestamp,
591 };