[FFmpeg-devel] [PATCH] add hds demuxer
Steven Liu
lq at chinaffmpeg.org
Wed Oct 12 10:56:49 EEST 2016
init add hds demuxer
Based-on: patch by CORY MCCARTHY <cory.mccarthy at shaw.ca>
Based-on: patch by Gorilla Maguila <gorilla.maguila at gmail.com>
Signed-off-by: Steven Liu <lq at chinaffmpeg.org>
---
configure | 5 +
libavformat/Makefile | 1 +
libavformat/allformats.c | 2 +-
libavformat/amfmetadata.c | 219 +++++++++++++
libavformat/amfmetadata.h | 39 +++
libavformat/f4fbox.c | 381 +++++++++++++++++++++++
libavformat/f4fbox.h | 95 ++++++
libavformat/f4mmanifest.c | 324 +++++++++++++++++++
libavformat/f4mmanifest.h | 59 ++++
libavformat/flvtag.c | 370 ++++++++++++++++++++++
libavformat/flvtag.h | 32 ++
libavformat/hdsdec.c | 759 +++++++++++++++++++++++++++++++++++++++++++++
12 files changed, 2285 insertions(+), 1 deletions(-)
create mode 100644 libavformat/amfmetadata.c
create mode 100644 libavformat/amfmetadata.h
create mode 100644 libavformat/f4fbox.c
create mode 100644 libavformat/f4fbox.h
create mode 100644 libavformat/f4mmanifest.c
create mode 100644 libavformat/f4mmanifest.h
create mode 100644 libavformat/flvtag.c
create mode 100644 libavformat/flvtag.h
create mode 100644 libavformat/hdsdec.c
diff --git a/configure b/configure
index 8fc71fb..d695e29 100755
--- a/configure
+++ b/configure
@@ -295,6 +295,7 @@ External library support:
on OSX if openssl and gnutls are not used [autodetect]
--enable-x11grab enable X11 grabbing (legacy) [no]
--disable-xlib disable xlib [autodetect]
+ --disable-xml2 disable XML parsing using the C library libxml2 [autodetect]
--disable-zlib disable zlib [autodetect]
The following libraries provide various hardware acceleration features:
@@ -1552,6 +1553,7 @@ EXTERNAL_LIBRARY_LIST="
videotoolbox
x11grab
xlib
+ xml2
zlib
"
@@ -2854,6 +2856,7 @@ eac3_demuxer_select="ac3_parser"
f4v_muxer_select="mov_muxer"
fifo_muxer_deps="threads"
flac_demuxer_select="flac_parser"
+hds_demuxer_select="xml2"
hds_muxer_select="flv_muxer"
hls_muxer_select="mpegts_muxer"
image2_alias_pix_demuxer_select="image2_demuxer"
@@ -5627,6 +5630,8 @@ disabled zlib || check_lib zlib.h zlibVersion -lz || disable zlib
disabled bzlib || check_lib2 bzlib.h BZ2_bzlibVersion -lbz2 || disable bzlib
disabled lzma || check_lib2 lzma.h lzma_version_number -llzma || disable lzma
+disabled xml2 || require_pkg_config libxml-2.0 libxml2/libxml/xmlversion.h xmlCheckVersion || disable xml2
+
check_lib math.h sin -lm && LIBM="-lm"
disabled crystalhd || check_lib libcrystalhd/libcrystalhd_if.h DtsCrystalHDVersion -lcrystalhd || disable crystalhd
diff --git a/libavformat/Makefile b/libavformat/Makefile
index 5d827d3..e2b4dd4 100644
--- a/libavformat/Makefile
+++ b/libavformat/Makefile
@@ -202,6 +202,7 @@ OBJS-$(CONFIG_H264_DEMUXER) += h264dec.o rawdec.o
OBJS-$(CONFIG_H264_MUXER) += rawenc.o
OBJS-$(CONFIG_HASH_MUXER) += hashenc.o
OBJS-$(CONFIG_HDS_MUXER) += hdsenc.o
+OBJS-$(CONFIG_HDS_DEMUXER) += hdsdec.o amfmetadata.o f4mmanifest.o f4fbox.o flvtag.o
OBJS-$(CONFIG_HEVC_DEMUXER) += hevcdec.o rawdec.o
OBJS-$(CONFIG_HEVC_MUXER) += rawenc.o
OBJS-$(CONFIG_HLS_DEMUXER) += hls.o
diff --git a/libavformat/allformats.c b/libavformat/allformats.c
index 6a216ef..39505c3 100644
--- a/libavformat/allformats.c
+++ b/libavformat/allformats.c
@@ -146,9 +146,9 @@ void av_register_all(void)
REGISTER_MUXDEMUX(H263, h263);
REGISTER_MUXDEMUX(H264, h264);
REGISTER_MUXER (HASH, hash);
- REGISTER_MUXER (HDS, hds);
REGISTER_MUXDEMUX(HEVC, hevc);
REGISTER_MUXDEMUX(HLS, hls);
+ REGISTER_MUXDEMUX(HDS, hds);
REGISTER_DEMUXER (HNM, hnm);
REGISTER_MUXDEMUX(ICO, ico);
REGISTER_DEMUXER (IDCIN, idcin);
diff --git a/libavformat/amfmetadata.c b/libavformat/amfmetadata.c
new file mode 100644
index 0000000..0e7a2ea
--- /dev/null
+++ b/libavformat/amfmetadata.c
@@ -0,0 +1,219 @@
+/*
+ * Adobe Action Message Format Parser
+ * Copyright (c) 2013 Cory McCarthy
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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,
+ * 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
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+
+#include "amfmetadata.h"
+#include "avio_internal.h"
+#include "flv.h"
+#include "libavutil/avstring.h"
+#include "libavutil/intfloat.h"
+
+static int amf_metadata_parse_value(AVIOContext *in, AMFMetadata *metadata, const char *name);
+
+static int amf_get_string(AVIOContext *in, char *buffer, int buffsize)
+{
+ int length;
+
+ length = avio_rb16(in);
+ if (length >= buffsize) {
+ avio_skip(in, length);
+ return AVERROR_INVALIDDATA;
+ }
+ avio_read(in, buffer, length);
+ buffer[length] = '\0';
+
+ return length;
+}
+
+static int amf_metadata_read_string_value(AVIOContext *in, char *str, int str_size)
+{
+ uint8_t type;
+
+ type = avio_r8(in);
+ if (type != AMF_DATA_TYPE_STRING){
+ return AVERROR_INVALIDDATA;
+ }
+
+ return amf_get_string(in, str, str_size);
+}
+
+static void amf_metadata_assign_property_number(AMFMetadata *metadata, const char *name, double value)
+{
+ if (!av_strcasecmp("width", name)){
+ metadata->width = value;
+ } else if (!av_strcasecmp("height", name)){
+ metadata->height = value;
+ } else if (!av_strcasecmp("framerate", name)){
+ metadata->frame_rate = value;
+ } else if (!av_strcasecmp("videodatarate", name)){
+ metadata->video_data_rate = value;
+ } else if (!av_strcasecmp("audiosamplerate", name)){
+ metadata->audio_sample_rate = value;
+ } else if (!av_strcasecmp("audiochannels", name)){
+ metadata->nb_audio_channels = value;
+ } else if (!av_strcasecmp("stereo", name)){
+ metadata->nb_audio_channels = (value) ? 2 : 1;
+ } else if (!av_strcasecmp("audiodatarate", name)){
+ metadata->audio_data_rate = value;
+ } else if (!av_strcasecmp("audiocodecid", name)){
+ if (value == 10)
+ metadata->audio_codec_id = AV_CODEC_ID_AAC;
+ } else if (!av_strcasecmp("videocodecid", name)){
+ if (value == 7)
+ metadata->video_codec_id = AV_CODEC_ID_H264;
+ }
+}
+
+static void amf_metadata_assign_property_string(AMFMetadata *metadata, const char *name, const char *value)
+{
+ if (!av_strcasecmp("audiocodecid", name)){
+ if (!av_strcasecmp("mp4a", value)){
+ metadata->audio_codec_id = AV_CODEC_ID_AAC;
+ } else if (!av_strcasecmp("aac", value)){
+ metadata->audio_codec_id = AV_CODEC_ID_AAC;
+ }
+ } else if (!av_strcasecmp("videocodecid", name)) {
+ if (!av_strcasecmp("avc1", value)){
+ metadata->video_codec_id = AV_CODEC_ID_H264;
+ } else if (!av_strcasecmp("h264", value)){
+ metadata->video_codec_id = AV_CODEC_ID_H264;
+ }
+ }
+}
+
+static int amf_metadata_parse_object_property(AVIOContext *in, AMFMetadata *metadata)
+{
+ char name[1024];
+ int ret;
+
+ if ((ret = amf_get_string(in, name, sizeof(name))) < 0)
+ return ret;
+
+ return amf_metadata_parse_value(in, metadata, name);
+}
+
+static int amf_metadata_parse_object(AVIOContext *in, AMFMetadata *metadata)
+{
+ int ret;
+
+ while (!avio_feof(in)) {
+ if ((ret = amf_metadata_parse_object_property(in, metadata)) < 0) {
+ if (avio_r8(in) != AMF_END_OF_OBJECT)
+ return ret;
+ break;
+ }
+ }
+
+ return 0;
+}
+
+static int amf_metadata_parse_strict_array(AVIOContext *in, AMFMetadata *metadata)
+{
+ int length;
+ int ret;
+
+ length = avio_rb32(in);
+ while (!avio_feof(in) && length > 0) {
+ if ((ret = amf_metadata_parse_value(in, metadata, NULL)) < 0){
+ return ret;
+ }
+ length--;
+ }
+
+ return 0;
+}
+
+static int amf_metadata_parse_value(AVIOContext *in, AMFMetadata *metadata, const char *name)
+{
+ uint8_t type;
+ char value_str[1024];
+ double value_number;
+ int ret = 0;
+
+ type = avio_r8(in);
+ switch (type){
+ case AMF_DATA_TYPE_NUMBER:
+ value_number = av_int2double(avio_rb64(in));
+ amf_metadata_assign_property_number(metadata, name, value_number);
+ break;
+ case AMF_DATA_TYPE_BOOL:
+ value_number = avio_r8(in);
+ amf_metadata_assign_property_number(metadata, name, value_number);
+ break;
+ case AMF_DATA_TYPE_STRING:
+ if ((ret = amf_get_string(in, value_str, sizeof(value_str))) < 0){
+ return ret;
+ }
+ amf_metadata_assign_property_string(metadata, name, value_str);
+ break;
+ case AMF_DATA_TYPE_OBJECT:
+ ret = amf_metadata_parse_object(in, metadata);
+ break;
+ case AMF_DATA_TYPE_MIXEDARRAY:
+ avio_skip(in, 4);
+ ret = amf_metadata_parse_object(in, metadata);
+ break;
+ case AMF_DATA_TYPE_ARRAY:
+ ret = amf_metadata_parse_strict_array(in, metadata);
+ break;
+ default:
+ break;
+ }
+ return ret;
+}
+
+static int amf_metadata_parse(AVFormatContext *s, AVIOContext *in, AMFMetadata *metadata)
+{
+ char name[1024];
+ int ret;
+
+ if ((ret = amf_metadata_read_string_value(in, name, sizeof(name))) < 0) {
+ av_log(s, AV_LOG_ERROR, "amfmetadata Failed to read onMetadata string, ret: %d \n", ret);
+ return ret;
+ }
+
+ if (av_strcasecmp(name, "onMetaData")) {
+ av_log(s, AV_LOG_ERROR, "amfmetadata Expected onMetadata, str = %s \n", name);
+ return AVERROR_INVALIDDATA;
+ }
+
+ return amf_metadata_parse_value(in, metadata, name);
+}
+
+int ff_parse_amf_metadata(AVFormatContext *s, AMFMetadata *metadata, uint8_t *buffer, int buffer_size)
+{
+ AVIOContext *in;
+ int ret;
+
+ if (!buffer)
+ return 0;
+ if (buffer_size <= 0)
+ return 0;
+
+ in = avio_alloc_context(buffer, buffer_size, 0, NULL, NULL, NULL, NULL);
+ if (!in)
+ return AVERROR(ENOMEM);
+
+ ret = amf_metadata_parse(s, in, metadata);
+ av_freep(&in);
+
+ return ret;
+}
diff --git a/libavformat/amfmetadata.h b/libavformat/amfmetadata.h
new file mode 100644
index 0000000..f0c85c3
--- /dev/null
+++ b/libavformat/amfmetadata.h
@@ -0,0 +1,39 @@
+/*
+ * Adobe Action Message Format Parser
+ * Copyright (c) 2013 Cory McCarthy
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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,
+ * 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
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+
+#include "avformat.h"
+#include "libavcodec/avcodec.h"
+
+typedef struct AMFMetadata {
+ int width;
+ int height;
+ int frame_rate;
+ int audio_sample_rate;
+ int nb_audio_channels;
+ int audio_data_rate;
+ int video_data_rate;
+
+ enum AVCodecID audio_codec_id;
+ enum AVCodecID video_codec_id;
+} AMFMetadata;
+
+int ff_parse_amf_metadata(AVFormatContext *s ,AMFMetadata *metadata, uint8_t *buffer, int buffer_size);
diff --git a/libavformat/f4fbox.c b/libavformat/f4fbox.c
new file mode 100644
index 0000000..21d4eb0
--- /dev/null
+++ b/libavformat/f4fbox.c
@@ -0,0 +1,381 @@
+/*
+ * Adobe Fragmented F4V File (F4F) Parser
+ * Copyright (c) 2013 Cory McCarthy
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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,
+ * 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
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+
+#include "f4fbox.h"
+#include "avformat.h"
+
+static int f4fbox_parse_asrt(AVFormatContext *s, AVIOContext *in, int64_t data_size, void *opaque)
+{
+ F4FBootstrapInfoBox *parent = (F4FBootstrapInfoBox*)opaque;
+ F4FSegmentRunTableBox *asrt;
+ F4FSegmentRunEntry *entry;
+ uint8_t quality_entry_count;
+ uint32_t segment_run_entry_count;
+ char url[1024];
+ int i;
+
+ asrt = av_mallocz(sizeof(*asrt));
+ if (!asrt)
+ return AVERROR(ENOMEM);
+
+ parent->segment_run_table_boxes[parent->nb_segment_run_table_boxes] = asrt;
+ parent->nb_segment_run_table_boxes++;
+
+ asrt->version = avio_r8(in);
+ asrt->flags = avio_rb24(in);
+
+ quality_entry_count = avio_r8(in);
+ for (i = 0; i < quality_entry_count; i++) {
+ avio_get_str(in, sizeof(url), url, sizeof(url));
+ }
+
+ segment_run_entry_count = avio_rb32(in);
+ for (i = 0; i < segment_run_entry_count; i++) {
+ entry = av_mallocz(sizeof(*entry));
+ if (!entry)
+ return AVERROR(ENOMEM);
+
+ asrt->segment_run_entries[asrt->nb_segment_run_entries] = entry;
+ asrt->nb_segment_run_entries++;
+
+ entry->first_segment = avio_rb32(in);
+ entry->fragments_per_segment = avio_rb32(in);
+ }
+
+ return 0;
+}
+
+static int f4fbox_parse_afrt(AVFormatContext *s, AVIOContext *in, int64_t data_size, void *opaque)
+{
+ F4FBootstrapInfoBox *parent = (F4FBootstrapInfoBox*)opaque;
+ F4FFragmentRunTableBox *afrt;
+ F4FFragmentRunEntry *entry;
+ uint8_t quality_entry_count;
+ uint32_t fragment_run_entry_count;
+ char url[1024] = {0, };
+ int i;
+
+ afrt = av_mallocz(sizeof(*afrt));
+ if (!afrt)
+ return AVERROR(ENOMEM);
+
+ parent->fragment_run_table_boxes[parent->nb_fragment_run_table_boxes] = afrt;
+ parent->nb_fragment_run_table_boxes++;
+ afrt->version = avio_r8(in);
+ afrt->flags = avio_rb24(in);
+ afrt->timescale = avio_rb32(in);
+ quality_entry_count = avio_r8(in);
+ for (i = 0; i < quality_entry_count; i++) {
+ avio_get_str(in, sizeof(url), url, sizeof(url));
+ }
+
+ fragment_run_entry_count = avio_rb32(in);
+ for (i = 0; i < fragment_run_entry_count; i++) {
+ entry = av_mallocz(sizeof(*entry));
+ if (!entry)
+ return AVERROR(ENOMEM);
+
+ afrt->fragment_run_entries[afrt->nb_fragment_run_entries] = entry;
+ afrt->nb_fragment_run_entries++;
+
+ entry->first_fragment = avio_rb32(in);
+ entry->first_fragment_time_stamp = avio_rb64(in);
+ entry->fragment_duration = avio_rb32(in);
+ if (!entry->fragment_duration) {
+ entry->discontinuity_indicator = avio_r8(in);
+ }
+ }
+
+ return 0;
+}
+
+
+static int f4fbox_parse_single_afrt(AVFormatContext *s, AVIOContext *in, void *opaque)
+{
+ int64_t bytes_read, bytes_left, start_pos, end_pos;
+ uint64_t size;
+ uint32_t type;
+ int ret = 0;
+
+ bytes_read = 0;
+ start_pos = avio_tell(in);
+ size = avio_rb32(in);
+ type = avio_rl32(in);
+ bytes_read += 8;
+
+ if (size == 1) {/* 64 bit extended size */
+ size = avio_rb64(in) - 8;
+ bytes_read += 8;
+ }
+ if (!size){
+ return AVERROR_INVALIDDATA;
+ }
+ if (type == MKTAG('a', 'f', 'r', 't')) {
+ ret = f4fbox_parse_afrt(s, in, size, opaque);
+ } else {
+ return AVERROR_INVALIDDATA;
+ }
+ if (ret < 0)
+ return ret;
+
+ end_pos = avio_tell(in);
+ bytes_left = size - (end_pos - start_pos);
+ if (bytes_left > 0)
+ avio_skip(in, bytes_left);
+
+ bytes_read += size;
+
+ return bytes_read;
+}
+
+
+static int f4fbox_parse_single_asrt(AVFormatContext *s, AVIOContext *in, void *opaque)
+{
+ int64_t bytes_read, bytes_left, start_pos, end_pos;
+ uint64_t size;
+ uint32_t type;
+ int ret = 0;
+
+ bytes_read = 0;
+ start_pos = avio_tell(in);
+ size = avio_rb32(in);
+ type = avio_rl32(in);
+ bytes_read += 8;
+
+ if (size == 1) {/* 64 bit extended size */
+ size = avio_rb64(in) - 8;
+ bytes_read += 8;
+ }
+ if (!size){
+ return AVERROR_INVALIDDATA;
+ }
+ if (type == MKTAG('a', 's', 'r', 't')) {
+ ret = f4fbox_parse_asrt(s, in, size, opaque);
+ } else {
+ return AVERROR_INVALIDDATA;
+ }
+ if (ret < 0)
+ return ret;
+
+ end_pos = avio_tell(in);
+ bytes_left = size - (end_pos - start_pos);
+ if (bytes_left > 0)
+ avio_skip(in, bytes_left);
+
+ bytes_read += size;
+
+ return bytes_read;
+}
+
+static int f4fbox_parse_abst(AVFormatContext *s, AVIOContext *in, int64_t data_size, void *opaque)
+{
+ F4FBox *parent = (F4FBox*)opaque;
+ F4FBootstrapInfoBox *abst = &(parent->abst);
+ uint8_t server_entry_count, quality_entry_count;
+ uint8_t segment_run_table_count, fragment_run_table_count;
+ uint8_t byte;
+ char url[1024] = {0, };
+ int i;
+ int ret = 0;
+
+ abst->version = avio_r8(in);
+ abst->flags = avio_rb24(in);
+ abst->bootstrap_info_version = avio_rb32(in);
+
+ byte = avio_r8(in);
+ abst->profile = byte >> 6 & 0x03;
+ abst->is_live = byte >> 5 & 0x01;
+ abst->is_update = byte >> 4 & 0x01;
+
+ abst->timescale = avio_rb32(in);
+ abst->current_media_time = avio_rb64(in);
+ abst->smpte_time_code_offset = avio_rb64(in);
+
+ avio_get_str(in, sizeof(abst->movie_id), abst->movie_id, sizeof(abst->movie_id));
+
+ server_entry_count = avio_r8(in);
+ for (i = 0; i < server_entry_count; i++) {
+ avio_get_str(in, sizeof(url), url, sizeof(url));
+ }
+
+ quality_entry_count = avio_r8(in);
+ for (i = 0; i < quality_entry_count; i++) {
+ avio_get_str(in, sizeof(url), url, sizeof(url));
+ }
+
+ avio_get_str(in, sizeof(abst->drm_data), abst->drm_data, sizeof(abst->drm_data));
+ avio_get_str(in, sizeof(abst->metadata), abst->metadata, sizeof(abst->metadata));
+
+ segment_run_table_count = avio_r8(in);
+ for (i = 0; i < segment_run_table_count; i++) {
+ if ((ret = f4fbox_parse_single_asrt(s, in, abst)) < 0) {
+ av_log(s, AV_LOG_ERROR, "f4fbox Failed to parse asrt box, ret: %d \n", ret);
+ return ret;
+ }
+ }
+ fragment_run_table_count = avio_r8(in);
+ for (i = 0; i < fragment_run_table_count; i++) {
+ if ((ret = f4fbox_parse_single_afrt(s, in, abst)) < 0) {
+ av_log(s, AV_LOG_ERROR, "f4fbox Failed to parse afrt box, ret: %d \n", ret);
+ return ret;
+ }
+ }
+
+ return ret;
+}
+
+static int f4fbox_parse_mdat(AVFormatContext *s, AVIOContext *in, int64_t data_size, void *opaque)
+{
+ F4FBox *parent = (F4FBox*)opaque;
+ F4FMediaDataBox *mdat = &(parent->mdat);
+
+ mdat->data = av_malloc(data_size);
+ if (!mdat->data)
+ return AVERROR(ENOMEM);
+
+ mdat->size = data_size;
+ avio_read(in, mdat->data, mdat->size);
+
+ return 0;
+}
+
+static int f4fbox_parse_single_box(AVFormatContext *s, AVIOContext *in, void *opaque)
+{
+ int64_t bytes_read, bytes_left, start_pos, end_pos;
+ uint64_t size;
+ uint32_t type;
+ int ret = 0;
+
+ bytes_read = 0;
+ start_pos = avio_tell(in);
+
+ size = avio_rb32(in);
+ type = avio_rl32(in);
+ bytes_read += 8;
+
+ if (size == 1) {/* 64 bit extended size */
+ size = avio_rb64(in) - 8;
+ bytes_read += 8;
+ }
+
+ if (!size){
+ return AVERROR_INVALIDDATA;
+ }
+
+ switch (type) {
+ case MKTAG('a', 'b', 's', 't'):
+ ret = f4fbox_parse_abst(s, in, size, opaque);
+ break;
+ case MKTAG('a', 's', 'r', 't'):
+ ret = f4fbox_parse_asrt(s, in, size, opaque);
+ break;
+ case MKTAG('a', 'f', 'r', 't'):
+ ret = f4fbox_parse_afrt(s, in, size, opaque);
+ break;
+ case MKTAG('m', 'd', 'a', 't'):
+ ret = f4fbox_parse_mdat(s, in, size, opaque);
+ break;
+ default:
+ break;
+ }
+
+ if (ret < 0)
+ return ret;
+
+ end_pos = avio_tell(in);
+ bytes_left = size - (end_pos - start_pos);
+ if (bytes_left > 0)
+ avio_skip(in, bytes_left);
+
+ bytes_read += size;
+
+ return bytes_read;
+}
+
+static int f4fbox_parse(AVFormatContext *s, AVIOContext *in, int64_t data_size, void *opaque)
+{
+ int64_t bytes_read = 0;
+ int ret;
+
+ while (!avio_feof(in) && bytes_read + 8 < data_size) {
+ if ((ret = f4fbox_parse_single_box(s, in, opaque)) < 0) {
+ av_log(s, AV_LOG_ERROR, "f4fbox Failed to parse box, ret: %d \n", ret);
+ return ret;
+ }
+ bytes_read += ret;
+ }
+
+ return 0;
+}
+
+int ff_parse_f4f_box(AVFormatContext *s, uint8_t *buffer, int buffer_size, void *opaque)
+{
+ AVIOContext *in;
+ int ret;
+
+ in = avio_alloc_context(buffer, buffer_size, 0, NULL, NULL, NULL, NULL);
+ if (!in)
+ return AVERROR(ENOMEM);
+
+ ret = f4fbox_parse(s, in, buffer_size, opaque);
+ av_freep(&in);
+
+ return ret;
+}
+
+int ff_free_f4f_box(F4FBox *box)
+{
+ F4FBootstrapInfoBox *abst;
+ F4FSegmentRunTableBox *asrt;
+ F4FSegmentRunEntry *sre;
+ F4FFragmentRunTableBox *afrt;
+ F4FFragmentRunEntry *fre;
+ F4FMediaDataBox *mdat;
+ int i, j;
+
+ abst = &(box->abst);
+ for (i = 0; i < abst->nb_segment_run_table_boxes; i++) {
+ asrt = abst->segment_run_table_boxes[i];
+ for (j = 0; j < asrt->nb_segment_run_entries; j++) {
+ sre = asrt->segment_run_entries[j];
+ av_freep(&sre);
+ }
+ av_freep(&asrt);
+ }
+
+ for (i = 0; i < abst->nb_fragment_run_table_boxes; i++) {
+ afrt = abst->fragment_run_table_boxes[i];
+ for (j = 0; j < afrt->nb_fragment_run_entries; j++) {
+ fre = afrt->fragment_run_entries[j];
+ av_freep(&fre);
+ }
+ av_freep(&afrt);
+ }
+
+ mdat = &(box->mdat);
+ if (mdat->size > 0)
+ av_freep(&mdat->data);
+
+ memset(box, 0x00, sizeof(*box));
+
+ return 0;
+}
diff --git a/libavformat/f4fbox.h b/libavformat/f4fbox.h
new file mode 100644
index 0000000..c0aa4f2
--- /dev/null
+++ b/libavformat/f4fbox.h
@@ -0,0 +1,95 @@
+/*
+ * Adobe Fragmented F4V File (F4F) Parser
+ * Copyright (c) 2013 Cory McCarthy
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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,
+ * 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
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "avformat.h"
+#include "avio_internal.h"
+
+#define MAX_NB_SEGMENT_RUN_TABLE_BOXES 256
+#define MAX_NB_FRAGMENT_RUN_TABLE_BOXES 256
+
+#define MAX_NB_SEGMENT_RUN_ENTRIES 1024
+#define MAX_NB_FRAGMENT_RUN_ENTRIES 1024
+
+typedef struct F4FFragmentRunEntry {
+ uint32_t first_fragment;
+ uint64_t first_fragment_time_stamp;
+ uint32_t fragment_duration;
+ uint8_t discontinuity_indicator;
+} F4FFragmentRunEntry;
+
+typedef struct F4FFragmentRunTableBox {
+ uint8_t version;
+ uint32_t flags;
+ uint32_t timescale;
+
+ uint32_t nb_fragment_run_entries;
+ F4FFragmentRunEntry *fragment_run_entries[MAX_NB_FRAGMENT_RUN_ENTRIES];
+} F4FFragmentRunTableBox;
+
+typedef struct F4FSegmentRunEntry {
+ uint32_t first_segment;
+ uint32_t fragments_per_segment;
+} F4FSegmentRunEntry;
+
+typedef struct F4FSegmentRunTableBox {
+ uint8_t version;
+ uint32_t flags;
+
+ uint32_t nb_segment_run_entries;
+ F4FSegmentRunEntry *segment_run_entries[MAX_NB_SEGMENT_RUN_ENTRIES];
+} F4FSegmentRunTableBox;
+
+typedef struct F4FBootstrapInfoBox {
+ uint8_t version;
+ uint32_t flags;
+ uint32_t bootstrap_info_version;
+
+ uint8_t profile;
+ uint8_t is_live;
+ uint8_t is_update;
+
+ uint32_t timescale;
+ uint64_t current_media_time;
+ uint64_t smpte_time_code_offset;
+
+ char movie_id[1024];
+ char drm_data[1024];
+ char metadata[1024];
+
+ uint8_t nb_segment_run_table_boxes;
+ F4FSegmentRunTableBox *segment_run_table_boxes[MAX_NB_SEGMENT_RUN_TABLE_BOXES];
+
+ uint8_t nb_fragment_run_table_boxes;
+ F4FFragmentRunTableBox *fragment_run_table_boxes[MAX_NB_FRAGMENT_RUN_TABLE_BOXES];
+} F4FBootstrapInfoBox;
+
+typedef struct F4FMediaDataBox {
+ uint32_t size;
+ uint8_t *data;
+} F4FMediaDataBox;
+
+typedef struct F4FBox {
+ F4FBootstrapInfoBox abst;
+ F4FMediaDataBox mdat;
+} F4FBox;
+
+int ff_parse_f4f_box(AVFormatContext *s, uint8_t *buffer, int buffer_size, void *opaque);
+int ff_free_f4f_box(F4FBox *box);
diff --git a/libavformat/f4mmanifest.c b/libavformat/f4mmanifest.c
new file mode 100644
index 0000000..7dd51be
--- /dev/null
+++ b/libavformat/f4mmanifest.c
@@ -0,0 +1,324 @@
+/*
+ * Adobe Media Manifest (F4M) File Parser
+ * Copyright (c) 2013 Cory McCarthy
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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,
+ * 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
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <libxml/parser.h>
+#include <libxml/tree.h>
+
+#include "f4mmanifest.h"
+#include "libavutil/avstring.h"
+#include "libavutil/base64.h"
+
+#define XML_FORMATIC_TAB 0x0a
+#define XML_FORMATIC_LF 0x09
+#define XML_FORMATIC_CR 0x0d
+#define XML_FORMATIC_WHITE 0x20
+
+
+static int f4m_get_xml_content_offset(xmlChar *p)
+{
+ int result = 0;
+ int len = strlen(p);
+ int i;
+
+ for (i = 0; i < len; i++) {
+ if (p[i] == XML_FORMATIC_LF ||
+ p[i] == XML_FORMATIC_TAB ||
+ p[i] == XML_FORMATIC_CR ||
+ p[i] == XML_FORMATIC_WHITE) {
+ result++;
+ } else {
+ break;
+ }
+ }
+
+ if (result > len)
+ result = 0;
+
+ return result;
+}
+
+static int f4m_get_xml_content_length(xmlChar *p)
+{
+ int result = 0;
+ int len = strlen(p);
+ int i;
+
+ for (i = 0; i < len; i++) {
+ if (p[i] != XML_FORMATIC_LF &&
+ p[i] != XML_FORMATIC_TAB &&
+ p[i] != XML_FORMATIC_CR &&
+ p[i] != XML_FORMATIC_WHITE) {
+ result++;
+ }
+ }
+ result++;
+ result = FFMIN(result, MAX_URL_SIZE);
+
+ return result;
+}
+
+static int f4m_parse_bootstrap_info_node(AVFormatContext *s, xmlNodePtr node, F4MBootstrapInfo *bootstrap_info)
+{
+ xmlChar *p;
+ uint8_t *dst;
+ int ret;
+ int len;
+ int offset;
+
+ p = xmlGetProp(node, "id");
+ if (p) {
+ av_strlcpy(bootstrap_info->id, p, sizeof(bootstrap_info->id));
+ xmlFree(p);
+ }
+
+ p = xmlGetProp(node, "url");
+ if (p) {
+ av_strlcpy(bootstrap_info->url, p, sizeof(bootstrap_info->url));
+ xmlFree(p);
+ }
+
+ p = xmlGetProp(node, "profile");
+ if (p) {
+ av_strlcpy(bootstrap_info->profile, p, sizeof(bootstrap_info->profile));
+ xmlFree(p);
+ }
+
+ p = xmlNodeGetContent(node);
+ if (p) {
+ len = f4m_get_xml_content_length(p);
+ offset = f4m_get_xml_content_offset(p);
+ dst = av_mallocz(len);
+ if (!dst) {
+ xmlFree(p);
+ return AVERROR(ENOMEM);
+ }
+ if ((ret = av_base64_decode(dst, p + offset, len)) < 0) {
+ av_log(s, AV_LOG_ERROR, "f4mmanifest Failed to decode bootstrap node base64 metadata, ret: %d \n", ret);
+ xmlFree(p);
+ av_freep(&dst);
+ return ret;
+ }
+
+ bootstrap_info->metadata = av_mallocz(ret);
+ if (!bootstrap_info->metadata) {
+ xmlFree(p);
+ av_freep(&dst);
+ return AVERROR(ENOMEM);
+ }
+
+ bootstrap_info->metadata_size = ret;
+ memcpy(bootstrap_info->metadata, dst, ret);
+ av_freep(&dst);
+ xmlFree(p);
+ }
+
+ return 0;
+}
+
+static int f4m_parse_metadata_node(AVFormatContext *s, xmlNodePtr node, F4MMedia *media)
+{
+ xmlNodePtr metadata_node;
+ xmlChar *p;
+ uint8_t *dst;
+ int len;
+ int offset;
+ int ret;
+
+ metadata_node = node->children;
+ while (metadata_node) {
+ if (!av_strcasecmp(metadata_node->name, "metadata")) {
+ p = xmlNodeGetContent(metadata_node);
+ break;
+ }
+ metadata_node = metadata_node->next;
+ }
+
+ if (!p)
+ return 0;
+
+ len = f4m_get_xml_content_length(p);
+ offset = f4m_get_xml_content_offset(p);
+
+ dst = av_mallocz(len);
+ if (!dst) {
+ xmlFree(p);
+ return AVERROR(ENOMEM);
+ }
+
+ if ((ret = av_base64_decode(dst, p + offset, len)) < 0) {
+ av_log(s, AV_LOG_ERROR, "f4mmanifest Failed to decode base64 metadata, ret: %d \n", ret);
+ xmlFree(p);
+ av_freep(&dst);
+ return ret;
+ }
+
+ media->metadata = av_mallocz(ret);
+ if (!media->metadata) {
+ xmlFree(p);
+ av_freep(&dst);
+ return AVERROR(ENOMEM);
+ }
+
+ media->metadata_size = ret;
+ memcpy(media->metadata, dst, ret);
+
+ xmlFree(p);
+ av_freep(&dst);
+
+ return 0;
+}
+
+static int f4m_parse_media_node(AVFormatContext *s, xmlNodePtr node, F4MMedia *media, F4MManifest *manifest)
+{
+ xmlChar *p;
+ int ret;
+
+ p = xmlGetProp(node, "bitrate");
+ if (p) {
+ media->bitrate = strtoul(p, NULL, 10);
+ xmlFree(p);
+ }
+ p = xmlGetProp(node, "url");
+ if (p) {
+ av_strlcpy(media->url, p, sizeof(media->url));
+ xmlFree(p);
+ }
+ p = xmlGetProp(node, "bootstrapInfoId");
+ if (p) {
+ av_strlcpy(media->bootstrap_info_id, p, sizeof(media->bootstrap_info_id));
+ xmlFree(p);
+ }
+ if ((ret = f4m_parse_metadata_node(s, node, media)) < 0) {
+ return ret;
+ }
+ return 0;
+}
+
+static int f4m_parse_manifest_node(AVFormatContext *s, xmlNodePtr root_node, F4MManifest *manifest)
+{
+ F4MBootstrapInfo *bootstrap_info;
+ F4MMedia *media;
+ xmlNodePtr node;
+ xmlChar *node_content;
+ int ret;
+ int len;
+ int offset;
+
+ for (node = root_node->children; node != root_node->last; node = node->next) {
+ if (!av_strcasecmp(node->name, "text"))
+ continue;
+
+ node_content = xmlNodeGetContent(node);
+ if (!node_content)
+ return AVERROR(ENOMEM);
+
+ offset = f4m_get_xml_content_offset(node_content);
+ len = f4m_get_xml_content_length(node_content);
+ if (!av_strcasecmp(node->name, "id") && node_content) {
+ av_strlcpy(manifest->id, node_content + offset, len);
+ }
+ if (!av_strcasecmp(node->name, "streamType") && node_content) {
+ av_strlcpy(manifest->stream_type, node_content + offset, len);
+ } else if (!av_strcasecmp(node->name, "bootstrapInfo")) {
+ bootstrap_info = av_mallocz(sizeof(*bootstrap_info));
+ if (!bootstrap_info) {
+ xmlFree(node_content);
+ return AVERROR(ENOMEM);
+ }
+ manifest->bootstraps[manifest->nb_bootstraps++] = bootstrap_info;
+ ret = f4m_parse_bootstrap_info_node(s, node, bootstrap_info);
+ } else if (!av_strcasecmp(node->name, "media")) {
+ media = av_mallocz(sizeof(*media));
+ if (!media) {
+ xmlFree(node_content);
+ return AVERROR(ENOMEM);
+ }
+ manifest->media[manifest->nb_media++] = media;
+ ret = f4m_parse_media_node(s, node, media, manifest);
+ }
+
+ if (node_content)
+ xmlFree(node_content);
+ if (ret < 0)
+ return ret;
+ }
+
+ return 0;
+}
+
+static int f4m_parse_xml_file(AVFormatContext *s, uint8_t *buffer, int size, F4MManifest *manifest)
+{
+ xmlDocPtr doc;
+ xmlNodePtr root_node;
+ int ret;
+
+ doc = xmlReadMemory(buffer, size, "noname.xml", NULL, 0);
+ if (!doc) {
+ return AVERROR_INVALIDDATA;
+ }
+
+ root_node = xmlDocGetRootElement(doc);
+ if (!root_node) {
+ av_log(s, AV_LOG_ERROR, "f4mmanifest Root element not found \n");
+ xmlFreeDoc(doc);
+ return AVERROR_INVALIDDATA;
+ }
+
+ if (av_strcasecmp(root_node->name, "manifest")) {
+ av_log(s, AV_LOG_ERROR, "f4mmanifest Root element is not named manifest, name = %s \n",
+ root_node->name);
+ xmlFreeDoc(doc);
+ return AVERROR_INVALIDDATA;
+ }
+
+ ret = f4m_parse_manifest_node(s, root_node, manifest);
+ xmlFreeDoc(doc);
+
+ return ret;
+}
+
+int ff_parse_f4m_manifest(AVFormatContext *s, uint8_t *buffer, int size, F4MManifest *manifest)
+{
+ return f4m_parse_xml_file(s, buffer, size, manifest);
+}
+
+int ff_free_manifest(F4MManifest *manifest)
+{
+ F4MBootstrapInfo *bootstrap_info;
+ F4MMedia *media;
+ int i;
+
+ for (i = 0; i < manifest->nb_bootstraps; i++) {
+ bootstrap_info = manifest->bootstraps[i];
+ av_freep(&bootstrap_info->metadata);
+ av_freep(&bootstrap_info);
+ }
+
+ for (i = 0; i < manifest->nb_media; i++) {
+ media = manifest->media[i];
+ av_freep(&media->metadata);
+ av_freep(&media);
+ }
+
+ memset(manifest, 0x00, sizeof(*manifest));
+
+ return 0;
+}
diff --git a/libavformat/f4mmanifest.h b/libavformat/f4mmanifest.h
new file mode 100644
index 0000000..0986c3f
--- /dev/null
+++ b/libavformat/f4mmanifest.h
@@ -0,0 +1,59 @@
+/*
+ * Adobe Media Manifest (F4M) File Parser
+ * Copyright (c) 2013 Cory McCarthy
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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,
+ * 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
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "avformat.h"
+#include "internal.h"
+
+#define MAX_NB_BOOTSTRAPS 32
+#define MAX_NB_MEDIA 32
+
+
+typedef struct F4MBootstrapInfo {
+ char id[MAX_URL_SIZE];
+ char url[MAX_URL_SIZE];
+ char profile[MAX_URL_SIZE];
+
+ int metadata_size;
+ uint8_t *metadata;
+} F4MBootstrapInfo;
+
+typedef struct F4MMedia {
+ int bitrate;
+ char url[MAX_URL_SIZE];
+ char bootstrap_info_id[MAX_URL_SIZE];
+
+ int metadata_size;
+ uint8_t *metadata;
+} F4MMedia;
+
+
+typedef struct F4MManifest {
+ char id[MAX_URL_SIZE];
+ char stream_type[MAX_URL_SIZE];
+ int nb_bootstraps;
+ F4MBootstrapInfo *bootstraps[MAX_NB_BOOTSTRAPS];
+
+ int nb_media;
+ F4MMedia *media[MAX_NB_MEDIA];
+} F4MManifest;
+
+int ff_parse_f4m_manifest(AVFormatContext *s, uint8_t *buffer, int size, F4MManifest *manifest);
+int ff_free_manifest(F4MManifest *manifest);
diff --git a/libavformat/flvtag.c b/libavformat/flvtag.c
new file mode 100644
index 0000000..af080b7
--- /dev/null
+++ b/libavformat/flvtag.c
@@ -0,0 +1,370 @@
+/*
+ * Adobe FLV Tag Parser
+ * Copyright (c) 2013 Cory McCarthy
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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,
+ * 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
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "flvtag.h"
+#include "libavformat/avio.h"
+
+typedef struct FLVTagAudioHeader {
+ uint8_t sound_format;
+ uint8_t sound_rate;
+ uint8_t sound_size;
+ uint8_t sound_type;
+
+ uint8_t aac_packet_type;
+} FLVTagAudioHeader;
+
+typedef struct FLVTagAudioBody {
+ uint8_t sound_format;
+ uint8_t sound_rate;
+ uint8_t sound_size;
+ uint8_t sound_type;
+
+ uint8_t aac_packet_type;
+} FLVTagAudioBody;
+
+typedef struct FLVTagVideoHeader {
+ uint8_t frame_type;
+ uint8_t codec_id;
+
+ uint8_t avc_packet_type;
+ int32_t composition_time;
+} FLVTagVideoHeader;
+
+typedef struct FLVTagVideoBody {
+ uint8_t configuration_version;
+ uint8_t avc_profile_indication;
+ uint8_t profile_compatibility;
+ uint8_t avc_level_indication;
+
+ uint8_t length_size_minus_one;
+
+ uint8_t *sps_data;
+ int sps_data_size;
+
+ uint8_t *pps_data;
+ int pps_data_size;
+} FLVTagVideoBody;
+
+static int flv_tag_parse_audio_header(AVIOContext *in,
+ FLVTagAudioHeader *header)
+{
+ int ret = 0;
+ uint8_t byte;
+
+ byte = avio_r8(in);
+ ret++;
+
+ header->sound_format = (byte >> 4) & 0x0F;
+ header->sound_rate = (byte >> 2) & 0x03;
+ header->sound_size = (byte >> 1) & 0x01;
+ header->sound_type = (byte >> 0) & 0x01;
+
+ if (header->sound_format == 10) {
+ header->aac_packet_type = avio_r8(in);
+ ret++;
+ }
+
+ return ret;
+}
+
+static int flv_tag_parse_audio_body(AVFormatContext *s, AVIOContext *in, uint32_t data_size,
+ FLVTagAudioHeader *header, FLVTagAudioBody *body, FLVMediaSample **sample_out)
+{
+ FLVMediaSample *sample;
+
+ if (header->sound_format != 10) {
+ av_log(s, AV_LOG_ERROR, "flvtag Unhandled sound format, fmt: %d \n", header->sound_format);
+ return 0;
+ }
+
+ if (!header->aac_packet_type)
+ return 0;//skip AudioSpecificConfig
+
+ if (header->aac_packet_type != 1) {
+ av_log(s, AV_LOG_ERROR, "flvtag Unhandled aac_packet_type, type: %d \n", header->aac_packet_type);
+ return 0;
+ }
+
+ sample = av_mallocz(sizeof(*sample));
+ if (!sample)
+ return AVERROR(ENOMEM);
+
+ sample->type = AVMEDIA_TYPE_AUDIO;
+ sample->data = av_malloc(data_size);
+ if (!sample->data)
+ return AVERROR(ENOMEM);
+
+ sample->data_size = data_size;
+ avio_read(in, sample->data, sample->data_size);
+
+ if (sample_out)
+ *sample_out = sample;
+
+ return data_size;
+}
+
+static int flv_tag_parse_video_header(AVIOContext *in,
+ FLVTagVideoHeader *header)
+{
+ int ret = 0;
+ uint8_t byte;
+
+ byte = avio_r8(in);
+ ret++;
+
+ header->frame_type = (byte >> 4) & 0x0F;
+ header->codec_id = byte & 0x0F;
+
+ if (header->codec_id == 0x07) {
+ header->avc_packet_type = avio_r8(in);
+ header->composition_time = avio_rb24(in);
+ ret += 4;
+ }
+
+ return ret;
+}
+
+static int flv_tag_parse_video_body(AVFormatContext *s, AVIOContext *in, uint32_t data_size,
+ FLVTagVideoHeader *header, FLVTagVideoBody *body, FLVMediaSample **sample_out)
+{
+ FLVMediaSample *sample;
+ uint8_t *p;
+ uint8_t nb_sps, nb_pps;
+ uint16_t sps_length, pps_length;
+ uint32_t nal_size;
+ int i, ret = 0;
+
+ if (header->frame_type == 0x05) {
+ avio_r8(in);
+ return 1;
+ }
+
+ if (header->codec_id != 0x07) {
+ av_log(s, AV_LOG_ERROR, "flvtag Unhandled video codec id, id: %d \n", header->codec_id);
+ return 0;
+ }
+
+ if (header->avc_packet_type == 0x00) {
+ body->configuration_version = avio_r8(in);
+ body->avc_profile_indication = avio_r8(in);
+ body->profile_compatibility = avio_r8(in);
+ body->avc_level_indication = avio_r8(in);
+ ret += 4;
+
+ body->length_size_minus_one = avio_r8(in) & 0x03;
+ ret++;
+
+ if (body->sps_data_size > 0)
+ av_freep(&body->sps_data);
+ if (body->pps_data_size > 0)
+ av_freep(&body->pps_data);
+
+ nb_sps = avio_r8(in) & 0x1F;
+ ret++;
+
+ for (i = 0; i < nb_sps; i++) {
+ sps_length = avio_rb16(in);
+ ret += 2;
+
+ body->sps_data = av_realloc(body->sps_data,
+ body->sps_data_size + sps_length + 4);
+ if (!body->sps_data)
+ return AVERROR(ENOMEM);
+
+ p = body->sps_data + body->sps_data_size;
+
+ *p++ = 0x00;
+ *p++ = 0x00;
+ *p++ = 0x00;
+ *p++ = 0x01;
+ body->sps_data_size += 4;
+
+ avio_read(in, p, sps_length);
+ body->sps_data_size += sps_length;
+
+ ret += sps_length;
+ }
+
+ nb_pps = avio_r8(in);
+ ret++;
+
+ for (i = 0; i < nb_pps; i++) {
+ pps_length = avio_rb16(in);
+ ret += 2;
+
+ body->pps_data = av_realloc(body->pps_data,
+ body->pps_data_size + pps_length + 4);
+ if (!body->pps_data)
+ return AVERROR(ENOMEM);
+
+ p = body->pps_data + body->pps_data_size;
+
+ *p++ = 0x00;
+ *p++ = 0x00;
+ *p++ = 0x00;
+ *p++ = 0x01;
+ body->pps_data_size += 4;
+
+ avio_read(in, p, pps_length);
+ body->pps_data_size += pps_length;
+
+ ret += pps_length;
+ }
+ } else if (header->avc_packet_type == 0x01) {
+ sample = av_mallocz(sizeof(*sample));
+ if (!sample)
+ return AVERROR(ENOMEM);
+
+ sample->type = AVMEDIA_TYPE_VIDEO;
+ sample->data_size = body->sps_data_size + body->pps_data_size;
+ sample->data_size += (4 + data_size);
+ sample->data = av_malloc(sample->data_size);
+ if (!sample->data)
+ return AVERROR(ENOMEM);
+
+ p = sample->data;
+
+ memcpy(p, body->sps_data, body->sps_data_size);
+ p += body->sps_data_size;
+
+ memcpy(p, body->pps_data, body->pps_data_size);
+ p += body->pps_data_size;
+
+ while (ret < data_size) {
+ *p++ = 0x00;
+ *p++ = 0x00;
+ *p++ = 0x00;
+ *p++ = 0x01;
+
+ nal_size = avio_rb32(in);
+ ret += 4;
+
+ avio_read(in, p, nal_size);
+ p += nal_size;
+ ret += nal_size;
+ }
+ }
+
+ if (sample_out)
+ *sample_out = sample;
+
+ return ret;
+}
+
+static int flv_tag_decode_body(AVFormatContext *s, uint8_t *buffer, int buffer_size,
+ FLVMediaSample **samples, int *nb_samples_out)
+{
+ FLVMediaSample *sample;
+ AVIOContext *in;
+ FLVTagAudioHeader audio_header;
+ FLVTagAudioBody audio_body;
+ FLVTagVideoHeader video_header;
+ FLVTagVideoBody video_body;
+ uint8_t byte, filter, tag_type;
+ uint32_t data_size, timestamp, timestamp_extended, dts, stream_id;
+ int nb_samples = 0;
+ int ret;
+
+ memset(&audio_header, 0x00, sizeof(audio_header));
+ memset(&audio_body, 0x00, sizeof(audio_body));
+ memset(&video_header, 0x00, sizeof(video_header));
+ memset(&video_body, 0x00, sizeof(video_body));
+
+ in = avio_alloc_context(buffer, buffer_size, 0, NULL, NULL, NULL, NULL);
+ if (!in)
+ return AVERROR(ENOMEM);
+
+ while (!avio_feof(in)) {
+ byte = avio_r8(in);
+ filter = (byte >> 5) & 0x01;
+ tag_type = (byte & 0x01F);
+ data_size = avio_rb24(in);
+ timestamp = avio_rb24(in);
+ timestamp_extended = avio_r8(in);
+ dts = ((timestamp_extended << 24) & 0xFF000000) | timestamp;
+
+ stream_id = avio_rb24(in);
+ if (stream_id) {
+ av_log(s, AV_LOG_ERROR, "flvtag Invalid stream_id %d \n", stream_id);
+ return -1;
+ }
+
+ if (tag_type == 0x08) {
+ data_size -= flv_tag_parse_audio_header(in, &audio_header);
+ } else if (tag_type == 0x09) {
+ data_size -= flv_tag_parse_video_header(in, &video_header);
+ }
+
+ if (filter == 0x01) {
+ //EncryptionTagHeader
+ //FilterParams
+ }
+
+ sample = NULL;
+
+ if (tag_type == 8) {
+ if ((ret = flv_tag_parse_audio_body(s, in, data_size,
+ &audio_header, &audio_body, &sample)) < 0) {
+ av_freep(&in);
+ return ret;
+ }
+ data_size -= ret;
+ } else if (tag_type == 9) {
+ if ((ret = flv_tag_parse_video_body(s, in, data_size,
+ &video_header, &video_body, &sample)) < 0) {
+
+ av_freep(&in);
+ return ret;
+ }
+ data_size -= ret;
+ } else if (tag_type == 18) {
+ //ScriptData
+ }
+
+ if (sample) {
+ sample->timestamp = dts;
+ samples[nb_samples++] = sample;
+ }
+
+ if (data_size) {
+ avio_skip(in, data_size);
+ }
+ avio_rb32(in);
+ }
+
+ av_freep(&in);
+
+ if (video_body.sps_data_size > 0)
+ av_freep(&video_body.sps_data);
+ if (video_body.pps_data_size > 0)
+ av_freep(&video_body.pps_data);
+
+ if (nb_samples_out)
+ *nb_samples_out = nb_samples;
+
+ return 0;
+}
+
+int ff_decode_flv_body(AVFormatContext *s, uint8_t *buffer, int buffer_size,
+ FLVMediaSample **samples, int *nb_samples_out)
+{
+ return flv_tag_decode_body(s, buffer, buffer_size, samples, nb_samples_out);
+}
diff --git a/libavformat/flvtag.h b/libavformat/flvtag.h
new file mode 100644
index 0000000..7c468af
--- /dev/null
+++ b/libavformat/flvtag.h
@@ -0,0 +1,32 @@
+/*
+ * Adobe FLV Tag Parser
+ * Copyright (c) 2013 Cory McCarthy
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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,
+ * 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
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "avformat.h"
+#include "libavutil/avutil.h"
+
+typedef struct FLVMediaSample {
+ enum AVMediaType type;
+ uint32_t timestamp;
+ int data_size;
+ uint8_t *data;
+} FLVMediaSample;
+
+int ff_decode_flv_body(AVFormatContext *s, uint8_t *buffer, int buffer_size, FLVMediaSample **samples, int *nb_samples_out);
diff --git a/libavformat/hdsdec.c b/libavformat/hdsdec.c
new file mode 100644
index 0000000..c99cb9c
--- /dev/null
+++ b/libavformat/hdsdec.c
@@ -0,0 +1,759 @@
+/*
+ * Adobe HTTP Dynamic Streaming (HDS) demuxer
+ * Copyright (c) 2013 Cory McCarthy
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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,
+ * 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
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+/**
+ * @file
+ * @brief Adobe HTTP Dynamic Streaming (HDS) demuxer
+ * @author Cory McCarthy
+ * @see http://www.adobe.com/devnet/hds.html
+ * @see http://wwwimages.adobe.com/www.adobe.com/content/dam/Adobe/en/devnet/hds/pdfs/adobe-hds-specification.pdf
+ * @see http://wwwimages.adobe.com/www.adobe.com/content/dam/Adobe/en/devnet/hds/pdfs/adobe-media-manifest-specification.pdf
+ * @see http://download.macromedia.com/f4v/video_file_format_spec_v10_1.pdf
+ *
+ * @note Link for a HDS test player below:
+ * @see http://mediapm.edgesuite.net/edgeflash/public/zeri/debug/Main.html
+ *
+ * @note Test streams are below:
+ * @test http://multiplatform-f.akamaihd.net/z/multi/april11/hdworld/hdworld_,512x288_450_b,640x360_700_b,768x432_1000_b,1024x576_1400_m,1280x720_1900_m,1280x720_2500_m,1280x720_3500_m,.mp4.csmil/manifest.f4m?hdcore
+ * @test http://multiplatform-f.akamaihd.net/z/multi/april11/cctv/cctv_,512x288_450_b,640x360_700_b,768x432_1000_b,1024x576_1400_m,1280x720_1900_m,1280x720_2500_m,1280x720_3500_m,.mp4.csmil/manifest.f4m?hdcore
+ * @test http://multiplatform-f.akamaihd.net/z/multi/april11/sintel/sintel-hd_,512x288_450_b,640x360_700_b,768x432_1000_b,1024x576_1400_m,1280x720_1900_m,1280x720_2500_m,1280x720_3500_m,.mp4.csmil/manifest.f4m?hdcore
+ * @test http://multiplatform-f.akamaihd.net/z/multi/akamai10year/Akamai_10_Year_,200,300,600,800,1000,1500,2500,4000,k.mp4.csmil/manifest.f4m?hdcore
+ * @test http://zerihdndemo-f.akamaihd.net/z/h264/seeker/LegendofSeeker_16x9_24fps_H264_,400K,650K,1Mbps,1.4Mbps,1.8Mbps,2.5Mbps,.mp4.csmil/manifest.f4m?hdcore
+ * @test http://multiplatform-f.akamaihd.net/z/multi/will/bunny/big_buck_bunny_,640x360_400,640x360_700,640x360_1000,950x540_1500,1280x720_2000,1280x720_3000,.f4v.csmil/manifest.f4m?hdcore
+ * @test http://multiplatform-f.akamaihd.net/z/multi/companion/nba_game/nba_game.mov_,300,600,800,1000,2500,4000,9000,k.mp4.csmil/manifest.f4m?hdcore
+ * @test http://multiplatform-f.akamaihd.net/z/multi/companion/big_bang_theory/big_bang_theory.mov_,300,600,800,1000,2500,4000,9000,k.mp4.csmil/manifest.f4m?hdcore
+ * @test http://multiplatform-f.akamaihd.net/z/multi/shuttle/shuttle_,300,600,800,1000,k.mp4.csmil/manifest.f4m?hdcore
+ * @test http://multiplatform-f.akamaihd.net/z/multi/up_trailer/up_trailer_720p_,300,600,800,1000,k.mp4.csmil/manifest.f4m?hdcore
+ * @test http://multiformatlive-f.akamaihd.net/z/demostream_1@2131/manifest.f4m?hdcore
+ * @test http://zerihdndemo-f.akamaihd.net/z/h264/darkknight/darkknight.smil/manifest.f4m?hdcore
+ * @test http://zerihdndemo-f.akamaihd.net/z/h264/amours/amours.smil/manifest.f4m?hdcore
+ * @test http://zerihdndemo-f.akamaihd.net/z/h264/robinhood/robinhood.smil/manifest.f4m?hdcore
+ * @test http://zerihdndemo-f.akamaihd.net/z/h264/wallstreet/wallstreet.smil/manifest.f4m?hdcore
+ * @test http://zerihdndemo-f.akamaihd.net/z/h264/rockandroll/rockandroll.smil/manifest.f4m?hdcore
+ * @test http://184.72.239.149/vod/smil:bigbuckbunny.smil/manifest.f4m
+ *
+ * @test http://livehds.rasset.ie/hds-live/_definst_/newsnow/newsnow_540p.f4m
+ * @test http://livehds.rasset.ie/hds-live/_definst_/rte1/rte1_288p.f4m
+ * @test http://livehds.rasset.ie/hds-live/_definst_/rte2/rte2_288p.f4m
+ * @test http://ooyalahd2-f.akamaihd.net/z/godtv02_delivery@17351/manifest.f4m?hdcore=2.10.3&g=ILYQWQWFPMLW
+ */
+
+#include "avformat.h"
+#include "internal.h"
+#include "url.h"
+#include "avio_internal.h"
+#include "libavutil/avstring.h"
+#include "libavutil/parseutils.h"
+#include "libavutil/time.h"
+
+#include "amfmetadata.h"
+#include "f4mmanifest.h"
+#include "f4fbox.h"
+#include "flvtag.h"
+
+#define MAX_NB_SAMPLES 1024
+
+typedef struct HDSBootstrapInfo {
+ char id[MAX_URL_SIZE];
+ char url[MAX_URL_SIZE];
+ char profile[MAX_URL_SIZE];
+
+ F4FBox box;
+} HDSBootstrapInfo;
+
+typedef struct HDSMedia {
+ int bitrate;
+ char url[MAX_URL_SIZE];
+ char bootstrap_info_id[MAX_URL_SIZE];
+
+ AVStream *audio_stream;
+ AVStream *video_stream;
+ int nb_samples;
+ FLVMediaSample *samples[MAX_NB_SAMPLES];
+ int sample_index;
+
+ int nb_first_fragment;
+ int nb_offset_fragment;
+ int nb_fragments_read;
+ int nb_fragments_total;
+} HDSMedia;
+
+typedef struct HDSContext {
+ char id[MAX_URL_SIZE];
+ int is_live;
+ char base_url[MAX_URL_SIZE];
+ int nb_bootstraps;
+ HDSBootstrapInfo *bootstrap_info[MAX_NB_BOOTSTRAPS];
+ int nb_media;
+ HDSMedia *media[MAX_NB_MEDIA];
+} HDSContext;
+
+static void construct_bootstrap_url(const char *base_url, const char *bootstrap_url,
+ const char *suffix, char *url_out, size_t url_size)
+{
+ char *p = url_out;
+
+ p += av_strlcat(p, base_url, url_size);
+ p += av_strlcat(p, bootstrap_url, url_size);
+ p += av_strlcat(p, suffix, url_size);
+}
+
+static int download_bootstrap(AVFormatContext *s, HDSBootstrapInfo *bootstrap,
+ uint8_t **buffer_out, int *buffer_size_out)
+{
+ HDSContext *c = s->priv_data;
+ URLContext *puc;
+ char url[MAX_URL_SIZE];
+ uint8_t *buffer;
+ int buffer_size;
+ int ret = 0;
+
+ memset(url, 0x00, sizeof(url));
+
+ if (!av_stristr(bootstrap->url, "?") && av_stristr(s->filename, "?")) {
+ construct_bootstrap_url(c->base_url, bootstrap->url, av_stristr(s->filename, "?"), url, MAX_URL_SIZE);
+ } else {
+ construct_bootstrap_url(c->base_url, bootstrap->url, "", url, MAX_URL_SIZE);
+ }
+
+ if ((ret = ffurl_open(&puc, url, AVIO_FLAG_READ, &s->interrupt_callback, NULL)) < 0) {
+ av_log(s, AV_LOG_ERROR, "hds Failed to start downloading bootstrap, ret: %d \n", ret);
+ return ret;
+ }
+
+ buffer_size = ffurl_size(puc);
+ buffer = av_mallocz(buffer_size+FF_INPUT_BUFFER_PADDING_SIZE);
+ if (!buffer)
+ return AVERROR(ENOMEM);
+
+ if ((ret = ffurl_read_complete(puc, buffer, buffer_size)) < 0) {
+ av_log(s, AV_LOG_ERROR, "hds Failed to downloaded bootstrap, ret: %d \n", ret);
+ av_freep(&buffer);
+ return ret;
+ }
+
+ if ((ret = ffurl_close(puc)) < 0) {
+ av_log(s, AV_LOG_ERROR, "hds Failed to finish downloading bootstrap, ret: %d \n", ret);
+ av_freep(&buffer);
+ return ret;
+ }
+
+ if (buffer_out)
+ *buffer_out = buffer;
+ if (buffer_size_out)
+ *buffer_size_out = buffer_size;
+
+ return ret;
+}
+
+static int create_bootstrap_info(AVFormatContext *s, F4MBootstrapInfo *f4m_bootstrap_info)
+{
+ HDSContext *c = s->priv_data;
+ HDSBootstrapInfo *bootstrap_info;
+ uint8_t *buffer;
+ int buffer_size, ret;
+
+ bootstrap_info = av_mallocz(sizeof(HDSBootstrapInfo));
+ if (!bootstrap_info)
+ return AVERROR(ENOMEM);
+
+ c->bootstrap_info[c->nb_bootstraps++] = bootstrap_info;
+
+ memcpy(bootstrap_info->id, f4m_bootstrap_info->id, sizeof(bootstrap_info->id));
+ memcpy(bootstrap_info->url, f4m_bootstrap_info->url, sizeof(bootstrap_info->url));
+ memcpy(bootstrap_info->profile, f4m_bootstrap_info->profile, sizeof(bootstrap_info->profile));
+
+ if (f4m_bootstrap_info->metadata_size > 0) {
+ buffer = f4m_bootstrap_info->metadata;
+ buffer_size = f4m_bootstrap_info->metadata_size;
+
+ if ((ret = ff_parse_f4f_box(s, buffer, buffer_size, &(bootstrap_info->box))) < 0) {
+ av_log(s, AV_LOG_ERROR, "hds Failed to parse metadata bootstrap box, ret: %d \n", ret);
+ return ret;
+ }
+ } else {
+ if ((ret = download_bootstrap(s, bootstrap_info, &buffer, &buffer_size)) < 0) {
+ av_log(s, AV_LOG_ERROR, "hds Failed to download bootstrap, ret: %d \n", ret);
+ return ret;
+ }
+
+ if ((ret = ff_parse_f4f_box(s, buffer, buffer_size, &(bootstrap_info->box))) < 0) {
+ av_log(s, AV_LOG_ERROR, "hds Failed to parse downloaded bootstrap box, ret: %d \n", ret);
+ av_freep(&buffer);
+ return ret;
+ }
+
+ av_freep(&buffer);
+ }
+
+ return 0;
+}
+
+static int create_streams(AVFormatContext *s, HDSMedia *media, AMFMetadata *metadata)
+{
+ AVStream *st;
+
+ st = avformat_new_stream(s, NULL);
+ if (!st)
+ return AVERROR(ENOMEM);
+
+ media->video_stream = st;
+
+ st->id = 0;
+ avpriv_set_pts_info(st, 32, 1, 1000);
+
+ st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
+ st->codecpar->codec_id = metadata->video_codec_id;
+ st->codecpar->width = metadata->width;
+ st->codecpar->height = metadata->height;
+ st->codecpar->bit_rate = metadata->video_data_rate * 1000;
+
+ st = avformat_new_stream(s, NULL);
+ if (!st)
+ return AVERROR(ENOMEM);
+
+ media->audio_stream = st;
+
+ st->id = 0;
+ avpriv_set_pts_info(st, 32, 1, 1000);
+
+ st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
+ st->codecpar->codec_id = metadata->audio_codec_id;
+ st->codecpar->channels = metadata->nb_audio_channels;
+ st->codecpar->sample_rate = metadata->audio_sample_rate;
+ st->codecpar->bits_per_raw_sample = AV_SAMPLE_FMT_S16;
+ st->codecpar->bit_rate = metadata->audio_data_rate * 1000;
+
+ return 0;
+}
+
+static int create_media(AVFormatContext *s, F4MMedia *f4m_media)
+{
+ HDSContext *c = s->priv_data;
+ HDSMedia *media;
+ AMFMetadata metadata;
+ int ret;
+
+ media = av_mallocz(sizeof(*media));
+ if (!media)
+ return AVERROR(ENOMEM);
+ c->media[c->nb_media++] = media;
+
+ media->bitrate = f4m_media->bitrate;
+ memcpy(media->url, f4m_media->url, sizeof(media->url));
+ memcpy(media->bootstrap_info_id, f4m_media->bootstrap_info_id, sizeof(media->bootstrap_info_id));
+
+ memset(&metadata, 0x00, sizeof(metadata));
+ if ((ret = ff_parse_amf_metadata(s, &metadata, f4m_media->metadata, f4m_media->metadata_size)) < 0) {
+ av_log(s, AV_LOG_ERROR, "hds Failed to parse metadata, ret: %d \n", ret);
+ return ret;
+ }
+
+ if ((ret = create_streams(s, media, &metadata)) < 0)
+ return ret;
+
+ return 0;
+}
+
+static int create_pmt(AVFormatContext *s)
+{
+ HDSContext *c = s->priv_data;
+ HDSMedia *media;
+ AVProgram *p;
+ uint8_t value[1024];
+ int i, j = 0;
+
+ for (i = 0; i < c->nb_media; i++) {
+ media = c->media[i];
+ p = av_new_program(s, j++);
+ if (!p)
+ return AVERROR(ENOMEM);
+ snprintf(value, sizeof(value),"Bandwidth: %dKbps", media->bitrate);
+ av_dict_set(&p->metadata,"name", value, 0);
+ av_program_add_stream_index(s, p->id, media->video_stream->index);
+ av_program_add_stream_index(s, p->id, media->audio_stream->index);
+ }
+
+ return 0;
+}
+
+static int hds_create_context(AVFormatContext *s, F4MManifest *manifest)
+{
+ HDSContext *c = s->priv_data;
+ F4MBootstrapInfo *f4m_bootstrap_info;
+ F4MMedia *f4m_media;
+ int i, ret;
+
+ for (i = 0; i < manifest->nb_bootstraps; i++) {
+ f4m_bootstrap_info = manifest->bootstraps[i];
+ if ((ret = create_bootstrap_info(s, f4m_bootstrap_info)) < 0) {
+ av_log(s, AV_LOG_ERROR, "hds Failed to create bootstrap_info, ret: %d \n", ret);
+ return ret;
+ }
+ }
+
+ for (i = 0; i < manifest->nb_media; i++) {
+ f4m_media = manifest->media[i];
+ if ((ret = create_media(s, f4m_media)) < 0) {
+ av_log(s, AV_LOG_ERROR, "hds Failed to create media, ret: %d \n", ret);
+ return ret;
+ }
+ }
+
+ if ((ret = create_pmt(s)) < 0) {
+ av_log(s, AV_LOG_ERROR, "hds Failed to create PMT, ret: %d \n", ret);
+ return ret;
+ }
+
+ if (!av_strcasecmp(manifest->stream_type, "live"))
+ c->is_live = 1;
+ av_log(s, AV_LOG_DEBUG, "hds stream_type live %s \n", c->is_live ? "TRUE" : "FALSE");
+
+ return 0;
+}
+
+static int hds_read_header(AVFormatContext *s)
+{
+ HDSContext *c = s->priv_data;
+ AVIOContext *in = s->pb;
+ F4MManifest manifest;
+ int64_t filesize;
+ uint8_t *buf;
+ char *p, *pch;
+ int ret;
+
+ p = av_stristr(s->filename, ".f4m");
+ pch = strrchr(s->filename, '/');
+ if (!p || !pch) {
+ av_log(s, AV_LOG_ERROR, "hds Failed to build base url, url: %s \n", s->filename);
+ return -1;
+ }
+ av_strlcpy(c->base_url, s->filename, pch - s->filename + 2);
+ av_log(s, AV_LOG_DEBUG, "hds build base url: %s \n", c->base_url);
+ filesize = avio_size(in);
+ if (filesize <= 0){
+ filesize = 8 * 1024;
+ }
+ buf = av_mallocz(filesize);
+ if (!buf)
+ return AVERROR(ENOMEM);
+
+ avio_read(in, buf, filesize);
+ memset(&manifest, 0x00, sizeof(manifest));
+ if ((ret = ff_parse_f4m_manifest(s, buf, filesize, &manifest)) < 0) {
+ av_freep(&buf);
+ ff_free_manifest(&manifest);
+ return ret;
+ }
+
+ av_freep(&buf);
+
+ ret = hds_create_context(s, &manifest);
+ ff_free_manifest(&manifest);
+
+ return ret;
+}
+
+static void construct_fragment_url(const char *base_url, const char *media_url,
+ int segment, int fragment, const char *suffix, char *url_out, size_t url_size)
+{
+ char *p;
+ char fragment_str[1024];
+
+ p = url_out;
+ p += av_strlcat(p, base_url, url_size);
+ p += av_strlcat(p, media_url, url_size);
+
+ snprintf(fragment_str, sizeof (fragment_str), "Seg%d-Frag%d", segment, fragment);
+ p += av_strlcat(p, fragment_str, url_size);
+ p += av_strlcat(p, suffix, url_size);
+}
+
+static int get_offset_fragment(HDSBootstrapInfo *bootstrap_info)
+{
+ F4FBootstrapInfoBox *abst = &(bootstrap_info->box.abst);
+ F4FSegmentRunTableBox *asrt;
+ F4FSegmentRunEntry *segment_entry;
+ int offset = 0;
+ int i,j;
+
+ for (i = 0; i < abst->nb_segment_run_table_boxes; i++) {
+ asrt = abst->segment_run_table_boxes[i];
+ for (j = 0; j < asrt->nb_segment_run_entries; j++) {
+ segment_entry = asrt->segment_run_entries[j];
+ offset += segment_entry->fragments_per_segment;
+ }
+ }
+
+ return offset;
+}
+
+static int get_total_fragment(HDSBootstrapInfo *bootstrap_info)
+{
+ F4FBootstrapInfoBox *abst = &(bootstrap_info->box.abst);
+ F4FSegmentRunTableBox *asrt;
+ F4FSegmentRunEntry *segment_entry;
+ int total = 0;
+ int i;
+
+ for (i = 0; i < abst->nb_segment_run_table_boxes; i++) {
+ asrt = abst->segment_run_table_boxes[i];
+ segment_entry = asrt->segment_run_entries[0];
+ total = asrt->nb_segment_run_entries * segment_entry->fragments_per_segment;
+ }
+
+ return total;
+}
+
+
+static int get_current_segment(HDSBootstrapInfo *bootstrap_info)
+{
+ F4FBootstrapInfoBox *abst = &(bootstrap_info->box.abst);
+ F4FSegmentRunTableBox *asrt;
+ F4FSegmentRunEntry *segment_entry;
+ int segment = 0;
+ int i, j;
+
+ for (i = 0; i < abst->nb_segment_run_table_boxes; i++) {
+ asrt = abst->segment_run_table_boxes[i];
+ for (j = 0; j < asrt->nb_segment_run_entries; j++) {
+ segment_entry = asrt->segment_run_entries[j];
+ segment = segment_entry->first_segment;
+ }
+ }
+ return segment;
+}
+
+
+static int get_first_fragment(HDSBootstrapInfo *bootstrap_info)
+{
+ F4FBootstrapInfoBox *abst = &(bootstrap_info->box.abst);
+ F4FFragmentRunTableBox *afrt;
+ F4FFragmentRunEntry *fragment_entry;
+ int fragment = 0;
+ int i, j;
+
+ for (i = 0; i < abst->nb_fragment_run_table_boxes; i++) {
+ afrt = abst->fragment_run_table_boxes[i];
+ for (j = 0; j < afrt->nb_fragment_run_entries; j++) {
+ fragment_entry = afrt->fragment_run_entries[j];
+ if (fragment_entry->first_fragment > 0) {
+ fragment = fragment_entry->first_fragment;
+ return fragment;
+ }
+ }
+ }
+
+ return fragment;
+}
+
+static int get_segment_fragment(AVFormatContext *s, HDSBootstrapInfo *bootstrap_info,
+ HDSMedia *media, int is_live, int *segment_out, int *fragment_out)
+{
+ uint8_t *buffer;
+ int segment, fragment;
+ int buffer_size;
+ int ret = 0;
+
+ segment = get_current_segment(bootstrap_info);
+ if (!media->nb_first_fragment)
+ media->nb_first_fragment = get_first_fragment(bootstrap_info);
+ if (!media->nb_fragments_total)
+ media->nb_fragments_total = get_total_fragment(bootstrap_info);
+
+ fragment = media->nb_first_fragment + media->nb_fragments_read;
+ av_log(s, AV_LOG_DEBUG, "hds current_segment: %d current_fragment: %d\n", segment, fragment);
+ if (is_live) {
+ if (!media->nb_offset_fragment)
+ media->nb_offset_fragment = get_offset_fragment(bootstrap_info);
+ fragment += media->nb_offset_fragment - 1;
+
+ av_log(s, AV_LOG_DEBUG, "hds live current_fragment: %d total_fragments: %d\n",
+ fragment, media->nb_first_fragment + media->nb_fragments_total);
+
+ if (fragment >= (media->nb_first_fragment + media->nb_fragments_total)) {
+ /* Update bootstrap info*/
+ av_log(s, AV_LOG_DEBUG, "update bootstrap_info\n");
+ if ((ret = ff_free_f4f_box(&(bootstrap_info->box))) < 0) {
+ av_log(s, AV_LOG_ERROR, "hds Failed to free bootstrap box, ret: %d \n", ret);
+ return ret;
+ }
+ if ((ret = download_bootstrap(s, bootstrap_info, &buffer, &buffer_size)) < 0) {
+ av_log(s, AV_LOG_ERROR, "hds Failed to download bootstrap, ret: %d \n", ret);
+ return ret;
+ }
+ if ((ret = ff_parse_f4f_box(s, buffer, buffer_size, &(bootstrap_info->box))) < 0) {
+ av_log(s, AV_LOG_ERROR, "hds Failed to parse downloaded bootstrap box, ret: %d \n", ret);
+ av_freep(&buffer);
+ return ret;
+ }
+ segment = get_current_segment(bootstrap_info);
+ media->nb_first_fragment = 0;
+ media->nb_fragments_read = 0;
+ media->nb_fragments_total = 0;
+ media->nb_offset_fragment = 0;
+ av_freep(&buffer);
+ }
+ }
+
+ if (!is_live && fragment >= (media->nb_first_fragment + media->nb_fragments_total)) {
+ return AVERROR_EOF;
+ }
+
+ if (segment_out)
+ *segment_out = segment;
+ if (fragment_out)
+ *fragment_out = fragment;
+ return ret;
+}
+
+static int download_fragment(AVFormatContext *s, HDSBootstrapInfo *bootstrap_info, HDSMedia *media,
+ uint8_t **buffer_out, int *buffer_size_out)
+{
+ HDSContext *c = s->priv_data;
+ URLContext *puc;
+ char url[MAX_URL_SIZE];
+ uint8_t *buffer;
+ int buffer_size;
+ int segment, fragment;
+ int ret;
+
+ if ((ret = get_segment_fragment(s, bootstrap_info, media, c->is_live, &segment, &fragment)) < 0) {
+ return ret;
+ }
+
+ memset(url, 0x00, sizeof(url));
+
+ if (!av_stristr(media->url, "?") && av_stristr(s->filename, "?")) {
+ construct_fragment_url(c->base_url, media->url,
+ segment, fragment, av_stristr(s->filename, "?"), url, MAX_URL_SIZE);
+ } else {
+ construct_fragment_url(c->base_url, media->url, segment, fragment, "", url, MAX_URL_SIZE);
+ }
+
+ if ((ret = ffurl_open(&puc, url, AVIO_FLAG_READ, &s->interrupt_callback, NULL)) < 0) {
+ if (ret != AVERROR(EIO))
+ av_log(s, AV_LOG_ERROR, "hds Failed to start downloading fragment, url:%s, ret:%d \n", url, ret);
+ return ret;
+ }
+
+ buffer_size = ffurl_size(puc);
+ buffer = av_mallocz(buffer_size+FF_INPUT_BUFFER_PADDING_SIZE);
+ if (!buffer)
+ return AVERROR(ENOMEM);
+
+ if ((ret = ffurl_read_complete(puc, buffer, buffer_size)) < 0) {
+ av_log(s, AV_LOG_ERROR, "hds Failed to downloaded fragment, ret: %d \n", ret);
+ av_freep(&buffer);
+ return ret;
+ }
+
+ if ((ret = ffurl_close(puc)) < 0) {
+ av_log(s, AV_LOG_ERROR, "hds Failed to finish downloading fragment, ret: %d \n", ret);
+ av_freep(&buffer);
+ return ret;
+ }
+
+ media->nb_fragments_read++;
+
+ if (buffer_out)
+ *buffer_out = buffer;
+ if (buffer_size_out)
+ *buffer_size_out = buffer_size;
+
+ return 0;
+}
+
+static int get_next_fragment(AVFormatContext *s, HDSBootstrapInfo *bootstrap_info, HDSMedia *media)
+{
+ F4FBox box;
+ uint8_t *buffer;
+ int buffer_size, ret;
+
+ if ((ret = download_fragment(s, bootstrap_info, media, &buffer, &buffer_size)) < 0) {
+ return ret;
+ }
+
+ memset(&box, 0x00, sizeof(box));
+ if ((ret = ff_parse_f4f_box(s, buffer, buffer_size, &box)) < 0) {
+ av_log(s, AV_LOG_ERROR, "hds Failed to parse bootstrap box, ret: %d \n", ret);
+ av_freep(&buffer);
+ ff_free_f4f_box(&box);
+ return ret;
+ }
+ av_freep(&buffer);
+
+ if ((ret = ff_decode_flv_body(s ,box.mdat.data, box.mdat.size, media->samples, &media->nb_samples)) < 0) {
+ av_log(s, AV_LOG_ERROR, "hds Failed to decode FLV body, ret: %d \n", ret);
+ ff_free_f4f_box(&box);
+ return ret;
+ }
+
+ ff_free_f4f_box(&box);
+
+ return 0;
+}
+
+static void read_next_sample(HDSMedia *media, AVPacket *pkt)
+{
+ FLVMediaSample *sample;
+
+ sample = media->samples[media->sample_index];
+ media->sample_index++;
+
+ av_new_packet(pkt, sample->data_size);
+ memcpy(pkt->data, sample->data, sample->data_size);
+
+ pkt->dts = sample->timestamp;
+ if (sample->type == AVMEDIA_TYPE_VIDEO && media->video_stream) {
+ pkt->stream_index = media->video_stream->index;
+ } else if (sample->type == AVMEDIA_TYPE_AUDIO && media->audio_stream) {
+ pkt->stream_index = media->audio_stream->index;
+ }
+}
+
+static void clear_samples(HDSMedia *media)
+{
+ FLVMediaSample *sample;
+ int i;
+
+ for (i = 0; i < media->nb_samples; i++) {
+ sample = media->samples[i];
+ av_freep(&sample->data);
+ av_freep(&sample);
+ media->samples[i] = NULL;
+ }
+
+ media->nb_samples = 0;
+ media->sample_index = 0;
+}
+
+static int get_next_packet(AVFormatContext *s,
+ HDSBootstrapInfo *bootstrap_info, HDSMedia *media, AVPacket *pkt)
+{
+ int ret = 0;
+
+ if (!media->nb_samples) {
+ if ((ret = get_next_fragment(s, bootstrap_info, media)) < 0) {
+ return ret;
+ }
+ }
+
+ if (media->nb_samples > 0) {
+ read_next_sample(media, pkt);
+ }
+
+ if (media->sample_index >= media->nb_samples) {
+ clear_samples(media);
+ }
+
+ return ret;
+}
+
+static int hds_read_packet(AVFormatContext *s, AVPacket *pkt)
+{
+ HDSContext *c = s->priv_data;
+ HDSBootstrapInfo *bootstrap_info;
+ HDSMedia *media;
+ int i, j;
+
+ for (i = 0; i < c->nb_media; i++) {
+ media = c->media[i];
+ bootstrap_info = NULL;
+
+ if (media->video_stream->discard == AVDISCARD_ALL &&
+ media->audio_stream->discard == AVDISCARD_ALL) {
+ continue;
+ }
+
+ for (j = 0; j < c->nb_bootstraps; j++) {
+ if (av_strcasecmp(media->bootstrap_info_id, c->bootstrap_info[j]->id)) {
+ continue;
+ }
+ bootstrap_info = c->bootstrap_info[j];
+ break;
+ }
+ if (!bootstrap_info)
+ continue;
+
+ break;
+ }
+
+ if (!bootstrap_info) {
+ av_log(s, AV_LOG_ERROR, "cannot find bootstrap info");
+ return AVERROR(EINVAL);
+ }
+
+ if (!media) {
+ av_log(s, AV_LOG_ERROR, "cannot find media");
+ return AVERROR(EINVAL);
+ }
+
+ return get_next_packet(s, bootstrap_info, media, pkt);
+}
+
+static int hds_close(AVFormatContext *s)
+{
+ HDSContext *c = s->priv_data;
+ HDSBootstrapInfo *bootstrap_info;
+ HDSMedia *media;
+ int i;
+
+ for (i = 0; i < c->nb_bootstraps; i++) {
+ bootstrap_info = c->bootstrap_info[i];
+ ff_free_f4f_box(&bootstrap_info->box);
+ av_freep(&bootstrap_info);
+ }
+
+ for (i = 0; i < c->nb_media; i++) {
+ media = c->media[i];
+ clear_samples(media);
+ av_freep(&media);
+ }
+
+ memset(c, 0x00, sizeof(*c));
+
+ return 0;
+}
+
+static int hds_probe(AVProbeData *p)
+{
+ if (strncmp(p->buf, "<?xml version", 13)) {
+ return 0;
+ }
+
+ if (strstr(p->buf, "<manifest xmlns=\"http://ns.adobe.com/f4m") ||
+ strstr(p->buf, "<bootstrapInfo") ||
+ strstr(p->buf, "<media")) {
+ return AVPROBE_SCORE_MAX;
+ }
+ return 0;
+}
+
+AVInputFormat ff_hds_demuxer = {
+ .name = "hds",
+ .long_name = NULL_IF_CONFIG_SMALL("Adobe HTTP Dynamic Streaming Demuxer"),
+ .priv_data_size = sizeof(HDSContext),
+ .read_probe = hds_probe,
+ .read_header = hds_read_header,
+ .read_packet = hds_read_packet,
+ .read_close = hds_close,
+};
--
1.7.1
More information about the ffmpeg-devel
mailing list