falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
7023 Commits
32 Branches
593MB
Tree: 2b5269b51c
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '2b5269b51c'
${ noResults }
FFmpeg/libavformat/gxf.c

517 lines
16KB
Raw Blame History 

  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 (ABS(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. };