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