Merge remote-tracking branch 'qatar/master'

* qatar/master: (21 commits)
  CDXL demuxer and decoder
  hls: Re-add legacy applehttp name to preserve interface compatibility.
  hlsproto: Rename the functions and context
  hlsproto: Encourage users to try the hls demuxer instead of the proto
  doc: Move the hls protocol section into the right place
  libavformat: Rename the applehttp protocol to hls
  hls: Rename the functions and context
  libavformat: Rename the applehttp demuxer to hls
  rtpdec: Support H263 in RFC 2190 format
  rv30: check block type validity
  ttadec: CRC checking
  movenc: Support muxing VC1
  avconv: Don't split out inline sequence headers when stream copying VC1
  rv34: handle size changes during frame multithreading
  rv40: prevent undefined signed overflow in rv40_loop_filter()
  rv34: use AVERROR return values in ff_rv34_decode_frame()
  rv34: use uint16_t for RV34DecContext.deblock_coefs
  librtmp: Add "lib" prefix to librtmp URLProtocol declarations.
  movenc: Use defines instead of hardcoded numbers for RTCP types
  smjpegdec: implement seeking
  ...

Conflicts:
	Changelog
	doc/general.texi
	libavcodec/avcodec.h
	libavcodec/rv30.c
	libavcodec/tta.c
	libavcodec/version.h
	libavformat/Makefile
	libavformat/allformats.c
	libavformat/version.h
	libswscale/x86/swscale_mmx.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>

14 files changed, 643 insertions, 64 deletions

diff --git a/libavformat/Makefile b/libavformat/Makefile
index 45d2aa3ca7..634d39b821 100644
--- a/libavformat/Makefile
+++ b/libavformat/Makefile
@@ -37,7 +37,6 @@ OBJS-$(CONFIG_AMR_MUXER)                 += amr.o
 OBJS-$(CONFIG_ANM_DEMUXER)               += anm.o
 OBJS-$(CONFIG_APC_DEMUXER)               += apc.o
 OBJS-$(CONFIG_APE_DEMUXER)               += ape.o apetag.o
-OBJS-$(CONFIG_APPLEHTTP_DEMUXER)         += applehttp.o
 OBJS-$(CONFIG_ASF_DEMUXER)               += asfdec.o asf.o asfcrypt.o \
                                             avlanguage.o
 OBJS-$(CONFIG_ASF_MUXER)                 += asfenc.o asf.o
@@ -64,6 +63,7 @@ OBJS-$(CONFIG_CAF_MUXER)                 += cafenc.o caf.o riff.o isom.o
 OBJS-$(CONFIG_CAVSVIDEO_DEMUXER)         += cavsvideodec.o rawdec.o
 OBJS-$(CONFIG_CAVSVIDEO_MUXER)           += rawenc.o
 OBJS-$(CONFIG_CDG_DEMUXER)               += cdg.o
+OBJS-$(CONFIG_CDXL_DEMUXER)              += cdxl.o
 OBJS-$(CONFIG_CRC_MUXER)                 += crcenc.o
 OBJS-$(CONFIG_DAUD_DEMUXER)              += daud.o
 OBJS-$(CONFIG_DAUD_MUXER)                += daud.o
@@ -114,6 +114,7 @@ OBJS-$(CONFIG_H263_DEMUXER)              += h263dec.o rawdec.o
 OBJS-$(CONFIG_H263_MUXER)                += rawenc.o
 OBJS-$(CONFIG_H264_DEMUXER)              += h264dec.o rawdec.o
 OBJS-$(CONFIG_H264_MUXER)                += rawenc.o
+OBJS-$(CONFIG_HLS_DEMUXER)               += hls.o
 OBJS-$(CONFIG_ICO_DEMUXER)               += icodec.o
 OBJS-$(CONFIG_IDCIN_DEMUXER)             += idcin.o
 OBJS-$(CONFIG_IDF_DEMUXER)               += bintext.o
@@ -270,6 +271,7 @@ OBJS-$(CONFIG_RTPDEC)                    += rdt.o         \
                                             rtpdec_asf.o  \
                                             rtpdec_g726.o \
                                             rtpdec_h263.o \
+                                            rtpdec_h263_rfc2190.o \
                                             rtpdec_h264.o \
                                             rtpdec_latm.o \
                                             rtpdec_mpeg4.o \
@@ -344,16 +346,18 @@ OBJS-$(CONFIG_YUV4MPEGPIPE_DEMUXER)      += yuv4mpeg.o
 OBJS-$(CONFIG_LIBMODPLUG_DEMUXER)        += libmodplug.o
 OBJS-$(CONFIG_LIBNUT_DEMUXER)            += libnut.o
 OBJS-$(CONFIG_LIBNUT_MUXER)              += libnut.o
+OBJS-$(CONFIG_LIBRTMP)                   += librtmp.o
 
 # protocols I/O
 OBJS+= avio.o aviobuf.o
 
-OBJS-$(CONFIG_APPLEHTTP_PROTOCOL)        += applehttpproto.o
+OBJS-$(CONFIG_APPLEHTTP_PROTOCOL)        += hlsproto.o
 OBJS-$(CONFIG_CACHE_PROTOCOL)            += cache.o
 OBJS-$(CONFIG_CONCAT_PROTOCOL)           += concat.o
 OBJS-$(CONFIG_CRYPTO_PROTOCOL)           += crypto.o
 OBJS-$(CONFIG_FILE_PROTOCOL)             += file.o
 OBJS-$(CONFIG_GOPHER_PROTOCOL)           += gopher.o
+OBJS-$(CONFIG_HLS_PROTOCOL)              += hlsproto.o
 OBJS-$(CONFIG_HTTP_PROTOCOL)             += http.o httpauth.o
 OBJS-$(CONFIG_HTTPPROXY_PROTOCOL)        += http.o httpauth.o
 OBJS-$(CONFIG_HTTPS_PROTOCOL)            += http.o httpauth.o
@@ -361,12 +365,7 @@ OBJS-$(CONFIG_MMSH_PROTOCOL)             += mmsh.o mms.o asf.o
 OBJS-$(CONFIG_MMST_PROTOCOL)             += mmst.o mms.o asf.o
 OBJS-$(CONFIG_MD5_PROTOCOL)              += md5proto.o
 OBJS-$(CONFIG_PIPE_PROTOCOL)             += file.o
-
-# external or internal rtmp
-RTMP-OBJS-$(CONFIG_LIBRTMP)               = librtmp.o
-RTMP-OBJS-$(!CONFIG_LIBRTMP)              = rtmpproto.o rtmppkt.o
-OBJS-$(CONFIG_RTMP_PROTOCOL)             += $(RTMP-OBJS-yes)
-
+OBJS-$(CONFIG_RTMP_PROTOCOL)             += rtmpproto.o rtmppkt.o
 OBJS-$(CONFIG_RTP_PROTOCOL)              += rtpproto.o
 OBJS-$(CONFIG_TCP_PROTOCOL)              += tcp.o
 OBJS-$(CONFIG_TLS_PROTOCOL)              += tls.o
diff --git a/libavformat/allformats.c b/libavformat/allformats.c
index 8b1c525217..7648f7fe7b 100644
--- a/libavformat/allformats.c
+++ b/libavformat/allformats.c
@@ -22,6 +22,7 @@
 #include "rtp.h"
 #include "rdt.h"
 #include "url.h"
+#include "version.h"
 
 #define REGISTER_MUXER(X,x) { \
     extern AVOutputFormat ff_##x##_muxer; \
@@ -61,7 +62,6 @@ void av_register_all(void)
     REGISTER_DEMUXER  (ANM, anm);
     REGISTER_DEMUXER  (APC, apc);
     REGISTER_DEMUXER  (APE, ape);
-    REGISTER_DEMUXER  (APPLEHTTP, applehttp);
     REGISTER_MUXDEMUX (ASF, asf);
     REGISTER_MUXDEMUX (ASS, ass);
     REGISTER_MUXER    (ASF_STREAM, asf_stream);
@@ -80,6 +80,7 @@ void av_register_all(void)
     REGISTER_MUXDEMUX (CAF, caf);
     REGISTER_MUXDEMUX (CAVSVIDEO, cavsvideo);
     REGISTER_DEMUXER  (CDG, cdg);
+    REGISTER_DEMUXER  (CDXL, cdxl);
     REGISTER_MUXER    (CRC, crc);
     REGISTER_MUXDEMUX (DAUD, daud);
     REGISTER_DEMUXER  (DFA, dfa);
@@ -110,6 +111,7 @@ void av_register_all(void)
     REGISTER_MUXDEMUX (H261, h261);
     REGISTER_MUXDEMUX (H263, h263);
     REGISTER_MUXDEMUX (H264, h264);
+    REGISTER_DEMUXER  (HLS, hls);
     REGISTER_DEMUXER  (ICO, ico);
     REGISTER_DEMUXER  (IDCIN, idcin);
     REGISTER_DEMUXER  (IDF, idf);
@@ -254,15 +256,16 @@ void av_register_all(void)
 #if CONFIG_LIBMODPLUG
     REGISTER_DEMUXER  (LIBMODPLUG, libmodplug);
 #endif
-    REGISTER_MUXDEMUX (LIBNUT, libnut);
-
     /* protocols */
+#if FF_API_APPLEHTTP_PROTO
     REGISTER_PROTOCOL (APPLEHTTP, applehttp);
+#endif
     REGISTER_PROTOCOL (CACHE, cache);
     REGISTER_PROTOCOL (CONCAT, concat);
     REGISTER_PROTOCOL (CRYPTO, crypto);
     REGISTER_PROTOCOL (FILE, file);
     REGISTER_PROTOCOL (GOPHER, gopher);
+    REGISTER_PROTOCOL (HLS, hls);
     REGISTER_PROTOCOL (HTTP, http);
     REGISTER_PROTOCOL (HTTPPROXY, httpproxy);
     REGISTER_PROTOCOL (HTTPS, https);
@@ -271,12 +274,16 @@ void av_register_all(void)
     REGISTER_PROTOCOL (MD5,  md5);
     REGISTER_PROTOCOL (PIPE, pipe);
     REGISTER_PROTOCOL (RTMP, rtmp);
-    REGISTER_PROTOCOL (RTMPE, rtmpe);
-    REGISTER_PROTOCOL (RTMPS, rtmps);
-    REGISTER_PROTOCOL (RTMPT, rtmpt);
-    REGISTER_PROTOCOL (RTMPTE, rtmpte);
     REGISTER_PROTOCOL (RTP, rtp);
     REGISTER_PROTOCOL (TCP, tcp);
     REGISTER_PROTOCOL (TLS, tls);
     REGISTER_PROTOCOL (UDP, udp);
+
+    /* external libraries */
+    REGISTER_MUXDEMUX (LIBNUT, libnut);
+    REGISTER_PROTOCOL (LIBRTMP, librtmp);
+    REGISTER_PROTOCOL (LIBRTMPE, librtmpe);
+    REGISTER_PROTOCOL (LIBRTMPS, librtmps);
+    REGISTER_PROTOCOL (LIBRTMPT, librtmpt);
+    REGISTER_PROTOCOL (LIBRTMPTE, librtmpte);
 }
diff --git a/libavformat/cdxl.c b/libavformat/cdxl.c
new file mode 100644
index 0000000000..f2956dd2f2
--- /dev/null
+++ b/libavformat/cdxl.c
@@ -0,0 +1,170 @@
+/*
+ * CDXL demuxer
+ * Copyright (c) 2011-2012 Paul B Mahol
+ *
+ * This file is part of Libav.
+ *
+ * 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.
+ *
+ * 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 Libav; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "libavutil/intreadwrite.h"
+#include "libavutil/parseutils.h"
+#include "libavutil/opt.h"
+#include "avformat.h"
+#include "internal.h"
+
+#define CDXL_HEADER_SIZE 32
+
+typedef struct CDXLDemuxContext {
+    AVClass     *class;
+    int         sample_rate;
+    char        *framerate;
+    AVRational  fps;
+    int         read_chunk;
+    uint8_t     header[CDXL_HEADER_SIZE];
+    int         video_stream_index;
+    int         audio_stream_index;
+} CDXLDemuxContext;
+
+static int cdxl_read_header(AVFormatContext *s)
+{
+    CDXLDemuxContext *cdxl = s->priv_data;
+    int ret;
+
+    if ((ret = av_parse_video_rate(&cdxl->fps, cdxl->framerate)) < 0) {
+        av_log(s, AV_LOG_ERROR,
+               "Could not parse framerate: %s.\n", cdxl->framerate);
+        return ret;
+    }
+
+    cdxl->read_chunk         =  0;
+    cdxl->video_stream_index = -1;
+    cdxl->audio_stream_index = -1;
+
+    s->ctx_flags |= AVFMTCTX_NOHEADER;
+
+    return 0;
+}
+
+static int cdxl_read_packet(AVFormatContext *s, AVPacket *pkt)
+{
+    CDXLDemuxContext *cdxl = s->priv_data;
+    AVIOContext *pb = s->pb;
+    uint32_t current_size;
+    uint16_t audio_size, palette_size;
+    int32_t  video_size;
+    int64_t  pos;
+    int      ret;
+
+    if (pb->eof_reached)
+        return AVERROR_EOF;
+
+    pos = avio_tell(pb);
+    if (!cdxl->read_chunk &&
+        avio_read(pb, cdxl->header, CDXL_HEADER_SIZE) != CDXL_HEADER_SIZE)
+        return AVERROR_EOF;
+    if (cdxl->header[0] != 1) {
+        av_log(s, AV_LOG_ERROR, "non-standard cdxl file\n");
+        return AVERROR_INVALIDDATA;
+    }
+
+    current_size = AV_RB32(&cdxl->header[2]);
+    palette_size = AV_RB16(&cdxl->header[20]);
+    audio_size   = AV_RB16(&cdxl->header[22]);
+
+    if (palette_size > 512)
+        return AVERROR_INVALIDDATA;
+    if (current_size < audio_size + palette_size + CDXL_HEADER_SIZE)
+        return AVERROR_INVALIDDATA;
+    video_size   = current_size - audio_size - CDXL_HEADER_SIZE;
+
+    if (cdxl->read_chunk && audio_size) {
+        if (cdxl->audio_stream_index == -1) {
+            AVStream *st = avformat_new_stream(s, NULL);
+            if (!st)
+                return AVERROR(ENOMEM);
+
+            st->codec->codec_type    = AVMEDIA_TYPE_AUDIO;
+            st->codec->codec_tag     = 0;
+            st->codec->codec_id      = CODEC_ID_PCM_S8;
+            st->codec->channels      = cdxl->header[1] & 0x10 ? 2 : 1;
+            st->codec->sample_rate   = cdxl->sample_rate;
+            cdxl->audio_stream_index = st->index;
+            avpriv_set_pts_info(st, 32, 1, cdxl->sample_rate);
+        }
+
+        ret = av_get_packet(pb, pkt, audio_size);
+        if (ret < 0)
+            return ret;
+        pkt->stream_index = cdxl->audio_stream_index;
+        pkt->pos          = pos;
+        pkt->duration     = audio_size;
+        cdxl->read_chunk  = 0;
+    } else {
+        if (cdxl->video_stream_index == -1) {
+            AVStream *st = avformat_new_stream(s, NULL);
+            if (!st)
+                return AVERROR(ENOMEM);
+
+            st->codec->codec_type    = AVMEDIA_TYPE_VIDEO;
+            st->codec->codec_tag     = 0;
+            st->codec->codec_id      = CODEC_ID_CDXL;
+            st->codec->width         = AV_RB16(&cdxl->header[14]);
+            st->codec->height        = AV_RB16(&cdxl->header[16]);
+            cdxl->video_stream_index = st->index;
+            avpriv_set_pts_info(st, 63, cdxl->fps.den, cdxl->fps.num);
+        }
+
+        if (av_new_packet(pkt, video_size + CDXL_HEADER_SIZE) < 0)
+            return AVERROR(ENOMEM);
+        memcpy(pkt->data, cdxl->header, CDXL_HEADER_SIZE);
+        ret = avio_read(pb, pkt->data + CDXL_HEADER_SIZE, video_size);
+        if (ret < 0) {
+            av_free_packet(pkt);
+            return ret;
+        }
+        pkt->stream_index  = cdxl->video_stream_index;
+        pkt->flags        |= AV_PKT_FLAG_KEY;
+        pkt->pos           = pos;
+        cdxl->read_chunk   = audio_size;
+    }
+
+    return ret;
+}
+
+#define OFFSET(x) offsetof(CDXLDemuxContext, x)
+static const AVOption cdxl_options[] = {
+    { "sample_rate", "", OFFSET(sample_rate), AV_OPT_TYPE_INT,    { .dbl = 11025 }, 1, INT_MAX, AV_OPT_FLAG_DECODING_PARAM },
+    { "framerate",   "", OFFSET(framerate),   AV_OPT_TYPE_STRING, { .str = "10" },  0, 0,       AV_OPT_FLAG_DECODING_PARAM },
+    { NULL },
+};
+
+static const AVClass cdxl_demuxer_class = {
+    .class_name = "CDXL demuxer",
+    .item_name  = av_default_item_name,
+    .option     = cdxl_options,
+    .version    = LIBAVUTIL_VERSION_INT,
+};
+
+AVInputFormat ff_cdxl_demuxer = {
+    .name           = "cdxl",
+    .long_name      = NULL_IF_CONFIG_SMALL("Commodore CDXL video format"),
+    .priv_data_size = sizeof(CDXLDemuxContext),
+    .read_header    = cdxl_read_header,
+    .read_packet    = cdxl_read_packet,
+    .extensions     = "cdxl,xl",
+    .flags          = AVFMT_GENERIC_INDEX,
+    .priv_class     = &cdxl_demuxer_class,
+};
diff --git a/libavformat/applehttp.c b/libavformat/hls.c
index 7e6346a989..c27b7d30b0 100644
--- a/libavformat/applehttp.c
+++ b/libavformat/hls.c
@@ -93,7 +93,7 @@ struct variant {
     uint8_t key[16];
 };
 
-typedef struct AppleHTTPContext {
+typedef struct HLSContext {
     int n_variants;
     struct variant **variants;
     int cur_seq_no;
@@ -103,7 +103,7 @@ typedef struct AppleHTTPContext {
     int64_t seek_timestamp;
     int seek_flags;
     AVIOInterruptCB *interrupt_callback;
-} AppleHTTPContext;
+} HLSContext;
 
 static int read_chomp_line(AVIOContext *s, char *buf, int maxlen)
 {
@@ -122,7 +122,7 @@ static void free_segment_list(struct variant *var)
     var->n_segments = 0;
 }
 
-static void free_variant_list(AppleHTTPContext *c)
+static void free_variant_list(HLSContext *c)
 {
     int i;
     for (i = 0; i < c->n_variants; i++) {
@@ -152,7 +152,7 @@ static void reset_packet(AVPacket *pkt)
     pkt->data = NULL;
 }
 
-static struct variant *new_variant(AppleHTTPContext *c, int bandwidth,
+static struct variant *new_variant(HLSContext *c, int bandwidth,
                                    const char *url, const char *base)
 {
     struct variant *var = av_mallocz(sizeof(struct variant));
@@ -199,7 +199,7 @@ static void handle_key_args(struct key_info *info, const char *key,
     }
 }
 
-static int parse_playlist(AppleHTTPContext *c, const char *url,
+static int parse_playlist(HLSContext *c, const char *url,
                           struct variant *var, AVIOContext *in)
 {
     int ret = 0, duration = 0, is_segment = 0, is_variant = 0, bandwidth = 0;
@@ -373,7 +373,7 @@ static int open_input(struct variant *var)
 static int read_data(void *opaque, uint8_t *buf, int buf_size)
 {
     struct variant *v = opaque;
-    AppleHTTPContext *c = v->parent->priv_data;
+    HLSContext *c = v->parent->priv_data;
     int ret, i;
 
 restart:
@@ -445,9 +445,9 @@ reload:
     goto restart;
 }
 
-static int applehttp_read_header(AVFormatContext *s)
+static int hls_read_header(AVFormatContext *s)
 {
-    AppleHTTPContext *c = s->priv_data;
+    HLSContext *c = s->priv_data;
     int ret = 0, i, j, stream_offset = 0;
 
     c->interrupt_callback = &s->interrupt_callback;
@@ -557,7 +557,7 @@ fail:
 
 static int recheck_discard_flags(AVFormatContext *s, int first)
 {
-    AppleHTTPContext *c = s->priv_data;
+    HLSContext *c = s->priv_data;
     int i, changed = 0;
 
     /* Check if any new streams are needed */
@@ -590,9 +590,9 @@ static int recheck_discard_flags(AVFormatContext *s, int first)
     return changed;
 }
 
-static int applehttp_read_packet(AVFormatContext *s, AVPacket *pkt)
+static int hls_read_packet(AVFormatContext *s, AVPacket *pkt)
 {
-    AppleHTTPContext *c = s->priv_data;
+    HLSContext *c = s->priv_data;
     int ret, i, minvariant = -1;
 
     if (c->first_packet) {
@@ -668,18 +668,18 @@ start:
     return AVERROR_EOF;
 }
 
-static int applehttp_close(AVFormatContext *s)
+static int hls_close(AVFormatContext *s)
 {
-    AppleHTTPContext *c = s->priv_data;
+    HLSContext *c = s->priv_data;
 
     free_variant_list(c);
     return 0;
 }
 
-static int applehttp_read_seek(AVFormatContext *s, int stream_index,
+static int hls_read_seek(AVFormatContext *s, int stream_index,
                                int64_t timestamp, int flags)
 {
-    AppleHTTPContext *c = s->priv_data;
+    HLSContext *c = s->priv_data;
     int i, j, ret;
 
     if ((flags & AVSEEK_FLAG_BYTE) || !c->variants[0]->finished)
@@ -729,7 +729,7 @@ static int applehttp_read_seek(AVFormatContext *s, int stream_index,
     return ret;
 }
 
-static int applehttp_probe(AVProbeData *p)
+static int hls_probe(AVProbeData *p)
 {
     /* Require #EXTM3U at the start, and either one of the ones below
      * somewhere for a proper match. */
@@ -742,13 +742,13 @@ static int applehttp_probe(AVProbeData *p)
     return 0;
 }
 
-AVInputFormat ff_applehttp_demuxer = {
-    .name           = "applehttp",
+AVInputFormat ff_hls_demuxer = {
+    .name           = "hls,applehttp",
     .long_name      = NULL_IF_CONFIG_SMALL("Apple HTTP Live Streaming format"),
-    .priv_data_size = sizeof(AppleHTTPContext),
-    .read_probe     = applehttp_probe,
-    .read_header    = applehttp_read_header,
-    .read_packet    = applehttp_read_packet,
-    .read_close     = applehttp_close,
-    .read_seek      = applehttp_read_seek,
+    .priv_data_size = sizeof(HLSContext),
+    .read_probe     = hls_probe,
+    .read_header    = hls_read_header,
+    .read_packet    = hls_read_packet,
+    .read_close     = hls_close,
+    .read_seek      = hls_read_seek,
 };
diff --git a/libavformat/applehttpproto.c b/libavformat/hlsproto.c
index be04131642..8c25689f91 100644
--- a/libavformat/applehttpproto.c
+++ b/libavformat/hlsproto.c
@@ -29,6 +29,7 @@
 #include "avformat.h"
 #include "internal.h"
 #include "url.h"
+#include "version.h"
 #include <unistd.h>
 
 /*
@@ -53,7 +54,7 @@ struct variant {
     char url[MAX_URL_SIZE];
 };
 
-typedef struct AppleHTTPContext {
+typedef struct HLSContext {
     char playlisturl[MAX_URL_SIZE];
     int target_duration;
     int start_seq_no;
@@ -65,7 +66,7 @@ typedef struct AppleHTTPContext {
     int cur_seq_no;
     URLContext *seg_hd;
     int64_t last_load_time;
-} AppleHTTPContext;
+} HLSContext;
 
 static int read_chomp_line(AVIOContext *s, char *buf, int maxlen)
 {
@@ -75,7 +76,7 @@ static int read_chomp_line(AVIOContext *s, char *buf, int maxlen)
     return len;
 }
 
-static void free_segment_list(AppleHTTPContext *s)
+static void free_segment_list(HLSContext *s)
 {
     int i;
     for (i = 0; i < s->n_segments; i++)
@@ -84,7 +85,7 @@ static void free_segment_list(AppleHTTPContext *s)
     s->n_segments = 0;
 }
 
-static void free_variant_list(AppleHTTPContext *s)
+static void free_variant_list(HLSContext *s)
 {
     int i;
     for (i = 0; i < s->n_variants; i++)
@@ -108,7 +109,7 @@ static void handle_variant_args(struct variant_info *info, const char *key,
 
 static int parse_playlist(URLContext *h, const char *url)
 {
-    AppleHTTPContext *s = h->priv_data;
+    HLSContext *s = h->priv_data;
     AVIOContext *in;
     int ret = 0, duration = 0, is_segment = 0, is_variant = 0, bandwidth = 0;
     char line[1024];
@@ -174,9 +175,9 @@ fail:
     return ret;
 }
 
-static int applehttp_close(URLContext *h)
+static int hls_close(URLContext *h)
 {
-    AppleHTTPContext *s = h->priv_data;
+    HLSContext *s = h->priv_data;
 
     free_segment_list(s);
     free_variant_list(s);
@@ -184,9 +185,9 @@ static int applehttp_close(URLContext *h)
     return 0;
 }
 
-static int applehttp_open(URLContext *h, const char *uri, int flags)
+static int hls_open(URLContext *h, const char *uri, int flags)
 {
-    AppleHTTPContext *s = h->priv_data;
+    HLSContext *s = h->priv_data;
     int ret, i;
     const char *nested_url;
 
@@ -195,16 +196,38 @@ static int applehttp_open(URLContext *h, const char *uri, int flags)
 
     h->is_streamed = 1;
 
-    if (av_strstart(uri, "applehttp+", &nested_url)) {
+    if (av_strstart(uri, "hls+", &nested_url)) {
         av_strlcpy(s->playlisturl, nested_url, sizeof(s->playlisturl));
+    } else if (av_strstart(uri, "hls://", &nested_url)) {
+        av_log(h, AV_LOG_ERROR,
+               "No nested protocol specified. Specify e.g. hls+http://%s\n",
+               nested_url);
+        ret = AVERROR(EINVAL);
+        goto fail;
+#if FF_API_APPLEHTTP_PROTO
+    } else if (av_strstart(uri, "applehttp+", &nested_url)) {
+        av_strlcpy(s->playlisturl, nested_url, sizeof(s->playlisturl));
+        av_log(h, AV_LOG_WARNING,
+               "The applehttp protocol is deprecated, use hls+%s as url "
+               "instead.\n", nested_url);
     } else if (av_strstart(uri, "applehttp://", &nested_url)) {
         av_strlcpy(s->playlisturl, "http://", sizeof(s->playlisturl));
         av_strlcat(s->playlisturl, nested_url, sizeof(s->playlisturl));
+        av_log(h, AV_LOG_WARNING,
+               "The applehttp protocol is deprecated, use hls+http://%s as url "
+               "instead.\n", nested_url);
+#endif
     } else {
         av_log(h, AV_LOG_ERROR, "Unsupported url %s\n", uri);
         ret = AVERROR(EINVAL);
         goto fail;
     }
+    av_log(h, AV_LOG_WARNING,
+           "Using the hls protocol is discouraged, please try using the "
+           "hls demuxer instead. The hls demuxer should be more complete "
+           "and work as well as the protocol implementation. (If not, "
+           "please report it.) To use the demuxer, simply use %s as url.\n",
+           s->playlisturl);
 
     if ((ret = parse_playlist(h, s->playlisturl)) < 0)
         goto fail;
@@ -235,13 +258,13 @@ static int applehttp_open(URLContext *h, const char *uri, int flags)
     return 0;
 
 fail:
-    applehttp_close(h);
+    hls_close(h);
     return ret;
 }
 
-static int applehttp_read(URLContext *h, uint8_t *buf, int size)
+static int hls_read(URLContext *h, uint8_t *buf, int size)
 {
-    AppleHTTPContext *s = h->priv_data;
+    HLSContext *s = h->priv_data;
     const char *url;
     int ret;
     int64_t reload_interval;
@@ -303,11 +326,22 @@ retry:
     goto start;
 }
 
+#if FF_API_APPLEHTTP_PROTO
 URLProtocol ff_applehttp_protocol = {
     .name           = "applehttp",
-    .url_open       = applehttp_open,
-    .url_read       = applehttp_read,
-    .url_close      = applehttp_close,
+    .url_open       = hls_open,
+    .url_read       = hls_read,
+    .url_close      = hls_close,
+    .flags          = URL_PROTOCOL_FLAG_NESTED_SCHEME,
+    .priv_data_size = sizeof(HLSContext),
+};
+#endif
+
+URLProtocol ff_hls_protocol = {
+    .name           = "hls",
+    .url_open       = hls_open,
+    .url_read       = hls_read,
+    .url_close      = hls_close,
     .flags          = URL_PROTOCOL_FLAG_NESTED_SCHEME,
-    .priv_data_size = sizeof(AppleHTTPContext),
+    .priv_data_size = sizeof(HLSContext),
 };
diff --git a/libavformat/librtmp.c b/libavformat/librtmp.c
index e433860823..d717c644d6 100644
--- a/libavformat/librtmp.c
+++ b/libavformat/librtmp.c
@@ -152,7 +152,7 @@ static int rtmp_get_file_handle(URLContext *s)
     return RTMP_Socket(r);
 }
 
-URLProtocol ff_rtmp_protocol = {
+URLProtocol ff_librtmp_protocol = {
     .name                = "rtmp",
     .url_open            = rtmp_open,
     .url_read            = rtmp_read,
@@ -165,7 +165,7 @@ URLProtocol ff_rtmp_protocol = {
     .flags               = URL_PROTOCOL_FLAG_NETWORK,
 };
 
-URLProtocol ff_rtmpt_protocol = {
+URLProtocol ff_librtmpt_protocol = {
     .name                = "rtmpt",
     .url_open            = rtmp_open,
     .url_read            = rtmp_read,
@@ -178,7 +178,7 @@ URLProtocol ff_rtmpt_protocol = {
     .flags               = URL_PROTOCOL_FLAG_NETWORK,
 };
 
-URLProtocol ff_rtmpe_protocol = {
+URLProtocol ff_librtmpe_protocol = {
     .name                = "rtmpe",
     .url_open            = rtmp_open,
     .url_read            = rtmp_read,
@@ -191,7 +191,7 @@ URLProtocol ff_rtmpe_protocol = {
     .flags               = URL_PROTOCOL_FLAG_NETWORK,
 };
 
-URLProtocol ff_rtmpte_protocol = {
+URLProtocol ff_librtmpte_protocol = {
     .name                = "rtmpte",
     .url_open            = rtmp_open,
     .url_read            = rtmp_read,
@@ -204,7 +204,7 @@ URLProtocol ff_rtmpte_protocol = {
     .flags               = URL_PROTOCOL_FLAG_NETWORK,
 };
 
-URLProtocol ff_rtmps_protocol = {
+URLProtocol ff_librtmps_protocol = {
     .name                = "rtmps",
     .url_open            = rtmp_open,
     .url_read            = rtmp_read,
diff --git a/libavformat/movenc.c b/libavformat/movenc.c
index fe5a55c66f..dfd6385b24 100644
--- a/libavformat/movenc.c
+++ b/libavformat/movenc.c
@@ -30,6 +30,7 @@
 #include "avc.h"
 #include "libavcodec/get_bits.h"
 #include "libavcodec/put_bits.h"
+#include "libavcodec/vc1.h"
 #include "internal.h"
 #include "libavutil/avstring.h"
 #include "libavutil/intfloat.h"
@@ -433,6 +434,98 @@ static int mov_write_wave_tag(AVIOContext *pb, MOVTrack *track)
     return update_size(pb, pos);
 }
 
+static int mov_write_dvc1_structs(MOVTrack *track, uint8_t *buf)
+{
+    uint8_t *unescaped;
+    const uint8_t *start, *next, *end = track->vos_data + track->vos_len;
+    int unescaped_size, seq_found = 0;
+    int level = 0, interlace = 0;
+    int packet_seq   = track->vc1_info.packet_seq;
+    int packet_entry = track->vc1_info.packet_entry;
+    int slices       = track->vc1_info.slices;
+    PutBitContext pbc;
+
+    if (track->start_dts == AV_NOPTS_VALUE) {
+        /* No packets written yet, vc1_info isn't authoritative yet. */
+        /* Assume inline sequence and entry headers. This will be
+         * overwritten at the end if the file is seekable. */
+        packet_seq = packet_entry = 1;
+    }
+
+    unescaped = av_mallocz(track->vos_len + FF_INPUT_BUFFER_PADDING_SIZE);
+    if (!unescaped)
+        return AVERROR(ENOMEM);
+    start = find_next_marker(track->vos_data, end);
+    for (next = start; next < end; start = next) {
+        GetBitContext gb;
+        int size;
+        next = find_next_marker(start + 4, end);
+        size = next - start - 4;
+        if (size <= 0)
+            continue;
+        unescaped_size = vc1_unescape_buffer(start + 4, size, unescaped);
+        init_get_bits(&gb, unescaped, 8 * unescaped_size);
+        if (AV_RB32(start) == VC1_CODE_SEQHDR) {
+            int profile = get_bits(&gb, 2);
+            if (profile != PROFILE_ADVANCED) {
+                av_free(unescaped);
+                return AVERROR(ENOSYS);
+            }
+            seq_found = 1;
+            level = get_bits(&gb, 3);
+            /* chromaformat, frmrtq_postproc, bitrtq_postproc, postprocflag,
+             * width, height */
+            skip_bits_long(&gb, 2 + 3 + 5 + 1 + 2*12);
+            skip_bits(&gb, 1); /* broadcast */
+            interlace = get_bits1(&gb);
+            skip_bits(&gb, 4); /* tfcntrflag, finterpflag, reserved, psf */
+        }
+    }
+    if (!seq_found) {
+        av_free(unescaped);
+        return AVERROR(ENOSYS);
+    }
+
+    init_put_bits(&pbc, buf, 7);
+    /* VC1DecSpecStruc */
+    put_bits(&pbc, 4, 12); /* profile - advanced */
+    put_bits(&pbc, 3, level);
+    put_bits(&pbc, 1, 0); /* reserved */
+    /* VC1AdvDecSpecStruc */
+    put_bits(&pbc, 3, level);
+    put_bits(&pbc, 1, 0); /* cbr */
+    put_bits(&pbc, 6, 0); /* reserved */
+    put_bits(&pbc, 1, !interlace); /* no interlace */
+    put_bits(&pbc, 1, !packet_seq); /* no multiple seq */
+    put_bits(&pbc, 1, !packet_entry); /* no multiple entry */
+    put_bits(&pbc, 1, !slices); /* no slice code */
+    put_bits(&pbc, 1, 0); /* no bframe */
+    put_bits(&pbc, 1, 0); /* reserved */
+    put_bits32(&pbc, track->enc->time_base.den); /* framerate */
+    flush_put_bits(&pbc);
+
+    av_free(unescaped);
+
+    return 0;
+}
+
+static int mov_write_dvc1_tag(AVIOContext *pb, MOVTrack *track)
+{
+    uint8_t buf[7] = { 0 };
+    int ret;
+
+    if ((ret = mov_write_dvc1_structs(track, buf)) < 0)
+        return ret;
+
+    avio_wb32(pb, track->vos_len + 8 + sizeof(buf));
+    ffio_wfourcc(pb, "dvc1");
+    track->vc1_info.struct_offset = avio_tell(pb);
+    avio_write(pb, buf, sizeof(buf));
+    avio_write(pb, track->vos_data, track->vos_len);
+
+    return 0;
+}
+
 static int mov_write_glbl_tag(AVIOContext *pb, MOVTrack *track)
 {
     avio_wb32(pb, track->vos_len + 8);
@@ -659,6 +752,7 @@ static int mp4_get_codec_tag(AVFormatContext *s, MOVTrack *track)
     else if (track->enc->codec_id == CODEC_ID_AC3)       tag = MKTAG('a','c','-','3');
     else if (track->enc->codec_id == CODEC_ID_DIRAC)     tag = MKTAG('d','r','a','c');
     else if (track->enc->codec_id == CODEC_ID_MOV_TEXT)  tag = MKTAG('t','x','3','g');
+    else if (track->enc->codec_id == CODEC_ID_VC1)       tag = MKTAG('v','c','-','1');
     else if (track->enc->codec_type == AVMEDIA_TYPE_VIDEO) tag = MKTAG('m','p','4','v');
     else if (track->enc->codec_type == AVMEDIA_TYPE_AUDIO) tag = MKTAG('m','p','4','a');
 
@@ -945,6 +1039,8 @@ static int mov_write_video_tag(AVIOContext *pb, MOVTrack *track)
             mov_write_uuid_tag_ipod(pb);
     } else if (track->enc->field_order != AV_FIELD_UNKNOWN)
         mov_write_fiel_tag(pb, track);
+    else if (track->enc->codec_id == CODEC_ID_VC1 && track->vos_len > 0)
+        mov_write_dvc1_tag(pb, track);
     else if (track->vos_len > 0)
         mov_write_glbl_tag(pb, track);
 
@@ -2557,6 +2653,63 @@ static int mov_parse_mpeg2_frame(AVPacket *pkt, uint32_t *flags)
     return 0;
 }
 
+static void mov_parse_vc1_frame(AVPacket *pkt, MOVTrack *trk, int fragment)
+{
+    const uint8_t *start, *next, *end = pkt->data + pkt->size;
+    int seq = 0, entry = 0;
+    int key = pkt->flags & AV_PKT_FLAG_KEY;
+    start = find_next_marker(pkt->data, end);
+    for (next = start; next < end; start = next) {
+        next = find_next_marker(start + 4, end);
+        switch (AV_RB32(start)) {
+        case VC1_CODE_SEQHDR:
+            seq = 1;
+            break;
+        case VC1_CODE_ENTRYPOINT:
+            entry = 1;
+            break;
+        case VC1_CODE_SLICE:
+            trk->vc1_info.slices = 1;
+            break;
+        }
+    }
+    if (!trk->entry && !fragment) {
+        /* First packet in first fragment */
+        trk->vc1_info.first_packet_seq   = seq;
+        trk->vc1_info.first_packet_entry = entry;
+    } else if ((seq && !trk->vc1_info.packet_seq) ||
+               (entry && !trk->vc1_info.packet_entry)) {
+        int i;
+        for (i = 0; i < trk->entry; i++)
+            trk->cluster[i].flags &= ~MOV_SYNC_SAMPLE;
+        trk->has_keyframes = 0;
+        if (seq)
+            trk->vc1_info.packet_seq = 1;
+        if (entry)
+            trk->vc1_info.packet_entry = 1;
+        if (!fragment) {
+            /* First fragment */
+            if ((!seq   || trk->vc1_info.first_packet_seq) &&
+                (!entry || trk->vc1_info.first_packet_entry)) {
+                /* First packet had the same headers as this one, readd the
+                 * sync sample flag. */
+                trk->cluster[0].flags |= MOV_SYNC_SAMPLE;
+                trk->has_keyframes = 1;
+            }
+        }
+    }
+    if (trk->vc1_info.packet_seq && trk->vc1_info.packet_entry)
+        key = seq && entry;
+    else if (trk->vc1_info.packet_seq)
+        key = seq;
+    else if (trk->vc1_info.packet_entry)
+        key = entry;
+    if (key) {
+        trk->cluster[trk->entry].flags |= MOV_SYNC_SAMPLE;
+        trk->has_keyframes++;
+    }
+}
+
 static int mov_flush_fragment(AVFormatContext *s)
 {
     MOVMuxContext *mov = s->priv_data;
@@ -2788,7 +2941,9 @@ static int mov_write_packet_internal(AVFormatContext *s, AVPacket *pkt)
         trk->flags |= MOV_TRACK_CTTS;
     trk->cluster[trk->entry].cts = pkt->pts - pkt->dts;
     trk->cluster[trk->entry].flags = 0;
-    if (pkt->flags & AV_PKT_FLAG_KEY) {
+    if (enc->codec_id == CODEC_ID_VC1) {
+        mov_parse_vc1_frame(pkt, trk, mov->fragments);
+    } else if (pkt->flags & AV_PKT_FLAG_KEY) {
         if (mov->mode == MODE_MOV && enc->codec_id == CODEC_ID_MPEG2VIDEO &&
             trk->entry > 0) { // force sync sample for the first key frame
             mov_parse_mpeg2_frame(pkt, &trk->cluster[trk->entry].flags);
@@ -3113,6 +3268,16 @@ static int mov_write_trailer(AVFormatContext *s)
     for (i=0; i<mov->nb_streams; i++) {
         if (mov->tracks[i].tag == MKTAG('r','t','p',' '))
             ff_mov_close_hinting(&mov->tracks[i]);
+        if (mov->flags & FF_MOV_FLAG_FRAGMENT &&
+            mov->tracks[i].vc1_info.struct_offset && s->pb->seekable) {
+            int64_t off = avio_tell(pb);
+            uint8_t buf[7];
+            if (mov_write_dvc1_structs(&mov->tracks[i], buf) >= 0) {
+                avio_seek(pb, mov->tracks[i].vc1_info.struct_offset, SEEK_SET);
+                avio_write(pb, buf, 7);
+                avio_seek(pb, off, SEEK_SET);
+            }
+        }
         av_freep(&mov->tracks[i].cluster);
         av_freep(&mov->tracks[i].frag_info);
 
diff --git a/libavformat/movenc.h b/libavformat/movenc.h
index e54053c6aa..fceb9b595d 100644
--- a/libavformat/movenc.h
+++ b/libavformat/movenc.h
@@ -122,6 +122,15 @@ typedef struct MOVIndex {
 
     int         nb_frag_info;
     MOVFragmentInfo *frag_info;
+
+    struct {
+        int64_t struct_offset;
+        int     first_packet_seq;
+        int     first_packet_entry;
+        int     packet_seq;
+        int     packet_entry;
+        int     slices;
+    } vc1_info;
 } MOVTrack;
 
 typedef struct MOVMuxContext {
diff --git a/libavformat/movenchint.c b/libavformat/movenchint.c
index 1b8b2c10ea..2318ff65a1 100644
--- a/libavformat/movenchint.c
+++ b/libavformat/movenchint.c
@@ -24,6 +24,7 @@
 #include "internal.h"
 #include "rtpenc_chain.h"
 #include "avio_internal.h"
+#include "rtp.h"
 
 int ff_mov_init_hinting(AVFormatContext *s, int index, int src_index)
 {
@@ -332,7 +333,7 @@ static int write_hint_packets(AVIOContext *out, const uint8_t *data,
         size -= 4;
         if (packet_len > size || packet_len <= 12)
             break;
-        if (data[1] >= 200 && data[1] <= 204) {
+        if (data[1] >= RTCP_SR && data[1] <= RTCP_APP) {
             /* RTCP packet, just skip */
             data += packet_len;
             size -= packet_len;
diff --git a/libavformat/rtpdec.c b/libavformat/rtpdec.c
index 7170e97ec9..72b430c423 100644
--- a/libavformat/rtpdec.c
+++ b/libavformat/rtpdec.c
@@ -66,6 +66,7 @@ void av_register_rtp_dynamic_payload_handlers(void)
     ff_register_dynamic_payload_handler(&ff_amr_wb_dynamic_handler);
     ff_register_dynamic_payload_handler(&ff_h263_1998_dynamic_handler);
     ff_register_dynamic_payload_handler(&ff_h263_2000_dynamic_handler);
+    ff_register_dynamic_payload_handler(&ff_h263_rfc2190_dynamic_handler);
     ff_register_dynamic_payload_handler(&ff_h264_dynamic_handler);
     ff_register_dynamic_payload_handler(&ff_vorbis_dynamic_handler);
     ff_register_dynamic_payload_handler(&ff_theora_dynamic_handler);
diff --git a/libavformat/rtpdec_formats.h b/libavformat/rtpdec_formats.h
index afd047be21..41d9590016 100644
--- a/libavformat/rtpdec_formats.h
+++ b/libavformat/rtpdec_formats.h
@@ -39,6 +39,7 @@ extern RTPDynamicProtocolHandler ff_g726_32_dynamic_handler;
 extern RTPDynamicProtocolHandler ff_g726_40_dynamic_handler;
 extern RTPDynamicProtocolHandler ff_h263_1998_dynamic_handler;
 extern RTPDynamicProtocolHandler ff_h263_2000_dynamic_handler;
+extern RTPDynamicProtocolHandler ff_h263_rfc2190_dynamic_handler;
 extern RTPDynamicProtocolHandler ff_h264_dynamic_handler;
 extern RTPDynamicProtocolHandler ff_mp4a_latm_dynamic_handler;
 extern RTPDynamicProtocolHandler ff_mp4v_es_dynamic_handler;
diff --git a/libavformat/rtpdec_h263_rfc2190.c b/libavformat/rtpdec_h263_rfc2190.c
new file mode 100644
index 0000000000..baec6a427c
--- /dev/null
+++ b/libavformat/rtpdec_h263_rfc2190.c
@@ -0,0 +1,184 @@
+/*
+ * RTP H.263 Depacketizer, RFC 2190
+ * Copyright (c) 2012 Martin Storsjo
+ * Based on the GStreamer H.263 Depayloder:
+ * Copyright 2005 Wim Taymans
+ * Copyright 2007 Edward Hervey
+ * Copyright 2007 Nokia Corporation
+ * Copyright 2007 Collabora Ltd, Philippe Kalaf
+ * Copyright 2010 Mark Nauwelaerts
+ *
+ * This file is part of Libav.
+ *
+ * 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.
+ *
+ * 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 Libav; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "avformat.h"
+#include "rtpdec_formats.h"
+#include "libavutil/intreadwrite.h"
+#include "libavcodec/get_bits.h"
+
+struct PayloadContext {
+    AVIOContext *buf;
+    uint8_t      endbyte;
+    int          endbyte_bits;
+    uint32_t     timestamp;
+};
+
+static PayloadContext *h263_new_context(void)
+{
+    return av_mallocz(sizeof(PayloadContext));
+}
+
+static void h263_free_context(PayloadContext *data)
+{
+    if (!data)
+        return;
+    if (data->buf) {
+        uint8_t *p;
+        avio_close_dyn_buf(data->buf, &p);
+        av_free(p);
+    }
+    av_free(data);
+}
+
+static int h263_handle_packet(AVFormatContext *ctx, PayloadContext *data,
+                              AVStream *st, AVPacket *pkt, uint32_t *timestamp,
+                              const uint8_t *buf, int len, int flags)
+{
+    int f, p, i, sbit, ebit; /* Corresponding to header fields in the RFC */
+    int header_size;
+
+    if (data->buf && data->timestamp != *timestamp) {
+        /* Dropping old buffered, unfinished data */
+        uint8_t *p;
+        avio_close_dyn_buf(data->buf, &p);
+        av_free(p);
+        data->buf = NULL;
+    }
+
+    if (len < 4) {
+        av_log(ctx, AV_LOG_ERROR, "Too short H.263 RTP packet: %d\n", len);
+        return AVERROR_INVALIDDATA;
+    }
+
+    f = buf[0] & 0x80;
+    p = buf[0] & 0x40;
+    if (!f) {
+        /* Mode A */
+        header_size = 4;
+        i = buf[1] & 0x10;
+    } else if (!p) {
+        /* Mode B */
+        header_size = 8;
+        if (len < header_size) {
+            av_log(ctx, AV_LOG_ERROR,
+                   "Too short H.263 RTP packet: %d bytes, %d header bytes\n",
+                   len, header_size);
+            return AVERROR_INVALIDDATA;
+        }
+        i = buf[4] & 0x80;
+    } else {
+        /* Mode C */
+        header_size = 12;
+        if (len < header_size) {
+            av_log(ctx, AV_LOG_ERROR,
+                   "Too short H.263 RTP packet: %d bytes, %d header bytes\n",
+                   len, header_size);
+            return AVERROR_INVALIDDATA;
+        }
+        i = buf[4] & 0x80;
+    }
+    sbit = (buf[0] >> 3) & 0x7;
+    ebit =  buf[0]       & 0x7;
+
+    buf += header_size;
+    len -= header_size;
+
+    if (!data->buf) {
+        /* Check the picture start code, only start buffering a new frame
+         * if this is correct */
+        if (!f && len > 4 && AV_RB32(buf) >> 10 == 0x20) {
+            int ret = avio_open_dyn_buf(&data->buf);
+            if (ret < 0)
+                return ret;
+            data->timestamp = *timestamp;
+        } else {
+            /* Frame not started yet, skipping */
+            return AVERROR(EAGAIN);
+        }
+    }
+
+    if (data->endbyte_bits || sbit) {
+        if (data->endbyte_bits == sbit) {
+            data->endbyte |= buf[0] & (0xff >> sbit);
+            data->endbyte_bits = 0;
+            buf++;
+            len--;
+            avio_w8(data->buf, data->endbyte);
+        } else {
+            /* Start/end skip bits not matching - missed packets? */
+            GetBitContext gb;
+            init_get_bits(&gb, buf, len*8 - ebit);
+            skip_bits(&gb, sbit);
+            if (data->endbyte_bits) {
+                data->endbyte |= get_bits(&gb, 8 - data->endbyte_bits);
+                avio_w8(data->buf, data->endbyte);
+            }
+            while (get_bits_left(&gb) >= 8)
+                avio_w8(data->buf, get_bits(&gb, 8));
+            data->endbyte_bits = get_bits_left(&gb);
+            if (data->endbyte_bits)
+                data->endbyte = get_bits(&gb, data->endbyte_bits) <<
+                                (8 - data->endbyte_bits);
+            ebit = 0;
+            len = 0;
+        }
+    }
+    if (ebit) {
+        if (len > 0)
+            avio_write(data->buf, buf, len - 1);
+        data->endbyte_bits = 8 - ebit;
+        data->endbyte = buf[len - 1] & (0xff << ebit);
+    } else {
+        avio_write(data->buf, buf, len);
+    }
+
+    if (!(flags & RTP_FLAG_MARKER))
+        return AVERROR(EAGAIN);
+
+    if (data->endbyte_bits)
+        avio_w8(data->buf, data->endbyte);
+    data->endbyte_bits = 0;
+
+    av_init_packet(pkt);
+    pkt->size         = avio_close_dyn_buf(data->buf, &pkt->data);
+    pkt->destruct     = av_destruct_packet;
+    pkt->stream_index = st->index;
+    if (!i)
+        pkt->flags   |= AV_PKT_FLAG_KEY;
+    data->buf = NULL;
+
+    return 0;
+}
+
+RTPDynamicProtocolHandler ff_h263_rfc2190_dynamic_handler = {
+    .codec_type        = AVMEDIA_TYPE_VIDEO,
+    .codec_id          = CODEC_ID_H263,
+    .parse_packet      = h263_handle_packet,
+    .alloc             = h263_new_context,
+    .free              = h263_free_context,
+    .static_payload_id = 34,
+};
diff --git a/libavformat/smjpegdec.c b/libavformat/smjpegdec.c
index 05a92839da..7764c0f34d 100644
--- a/libavformat/smjpegdec.c
+++ b/libavformat/smjpegdec.c
@@ -136,9 +136,11 @@ static int smjpeg_read_packet(AVFormatContext *s, AVPacket *pkt)
 {
     SMJPEGContext *sc = s->priv_data;
     uint32_t dtype, ret, size, timestamp;
+    int64_t pos;
 
     if (s->pb->eof_reached)
         return AVERROR_EOF;
+    pos   = avio_tell(s->pb);
     dtype = avio_rl32(s->pb);
     switch (dtype) {
     case SMJPEG_SNDD:
@@ -147,6 +149,7 @@ static int smjpeg_read_packet(AVFormatContext *s, AVPacket *pkt)
         ret = av_get_packet(s->pb, pkt, size);
         pkt->stream_index = sc->audio_stream_index;
         pkt->pts = timestamp;
+        pkt->pos = pos;
         break;
     case SMJPEG_VIDD:
         timestamp = avio_rb32(s->pb);
@@ -154,6 +157,7 @@ static int smjpeg_read_packet(AVFormatContext *s, AVPacket *pkt)
         ret = av_get_packet(s->pb, pkt, size);
         pkt->stream_index = sc->video_stream_index;
         pkt->pts = timestamp;
+        pkt->pos = pos;
         break;
     case SMJPEG_DONE:
         ret = AVERROR_EOF;
@@ -174,4 +178,5 @@ AVInputFormat ff_smjpeg_demuxer = {
     .read_header    = smjpeg_read_header,
     .read_packet    = smjpeg_read_packet,
     .extensions     = "mjpg",
+    .flags          = AVFMT_GENERIC_INDEX,
 };
diff --git a/libavformat/version.h b/libavformat/version.h
index 8a86c10d26..1fafa17dfc 100644
--- a/libavformat/version.h
+++ b/libavformat/version.h
@@ -30,7 +30,7 @@
 #include "libavutil/avutil.h"
 
 #define LIBAVFORMAT_VERSION_MAJOR 54
-#define LIBAVFORMAT_VERSION_MINOR  0
+#define LIBAVFORMAT_VERSION_MINOR  1
 #define LIBAVFORMAT_VERSION_MICRO 100
 
 #define LIBAVFORMAT_VERSION_INT AV_VERSION_INT(LIBAVFORMAT_VERSION_MAJOR, \
@@ -68,5 +68,8 @@
 #ifndef FF_API_CLOSE_INPUT_FILE
 #define FF_API_CLOSE_INPUT_FILE        (LIBAVFORMAT_VERSION_MAJOR < 55)
 #endif
+#ifndef FF_API_APPLEHTTP_PROTO
+#define FF_API_APPLEHTTP_PROTO         (LIBAVFORMAT_VERSION_MAJOR < 55)
+#endif
 
 #endif /* AVFORMAT_VERSION_H */