808
|
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 #include "avformat.h"
|
|
22 #include "common.h"
|
|
23
|
|
24 typedef enum {
|
|
25 PKT_MAP = 0xbc,
|
|
26 PKT_MEDIA = 0xbf,
|
|
27 PKT_EOS = 0xfb,
|
|
28 PKT_FLT = 0xfc,
|
|
29 PKT_UMF = 0xfd
|
|
30 } pkt_type_t;
|
|
31
|
|
32 typedef enum {
|
|
33 MAT_NAME = 0x40,
|
|
34 MAT_FIRST_FIELD = 0x41,
|
|
35 MAT_LAST_FIELD = 0x42,
|
|
36 MAT_MARK_IN = 0x43,
|
|
37 MAT_MARK_OUT = 0x44,
|
|
38 MAT_SIZE = 0x45
|
|
39 } mat_tag_t;
|
|
40
|
|
41 typedef enum {
|
|
42 TRACK_NAME = 0x4c,
|
|
43 TRACK_AUX = 0x4d,
|
|
44 TRACK_VER = 0x4e,
|
|
45 TRACK_MPG_AUX = 0x4f,
|
|
46 TRACK_FPS = 0x50,
|
|
47 TRACK_LINES = 0x51,
|
|
48 TRACK_FPF = 0x52
|
|
49 } track_tag_t;
|
|
50
|
|
51 typedef struct {
|
|
52 int64_t first_field;
|
|
53 int64_t last_field;
|
|
54 AVRational frames_per_second;
|
|
55 int32_t fields_per_frame;
|
|
56 } st_info_t;
|
|
57
|
|
58 /**
|
|
59 * \brief parses a packet header, extracting type and length
|
|
60 * \param pb ByteIOContext to read header from
|
|
61 * \param type detected packet type is stored here
|
|
62 * \param length detected packet length, excluding header is stored here
|
|
63 * \return 0 if header not found or contains invalid data, 1 otherwise
|
|
64 */
|
|
65 static int parse_packet_header(ByteIOContext *pb, pkt_type_t *type, int *length) {
|
|
66 if (get_be32(pb))
|
|
67 return 0;
|
|
68 if (get_byte(pb) != 1)
|
|
69 return 0;
|
|
70 *type = get_byte(pb);
|
|
71 *length = get_be32(pb);
|
|
72 if ((*length >> 24) || *length < 16)
|
|
73 return 0;
|
|
74 *length -= 16;
|
|
75 if (get_be32(pb))
|
|
76 return 0;
|
|
77 if (get_byte(pb) != 0xe1)
|
|
78 return 0;
|
|
79 if (get_byte(pb) != 0xe2)
|
|
80 return 0;
|
|
81 return 1;
|
|
82 }
|
|
83
|
|
84 /**
|
|
85 * \brief check if file starts with a PKT_MAP header
|
|
86 */
|
|
87 static int gxf_probe(AVProbeData *p) {
|
|
88 static const uint8_t startcode[] = {0, 0, 0, 0, 1, 0xbc}; // start with map packet
|
|
89 static const uint8_t endcode[] = {0, 0, 0, 0, 0xe1, 0xe2};
|
|
90 if (p->buf_size < 16)
|
|
91 return 0;
|
|
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 }
|
|
97
|
|
98 /**
|
|
99 * \brief gets the stream index for the track with the specified id, creates new
|
|
100 * stream if not found
|
|
101 * \param stream 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 for (i = 0; i < s->nb_streams; i++) {
|
|
108 if (s->streams[i]->id == id)
|
|
109 return i;
|
|
110 }
|
|
111 st = av_new_stream(s, id);
|
|
112 switch (format) {
|
|
113 case 3:
|
|
114 case 4:
|
|
115 st->codec->codec_type = CODEC_TYPE_VIDEO;
|
|
116 st->codec->codec_id = CODEC_ID_MJPEG;
|
|
117 break;
|
|
118 case 13:
|
|
119 case 15:
|
|
120 st->codec->codec_type = CODEC_TYPE_VIDEO;
|
|
121 st->codec->codec_id = CODEC_ID_DVVIDEO;
|
|
122 break;
|
|
123 case 14:
|
|
124 case 16:
|
|
125 st->codec->codec_type = CODEC_TYPE_VIDEO;
|
|
126 st->codec->codec_id = CODEC_ID_DVVIDEO;
|
|
127 break;
|
|
128 case 11:
|
|
129 case 12:
|
|
130 case 20:
|
|
131 st->codec->codec_type = CODEC_TYPE_VIDEO;
|
|
132 st->codec->codec_id = CODEC_ID_MPEG2VIDEO;
|
|
133 break;
|
|
134 case 22:
|
|
135 case 23:
|
|
136 st->codec->codec_type = CODEC_TYPE_VIDEO;
|
|
137 st->codec->codec_id = CODEC_ID_MPEG1VIDEO;
|
|
138 break;
|
|
139 case 9:
|
|
140 st->codec->codec_type = CODEC_TYPE_AUDIO;
|
|
141 st->codec->codec_id = CODEC_ID_PCM_S24LE;
|
|
142 st->codec->channels = 1;
|
|
143 st->codec->sample_rate = 48000;
|
|
144 st->codec->bit_rate = 3 * 1 * 48000 * 8;
|
|
145 st->codec->block_align = 3 * 1;
|
|
146 st->codec->bits_per_sample = 24;
|
|
147 break;
|
|
148 case 10:
|
|
149 st->codec->codec_type = CODEC_TYPE_AUDIO;
|
|
150 st->codec->codec_id = CODEC_ID_PCM_S16LE;
|
|
151 st->codec->channels = 1;
|
|
152 st->codec->sample_rate = 48000;
|
|
153 st->codec->bit_rate = 2 * 1 * 48000 * 8;
|
|
154 st->codec->block_align = 2 * 1;
|
|
155 st->codec->bits_per_sample = 16;
|
|
156 break;
|
|
157 case 17:
|
|
158 st->codec->codec_type = CODEC_TYPE_AUDIO;
|
|
159 st->codec->codec_id = CODEC_ID_AC3;
|
|
160 st->codec->channels = 2;
|
|
161 st->codec->sample_rate = 48000;
|
|
162 break;
|
|
163 default:
|
|
164 st->codec->codec_type = CODEC_TYPE_UNKNOWN;
|
|
165 st->codec->codec_id = CODEC_ID_NONE;
|
|
166 break;
|
|
167 }
|
|
168 return s->nb_streams - 1;
|
|
169 }
|
|
170
|
|
171 /**
|
|
172 * \brief filters out interesting tags from material information.
|
|
173 * \param len lenght of tag section, will be adjusted to contain remaining bytes
|
|
174 * \param si struct to store collected information into
|
|
175 */
|
|
176 static void gxf_material_tags(ByteIOContext *pb, int *len, st_info_t *si) {
|
|
177 si->first_field = AV_NOPTS_VALUE;
|
|
178 si->last_field = AV_NOPTS_VALUE;
|
|
179 while (*len >= 2) {
|
|
180 mat_tag_t tag = get_byte(pb);
|
|
181 int tlen = get_byte(pb);
|
|
182 *len -= 2;
|
|
183 if (tlen > *len)
|
|
184 return;
|
|
185 *len -= tlen;
|
|
186 if (tlen == 4) {
|
|
187 uint32_t value = get_be32(pb);
|
|
188 if (tag == MAT_FIRST_FIELD)
|
|
189 si->first_field = value;
|
|
190 else if (tag == MAT_LAST_FIELD)
|
|
191 si->last_field = value;
|
|
192 } else
|
|
193 url_fskip(pb, tlen);
|
|
194 }
|
|
195 }
|
|
196
|
|
197 /**
|
|
198 * \brief convert fps tag value to AVRational fps
|
|
199 * \param fps fps value from tag
|
|
200 * \return fps as AVRational, or 0 / 0 if unknown
|
|
201 */
|
|
202 static AVRational fps_tag2avr(int32_t fps) {
|
|
203 extern const AVRational ff_frame_rate_tab[];
|
|
204 if (fps < 1 || fps > 9) fps = 9;
|
|
205 return ff_frame_rate_tab[9 - fps]; // values have opposite order
|
|
206 }
|
|
207
|
|
208 /**
|
|
209 * \brief convert UMF attributes flags to AVRational fps
|
|
210 * \param fps fps value from flags
|
|
211 * \return fps as AVRational, or 0 / 0 if unknown
|
|
212 */
|
|
213 static AVRational fps_umf2avr(uint32_t flags) {
|
|
214 static const AVRational map[] = {{50, 1}, {60000, 1001}, {24, 1},
|
|
215 {25, 1}, {30000, 1001}};
|
|
216 int idx = av_log2((flags & 0x7c0) >> 6);
|
|
217 return map[idx];
|
|
218 }
|
|
219
|
|
220 /**
|
|
221 * \brief filters out interesting tags from track information.
|
|
222 * \param len length of tag section, will be adjusted to contain remaining bytes
|
|
223 * \param si struct to store collected information into
|
|
224 */
|
|
225 static void gxf_track_tags(ByteIOContext *pb, int *len, st_info_t *si) {
|
|
226 si->frames_per_second = (AVRational){0, 0};
|
|
227 si->fields_per_frame = 0;
|
|
228 while (*len >= 2) {
|
|
229 track_tag_t tag = get_byte(pb);
|
|
230 int tlen = get_byte(pb);
|
|
231 *len -= 2;
|
|
232 if (tlen > *len)
|
|
233 return;
|
|
234 *len -= tlen;
|
|
235 if (tlen == 4) {
|
|
236 uint32_t value = get_be32(pb);
|
|
237 if (tag == TRACK_FPS)
|
|
238 si->frames_per_second = fps_tag2avr(value);
|
|
239 else if (tag == TRACK_FPF && (value == 1 || value == 2))
|
|
240 si->fields_per_frame = value;
|
|
241 } else
|
|
242 url_fskip(pb, tlen);
|
|
243 }
|
|
244 }
|
|
245
|
|
246 /**
|
|
247 * \brief read index from FLT packet into stream 0 av_index
|
|
248 */
|
|
249 static void gxf_read_index(AVFormatContext *s, int pkt_len) {
|
|
250 ByteIOContext *pb = &s->pb;
|
|
251 AVStream *st = s->streams[0];
|
|
252 uint32_t fields_per_map = get_le32(pb);
|
|
253 uint32_t map_cnt = get_le32(pb);
|
|
254 int i;
|
|
255 pkt_len -= 8;
|
|
256 if (map_cnt > 1000) {
|
|
257 av_log(s, AV_LOG_ERROR, "GXF: too many index entries %u (%x)\n", map_cnt, map_cnt);
|
|
258 map_cnt = 1000;
|
|
259 }
|
|
260 if (pkt_len < 4 * map_cnt) {
|
|
261 av_log(s, AV_LOG_ERROR, "GXF: invalid index length\n");
|
|
262 url_fskip(pb, pkt_len);
|
|
263 return;
|
|
264 }
|
|
265 pkt_len -= 4 * map_cnt;
|
|
266 av_add_index_entry(st, 0, 0, 0, 0, 0);
|
|
267 for (i = 0; i < map_cnt; i++)
|
|
268 av_add_index_entry(st, (uint64_t)get_le32(pb) * 1024,
|
|
269 i * (uint64_t)fields_per_map + 1, 0, 0, 0);
|
|
270 url_fskip(pb, pkt_len);
|
|
271 }
|
|
272
|
|
273 static int gxf_header(AVFormatContext *s, AVFormatParameters *ap) {
|
|
274 ByteIOContext *pb = &s->pb;
|
|
275 pkt_type_t pkt_type;
|
|
276 int map_len;
|
|
277 int len;
|
|
278 AVRational main_timebase = {0, 0};
|
|
279 st_info_t si;
|
|
280 int i;
|
|
281 if (!parse_packet_header(pb, &pkt_type, &map_len) || pkt_type != PKT_MAP) {
|
|
282 av_log(s, AV_LOG_ERROR, "GXF: map packet not found\n");
|
|
283 return 0;
|
|
284 }
|
|
285 map_len -= 2;
|
|
286 if (get_byte(pb) != 0x0e0 || get_byte(pb) != 0xff) {
|
|
287 av_log(s, AV_LOG_ERROR, "GXF: unknown version or invalid map preamble\n");
|
|
288 return 0;
|
|
289 }
|
|
290 map_len -= 2;
|
|
291 len = get_be16(pb); // length of material data section
|
|
292 if (len > map_len) {
|
|
293 av_log(s, AV_LOG_ERROR, "GXF: material data longer than map data\n");
|
|
294 return 0;
|
|
295 }
|
|
296 map_len -= len;
|
|
297 gxf_material_tags(pb, &len, &si);
|
|
298 url_fskip(pb, len);
|
|
299 map_len -= 2;
|
|
300 len = get_be16(pb); // length of track description
|
|
301 if (len > map_len) {
|
|
302 av_log(s, AV_LOG_ERROR, "GXF: track description longer than map data\n");
|
|
303 return 0;
|
|
304 }
|
|
305 map_len -= len;
|
|
306 while (len > 0) {
|
|
307 int track_type, track_id, track_len;
|
|
308 AVStream *st;
|
|
309 int idx;
|
|
310 len -= 4;
|
|
311 track_type = get_byte(pb);
|
|
312 track_id = get_byte(pb);
|
|
313 track_len = get_be16(pb);
|
|
314 len -= track_len;
|
|
315 gxf_track_tags(pb, &track_len, &si);
|
|
316 url_fskip(pb, track_len);
|
|
317 if (!(track_type & 0x80)) {
|
|
318 av_log(s, AV_LOG_ERROR, "GXF: invalid track type %x\n", track_type);
|
|
319 continue;
|
|
320 }
|
|
321 track_type &= 0x7f;
|
|
322 if ((track_id & 0xc0) != 0xc0) {
|
|
323 av_log(s, AV_LOG_ERROR, "GXF: invalid track id %x\n", track_id);
|
|
324 continue;
|
|
325 }
|
|
326 track_id &= 0x3f;
|
|
327 idx = get_sindex(s, track_id, track_type);
|
|
328 if (idx < 0) continue;
|
|
329 st = s->streams[idx];
|
|
330 if (!main_timebase.num || !main_timebase.den) {
|
|
331 main_timebase.num = si.frames_per_second.den;
|
|
332 main_timebase.den = si.frames_per_second.num * si.fields_per_frame;
|
|
333 }
|
|
334 st->start_time = si.first_field;
|
|
335 if (si.first_field != AV_NOPTS_VALUE && si.last_field != AV_NOPTS_VALUE)
|
|
336 st->duration = si.last_field - si.first_field;
|
|
337 }
|
|
338 if (len < 0)
|
|
339 av_log(s, AV_LOG_ERROR, "GXF: invalid track description length specified\n");
|
|
340 if (map_len)
|
|
341 url_fskip(pb, map_len);
|
|
342 if (!parse_packet_header(pb, &pkt_type, &len)) {
|
|
343 av_log(s, AV_LOG_ERROR, "GXF: sync lost in header\n");
|
|
344 return -1;
|
|
345 }
|
|
346 if (pkt_type == PKT_FLT) {
|
|
347 gxf_read_index(s, len);
|
|
348 if (!parse_packet_header(pb, &pkt_type, &len)) {
|
|
349 av_log(s, AV_LOG_ERROR, "GXF: sync lost in header\n");
|
|
350 return -1;
|
|
351 }
|
|
352 }
|
|
353 if (pkt_type == PKT_UMF) {
|
|
354 if (len >= 9) {
|
|
355 AVRational fps;
|
|
356 len -= 9;
|
|
357 url_fskip(pb, 5);
|
|
358 fps = fps_umf2avr(get_le32(pb));
|
|
359 if (!main_timebase.num || !main_timebase.den) {
|
|
360 // this may not always be correct, but simply the best we can get
|
|
361 main_timebase.num = fps.den;
|
|
362 main_timebase.den = fps.num;
|
|
363 }
|
|
364 } else
|
|
365 av_log(s, AV_LOG_INFO, "GXF: UMF packet too short\n");
|
|
366 } else
|
|
367 av_log(s, AV_LOG_INFO, "GXF: UMF packet missing\n");
|
|
368 url_fskip(pb, len);
|
|
369 for (i = 0; i < s->nb_streams; i++) {
|
|
370 AVStream *st = s->streams[i];
|
|
371 if (main_timebase.num && main_timebase.den)
|
|
372 st->time_base = main_timebase;
|
|
373 else {
|
|
374 st->start_time = st->duration = AV_NOPTS_VALUE;
|
|
375 }
|
|
376 }
|
|
377 return 0;
|
|
378 }
|
|
379
|
|
380 #define READ_ONE() \
|
|
381 { \
|
|
382 if (!max_interval-- || url_feof(pb)) \
|
|
383 goto out; \
|
|
384 tmp = tmp << 8 | get_byte(pb); \
|
|
385 }
|
|
386
|
|
387 /**
|
|
388 * \brief resync the stream on the next media packet with specified properties
|
|
389 * \param max_interval how many bytes to search for matching packet at most
|
|
390 * \param track track id the media packet must belong to, -1 for any
|
|
391 * \param timestamp minimum timestamp (== field number) the packet must have, -1 for any
|
|
392 * \return timestamp of packet found
|
|
393 */
|
|
394 static int64_t gxf_resync_media(AVFormatContext *s, uint64_t max_interval, int track, int timestamp) {
|
|
395 uint32_t tmp;
|
|
396 uint64_t last_pos;
|
|
397 uint64_t last_found_pos = 0;
|
|
398 int cur_track;
|
|
399 int64_t cur_timestamp = AV_NOPTS_VALUE;
|
|
400 int len;
|
|
401 ByteIOContext *pb = &s->pb;
|
|
402 pkt_type_t type;
|
|
403 tmp = get_be32(pb);
|
|
404 start:
|
|
405 while (tmp)
|
|
406 READ_ONE();
|
|
407 READ_ONE();
|
|
408 if (tmp != 1)
|
|
409 goto start;
|
|
410 last_pos = url_ftell(pb);
|
|
411 url_fseek(pb, -5, SEEK_CUR);
|
|
412 if (!parse_packet_header(pb, &type, &len) || type != PKT_MEDIA) {
|
|
413 url_fseek(pb, last_pos, SEEK_SET);
|
|
414 goto start;
|
|
415 }
|
|
416 get_byte(pb);
|
|
417 cur_track = get_byte(pb);
|
|
418 cur_timestamp = get_be32(pb);
|
|
419 last_found_pos = url_ftell(pb) - 16 - 6;
|
|
420 if ((track >= 0 && track != cur_track) || (timestamp >= 0 && timestamp > cur_timestamp)) {
|
|
421 url_fseek(pb, last_pos, SEEK_SET);
|
|
422 goto start;
|
|
423 }
|
|
424 out:
|
|
425 if (last_found_pos)
|
|
426 url_fseek(pb, last_found_pos, SEEK_SET);
|
|
427 return cur_timestamp;
|
|
428 }
|
|
429
|
|
430 static int gxf_packet(AVFormatContext *s, AVPacket *pkt) {
|
|
431 ByteIOContext *pb = &s->pb;
|
|
432 pkt_type_t pkt_type;
|
|
433 int pkt_len;
|
|
434 while (!url_feof(pb)) {
|
|
435 int track_type, track_id, ret;
|
|
436 int field_nr;
|
|
437 if (!parse_packet_header(pb, &pkt_type, &pkt_len)) {
|
|
438 if (!url_feof(pb))
|
|
439 av_log(s, AV_LOG_ERROR, "GXF: sync lost\n");
|
|
440 return -1;
|
|
441 }
|
|
442 if (pkt_type == PKT_FLT) {
|
|
443 gxf_read_index(s, pkt_len);
|
|
444 continue;
|
|
445 }
|
|
446 if (pkt_type != PKT_MEDIA) {
|
|
447 url_fskip(pb, pkt_len);
|
|
448 continue;
|
|
449 }
|
|
450 if (pkt_len < 16) {
|
|
451 av_log(s, AV_LOG_ERROR, "GXF: invalid media packet length\n");
|
|
452 continue;
|
|
453 }
|
|
454 pkt_len -= 16;
|
|
455 track_type = get_byte(pb);
|
|
456 track_id = get_byte(pb);
|
|
457 field_nr = get_be32(pb);
|
|
458 get_be32(pb); // field information
|
|
459 get_be32(pb); // "timeline" field number
|
|
460 get_byte(pb); // flags
|
|
461 get_byte(pb); // reserved
|
|
462 // NOTE: there is also data length information in the
|
|
463 // field information, it might be better to take this into account
|
|
464 // as well.
|
|
465 ret = av_get_packet(pb, pkt, pkt_len);
|
|
466 pkt->stream_index = get_sindex(s, track_id, track_type);
|
|
467 pkt->dts = field_nr;
|
|
468 return ret;
|
|
469 }
|
|
470 return AVERROR_IO;
|
|
471 }
|
|
472
|
|
473 static int gxf_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags) {
|
|
474 uint64_t pos;
|
|
475 uint64_t maxlen = 100 * 1024 * 1024;
|
|
476 AVStream *st = s->streams[0];
|
|
477 int64_t start_time = s->streams[stream_index]->start_time;
|
|
478 int64_t found;
|
|
479 int idx;
|
|
480 if (timestamp < start_time) timestamp = start_time;
|
|
481 idx = av_index_search_timestamp(st, timestamp - start_time,
|
|
482 AVSEEK_FLAG_ANY | AVSEEK_FLAG_BACKWARD);
|
|
483 if (idx < 0)
|
|
484 return -1;
|
|
485 pos = st->index_entries[idx].pos;
|
|
486 if (idx < st->nb_index_entries - 2)
|
|
487 maxlen = st->index_entries[idx + 2].pos - pos;
|
|
488 maxlen = FFMAX(maxlen, 200 * 1024);
|
|
489 url_fseek(&s->pb, pos, SEEK_SET);
|
|
490 found = gxf_resync_media(s, maxlen, -1, timestamp);
|
|
491 if (FFABS(found - timestamp) > 4)
|
|
492 return -1;
|
|
493 return 0;
|
|
494 }
|
|
495
|
|
496 static int64_t gxf_read_timestamp(AVFormatContext *s, int stream_index,
|
|
497 int64_t *pos, int64_t pos_limit) {
|
|
498 ByteIOContext *pb = &s->pb;
|
|
499 int64_t res;
|
|
500 url_fseek(pb, *pos, SEEK_SET);
|
|
501 res = gxf_resync_media(s, pos_limit - *pos, -1, -1);
|
|
502 *pos = url_ftell(pb);
|
|
503 return res;
|
|
504 }
|
|
505
|
|
506 AVInputFormat gxf_demuxer = {
|
|
507 "gxf",
|
|
508 "GXF format",
|
|
509 0,
|
|
510 gxf_probe,
|
|
511 gxf_header,
|
|
512 gxf_packet,
|
|
513 NULL,
|
|
514 gxf_seek,
|
|
515 gxf_read_timestamp,
|
|
516 };
|