#include <limits.h>
#include <stdint.h>
-//#define MOV_EXPORT_ALL_METADATA
-
#include "libavutil/attributes.h"
#include "libavutil/channel_layout.h"
#include "libavutil/intreadwrite.h"
#include "libavutil/intfloat.h"
#include "libavutil/mathematics.h"
+#include "libavutil/time_internal.h"
#include "libavutil/avstring.h"
#include "libavutil/dict.h"
+#include "libavutil/opt.h"
#include "libavcodec/ac3tab.h"
#include "avformat.h"
#include "internal.h"
static int mov_read_udta_string(MOVContext *c, AVIOContext *pb, MOVAtom atom)
{
-#ifdef MOV_EXPORT_ALL_METADATA
char tmp_key[5];
-#endif
- char str[1024], key2[16], language[4] = {0};
+ char *str, key2[32], language[4] = {0};
const char *key = NULL;
uint16_t langcode = 0;
- uint32_t data_type = 0, str_size;
+ uint32_t data_type = 0, str_size, str_size_alloc;
int (*parse)(MOVContext*, AVIOContext*, unsigned, const char*) = NULL;
+ int raw = 0;
switch (atom.type) {
- case MKTAG(0xa9,'n','a','m'): key = "title"; break;
- case MKTAG(0xa9,'a','u','t'):
- case MKTAG(0xa9,'A','R','T'): key = "artist"; break;
+ case MKTAG( '@','P','R','M'): key = "premiere_version"; raw = 1; break;
+ case MKTAG( '@','P','R','Q'): key = "quicktime_version"; raw = 1; break;
+ case MKTAG( 'X','M','P','_'):
+ if (c->export_xmp) { key = "xmp"; raw = 1; } break;
case MKTAG( 'a','A','R','T'): key = "album_artist"; break;
- case MKTAG(0xa9,'w','r','t'): key = "composer"; break;
- case MKTAG( 'c','p','r','t'):
- case MKTAG(0xa9,'c','p','y'): key = "copyright"; break;
- case MKTAG(0xa9,'c','m','t'):
- case MKTAG(0xa9,'i','n','f'): key = "comment"; break;
- case MKTAG(0xa9,'a','l','b'): key = "album"; break;
- case MKTAG(0xa9,'d','a','y'): key = "date"; break;
- case MKTAG(0xa9,'g','e','n'): key = "genre"; break;
+ case MKTAG( 'a','k','I','D'): key = "account_type";
+ parse = mov_metadata_int8_no_padding; break;
+ case MKTAG( 'a','p','I','D'): key = "account_id"; break;
+ case MKTAG( 'c','a','t','g'): key = "category"; break;
+ case MKTAG( 'c','p','i','l'): key = "compilation";
+ parse = mov_metadata_int8_no_padding; break;
+ case MKTAG( 'c','p','r','t'): key = "copyright"; break;
+ case MKTAG( 'd','e','s','c'): key = "description"; break;
+ case MKTAG( 'd','i','s','k'): key = "disc";
+ parse = mov_metadata_track_or_disc_number; break;
+ case MKTAG( 'e','g','i','d'): key = "episode_uid";
+ parse = mov_metadata_int8_no_padding; break;
case MKTAG( 'g','n','r','e'): key = "genre";
parse = mov_metadata_gnre; break;
- case MKTAG(0xa9,'t','o','o'):
- case MKTAG(0xa9,'s','w','r'): key = "encoder"; break;
- case MKTAG(0xa9,'e','n','c'): key = "encoder"; break;
- case MKTAG(0xa9,'x','y','z'): key = "location"; break;
- case MKTAG( 'd','e','s','c'): key = "description";break;
+ case MKTAG( 'h','d','v','d'): key = "hd_video";
+ parse = mov_metadata_int8_no_padding; break;
+ case MKTAG( 'k','e','y','w'): key = "keywords"; break;
case MKTAG( 'l','d','e','s'): key = "synopsis"; break;
- case MKTAG( 't','v','s','h'): key = "show"; break;
- case MKTAG( 't','v','e','n'): key = "episode_id";break;
- case MKTAG( 't','v','n','n'): key = "network"; break;
+ case MKTAG( 'l','o','c','i'):
+ return mov_metadata_loci(c, pb, atom.size);
+ case MKTAG( 'p','c','s','t'): key = "podcast";
+ parse = mov_metadata_int8_no_padding; break;
+ case MKTAG( 'p','g','a','p'): key = "gapless_playback";
+ parse = mov_metadata_int8_no_padding; break;
+ case MKTAG( 'p','u','r','d'): key = "purchase_date"; break;
+ case MKTAG( 'r','t','n','g'): key = "rating";
+ parse = mov_metadata_int8_no_padding; break;
+ case MKTAG( 's','o','a','a'): key = "sort_album_artist"; break;
+ case MKTAG( 's','o','a','l'): key = "sort_album"; break;
+ case MKTAG( 's','o','a','r'): key = "sort_artist"; break;
+ case MKTAG( 's','o','c','o'): key = "sort_composer"; break;
+ case MKTAG( 's','o','n','m'): key = "sort_name"; break;
+ case MKTAG( 's','o','s','n'): key = "sort_show"; break;
+ case MKTAG( 's','t','i','k'): key = "media_type";
+ parse = mov_metadata_int8_no_padding; break;
case MKTAG( 't','r','k','n'): key = "track";
parse = mov_metadata_track_or_disc_number; break;
- case MKTAG( 'd','i','s','k'): key = "disc";
- parse = mov_metadata_track_or_disc_number; break;
+ case MKTAG( 't','v','e','n'): key = "episode_id"; break;
case MKTAG( 't','v','e','s'): key = "episode_sort";
parse = mov_metadata_int8_bypass_padding; break;
+ case MKTAG( 't','v','n','n'): key = "network"; break;
+ case MKTAG( 't','v','s','h'): key = "show"; break;
case MKTAG( 't','v','s','n'): key = "season_number";
parse = mov_metadata_int8_bypass_padding; break;
- case MKTAG( 's','t','i','k'): key = "media_type";
- parse = mov_metadata_int8_no_padding; break;
- case MKTAG( 'h','d','v','d'): key = "hd_video";
- parse = mov_metadata_int8_no_padding; break;
- case MKTAG( 'p','g','a','p'): key = "gapless_playback";
- parse = mov_metadata_int8_no_padding; break;
- case MKTAG( 'l','o','c','i'):
- return mov_metadata_loci(c, pb, atom.size);
+ case MKTAG(0xa9,'A','R','T'): key = "artist"; break;
+ case MKTAG(0xa9,'P','R','D'): key = "producer"; break;
+ case MKTAG(0xa9,'a','l','b'): key = "album"; break;
+ case MKTAG(0xa9,'a','u','t'): key = "artist"; break;
+ case MKTAG(0xa9,'c','h','p'): key = "chapter"; break;
+ case MKTAG(0xa9,'c','m','t'): key = "comment"; break;
+ case MKTAG(0xa9,'c','o','m'): key = "composer"; break;
+ case MKTAG(0xa9,'c','p','y'): key = "copyright"; break;
+ case MKTAG(0xa9,'d','a','y'): key = "date"; break;
+ case MKTAG(0xa9,'d','i','r'): key = "director"; break;
+ case MKTAG(0xa9,'d','i','s'): key = "disclaimer"; break;
+ case MKTAG(0xa9,'e','d','1'): key = "edit_date"; break;
+ case MKTAG(0xa9,'e','n','c'): key = "encoder"; break;
+ case MKTAG(0xa9,'f','m','t'): key = "original_format"; break;
+ case MKTAG(0xa9,'g','e','n'): key = "genre"; break;
+ case MKTAG(0xa9,'g','r','p'): key = "grouping"; break;
+ case MKTAG(0xa9,'h','s','t'): key = "host_computer"; break;
+ case MKTAG(0xa9,'i','n','f'): key = "comment"; break;
+ case MKTAG(0xa9,'l','y','r'): key = "lyrics"; break;
+ case MKTAG(0xa9,'m','a','k'): key = "make"; break;
+ case MKTAG(0xa9,'m','o','d'): key = "model"; break;
+ case MKTAG(0xa9,'n','a','m'): key = "title"; break;
+ case MKTAG(0xa9,'o','p','e'): key = "original_artist"; break;
+ case MKTAG(0xa9,'p','r','d'): key = "producer"; break;
+ case MKTAG(0xa9,'p','r','f'): key = "performers"; break;
+ case MKTAG(0xa9,'r','e','q'): key = "playback_requirements"; break;
+ case MKTAG(0xa9,'s','r','c'): key = "original_source"; break;
+ case MKTAG(0xa9,'s','t','3'): key = "subtitle"; break;
+ case MKTAG(0xa9,'s','w','r'): key = "encoder"; break;
+ case MKTAG(0xa9,'t','o','o'): key = "encoder"; break;
+ case MKTAG(0xa9,'t','r','k'): key = "track"; break;
+ case MKTAG(0xa9,'u','r','l'): key = "URL"; break;
+ case MKTAG(0xa9,'w','r','n'): key = "warning"; break;
+ case MKTAG(0xa9,'w','r','t'): key = "composer"; break;
+ case MKTAG(0xa9,'x','y','z'): key = "location"; break;
}
if (c->itunes_metadata && atom.size > 8) {
}
}
} else return 0;
- } else if (atom.size > 4 && key && !c->itunes_metadata) {
+ } else if (atom.size > 4 && key && !c->itunes_metadata && !raw) {
str_size = avio_rb16(pb); // string length
langcode = avio_rb16(pb);
ff_mov_lang_to_iso639(langcode, language);
} else
str_size = atom.size;
-#ifdef MOV_EXPORT_ALL_METADATA
- if (!key) {
+ if (c->export_all && !key) {
snprintf(tmp_key, 5, "%.4s", (char*)&atom.type);
key = tmp_key;
}
-#endif
if (!key)
return 0;
if (atom.size < 0)
return AVERROR_INVALIDDATA;
- str_size = FFMIN3(sizeof(str)-1, str_size, atom.size);
+ // allocate twice as much as worst-case
+ str_size_alloc = (raw ? str_size : str_size * 2) + 1;
+ str = av_malloc(str_size_alloc);
+ if (!str)
+ return AVERROR(ENOMEM);
if (parse)
parse(c, pb, str_size, key);
else {
- if (data_type == 3 || (data_type == 0 && (langcode < 0x400 || langcode == 0x7fff))) { // MAC Encoded
- mov_read_mac_string(c, pb, str_size, str, sizeof(str));
+ if (!raw && (data_type == 3 || (data_type == 0 && (langcode < 0x400 || langcode == 0x7fff)))) { // MAC Encoded
+ mov_read_mac_string(c, pb, str_size, str, str_size_alloc);
} else {
avio_read(pb, str, str_size);
str[str_size] = 0;
}
av_dlog(c->fc, "lang \"%3s\" ", language);
av_dlog(c->fc, "tag \"%s\" value \"%s\" atom \"%.4s\" %d %"PRId64"\n",
- key, str, (char*)&atom.type, str_size, atom.size);
+ key, str, (char*)&atom.type, str_size_alloc, atom.size);
+ av_freep(&str);
return 0;
}
AVStream *st;
uint32_t type;
uint32_t av_unused ctype;
+ int64_t title_size;
+ char *title_str;
if (c->fc->nb_streams < 1) // meta before first trak
return 0;
avio_rb32(pb); /* component flags */
avio_rb32(pb); /* component flags mask */
+ title_size = atom.size - 24;
+ if (title_size > 0) {
+ title_str = av_malloc(title_size + 1); /* Add null terminator */
+ if (!title_str)
+ return AVERROR(ENOMEM);
+ avio_read(pb, title_str, title_size);
+ title_str[title_size] = 0;
+ if (title_str[0]) {
+ int off = (!c->isom && title_str[0] == title_size - 1);
+ av_dict_set(&st->metadata, "handler_name", title_str + off, 0);
+ }
+ av_freep(&title_str);
+ }
+
return 0;
}
static int mov_read_dac3(MOVContext *c, AVIOContext *pb, MOVAtom atom)
{
AVStream *st;
+ enum AVAudioServiceType *ast;
int ac3info, acmod, lfeon, bsmod;
if (c->fc->nb_streams < 1)
return 0;
st = c->fc->streams[c->fc->nb_streams-1];
+ ast = (enum AVAudioServiceType*)ff_stream_new_side_data(st, AV_PKT_DATA_AUDIO_SERVICE_TYPE,
+ sizeof(*ast));
+ if (!ast)
+ return AVERROR(ENOMEM);
+
ac3info = avio_rb24(pb);
bsmod = (ac3info >> 14) & 0x7;
acmod = (ac3info >> 11) & 0x7;
st->codec->channel_layout = avpriv_ac3_channel_layout_tab[acmod];
if (lfeon)
st->codec->channel_layout |= AV_CH_LOW_FREQUENCY;
- st->codec->audio_service_type = bsmod;
+ *ast = bsmod;
if (st->codec->channels > 1 && bsmod == 0x7)
- st->codec->audio_service_type = AV_AUDIO_SERVICE_TYPE_KARAOKE;
+ *ast = AV_AUDIO_SERVICE_TYPE_KARAOKE;
+
+ st->codec->audio_service_type = *ast;
return 0;
}
static int mov_read_dec3(MOVContext *c, AVIOContext *pb, MOVAtom atom)
{
AVStream *st;
+ enum AVAudioServiceType *ast;
int eac3info, acmod, lfeon, bsmod;
if (c->fc->nb_streams < 1)
return 0;
st = c->fc->streams[c->fc->nb_streams-1];
+ ast = (enum AVAudioServiceType*)ff_stream_new_side_data(st, AV_PKT_DATA_AUDIO_SERVICE_TYPE,
+ sizeof(*ast));
+ if (!ast)
+ return AVERROR(ENOMEM);
+
/* No need to parse fields for additional independent substreams and its
* associated dependent substreams since libavcodec's E-AC-3 decoder
* does not support them yet. */
if (lfeon)
st->codec->channel_layout |= AV_CH_LOW_FREQUENCY;
st->codec->channels = av_get_channel_layout_nb_channels(st->codec->channel_layout);
- st->codec->audio_service_type = bsmod;
+ *ast = bsmod;
if (st->codec->channels > 1 && bsmod == 0x7)
- st->codec->audio_service_type = AV_AUDIO_SERVICE_TYPE_KARAOKE;
+ *ast = AV_AUDIO_SERVICE_TYPE_KARAOKE;
+
+ st->codec->audio_service_type = *ast;
return 0;
}
if (atom.size < 16)
return 0;
+ /* skip version and flags */
+ avio_skip(pb, 4);
+
ff_mov_read_chan(c->fc, pb, st, atom.size - 4);
return 0;
return 0;
st = c->fc->streams[c->fc->nb_streams-1];
- ff_get_wav_header(pb, st->codec, atom.size);
-
- return 0;
+ return ff_get_wav_header(pb, st->codec, atom.size);
}
static int mov_read_pasp(MOVContext *c, AVIOContext *pb, MOVAtom atom)
{
char buffer[32];
if (time) {
- struct tm *ptm;
+ struct tm *ptm, tmbuf;
time -= 2082844800; /* seconds between 1904-01-01 and Epoch */
- ptm = gmtime(&time);
+ ptm = gmtime_r(&time, &tmbuf);
if (!ptm) return;
- strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", ptm);
- av_dict_set(metadata, "creation_time", buffer, 0);
+ if (strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", ptm))
+ av_dict_set(metadata, "creation_time", buffer, 0);
}
}
return 0;
}
+static int mov_read_colr(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+{
+ AVStream *st;
+ char color_parameter_type[5] = { 0 };
+ int color_primaries, color_trc, color_matrix;
+
+ if (c->fc->nb_streams < 1)
+ return 0;
+ st = c->fc->streams[c->fc->nb_streams - 1];
+
+ avio_read(pb, color_parameter_type, 4);
+ if (strncmp(color_parameter_type, "nclx", 4) &&
+ strncmp(color_parameter_type, "nclc", 4)) {
+ av_log(c->fc, AV_LOG_WARNING, "unsupported color_parameter_type %s\n",
+ color_parameter_type);
+ return 0;
+ }
+
+ color_primaries = avio_rb16(pb);
+ color_trc = avio_rb16(pb);
+ color_matrix = avio_rb16(pb);
+
+ av_dlog(c->fc, "%s: pri %"PRIu16" trc %"PRIu16" matrix %"PRIu16"",
+ color_parameter_type, color_primaries, color_trc, color_matrix);
+
+ if (c->isom) {
+ uint8_t color_range = avio_r8(pb) >> 7;
+ av_dlog(c->fc, " full %"PRIu8"", color_range);
+ if (color_range)
+ st->codec->color_range = AVCOL_RANGE_JPEG;
+ else
+ st->codec->color_range = AVCOL_RANGE_MPEG;
+ /* 14496-12 references JPEG XR specs (rather than the more complete
+ * 23001-8) so some adjusting is required */
+ if (color_primaries >= AVCOL_PRI_FILM)
+ color_primaries = AVCOL_PRI_UNSPECIFIED;
+ if ((color_trc >= AVCOL_TRC_LINEAR &&
+ color_trc <= AVCOL_TRC_LOG_SQRT) ||
+ color_trc >= AVCOL_TRC_BT2020_10)
+ color_trc = AVCOL_TRC_UNSPECIFIED;
+ if (color_matrix >= AVCOL_SPC_BT2020_NCL)
+ color_matrix = AVCOL_SPC_UNSPECIFIED;
+ st->codec->color_primaries = color_primaries;
+ st->codec->color_trc = color_trc;
+ st->codec->colorspace = color_matrix;
+ } else {
+ /* color primaries, Table 4-4 */
+ switch (color_primaries) {
+ case 1: st->codec->color_primaries = AVCOL_PRI_BT709; break;
+ case 5: st->codec->color_primaries = AVCOL_PRI_SMPTE170M; break;
+ case 6: st->codec->color_primaries = AVCOL_PRI_SMPTE240M; break;
+ }
+ /* color transfer, Table 4-5 */
+ switch (color_trc) {
+ case 1: st->codec->color_trc = AVCOL_TRC_BT709; break;
+ case 7: st->codec->color_trc = AVCOL_TRC_SMPTE240M; break;
+ }
+ /* color matrix, Table 4-6 */
+ switch (color_matrix) {
+ case 1: st->codec->colorspace = AVCOL_SPC_BT709; break;
+ case 6: st->codec->colorspace = AVCOL_SPC_BT470BG; break;
+ case 7: st->codec->colorspace = AVCOL_SPC_SMPTE240M; break;
+ }
+ }
+ av_dlog(c->fc, "\n");
+
+ return 0;
+}
+
static int mov_read_fiel(MOVContext *c, AVIOContext *pb, MOVAtom atom)
{
AVStream *st;
}
if (entries >= UINT_MAX / sizeof(int))
return AVERROR_INVALIDDATA;
+ av_freep(&sc->keyframes);
sc->keyframes = av_malloc(entries * sizeof(int));
if (!sc->keyframes)
return AVERROR(ENOMEM);
}
// transform the display width/height according to the matrix
- // skip this if the display matrix is the default identity matrix
- // or if it is rotating the picture, ex iPhone 3GS
+ // skip this when the display matrix is the identity one
// to keep the same scale, use [width height 1<<16]
- if (width && height &&
- ((display_matrix[0][0] != 65536 ||
- display_matrix[1][1] != 65536) &&
- !display_matrix[0][1] &&
- !display_matrix[1][0] &&
- !display_matrix[2][0] && !display_matrix[2][1])) {
+ if (width && height && sc->display_matrix) {
for (i = 0; i < 2; i++)
disp_transform[i] =
(int64_t) width * display_matrix[0][i] +
((int64_t) display_matrix[2][i] << 16);
//sample aspect ratio is new width/height divided by old width/height
- st->sample_aspect_ratio = av_d2q(
- ((double) disp_transform[0] * height) /
- ((double) disp_transform[1] * width), INT_MAX);
+ if (disp_transform[0] > 0 && disp_transform[1] > 0)
+ st->sample_aspect_ratio = av_d2q(
+ ((double) disp_transform[0] * height) /
+ ((double) disp_transform[1] * width), INT_MAX);
}
return 0;
}
return 0;
}
+static int mov_read_tfdt(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+{
+ MOVFragment *frag = &c->fragment;
+ AVStream *st = NULL;
+ MOVStreamContext *sc;
+ int version, i;
+
+ for (i = 0; i < c->fc->nb_streams; i++) {
+ if (c->fc->streams[i]->id == frag->track_id) {
+ st = c->fc->streams[i];
+ break;
+ }
+ }
+ if (!st) {
+ av_log(c->fc, AV_LOG_ERROR, "could not find corresponding track id %d\n", frag->track_id);
+ return AVERROR_INVALIDDATA;
+ }
+ sc = st->priv_data;
+ if (sc->pseudo_stream_id + 1 != frag->stsd_id)
+ return 0;
+ version = avio_r8(pb);
+ avio_rb24(pb); /* flags */
+ if (version) {
+ sc->track_end = avio_rb64(pb);
+ } else {
+ sc->track_end = avio_rb32(pb);
+ }
+ return 0;
+}
+
static int mov_read_trun(MOVContext *c, AVIOContext *pb, MOVAtom atom)
{
MOVFragment *frag = &c->fragment;
{ MKTAG('a','v','s','s'), mov_read_extradata },
{ MKTAG('c','h','p','l'), mov_read_chpl },
{ MKTAG('c','o','6','4'), mov_read_stco },
+{ MKTAG('c','o','l','r'), mov_read_colr },
{ MKTAG('c','t','t','s'), mov_read_ctts }, /* composition time to sample */
{ MKTAG('d','i','n','f'), mov_read_default },
{ MKTAG('d','r','e','f'), mov_read_dref },
{ MKTAG('s','t','t','s'), mov_read_stts },
{ MKTAG('s','t','z','2'), mov_read_stsz }, /* compact sample size */
{ MKTAG('t','k','h','d'), mov_read_tkhd }, /* track header */
+{ MKTAG('t','f','d','t'), mov_read_tfdt },
{ MKTAG('t','f','h','d'), mov_read_tfhd }, /* track fragment header */
{ MKTAG('t','r','a','k'), mov_read_trak },
{ MKTAG('t','r','a','f'), mov_read_default },
MOVStreamContext *sc = st->priv_data;
if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
- if (st->codec->width <= 0 && st->codec->width <= 0) {
+ if (st->codec->width <= 0 || st->codec->height <= 0) {
st->codec->width = sc->width;
st->codec->height = sc->height;
}
return 0;
}
+#define OFFSET(x) offsetof(MOVContext, x)
+#define FLAGS AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
+static const AVOption mov_options[] = {
+ { "export_all", "Export unrecognized metadata entries", OFFSET(export_all),
+ AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, .flags = FLAGS },
+ { "export_xmp", "Export full XMP metadata", OFFSET(export_xmp),
+ AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, .flags = FLAGS },
+ { NULL },
+};
+
+static const AVClass mov_class = {
+ .class_name = "mov,mp4,m4a,3gp,3g2,mj2",
+ .item_name = av_default_item_name,
+ .option = mov_options,
+ .version = LIBAVUTIL_VERSION_INT,
+};
+
AVInputFormat ff_mov_demuxer = {
.name = "mov,mp4,m4a,3gp,3g2,mj2",
.long_name = NULL_IF_CONFIG_SMALL("QuickTime / MOV"),
+ .priv_class = &mov_class,
.priv_data_size = sizeof(MOVContext),
.extensions = "mov,mp4,m4a,3gp,3g2,mj2",
.read_probe = mov_probe,