avio: add avio_tell macro as a replacement for url_ftell
[ffmpeg.git] / libavformat / rtpdec_asf.c
index 44c1c83..8c49691 100644 (file)
  */
 
 /**
- * @file libavformat/rtpdec_asf.c
+ * @file
  * @brief Microsoft RTP/ASF support
  * @author Ronald S. Bultje <rbultje@ronald.bitfreak.net>
  */
 
-#include <libavutil/base64.h>
-#include <libavutil/avstring.h>
-#include <libavutil/intreadwrite.h>
+#include "libavutil/base64.h"
+#include "libavutil/avstring.h"
+#include "libavutil/intreadwrite.h"
 #include "rtp.h"
-#include "rtpdec_asf.h"
+#include "rtpdec_formats.h"
 #include "rtsp.h"
 #include "asf.h"
+#include "avio_internal.h"
 
 /**
  * From MSDN 2.2.1.4, we learn that ASF data packets over RTP should not
@@ -72,7 +73,7 @@ static int rtp_asf_fix_header(uint8_t *buf, int len)
 }
 
 /**
- * The following code is basically a buffered ByteIOContext,
+ * The following code is basically a buffered AVIOContext,
  * with the added benefit of returning -EAGAIN (instead of 0)
  * on packet boundaries, such that the ASF demuxer can return
  * safely and resume business at the next packet.
@@ -82,19 +83,20 @@ static int packetizer_read(void *opaque, uint8_t *buf, int buf_size)
     return AVERROR(EAGAIN);
 }
 
-static void init_packetizer(ByteIOContext *pb, uint8_t *buf, int len)
+static void init_packetizer(AVIOContext *pb, uint8_t *buf, int len)
 {
-    init_put_byte(pb, buf, len, 0, NULL, packetizer_read, NULL, NULL);
+    ffio_init_context(pb, buf, len, 0, NULL, packetizer_read, NULL, NULL);
 
     /* this "fills" the buffer with its current content */
     pb->pos     = len;
     pb->buf_end = buf + len;
 }
 
-void ff_wms_parse_sdp_a_line(AVFormatContext *s, const char *p)
+int ff_wms_parse_sdp_a_line(AVFormatContext *s, const char *p)
 {
+    int ret = 0;
     if (av_strstart(p, "pgmpu:data:application/vnd.ms.wms-hdr.asfv1;base64,", &p)) {
-        ByteIOContext pb;
+        AVIOContext pb;
         RTSPState *rt = s->priv_data;
         int len = strlen(p) * 6 / 8;
         char *buf = av_mallocz(len);
@@ -108,11 +110,15 @@ void ff_wms_parse_sdp_a_line(AVFormatContext *s, const char *p)
             av_close_input_stream(rt->asf_ctx);
             rt->asf_ctx = NULL;
         }
-        av_open_input_stream(&rt->asf_ctx, &pb, "", &asf_demuxer, NULL);
-        rt->asf_pb_pos = url_ftell(&pb);
+        ret = av_open_input_stream(&rt->asf_ctx, &pb, "", &ff_asf_demuxer, NULL);
+        if (ret < 0)
+            return ret;
+        av_metadata_copy(&s->metadata, rt->asf_ctx->metadata, 0);
+        rt->asf_pb_pos = avio_tell(&pb);
         av_free(buf);
         rt->asf_ctx->pb = NULL;
     }
+    return ret;
 }
 
 static int asfrtp_parse_sdp_line(AVFormatContext *s, int stream_index,
@@ -142,8 +148,8 @@ static int asfrtp_parse_sdp_line(AVFormatContext *s, int stream_index,
 }
 
 struct PayloadContext {
-    ByteIOContext *pktbuf, pb;
-    char *buf;
+    AVIOContext *pktbuf, pb;
+    uint8_t *buf;
 };
 
 /**
@@ -156,7 +162,7 @@ static int asfrtp_parse_packet(AVFormatContext *s, PayloadContext *asf,
                                uint32_t *timestamp,
                                const uint8_t *buf, int len, int flags)
 {
-    ByteIOContext *pb = &asf->pb;
+    AVIOContext *pb = &asf->pb;
     int res, mflags, len_off;
     RTSPState *rt = s->priv_data;
 
@@ -164,64 +170,72 @@ static int asfrtp_parse_packet(AVFormatContext *s, PayloadContext *asf,
         return -1;
 
     if (len > 0) {
-        int off, out_len;
+        int off, out_len = 0;
 
         if (len < 4)
             return -1;
 
-        init_put_byte(pb, buf, len, 0, NULL, NULL, NULL, NULL);
-        mflags = get_byte(pb);
-        if (mflags & 0x80)
-            flags |= RTP_FLAG_KEY;
-        len_off = get_be24(pb);
-        if (mflags & 0x20)   /**< relative timestamp */
-            url_fskip(pb, 4);
-        if (mflags & 0x10)   /**< has duration */
-            url_fskip(pb, 4);
-        if (mflags & 0x8)    /**< has location ID */
-            url_fskip(pb, 4);
-        off = url_ftell(pb);
-
         av_freep(&asf->buf);
-        if (!(mflags & 0x40)) {
-            /**
-             * If 0x40 is not set, the len_off field specifies an offset of this
-             * packet's payload data in the complete (reassembled) ASF packet.
-             * This is used to spread one ASF packet over multiple RTP packets.
-             */
-            if (asf->pktbuf && len_off != url_ftell(asf->pktbuf)) {
-                uint8_t *p;
-                url_close_dyn_buf(asf->pktbuf, &p);
+
+        ffio_init_context(pb, buf, len, 0, NULL, NULL, NULL, NULL);
+
+        while (avio_tell(pb) + 4 < len) {
+            int start_off = avio_tell(pb);
+
+            mflags = avio_r8(pb);
+            if (mflags & 0x80)
+                flags |= RTP_FLAG_KEY;
+            len_off = avio_rb24(pb);
+            if (mflags & 0x20)   /**< relative timestamp */
+                avio_seek(pb, 4, SEEK_CUR);
+            if (mflags & 0x10)   /**< has duration */
+                avio_seek(pb, 4, SEEK_CUR);
+            if (mflags & 0x8)    /**< has location ID */
+                avio_seek(pb, 4, SEEK_CUR);
+            off = avio_tell(pb);
+
+            if (!(mflags & 0x40)) {
+                /**
+                 * If 0x40 is not set, the len_off field specifies an offset
+                 * of this packet's payload data in the complete (reassembled)
+                 * ASF packet. This is used to spread one ASF packet over
+                 * multiple RTP packets.
+                 */
+                if (asf->pktbuf && len_off != avio_tell(asf->pktbuf)) {
+                    uint8_t *p;
+                    url_close_dyn_buf(asf->pktbuf, &p);
+                    asf->pktbuf = NULL;
+                    av_free(p);
+                }
+                if (!len_off && !asf->pktbuf &&
+                    (res = url_open_dyn_buf(&asf->pktbuf)) < 0)
+                    return res;
+                if (!asf->pktbuf)
+                    return AVERROR(EIO);
+
+                avio_write(asf->pktbuf, buf + off, len - off);
+                avio_seek(pb, len - off, SEEK_CUR);
+                if (!(flags & RTP_FLAG_MARKER))
+                    return -1;
+                out_len     = url_close_dyn_buf(asf->pktbuf, &asf->buf);
                 asf->pktbuf = NULL;
-                av_free(p);
-            }
-            if (!len_off && !asf->pktbuf &&
-                (res = url_open_dyn_buf(&asf->pktbuf)) < 0)
-                return res;
-            if (!asf->pktbuf)
-                return AVERROR(EIO);
-
-            put_buffer(asf->pktbuf, buf + off, len - off);
-            if (!(flags & RTP_FLAG_MARKER))
-                return -1;
-            out_len     = url_close_dyn_buf(asf->pktbuf, &asf->buf);
-            asf->pktbuf = NULL;
-        } else {
-            /**
-             * If 0x40 is set, the len_off field specifies the length of the
-             * next ASF packet that can be read from this payload data alone.
-             * This is commonly the same as the payload size, but could be
-             * less in case of packet splitting (i.e. multiple ASF packets in
-             * one RTP packet).
-             */
-            if (len_off != len) {
-                av_log_missing_feature(s,
-                    "RTSP-MS packet splitting", 1);
-                return -1;
+            } else {
+                /**
+                 * If 0x40 is set, the len_off field specifies the length of
+                 * the next ASF packet that can be read from this payload
+                 * data alone. This is commonly the same as the payload size,
+                 * but could be less in case of packet splitting (i.e.
+                 * multiple ASF packets in one RTP packet).
+                 */
+
+                int cur_len = start_off + len_off - off;
+                int prev_len = out_len;
+                out_len += cur_len;
+                asf->buf = av_realloc(asf->buf, out_len);
+                memcpy(asf->buf + prev_len, buf + off,
+                       FFMIN(cur_len, len - off));
+                avio_seek(pb, cur_len, SEEK_CUR);
             }
-            asf->buf = av_malloc(len - off);
-            out_len  = len - off;
-            memcpy(asf->buf, buf + off, len - off);
         }
 
         init_packetizer(pb, asf->buf, out_len);
@@ -234,7 +248,7 @@ static int asfrtp_parse_packet(AVFormatContext *s, PayloadContext *asf,
         int i;
 
         res = av_read_packet(rt->asf_ctx, pkt);
-        rt->asf_pb_pos = url_ftell(pb);
+        rt->asf_pb_pos = avio_tell(pb);
         if (res != 0)
             break;
         for (i = 0; i < s->nb_streams; i++) {
@@ -275,7 +289,7 @@ RTPDynamicProtocolHandler ff_ms_rtp_ ## n ## _handler = { \
     .open             = asfrtp_new_context, \
     .close            = asfrtp_free_context, \
     .parse_packet     = asfrtp_parse_packet,   \
-};
+}
 
-RTP_ASF_HANDLER(asf_pfv, "x-asf-pf",  CODEC_TYPE_VIDEO);
-RTP_ASF_HANDLER(asf_pfa, "x-asf-pf",  CODEC_TYPE_AUDIO);
+RTP_ASF_HANDLER(asf_pfv, "x-asf-pf",  AVMEDIA_TYPE_VIDEO);
+RTP_ASF_HANDLER(asf_pfa, "x-asf-pf",  AVMEDIA_TYPE_AUDIO);