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.
6311 Commits
32 Branches
411MB
Tree: 1f1aa1d955
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '1f1aa1d955'
${ noResults }
FFmpeg/libavformat/gxf.c

515 lines
16KB
Raw Blame History 

  1. /*

  2.  * GXF demuxer.

  3.  * Copyright (c) 2006 Reimar Doeffinger.

  4.  *

  5.  * This library is free software; you can redistribute it and/or

  6.  * modify it under the terms of the GNU Lesser General Public

  7.  * License as published by the Free Software Foundation; either

  8.  * version 2 of the License, or (at your option) any later version.

  9.  *

  10.  * This library is distributed in the hope that it will be useful,

  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  13.  * Lesser General Public License for more details.

  14.  *

  15.  * You should have received a copy of the GNU Lesser General Public

  16.  * License along with this library; if not, write to the Free Software

  17.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

  18.  */

  19. #include "avformat.h"

  20. #include "common.h"

  21. 

  22. typedef enum {

  23.     PKT_MAP = 0xbc,

  24.     PKT_MEDIA = 0xbf,

  25.     PKT_EOS = 0xfb,

  26.     PKT_FLT = 0xfc,

  27.     PKT_UMF = 0xfd

  28. } pkt_type_t;

  29. 

  30. typedef enum {

  31.     MAT_NAME = 0x40,

  32.     MAT_FIRST_FIELD = 0x41,

  33.     MAT_LAST_FIELD = 0x42,

  34.     MAT_MARK_IN = 0x43,

  35.     MAT_MARK_OUT = 0x44,

  36.     MAT_SIZE = 0x45

  37. } mat_tag_t;

  38. 

  39. typedef enum {

  40.     TRACK_NAME = 0x4c,

  41.     TRACK_AUX = 0x4d,

  42.     TRACK_VER = 0x4e,

  43.     TRACK_MPG_AUX = 0x4f,

  44.     TRACK_FPS = 0x50,

  45.     TRACK_LINES = 0x51,

  46.     TRACK_FPF = 0x52

  47. } track_tag_t;

  48. 

  49. typedef struct {

  50.     int64_t first_field;

  51.     int64_t last_field;

  52.     AVRational frames_per_second;

  53.     int32_t fields_per_frame;

  54. } st_info_t;

  55. 

  56. /**

  57.  * \brief parses a packet header, extracting type and length

  58.  * \param pb ByteIOContext 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(ByteIOContext *pb, pkt_type_t *type, int *length) {

  64.     if (get_be32(pb))

  65.         return 0;

  66.     if (get_byte(pb) != 1)

  67.         return 0;

  68.     *type = get_byte(pb);

  69.     *length = get_be32(pb);

  70.     if ((*length >> 24) || *length < 16)

  71.         return 0;

  72.     *length -= 16;

  73.     if (get_be32(pb))

  74.         return 0;

  75.     if (get_byte(pb) != 0xe1)

  76.         return 0;

  77.     if (get_byte(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 (p->buf_size < 16)

  89.         return 0;

  90.     if (!memcmp(p->buf, startcode, sizeof(startcode)) &&

  91.         !memcmp(&p->buf[16 - sizeof(endcode)], endcode, sizeof(endcode)))

  92.         return AVPROBE_SCORE_MAX;

  93.     return 0;

  94. }

  95. 

  96. /**

  97.  * \brief gets the stream index for the track with the specified id, creates new

  98.  *        stream if not found

  99.  * \param stream id of stream to find / add

  100.  * \param format stream format identifier

  101.  */

  102. static int get_sindex(AVFormatContext *s, int id, int format) {

  103.     int i;

  104.     AVStream *st = NULL;

  105.     for (i = 0; i < s->nb_streams; i++) {

  106.         if (s->streams[i]->id == id)

  107.             return i;

  108.     }

  109.     st = av_new_stream(s, id);

  110.     switch (format) {

  111.         case 3:

  112.         case 4:

  113.             st->codec->codec_type = CODEC_TYPE_VIDEO;

  114.             st->codec->codec_id = CODEC_ID_MJPEG;

  115.             break;

  116.         case 13:

  117.         case 15:

  118.             st->codec->codec_type = CODEC_TYPE_VIDEO;

  119.             st->codec->codec_id = CODEC_ID_DVVIDEO;

  120.             break;

  121.         case 14:

  122.         case 16:

  123.             st->codec->codec_type = CODEC_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 = CODEC_TYPE_VIDEO;

  130.             st->codec->codec_id = CODEC_ID_MPEG2VIDEO;

  131.             break;

  132.         case 22:

  133.         case 23:

  134.             st->codec->codec_type = CODEC_TYPE_VIDEO;

  135.             st->codec->codec_id = CODEC_ID_MPEG1VIDEO;

  136.             break;

  137.         case 9:

  138.             st->codec->codec_type = CODEC_TYPE_AUDIO;

  139.             st->codec->codec_id = CODEC_ID_PCM_S24LE;

  140.             st->codec->channels = 1;

  141.             st->codec->sample_rate = 48000;

  142.             st->codec->bit_rate = 3 * 1 * 48000 * 8;

  143.             st->codec->block_align = 3 * 1;

  144.             st->codec->bits_per_sample = 24;

  145.             break;

  146.         case 10:

  147.             st->codec->codec_type = CODEC_TYPE_AUDIO;

  148.             st->codec->codec_id = CODEC_ID_PCM_S16LE;

  149.             st->codec->channels = 1;

  150.             st->codec->sample_rate = 48000;

  151.             st->codec->bit_rate = 2 * 1 * 48000 * 8;

  152.             st->codec->block_align = 2 * 1;

  153.             st->codec->bits_per_sample = 16;

  154.             break;

  155.         case 17:

  156.             st->codec->codec_type = CODEC_TYPE_AUDIO;

  157.             st->codec->codec_id = CODEC_ID_AC3;

  158.             st->codec->channels = 2;

  159.             st->codec->sample_rate = 48000;

  160.             break;

  161.         default:

  162.             st->codec->codec_type = CODEC_TYPE_UNKNOWN;

  163.             st->codec->codec_id = CODEC_ID_NONE;

  164.             break;

  165.     }

  166.     return s->nb_streams - 1;

  167. }

  168. 

  169. /**

  170.  * \brief filters out interesting tags from material information.

  171.  * \param len lenght of tag section, will be adjusted to contain remaining bytes

  172.  * \param si struct to store collected information into

  173.  */

  174. static void gxf_material_tags(ByteIOContext *pb, int *len, st_info_t *si) {

  175.     si->first_field = AV_NOPTS_VALUE;

  176.     si->last_field = AV_NOPTS_VALUE;

  177.     while (*len >= 2) {

  178.         mat_tag_t tag = get_byte(pb);

  179.         int tlen = get_byte(pb);

  180.         *len -= 2;

  181.         if (tlen > *len)

  182.             return;

  183.         *len -= tlen;

  184.         if (tlen == 4) {

  185.             uint32_t value = get_be32(pb);

  186.             if (tag == MAT_FIRST_FIELD)

  187.                 si->first_field = value;

  188.             else if (tag == MAT_LAST_FIELD)

  189.                 si->last_field = value;

  190.         } else

  191.             url_fskip(pb, tlen);

  192.     }

  193. }

  194. 

  195. /**

  196.  * \brief convert fps tag value to AVRational fps

  197.  * \param fps fps value from tag

  198.  * \return fps as AVRational, or 0 / 0 if unknown

  199.  */

  200. static AVRational fps_tag2avr(int32_t fps) {

  201.     extern const AVRational ff_frame_rate_tab[];

  202.     if (fps < 1 || fps > 9) fps = 9;

  203.     return ff_frame_rate_tab[9 - fps]; // values have opposite order

  204. }

  205. 

  206. /**

  207.  * \brief convert UMF attributes flags to AVRational fps

  208.  * \param fps fps value from flags

  209.  * \return fps as AVRational, or 0 / 0 if unknown

  210.  */

  211. static AVRational fps_umf2avr(uint32_t flags) {

  212.     static const AVRational map[] = {{50, 1}, {60000, 1001}, {24, 1},

  213.         {25, 1}, {30000, 1001}};

  214.     int idx =  av_log2((flags & 0x7c0) >> 6);

  215.     return map[idx];

  216. }

  217. 

  218. /**

  219.  * \brief filters out interesting tags from track information.

  220.  * \param len length of tag section, will be adjusted to contain remaining bytes

  221.  * \param si struct to store collected information into

  222.  */

  223. static void gxf_track_tags(ByteIOContext *pb, int *len, st_info_t *si) {

  224.     si->frames_per_second = (AVRational){0, 0};

  225.     si->fields_per_frame = 0;

  226.     while (*len >= 2) {

  227.         track_tag_t tag = get_byte(pb);

  228.         int tlen = get_byte(pb);

  229.         *len -= 2;

  230.         if (tlen > *len)

  231.             return;

  232.         *len -= tlen;

  233.         if (tlen == 4) {

  234.             uint32_t value = get_be32(pb);

  235.             if (tag == TRACK_FPS)

  236.                 si->frames_per_second = fps_tag2avr(value);

  237.             else if (tag == TRACK_FPF && (value == 1 || value == 2))

  238.                 si->fields_per_frame = value;

  239.         } else

  240.             url_fskip(pb, tlen);

  241.     }

  242. }

  243. 

  244. /**

  245.  * \brief read index from FLT packet into stream 0 av_index

  246.  */

  247. static void gxf_read_index(AVFormatContext *s, int pkt_len) {

  248.     ByteIOContext *pb = &s->pb;

  249.     AVStream *st = s->streams[0];

  250.     uint32_t fields_per_map = get_le32(pb);

  251.     uint32_t map_cnt = get_le32(pb);

  252.     int i;

  253.     pkt_len -= 8;

  254.     if (map_cnt > 1000) {

  255.         av_log(s, AV_LOG_ERROR, "GXF: too many index entries %u (%x)\n", map_cnt, map_cnt);

  256.         map_cnt = 1000;

  257.     }

  258.     if (pkt_len < 4 * map_cnt) {

  259.         av_log(s, AV_LOG_ERROR, "GXF: invalid index length\n");

  260.         url_fskip(pb, pkt_len);

  261.         return;

  262.     }

  263.     pkt_len -= 4 * map_cnt;

  264.     av_add_index_entry(st, 0, 0, 0, 0, 0);

  265.     for (i = 0; i < map_cnt; i++)

  266.         av_add_index_entry(st, (uint64_t)get_le32(pb) * 1024,

  267.                            i * (uint64_t)fields_per_map + 1, 0, 0, 0);

  268.     url_fskip(pb, pkt_len);

  269. }

  270. 

  271. static int gxf_header(AVFormatContext *s, AVFormatParameters *ap) {

  272.     ByteIOContext *pb = &s->pb;

  273.     pkt_type_t pkt_type;

  274.     int map_len;

  275.     int len;

  276.     AVRational main_timebase = {0, 0};

  277.     st_info_t si;

  278.     int i;

  279.     if (!parse_packet_header(pb, &pkt_type, &map_len) || pkt_type != PKT_MAP) {

  280.         av_log(s, AV_LOG_ERROR, "GXF: map packet not found\n");

  281.         return 0;

  282.     }

  283.     map_len -= 2;

  284.     if (get_byte(pb) != 0x0e0 || get_byte(pb) != 0xff) {

  285.         av_log(s, AV_LOG_ERROR, "GXF: unknown version or invalid map preamble\n");

  286.         return 0;

  287.     }

  288.     map_len -= 2;

  289.     len = get_be16(pb); // length of material data section

  290.     if (len > map_len) {

  291.         av_log(s, AV_LOG_ERROR, "GXF: material data longer than map data\n");

  292.         return 0;

  293.     }

  294.     map_len -= len;

  295.     gxf_material_tags(pb, &len, &si);

  296.     url_fskip(pb, len);

  297.     map_len -= 2;

  298.     len = get_be16(pb); // length of track description

  299.     if (len > map_len) {

  300.         av_log(s, AV_LOG_ERROR, "GXF: track description longer than map data\n");

  301.         return 0;

  302.     }

  303.     map_len -= len;

  304.     while (len > 0) {

  305.         int track_type, track_id, track_len;

  306.         AVStream *st;

  307.         int idx;

  308.         len -= 4;

  309.         track_type = get_byte(pb);

  310.         track_id = get_byte(pb);

  311.         track_len = get_be16(pb);

  312.         len -= track_len;

  313.         gxf_track_tags(pb, &track_len, &si);

  314.         url_fskip(pb, track_len);

  315.         if (!(track_type & 0x80)) {

  316.            av_log(s, AV_LOG_ERROR, "GXF: invalid track type %x\n", track_type);

  317.            continue;

  318.         }

  319.         track_type &= 0x7f;

  320.         if ((track_id & 0xc0) != 0xc0) {

  321.            av_log(s, AV_LOG_ERROR, "GXF: invalid track id %x\n", track_id);

  322.            continue;

  323.         }

  324.         track_id &= 0x3f;

  325.         idx = get_sindex(s, track_id, track_type);

  326.         if (idx < 0) continue;

  327.         st = s->streams[idx];

  328.         if (!main_timebase.num || !main_timebase.den) {

  329.             main_timebase.num = si.frames_per_second.den;

  330.             main_timebase.den = si.frames_per_second.num * si.fields_per_frame;

  331.         }

  332.         st->start_time = si.first_field;

  333.         if (si.first_field != AV_NOPTS_VALUE && si.last_field != AV_NOPTS_VALUE)

  334.             st->duration = si.last_field - si.first_field;

  335.     }

  336.     if (len < 0)

  337.         av_log(s, AV_LOG_ERROR, "GXF: invalid track description length specified\n");

  338.     if (map_len)

  339.         url_fskip(pb, map_len);

  340.     if (!parse_packet_header(pb, &pkt_type, &len)) {

  341.         av_log(s, AV_LOG_ERROR, "GXF: sync lost in header\n");

  342.         return -1;

  343.     }

  344.     if (pkt_type == PKT_FLT) {

  345.         gxf_read_index(s, len);

  346.         if (!parse_packet_header(pb, &pkt_type, &len)) {

  347.             av_log(s, AV_LOG_ERROR, "GXF: sync lost in header\n");

  348.             return -1;

  349.         }

  350.     }

  351.     if (pkt_type == PKT_UMF) {

  352.         if (len >= 9) {

  353.             AVRational fps;

  354.             len -= 9;

  355.             url_fskip(pb, 5);

  356.             fps = fps_umf2avr(get_le32(pb));

  357.             if (!main_timebase.num || !main_timebase.den) {

  358.                 // this may not always be correct, but simply the best we can get

  359.                 main_timebase.num = fps.den;

  360.                 main_timebase.den = fps.num;

  361.             }

  362.         } else

  363.             av_log(s, AV_LOG_INFO, "GXF: UMF packet too short\n");

  364.     } else

  365.         av_log(s, AV_LOG_INFO, "GXF: UMF packet missing\n");

  366.     url_fskip(pb, len);

  367.     for (i = 0; i < s->nb_streams; i++) {

  368.         AVStream *st = s->streams[i];

  369.         if (main_timebase.num && main_timebase.den)

  370.             st->time_base = main_timebase;

  371.         else {

  372.             st->start_time = st->duration = AV_NOPTS_VALUE;

  373.         }

  374.     }

  375.     return 0;

  376. }

  377. 

  378. #define READ_ONE() \

  379.     { \

  380.         if (!max_interval-- || url_feof(pb)) \

  381.             goto out; \

  382.         tmp = tmp << 8 | get_byte(pb); \

  383.     }

  384. 

  385. /**

  386.  * \brief resync the stream on the next media packet with specified properties

  387.  * \param max_interval how many bytes to search for matching packet at most

  388.  * \param track track id the media packet must belong to, -1 for any

  389.  * \param timestamp minimum timestamp (== field number) the packet must have, -1 for any

  390.  * \return timestamp of packet found

  391.  */

  392. static int64_t gxf_resync_media(AVFormatContext *s, uint64_t max_interval, int track, int timestamp) {

  393.     uint32_t tmp;

  394.     uint64_t last_pos;

  395.     uint64_t last_found_pos = 0;

  396.     int cur_track;

  397.     int64_t cur_timestamp = AV_NOPTS_VALUE;

  398.     int len;

  399.     ByteIOContext *pb = &s->pb;

  400.     pkt_type_t type;

  401.     tmp = get_be32(pb);

  402. start:

  403.     while (tmp)

  404.         READ_ONE();

  405.     READ_ONE();

  406.     if (tmp != 1)

  407.         goto start;

  408.     last_pos = url_ftell(pb);

  409.     url_fseek(pb, -5, SEEK_CUR);

  410.     if (!parse_packet_header(pb, &type, &len) || type != PKT_MEDIA) {

  411.         url_fseek(pb, last_pos, SEEK_SET);

  412.         goto start;

  413.     }

  414.     get_byte(pb);

  415.     cur_track = get_byte(pb);

  416.     cur_timestamp = get_be32(pb);

  417.     last_found_pos = url_ftell(pb) - 16 - 6;

  418.     if ((track >= 0 && track != cur_track) || (timestamp >= 0 && timestamp > cur_timestamp)) {

  419.         url_fseek(pb, last_pos, SEEK_SET);

  420.         goto start;

  421.     }

  422. out:

  423.     if (last_found_pos)

  424.         url_fseek(pb, last_found_pos, SEEK_SET);

  425.     return cur_timestamp;

  426. }

  427. 

  428. static int gxf_packet(AVFormatContext *s, AVPacket *pkt) {

  429.     ByteIOContext *pb = &s->pb;

  430.     pkt_type_t pkt_type;

  431.     int pkt_len;

  432.     while (!url_feof(pb)) {

  433.         int track_type, track_id, ret;

  434.         int field_nr;

  435.         if (!parse_packet_header(pb, &pkt_type, &pkt_len)) {

  436.             if (!url_feof(pb))

  437.                 av_log(s, AV_LOG_ERROR, "GXF: sync lost\n");

  438.             return -1;

  439.         }

  440.         if (pkt_type == PKT_FLT) {

  441.             gxf_read_index(s, pkt_len);

  442.             continue;

  443.         }

  444.         if (pkt_type != PKT_MEDIA) {

  445.             url_fskip(pb, pkt_len);

  446.             continue;

  447.         }

  448.         if (pkt_len < 16) {

  449.             av_log(s, AV_LOG_ERROR, "GXF: invalid media packet length\n");

  450.             continue;

  451.         }

  452.         pkt_len -= 16;

  453.         track_type = get_byte(pb);

  454.         track_id = get_byte(pb);

  455.         field_nr = get_be32(pb);

  456.         get_be32(pb); // field information

  457.         get_be32(pb); // "timeline" field number

  458.         get_byte(pb); // flags

  459.         get_byte(pb); // reserved

  460.         // NOTE: there is also data length information in the

  461.         // field information, it might be better to take this into account

  462.         // as well.

  463.         ret = av_get_packet(pb, pkt, pkt_len);

  464.         pkt->stream_index = get_sindex(s, track_id, track_type);

  465.         pkt->dts = field_nr;

  466.         return ret;

  467.     }

  468.     return AVERROR_IO;

  469. }

  470. 

  471. static int gxf_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags) {

  472.     uint64_t pos;

  473.     uint64_t maxlen = 100 * 1024 * 1024;

  474.     AVStream *st = s->streams[0];

  475.     int64_t start_time = s->streams[stream_index]->start_time;

  476.     int64_t found;

  477.     int idx;

  478.     if (timestamp < start_time) timestamp = start_time;

  479.     idx = av_index_search_timestamp(st, timestamp - start_time,

  480.                                     AVSEEK_FLAG_ANY | AVSEEK_FLAG_BACKWARD);

  481.     if (idx < 0)

  482.         return -1;

  483.     pos = st->index_entries[idx].pos;

  484.     if (idx < st->nb_index_entries - 2)

  485.         maxlen = st->index_entries[idx + 2].pos - pos;

  486.     maxlen = FFMAX(maxlen, 200 * 1024);

  487.     url_fseek(&s->pb, pos, SEEK_SET);

  488.     found = gxf_resync_media(s, maxlen, -1, timestamp);

  489.     if (ABS(found - timestamp) > 4)

  490.         return -1;

  491.     return 0;

  492. }

  493. 

  494. static int64_t gxf_read_timestamp(AVFormatContext *s, int stream_index,

  495.                                   int64_t *pos, int64_t pos_limit) {

  496.     ByteIOContext *pb = &s->pb;

  497.     int64_t res;

  498.     url_fseek(pb, *pos, SEEK_SET);

  499.     res = gxf_resync_media(s, pos_limit - *pos, -1, -1);

  500.     *pos = url_ftell(pb);

  501.     return res;

  502. }

  503. 

  504. AVInputFormat gxf_demuxer = {

  505.     "gxf",

  506.     "GXF format",

  507.     0,

  508.     gxf_probe,

  509.     gxf_header,

  510.     gxf_packet,

  511.     NULL,

  512.     gxf_seek,

  513.     gxf_read_timestamp,

  514. };