#include "libavutil/dict.h"
#include "libavutil/opt.h"
#include "libavutil/pixdesc.h"
+#include "libavutil/spherical.h"
+#include "libavutil/stereo3d.h"
+
#include "libavcodec/ac3tab.h"
+#include "libavcodec/bitstream.h"
+
#include "avformat.h"
#include "internal.h"
#include "avio_internal.h"
#include "riff.h"
#include "isom.h"
-#include "libavcodec/get_bits.h"
#include "id3v1.h"
#include "mov_chan.h"
#include "replaygain.h"
for (i = 0; i < len; i++) {
uint8_t t, c = avio_r8(pb);
- if (c < 0x80 && p < end)
+
+ if (p >= end)
+ continue;
+
+ if (c < 0x80)
*p++ = c;
else
PUT_UTF8(mac_to_unicode[c-0x80], t, if (p < end) *p++ = t;);
ctype = avio_rl32(pb);
type = avio_rl32(pb); /* component subtype */
- av_log(c->fc, AV_LOG_TRACE, "ctype= %.4s (0x%08x)\n", (char*)&ctype, ctype);
+ av_log(c->fc, AV_LOG_TRACE, "ctype= %.4s (0x%08"PRIx32")\n", (char *)&ctype, ctype);
av_log(c->fc, AV_LOG_TRACE, "stype= %.4s\n", (char*)&type);
if (type == MKTAG('v','i','d','e'))
av_dict_set(&st->metadata, "encoder", codec_name, 0);
/* codec_tag YV12 triggers an UV swap in rawdec.c */
- if (!memcmp(codec_name, "Planar Y'CbCr 8-bit 4:2:0", 25))
+ if (!strncmp(codec_name, "Planar Y'CbCr 8-bit 4:2:0", 25))
st->codecpar->codec_tag = MKTAG('I', '4', '2', '0');
/* Flash Media Server uses tag H.263 with Sorenson Spark */
if (st->codecpar->codec_tag == MKTAG('H','2','6','3') &&
- !memcmp(codec_name, "Sorenson H263", 13))
+ !strncmp(codec_name, "Sorenson H263", 13))
st->codecpar->codec_id = AV_CODEC_ID_FLV1;
st->codecpar->bits_per_coded_sample = avio_rb16(pb); /* depth */
avio_rb24(pb); /* flags */
entries = avio_rb32(pb);
+ if (sc->extradata) {
+ av_log(c->fc, AV_LOG_ERROR,
+ "Duplicate stsd found in this track.\n");
+ return AVERROR_INVALIDDATA;
+ }
+
/* Prepare space for hosting multiple extradata. */
sc->extradata = av_mallocz_array(entries, sizeof(*sc->extradata));
if (!sc->extradata)
return 0;
}
-static inline int mov_stsc_index_valid(int index, int count)
+static inline int mov_stsc_index_valid(unsigned int index, unsigned int count)
{
- return index + 1 < count;
+ return index < count - 1;
}
/* Compute the samples value for the stsc entry at the given index. */
-static inline int mov_get_stsc_samples(MOVStreamContext *sc, int index)
+static inline int mov_get_stsc_samples(MOVStreamContext *sc, unsigned int index)
{
int chunk_count;
AVStream *st;
MOVStreamContext *sc;
unsigned int i, entries, sample_size, field_size, num_bytes;
- GetBitContext gb;
+ BitstreamContext bc;
unsigned char* buf;
int ret;
return ret;
}
- init_get_bits(&gb, buf, 8*num_bytes);
+ bitstream_init8(&bc, buf, num_bytes);
for (i = 0; i < entries && !pb->eof_reached; i++) {
- sc->sample_sizes[i] = get_bits_long(&gb, field_size);
+ sc->sample_sizes[i] = bitstream_read(&bc, field_size);
sc->data_size += sc->sample_sizes[i];
}
( (matrix)[0][0] == (1 << 16) && \
(matrix)[1][1] == (1 << 16) && \
(matrix)[2][2] == (1 << 30) && \
- !(matrix)[0][1] && !(matrix)[0][2] || \
- !(matrix)[1][0] && !(matrix)[1][2] || \
+ !(matrix)[0][1] && !(matrix)[0][2] && \
+ !(matrix)[1][0] && !(matrix)[1][2] && \
!(matrix)[2][0] && !(matrix)[2][1])
static int mov_read_tkhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
return 0;
}
+static int mov_read_st3d(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+{
+ AVStream *st;
+ MOVStreamContext *sc;
+ enum AVStereo3DType type;
+ int mode;
+
+ if (c->fc->nb_streams < 1)
+ return 0;
+
+ st = c->fc->streams[c->fc->nb_streams - 1];
+ sc = st->priv_data;
+
+ if (atom.size < 5) {
+ av_log(c->fc, AV_LOG_ERROR, "Empty stereoscopic video box\n");
+ return AVERROR_INVALIDDATA;
+ }
+ avio_skip(pb, 4); /* version + flags */
+
+ mode = avio_r8(pb);
+ switch (mode) {
+ case 0:
+ type = AV_STEREO3D_2D;
+ break;
+ case 1:
+ type = AV_STEREO3D_TOPBOTTOM;
+ break;
+ case 2:
+ type = AV_STEREO3D_SIDEBYSIDE;
+ break;
+ default:
+ av_log(c->fc, AV_LOG_WARNING, "Unknown st3d mode value %d\n", mode);
+ return 0;
+ }
+
+ sc->stereo3d = av_stereo3d_alloc();
+ if (!sc->stereo3d)
+ return AVERROR(ENOMEM);
+
+ sc->stereo3d->type = type;
+ return 0;
+}
+
+static int mov_read_sv3d(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+{
+ AVStream *st;
+ MOVStreamContext *sc;
+ int size;
+ int32_t yaw, pitch, roll;
+ uint32_t tag;
+ enum AVSphericalProjection projection;
+
+ if (c->fc->nb_streams < 1)
+ return 0;
+
+ st = c->fc->streams[c->fc->nb_streams - 1];
+ sc = st->priv_data;
+
+ if (atom.size < 8) {
+ av_log(c->fc, AV_LOG_ERROR, "Empty spherical video box\n");
+ return AVERROR_INVALIDDATA;
+ }
+
+ size = avio_rb32(pb);
+ if (size > atom.size)
+ return AVERROR_INVALIDDATA;
+
+ tag = avio_rl32(pb);
+ if (tag != MKTAG('s','v','h','d')) {
+ av_log(c->fc, AV_LOG_ERROR, "Missing spherical video header\n");
+ return 0;
+ }
+ avio_skip(pb, 4); /* version + flags */
+ avio_skip(pb, avio_r8(pb)); /* metadata_source */
+
+ size = avio_rb32(pb);
+ if (size > atom.size)
+ return AVERROR_INVALIDDATA;
+
+ tag = avio_rl32(pb);
+ if (tag != MKTAG('p','r','o','j')) {
+ av_log(c->fc, AV_LOG_ERROR, "Missing projection box\n");
+ return 0;
+ }
+
+ size = avio_rb32(pb);
+ if (size > atom.size)
+ return AVERROR_INVALIDDATA;
+
+ tag = avio_rl32(pb);
+ if (tag != MKTAG('p','r','h','d')) {
+ av_log(c->fc, AV_LOG_ERROR, "Missing projection header box\n");
+ return 0;
+ }
+ avio_skip(pb, 4); /* version + flags */
+
+ /* 16.16 fixed point */
+ yaw = avio_rb32(pb);
+ pitch = avio_rb32(pb);
+ roll = avio_rb32(pb);
+
+ size = avio_rb32(pb);
+ if (size > atom.size)
+ return AVERROR_INVALIDDATA;
+
+ tag = avio_rl32(pb);
+ avio_skip(pb, 4); /* version + flags */
+ switch (tag) {
+ case MKTAG('c','b','m','p'):
+ projection = AV_SPHERICAL_CUBEMAP;
+ break;
+ case MKTAG('e','q','u','i'):
+ projection = AV_SPHERICAL_EQUIRECTANGULAR;
+ break;
+ default:
+ av_log(c->fc, AV_LOG_ERROR, "Unknown projection type\n");
+ return 0;
+ }
+
+ sc->spherical = av_spherical_alloc(&sc->spherical_size);
+ if (!sc->spherical)
+ return AVERROR(ENOMEM);
+
+ sc->spherical->projection = projection;
+
+ sc->spherical->yaw = yaw;
+ sc->spherical->pitch = pitch;
+ sc->spherical->roll = roll;
+
+ return 0;
+}
+
+static int mov_parse_uuid_spherical(MOVStreamContext *sc, AVIOContext *pb, size_t len)
+{
+ int ret = 0;
+ uint8_t *buffer = av_malloc(len + 1);
+ const char *val;
+
+ if (!buffer)
+ return AVERROR(ENOMEM);
+ buffer[len] = '\0';
+
+ ret = ffio_read_size(pb, buffer, len);
+ if (ret < 0)
+ goto out;
+
+ /* Check for mandatory keys and values, try to support XML as best-effort */
+ if (av_stristr(buffer, "<GSpherical:StitchingSoftware>") &&
+ (val = av_stristr(buffer, "<GSpherical:Spherical>")) &&
+ av_stristr(val, "true") &&
+ (val = av_stristr(buffer, "<GSpherical:Stitched>")) &&
+ av_stristr(val, "true") &&
+ (val = av_stristr(buffer, "<GSpherical:ProjectionType>")) &&
+ av_stristr(val, "equirectangular")) {
+ sc->spherical = av_spherical_alloc(&sc->spherical_size);
+ if (!sc->spherical)
+ goto out;
+
+ sc->spherical->projection = AV_SPHERICAL_EQUIRECTANGULAR;
+
+ if (av_stristr(buffer, "<GSpherical:StereoMode>")) {
+ enum AVStereo3DType mode;
+
+ if (av_stristr(buffer, "left-right"))
+ mode = AV_STEREO3D_SIDEBYSIDE;
+ else if (av_stristr(buffer, "top-bottom"))
+ mode = AV_STEREO3D_TOPBOTTOM;
+ else
+ mode = AV_STEREO3D_2D;
+
+ sc->stereo3d = av_stereo3d_alloc();
+ if (!sc->stereo3d)
+ goto out;
+
+ sc->stereo3d->type = mode;
+ }
+
+ /* orientation */
+ val = av_stristr(buffer, "<GSpherical:InitialViewHeadingDegrees>");
+ if (val)
+ sc->spherical->yaw = strtol(val, NULL, 10) * (1 << 16);
+ val = av_stristr(buffer, "<GSpherical:InitialViewPitchDegrees>");
+ if (val)
+ sc->spherical->pitch = strtol(val, NULL, 10) * (1 << 16);
+ val = av_stristr(buffer, "<GSpherical:InitialViewRollDegrees>");
+ if (val)
+ sc->spherical->roll = strtol(val, NULL, 10) * (1 << 16);
+ }
+
+out:
+ av_free(buffer);
+ return ret;
+}
+
+static int mov_read_uuid(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+{
+ AVStream *st;
+ MOVStreamContext *sc;
+ int ret;
+
+ uint8_t uuid[16];
+ static const uint8_t uuid_spherical[] = {
+ 0xff, 0xcc, 0x82, 0x63, 0xf8, 0x55, 0x4a, 0x93,
+ 0x88, 0x14, 0x58, 0x7a, 0x02, 0x52, 0x1f, 0xdd,
+ };
+
+ if (atom.size < sizeof(uuid) || atom.size == INT64_MAX)
+ return AVERROR_INVALIDDATA;
+
+ if (c->fc->nb_streams < 1)
+ return 0;
+ st = c->fc->streams[c->fc->nb_streams - 1];
+ sc = st->priv_data;
+
+ ret = ffio_read_size(pb, uuid, sizeof(uuid));
+ if (ret < 0)
+ return ret;
+
+ if (!memcmp(uuid, uuid_spherical, sizeof(uuid)) && !sc->spherical) {
+ size_t len = atom.size - sizeof(uuid);
+ ret = mov_parse_uuid_spherical(sc, pb, len);
+ if (ret < 0)
+ return ret;
+ if (!sc->spherical)
+ av_log(c->fc, AV_LOG_WARNING, "Invalid spherical metadata found\n");
+ } else {
+ int i;
+ av_log(c->fc, AV_LOG_VERBOSE, "Unknown UUID found: 0x");
+ for (i = 0; i < sizeof(uuid); i++)
+ av_log(c->fc, AV_LOG_WARNING, "%02x", uuid[i]);
+ av_log(c->fc, AV_LOG_WARNING, "\n");
+ }
+
+ return 0;
+}
+
static const MOVParseTableEntry mov_default_parse_table[] = {
{ MKTAG('a','v','s','s'), mov_read_extradata },
{ MKTAG('c','h','p','l'), mov_read_chpl },
{ MKTAG('d','v','c','1'), mov_read_dvc1 },
{ MKTAG('s','b','g','p'), mov_read_sbgp },
{ MKTAG('h','v','c','C'), mov_read_glbl },
+{ MKTAG('s','t','3','d'), mov_read_st3d }, /* stereoscopic 3D video box */
+{ MKTAG('s','v','3','d'), mov_read_sv3d }, /* spherical video box */
+{ MKTAG('u','u','i','d'), mov_read_uuid }, /* universal unique identifier */
{ MKTAG('-','-','-','-'), mov_read_custom },
{ 0, NULL }
};
av_free(sc->extradata[j]);
av_freep(&sc->extradata);
av_freep(&sc->extradata_size);
+
+ av_freep(&sc->stereo3d);
+ av_freep(&sc->spherical);
}
if (mov->dv_demux) {
break;
case AVMEDIA_TYPE_VIDEO:
if (sc->display_matrix) {
- AVPacketSideData *sd, *tmp;
+ err = av_stream_add_side_data(st, AV_PKT_DATA_DISPLAYMATRIX,
+ (uint8_t *)sc->display_matrix,
+ sizeof(int32_t) * 9);
+ if (err < 0)
+ return err;
- tmp = av_realloc_array(st->side_data,
- st->nb_side_data + 1, sizeof(*tmp));
- if (!tmp)
- return AVERROR(ENOMEM);
+ sc->display_matrix = NULL;
+ }
+ if (sc->stereo3d) {
+ err = av_stream_add_side_data(st, AV_PKT_DATA_STEREO3D,
+ (uint8_t *)sc->stereo3d,
+ sizeof(*sc->stereo3d));
+ if (err < 0)
+ return err;
- st->side_data = tmp;
- st->nb_side_data++;
+ sc->stereo3d = NULL;
+ }
+ if (sc->spherical) {
+ err = av_stream_add_side_data(st, AV_PKT_DATA_SPHERICAL,
+ (uint8_t *)sc->spherical,
+ sc->spherical_size);
+ if (err < 0)
+ return err;
- sd = &st->side_data[st->nb_side_data - 1];
- sd->type = AV_PKT_DATA_DISPLAYMATRIX;
- sd->size = sizeof(int32_t) * 9;
- sd->data = (uint8_t*)sc->display_matrix;
- sc->display_matrix = NULL;
+ sc->spherical = NULL;
}
break;
}
{
MOVStreamContext *sc = st->priv_data;
int sample, time_sample;
- int i;
+ unsigned int i;
sample = av_index_search_timestamp(st, timestamp, flags);
av_log(s, AV_LOG_TRACE, "stream %d, timestamp %"PRId64", sample %d\n", st->index, timestamp, sample);
projects / ffmpeg / blobdiff