X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libavformat%2Fgxf.c;h=189584035b21a884e14f7ae3b211e17502250a67;hb=9b56d5c11488656254e9aed8d964ef2b7c2ff5e6;hp=dbc069c1935e04c6851d28c8abdf4071a31d6078;hpb=dd1c8f3e6e5380f993c86750bb09fd42e130143f;p=ffmpeg

diff --git a/libavformat/gxf.c b/libavformat/gxf.c
index dbc069c1935..189584035b2 100644
--- a/libavformat/gxf.c
+++ b/libavformat/gxf.c
@@ -1,63 +1,68 @@
 /*
  * GXF demuxer.
- * Copyright (c) 2006 Reimar Doeffinger.
+ * Copyright (c) 2006 Reimar Doeffinger
  *
- * This file is part of FFmpeg.
+ * This file is part of Libav.
  *
- * FFmpeg is free software; you can redistribute it and/or
+ * Libav is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *
- * FFmpeg is distributed in the hope that it will be useful,
+ * Libav is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
+ * License along with Libav; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
+#include <inttypes.h>
+
+#include "libavutil/channel_layout.h"
 #include "libavutil/common.h"
 #include "avformat.h"
+#include "internal.h"
 #include "gxf.h"
+#include "libavcodec/mpeg12data.h"
 
-typedef struct {
+struct gxf_stream_info {
     int64_t first_field;
     int64_t last_field;
     AVRational frames_per_second;
     int32_t fields_per_frame;
-} st_info_t;
+};
 
 /**
- * \brief parses a packet header, extracting type and length
- * \param pb ByteIOContext to read header from
- * \param type detected packet type is stored here
- * \param length detected packet length, excluding header is stored here
- * \return 0 if header not found or contains invalid data, 1 otherwise
+ * @brief parses a packet header, extracting type and length
+ * @param pb AVIOContext to read header from
+ * @param type detected packet type is stored here
+ * @param length detected packet length, excluding header is stored here
+ * @return 0 if header not found or contains invalid data, 1 otherwise
  */
-static int parse_packet_header(ByteIOContext *pb, pkt_type_t *type, int *length) {
-    if (get_be32(pb))
+static int parse_packet_header(AVIOContext *pb, GXFPktType *type, int *length) {
+    if (avio_rb32(pb))
         return 0;
-    if (get_byte(pb) != 1)
+    if (avio_r8(pb) != 1)
         return 0;
-    *type = get_byte(pb);
-    *length = get_be32(pb);
+    *type = avio_r8(pb);
+    *length = avio_rb32(pb);
     if ((*length >> 24) || *length < 16)
         return 0;
     *length -= 16;
-    if (get_be32(pb))
+    if (avio_rb32(pb))
         return 0;
-    if (get_byte(pb) != 0xe1)
+    if (avio_r8(pb) != 0xe1)
         return 0;
-    if (get_byte(pb) != 0xe2)
+    if (avio_r8(pb) != 0xe2)
         return 0;
     return 1;
 }
 
 /**
- * \brief check if file starts with a PKT_MAP header
+ * @brief check if file starts with a PKT_MAP header
  */
 static int gxf_probe(AVProbeData *p) {
     static const uint8_t startcode[] = {0, 0, 0, 0, 1, 0xbc}; // start with map packet
@@ -69,130 +74,144 @@ static int gxf_probe(AVProbeData *p) {
 }
 
 /**
- * \brief gets the stream index for the track with the specified id, creates new
+ * @brief gets the stream index for the track with the specified id, creates new
  *        stream if not found
- * \param stream id of stream to find / add
- * \param format stream format identifier
+ * @param id     id of stream to find / add
+ * @param format stream format identifier
  */
 static int get_sindex(AVFormatContext *s, int id, int format) {
     int i;
     AVStream *st = NULL;
-    for (i = 0; i < s->nb_streams; i++) {
-        if (s->streams[i]->id == id)
-            return i;
-    }
-    st = av_new_stream(s, id);
+    i = ff_find_stream_index(s, id);
+    if (i >= 0)
+        return i;
+    st = avformat_new_stream(s, NULL);
     if (!st)
         return AVERROR(ENOMEM);
+    st->id = id;
     switch (format) {
         case 3:
         case 4:
-            st->codec->codec_type = CODEC_TYPE_VIDEO;
-            st->codec->codec_id = CODEC_ID_MJPEG;
+            st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
+            st->codec->codec_id = AV_CODEC_ID_MJPEG;
             break;
         case 13:
         case 15:
-            st->codec->codec_type = CODEC_TYPE_VIDEO;
-            st->codec->codec_id = CODEC_ID_DVVIDEO;
+            st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
+            st->codec->codec_id = AV_CODEC_ID_DVVIDEO;
             break;
         case 14:
         case 16:
-            st->codec->codec_type = CODEC_TYPE_VIDEO;
-            st->codec->codec_id = CODEC_ID_DVVIDEO;
+            st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
+            st->codec->codec_id = AV_CODEC_ID_DVVIDEO;
             break;
         case 11:
         case 12:
         case 20:
-            st->codec->codec_type = CODEC_TYPE_VIDEO;
-            st->codec->codec_id = CODEC_ID_MPEG2VIDEO;
+            st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
+            st->codec->codec_id = AV_CODEC_ID_MPEG2VIDEO;
             st->need_parsing = AVSTREAM_PARSE_HEADERS; //get keyframe flag etc.
             break;
         case 22:
         case 23:
-            st->codec->codec_type = CODEC_TYPE_VIDEO;
-            st->codec->codec_id = CODEC_ID_MPEG1VIDEO;
+            st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
+            st->codec->codec_id = AV_CODEC_ID_MPEG1VIDEO;
             st->need_parsing = AVSTREAM_PARSE_HEADERS; //get keyframe flag etc.
             break;
         case 9:
-            st->codec->codec_type = CODEC_TYPE_AUDIO;
-            st->codec->codec_id = CODEC_ID_PCM_S24LE;
+            st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
+            st->codec->codec_id = AV_CODEC_ID_PCM_S24LE;
             st->codec->channels = 1;
+            st->codec->channel_layout = AV_CH_LAYOUT_MONO;
             st->codec->sample_rate = 48000;
             st->codec->bit_rate = 3 * 1 * 48000 * 8;
             st->codec->block_align = 3 * 1;
             st->codec->bits_per_coded_sample = 24;
             break;
         case 10:
-            st->codec->codec_type = CODEC_TYPE_AUDIO;
-            st->codec->codec_id = CODEC_ID_PCM_S16LE;
+            st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
+            st->codec->codec_id = AV_CODEC_ID_PCM_S16LE;
             st->codec->channels = 1;
+            st->codec->channel_layout = AV_CH_LAYOUT_MONO;
             st->codec->sample_rate = 48000;
             st->codec->bit_rate = 2 * 1 * 48000 * 8;
             st->codec->block_align = 2 * 1;
             st->codec->bits_per_coded_sample = 16;
             break;
         case 17:
-            st->codec->codec_type = CODEC_TYPE_AUDIO;
-            st->codec->codec_id = CODEC_ID_AC3;
+            st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
+            st->codec->codec_id = AV_CODEC_ID_AC3;
             st->codec->channels = 2;
+            st->codec->channel_layout = AV_CH_LAYOUT_STEREO;
             st->codec->sample_rate = 48000;
             break;
         // timecode tracks:
         case 7:
         case 8:
         case 24:
-            st->codec->codec_type = CODEC_TYPE_DATA;
-            st->codec->codec_id = CODEC_ID_NONE;
+            st->codec->codec_type = AVMEDIA_TYPE_DATA;
+            st->codec->codec_id = AV_CODEC_ID_NONE;
             break;
         default:
-            st->codec->codec_type = CODEC_TYPE_UNKNOWN;
-            st->codec->codec_id = CODEC_ID_NONE;
+            st->codec->codec_type = AVMEDIA_TYPE_UNKNOWN;
+            st->codec->codec_id = AV_CODEC_ID_NONE;
             break;
     }
     return s->nb_streams - 1;
 }
 
 /**
- * \brief filters out interesting tags from material information.
- * \param len length of tag section, will be adjusted to contain remaining bytes
- * \param si struct to store collected information into
+ * @brief filters out interesting tags from material information.
+ * @param len length of tag section, will be adjusted to contain remaining bytes
+ * @param si struct to store collected information into
  */
-static void gxf_material_tags(ByteIOContext *pb, int *len, st_info_t *si) {
+static void gxf_material_tags(AVIOContext *pb, int *len, struct gxf_stream_info *si) {
     si->first_field = AV_NOPTS_VALUE;
     si->last_field = AV_NOPTS_VALUE;
     while (*len >= 2) {
-        mat_tag_t tag = get_byte(pb);
-        int tlen = get_byte(pb);
+        GXFMatTag tag = avio_r8(pb);
+        int tlen = avio_r8(pb);
         *len -= 2;
         if (tlen > *len)
             return;
         *len -= tlen;
         if (tlen == 4) {
-            uint32_t value = get_be32(pb);
+            uint32_t value = avio_rb32(pb);
             if (tag == MAT_FIRST_FIELD)
                 si->first_field = value;
             else if (tag == MAT_LAST_FIELD)
                 si->last_field = value;
         } else
-            url_fskip(pb, tlen);
+            avio_skip(pb, tlen);
     }
 }
 
+static const AVRational frame_rate_tab[] = {
+    {   60,    1},
+    {60000, 1001},
+    {   50,    1},
+    {   30,    1},
+    {30000, 1001},
+    {   25,    1},
+    {   24,    1},
+    {24000, 1001},
+    {    0,    0},
+};
+
 /**
- * \brief convert fps tag value to AVRational fps
- * \param fps fps value from tag
- * \return fps as AVRational, or 0 / 0 if unknown
+ * @brief convert fps tag value to AVRational fps
+ * @param fps fps value from tag
+ * @return fps as AVRational, or 0 / 0 if unknown
  */
 static AVRational fps_tag2avr(int32_t fps) {
-    extern const AVRational ff_frame_rate_tab[];
     if (fps < 1 || fps > 9) fps = 9;
-    return ff_frame_rate_tab[9 - fps]; // values have opposite order
+    return frame_rate_tab[fps - 1];
 }
 
 /**
- * \brief convert UMF attributes flags to AVRational fps
- * \param fps fps value from flags
- * \return fps as AVRational, or 0 / 0 if unknown
+ * @brief convert UMF attributes flags to AVRational fps
+ * @param flags UMF flags to convert
+ * @return fps as AVRational, or 0 / 0 if unknown
  */
 static AVRational fps_umf2avr(uint32_t flags) {
     static const AVRational map[] = {{50, 1}, {60000, 1001}, {24, 1},
@@ -202,88 +221,94 @@ static AVRational fps_umf2avr(uint32_t flags) {
 }
 
 /**
- * \brief filters out interesting tags from track information.
- * \param len length of tag section, will be adjusted to contain remaining bytes
- * \param si struct to store collected information into
+ * @brief filters out interesting tags from track information.
+ * @param len length of tag section, will be adjusted to contain remaining bytes
+ * @param si struct to store collected information into
  */
-static void gxf_track_tags(ByteIOContext *pb, int *len, st_info_t *si) {
+static void gxf_track_tags(AVIOContext *pb, int *len, struct gxf_stream_info *si) {
     si->frames_per_second = (AVRational){0, 0};
     si->fields_per_frame = 0;
     while (*len >= 2) {
-        track_tag_t tag = get_byte(pb);
-        int tlen = get_byte(pb);
+        GXFTrackTag tag = avio_r8(pb);
+        int tlen = avio_r8(pb);
         *len -= 2;
         if (tlen > *len)
             return;
         *len -= tlen;
         if (tlen == 4) {
-            uint32_t value = get_be32(pb);
+            uint32_t value = avio_rb32(pb);
             if (tag == TRACK_FPS)
                 si->frames_per_second = fps_tag2avr(value);
             else if (tag == TRACK_FPF && (value == 1 || value == 2))
                 si->fields_per_frame = value;
         } else
-            url_fskip(pb, tlen);
+            avio_skip(pb, tlen);
     }
 }
 
 /**
- * \brief read index from FLT packet into stream 0 av_index
+ * @brief read index from FLT packet into stream 0 av_index
  */
 static void gxf_read_index(AVFormatContext *s, int pkt_len) {
-    ByteIOContext *pb = s->pb;
+    AVIOContext *pb = s->pb;
     AVStream *st = s->streams[0];
-    uint32_t fields_per_map = get_le32(pb);
-    uint32_t map_cnt = get_le32(pb);
+    uint32_t fields_per_map = avio_rl32(pb);
+    uint32_t map_cnt = avio_rl32(pb);
     int i;
     pkt_len -= 8;
+    if (s->flags & AVFMT_FLAG_IGNIDX) {
+        avio_skip(pb, pkt_len);
+        return;
+    }
     if (map_cnt > 1000) {
-        av_log(s, AV_LOG_ERROR, "GXF: too many index entries %u (%x)\n", map_cnt, map_cnt);
+        av_log(s, AV_LOG_ERROR,
+               "too many index entries %"PRIu32" (%"PRIx32")\n",
+               map_cnt, map_cnt);
         map_cnt = 1000;
     }
     if (pkt_len < 4 * map_cnt) {
-        av_log(s, AV_LOG_ERROR, "GXF: invalid index length\n");
-        url_fskip(pb, pkt_len);
+        av_log(s, AV_LOG_ERROR, "invalid index length\n");
+        avio_skip(pb, pkt_len);
         return;
     }
     pkt_len -= 4 * map_cnt;
     av_add_index_entry(st, 0, 0, 0, 0, 0);
     for (i = 0; i < map_cnt; i++)
-        av_add_index_entry(st, (uint64_t)get_le32(pb) * 1024,
+        av_add_index_entry(st, (uint64_t)avio_rl32(pb) * 1024,
                            i * (uint64_t)fields_per_map + 1, 0, 0, 0);
-    url_fskip(pb, pkt_len);
+    avio_skip(pb, pkt_len);
 }
 
-static int gxf_header(AVFormatContext *s, AVFormatParameters *ap) {
-    ByteIOContext *pb = s->pb;
-    pkt_type_t pkt_type;
+static int gxf_header(AVFormatContext *s) {
+    AVIOContext *pb = s->pb;
+    GXFPktType pkt_type;
     int map_len;
     int len;
     AVRational main_timebase = {0, 0};
-    st_info_t si;
+    struct gxf_stream_info *si = s->priv_data;
     int i;
     if (!parse_packet_header(pb, &pkt_type, &map_len) || pkt_type != PKT_MAP) {
-        av_log(s, AV_LOG_ERROR, "GXF: map packet not found\n");
+        av_log(s, AV_LOG_ERROR, "map packet not found\n");
         return 0;
     }
     map_len -= 2;
-    if (get_byte(pb) != 0x0e0 || get_byte(pb) != 0xff) {
-        av_log(s, AV_LOG_ERROR, "GXF: unknown version or invalid map preamble\n");
+    if (avio_r8(pb) != 0x0e0 || avio_r8(pb) != 0xff) {
+        av_log(s, AV_LOG_ERROR, "unknown version or invalid map preamble\n");
         return 0;
     }
     map_len -= 2;
-    len = get_be16(pb); // length of material data section
+    len = avio_rb16(pb); // length of material data section
     if (len > map_len) {
-        av_log(s, AV_LOG_ERROR, "GXF: material data longer than map data\n");
+        av_log(s, AV_LOG_ERROR, "material data longer than map data\n");
         return 0;
     }
     map_len -= len;
-    gxf_material_tags(pb, &len, &si);
-    url_fskip(pb, len);
+    gxf_material_tags(pb, &len, si);
+    avio_skip(pb, len);
     map_len -= 2;
-    len = get_be16(pb); // length of track description
+    len = avio_rb16(pb); // length of track description
     if (len > map_len) {
-        av_log(s, AV_LOG_ERROR, "GXF: track description longer than map data\n");
+        av_log(s, AV_LOG_ERROR, "track description longer than map data\n");
         return 0;
     }
     map_len -= len;
@@ -292,19 +317,19 @@ static int gxf_header(AVFormatContext *s, AVFormatParameters *ap) {
         AVStream *st;
         int idx;
         len -= 4;
-        track_type = get_byte(pb);
-        track_id = get_byte(pb);
-        track_len = get_be16(pb);
+        track_type = avio_r8(pb);
+        track_id = avio_r8(pb);
+        track_len = avio_rb16(pb);
         len -= track_len;
-        gxf_track_tags(pb, &track_len, &si);
-        url_fskip(pb, track_len);
+        gxf_track_tags(pb, &track_len, si);
+        avio_skip(pb, track_len);
         if (!(track_type & 0x80)) {
-           av_log(s, AV_LOG_ERROR, "GXF: invalid track type %x\n", track_type);
+           av_log(s, AV_LOG_ERROR, "invalid track type %x\n", track_type);
            continue;
         }
         track_type &= 0x7f;
         if ((track_id & 0xc0) != 0xc0) {
-           av_log(s, AV_LOG_ERROR, "GXF: invalid track id %x\n", track_id);
+           av_log(s, AV_LOG_ERROR, "invalid track id %x\n", track_id);
            continue;
         }
         track_id &= 0x3f;
@@ -312,25 +337,25 @@ static int gxf_header(AVFormatContext *s, AVFormatParameters *ap) {
         if (idx < 0) continue;
         st = s->streams[idx];
         if (!main_timebase.num || !main_timebase.den) {
-            main_timebase.num = si.frames_per_second.den;
-            main_timebase.den = si.frames_per_second.num * si.fields_per_frame;
+            main_timebase.num = si->frames_per_second.den;
+            main_timebase.den = si->frames_per_second.num * 2;
         }
-        st->start_time = si.first_field;
-        if (si.first_field != AV_NOPTS_VALUE && si.last_field != AV_NOPTS_VALUE)
-            st->duration = si.last_field - si.first_field;
+        st->start_time = si->first_field;
+        if (si->first_field != AV_NOPTS_VALUE && si->last_field != AV_NOPTS_VALUE)
+            st->duration = si->last_field - si->first_field;
     }
     if (len < 0)
-        av_log(s, AV_LOG_ERROR, "GXF: invalid track description length specified\n");
+        av_log(s, AV_LOG_ERROR, "invalid track description length specified\n");
     if (map_len)
-        url_fskip(pb, map_len);
+        avio_skip(pb, map_len);
     if (!parse_packet_header(pb, &pkt_type, &len)) {
-        av_log(s, AV_LOG_ERROR, "GXF: sync lost in header\n");
+        av_log(s, AV_LOG_ERROR, "sync lost in header\n");
         return -1;
     }
     if (pkt_type == PKT_FLT) {
         gxf_read_index(s, len);
         if (!parse_packet_header(pb, &pkt_type, &len)) {
-            av_log(s, AV_LOG_ERROR, "GXF: sync lost in header\n");
+            av_log(s, AV_LOG_ERROR, "sync lost in header\n");
             return -1;
         }
     }
@@ -338,41 +363,43 @@ static int gxf_header(AVFormatContext *s, AVFormatParameters *ap) {
         if (len >= 0x39) {
             AVRational fps;
             len -= 0x39;
-            url_fskip(pb, 5); // preamble
-            url_fskip(pb, 0x30); // payload description
-            fps = fps_umf2avr(get_le32(pb));
+            avio_skip(pb, 5); // preamble
+            avio_skip(pb, 0x30); // payload description
+            fps = fps_umf2avr(avio_rl32(pb));
             if (!main_timebase.num || !main_timebase.den) {
                 // this may not always be correct, but simply the best we can get
                 main_timebase.num = fps.den;
-                main_timebase.den = fps.num;
+                main_timebase.den = fps.num * 2;
             }
         } else
-            av_log(s, AV_LOG_INFO, "GXF: UMF packet too short\n");
+            av_log(s, AV_LOG_INFO, "UMF packet too short\n");
     } else
-        av_log(s, AV_LOG_INFO, "GXF: UMF packet missing\n");
-    url_fskip(pb, len);
+        av_log(s, AV_LOG_INFO, "UMF packet missing\n");
+    avio_skip(pb, len);
+    // set a fallback value, 60000/1001 is specified for audio-only files
+    // so use that regardless of why we do not know the video frame rate.
     if (!main_timebase.num || !main_timebase.den)
-        main_timebase = (AVRational){1, 50}; // set some arbitrary fallback
+        main_timebase = (AVRational){1001, 60000};
     for (i = 0; i < s->nb_streams; i++) {
         AVStream *st = s->streams[i];
-        av_set_pts_info(st, 32, main_timebase.num, main_timebase.den);
+        avpriv_set_pts_info(st, 32, main_timebase.num, main_timebase.den);
     }
     return 0;
 }
 
 #define READ_ONE() \
     { \
-        if (!max_interval-- || url_feof(pb)) \
+        if (!max_interval-- || pb->eof_reached) \
             goto out; \
-        tmp = tmp << 8 | get_byte(pb); \
+        tmp = tmp << 8 | avio_r8(pb); \
     }
 
 /**
- * \brief resync the stream on the next media packet with specified properties
- * \param max_interval how many bytes to search for matching packet at most
- * \param track track id the media packet must belong to, -1 for any
- * \param timestamp minimum timestamp (== field number) the packet must have, -1 for any
- * \return timestamp of packet found
+ * @brief resync the stream on the next media packet with specified properties
+ * @param max_interval how many bytes to search for matching packet at most
+ * @param track track id the media packet must belong to, -1 for any
+ * @param timestamp minimum timestamp (== field number) the packet must have, -1 for any
+ * @return timestamp of packet found
  */
 static int64_t gxf_resync_media(AVFormatContext *s, uint64_t max_interval, int track, int timestamp) {
     uint32_t tmp;
@@ -381,46 +408,51 @@ static int64_t gxf_resync_media(AVFormatContext *s, uint64_t max_interval, int t
     int cur_track;
     int64_t cur_timestamp = AV_NOPTS_VALUE;
     int len;
-    ByteIOContext *pb = s->pb;
-    pkt_type_t type;
-    tmp = get_be32(pb);
+    AVIOContext *pb = s->pb;
+    GXFPktType type;
+    tmp = avio_rb32(pb);
 start:
     while (tmp)
         READ_ONE();
     READ_ONE();
     if (tmp != 1)
         goto start;
-    last_pos = url_ftell(pb);
-    url_fseek(pb, -5, SEEK_CUR);
+    last_pos = avio_tell(pb);
+    if (avio_seek(pb, -5, SEEK_CUR) < 0)
+        goto out;
     if (!parse_packet_header(pb, &type, &len) || type != PKT_MEDIA) {
-        url_fseek(pb, last_pos, SEEK_SET);
+        if (avio_seek(pb, last_pos, SEEK_SET) < 0)
+            goto out;
         goto start;
     }
-    get_byte(pb);
-    cur_track = get_byte(pb);
-    cur_timestamp = get_be32(pb);
-    last_found_pos = url_ftell(pb) - 16 - 6;
+    avio_r8(pb);
+    cur_track = avio_r8(pb);
+    cur_timestamp = avio_rb32(pb);
+    last_found_pos = avio_tell(pb) - 16 - 6;
     if ((track >= 0 && track != cur_track) || (timestamp >= 0 && timestamp > cur_timestamp)) {
-        url_fseek(pb, last_pos, SEEK_SET);
-        goto start;
+        if (avio_seek(pb, last_pos, SEEK_SET) >= 0)
+            goto start;
     }
 out:
     if (last_found_pos)
-        url_fseek(pb, last_found_pos, SEEK_SET);
+        avio_seek(pb, last_found_pos, SEEK_SET);
     return cur_timestamp;
 }
 
 static int gxf_packet(AVFormatContext *s, AVPacket *pkt) {
-    ByteIOContext *pb = s->pb;
-    pkt_type_t pkt_type;
+    AVIOContext *pb = s->pb;
+    GXFPktType pkt_type;
     int pkt_len;
-    while (!url_feof(pb)) {
+    struct gxf_stream_info *si = s->priv_data;
+
+    while (!pb->eof_reached) {
+        AVStream *st;
         int track_type, track_id, ret;
-        int field_nr;
+        int field_nr, field_info, skip = 0;
         int stream_index;
         if (!parse_packet_header(pb, &pkt_type, &pkt_len)) {
-            if (!url_feof(pb))
-                av_log(s, AV_LOG_ERROR, "GXF: sync lost\n");
+            if (!pb->eof_reached)
+                av_log(s, AV_LOG_ERROR, "sync lost\n");
             return -1;
         }
         if (pkt_type == PKT_FLT) {
@@ -428,36 +460,54 @@ static int gxf_packet(AVFormatContext *s, AVPacket *pkt) {
             continue;
         }
         if (pkt_type != PKT_MEDIA) {
-            url_fskip(pb, pkt_len);
+            avio_skip(pb, pkt_len);
             continue;
         }
         if (pkt_len < 16) {
-            av_log(s, AV_LOG_ERROR, "GXF: invalid media packet length\n");
+            av_log(s, AV_LOG_ERROR, "invalid media packet length\n");
             continue;
         }
         pkt_len -= 16;
-        track_type = get_byte(pb);
-        track_id = get_byte(pb);
+        track_type = avio_r8(pb);
+        track_id = avio_r8(pb);
         stream_index = get_sindex(s, track_id, track_type);
         if (stream_index < 0)
             return stream_index;
-        field_nr = get_be32(pb);
-        get_be32(pb); // field information
-        get_be32(pb); // "timeline" field number
-        get_byte(pb); // flags
-        get_byte(pb); // reserved
-        // NOTE: there is also data length information in the
-        // field information, it might be better to take this into account
-        // as well.
+        st = s->streams[stream_index];
+        field_nr = avio_rb32(pb);
+        field_info = avio_rb32(pb);
+        avio_rb32(pb); // "timeline" field number
+        avio_r8(pb); // flags
+        avio_r8(pb); // reserved
+        if (st->codec->codec_id == AV_CODEC_ID_PCM_S24LE ||
+            st->codec->codec_id == AV_CODEC_ID_PCM_S16LE) {
+            int first = field_info >> 16;
+            int last  = field_info & 0xffff; // last is exclusive
+            int bps = av_get_bits_per_sample(st->codec->codec_id)>>3;
+            if (first <= last && last*bps <= pkt_len) {
+                avio_skip(pb, first*bps);
+                skip = pkt_len - last*bps;
+                pkt_len = (last-first)*bps;
+            } else
+                av_log(s, AV_LOG_ERROR, "invalid first and last sample values\n");
+        }
         ret = av_get_packet(pb, pkt, pkt_len);
+        if (skip)
+            avio_skip(pb, skip);
         pkt->stream_index = stream_index;
         pkt->dts = field_nr;
+
+        //set duration manually for DV or else lavf misdetects the frame rate
+        if (st->codec->codec_id == AV_CODEC_ID_DVVIDEO)
+            pkt->duration = si->fields_per_frame;
+
         return ret;
     }
     return AVERROR(EIO);
 }
 
 static int gxf_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags) {
+    int res = 0;
     uint64_t pos;
     uint64_t maxlen = 100 * 1024 * 1024;
     AVStream *st = s->streams[0];
@@ -473,7 +523,9 @@ static int gxf_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int
     if (idx < st->nb_index_entries - 2)
         maxlen = st->index_entries[idx + 2].pos - pos;
     maxlen = FFMAX(maxlen, 200 * 1024);
-    url_fseek(s->pb, pos, SEEK_SET);
+    res = avio_seek(s->pb, pos, SEEK_SET);
+    if (res < 0)
+        return res;
     found = gxf_resync_media(s, maxlen, -1, timestamp);
     if (FFABS(found - timestamp) > 4)
         return -1;
@@ -482,22 +534,22 @@ static int gxf_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int
 
 static int64_t gxf_read_timestamp(AVFormatContext *s, int stream_index,
                                   int64_t *pos, int64_t pos_limit) {
-    ByteIOContext *pb = s->pb;
+    AVIOContext *pb = s->pb;
     int64_t res;
-    url_fseek(pb, *pos, SEEK_SET);
+    if (avio_seek(pb, *pos, SEEK_SET) < 0)
+        return AV_NOPTS_VALUE;
     res = gxf_resync_media(s, pos_limit - *pos, -1, -1);
-    *pos = url_ftell(pb);
+    *pos = avio_tell(pb);
     return res;
 }
 
-AVInputFormat gxf_demuxer = {
-    "gxf",
-    NULL_IF_CONFIG_SMALL("GXF format"),
-    0,
-    gxf_probe,
-    gxf_header,
-    gxf_packet,
-    NULL,
-    gxf_seek,
-    gxf_read_timestamp,
+AVInputFormat ff_gxf_demuxer = {
+    .name           = "gxf",
+    .long_name      = NULL_IF_CONFIG_SMALL("GXF (General eXchange Format)"),
+    .priv_data_size = sizeof(struct gxf_stream_info),
+    .read_probe     = gxf_probe,
+    .read_header    = gxf_header,
+    .read_packet    = gxf_packet,
+    .read_seek      = gxf_seek,
+    .read_timestamp = gxf_read_timestamp,
 };