|
|
|
@ -406,8 +406,8 @@ retry: |
|
|
|
av_dict_set(&c->fc->metadata, key2, str, 0); |
|
|
|
av_dict_set(&c->fc->metadata, key2, str, 0); |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
av_dlog(c->fc, "lang \"%3s\" ", language); |
|
|
|
av_log(c->fc, AV_LOG_TRACE, "lang \"%3s\" ", language); |
|
|
|
av_dlog(c->fc, "tag \"%s\" value \"%s\" atom \"%.4s\" %d %"PRId64"\n", |
|
|
|
av_log(c->fc, AV_LOG_TRACE, "tag \"%s\" value \"%s\" atom \"%.4s\" %d %"PRId64"\n", |
|
|
|
key, str, (char*)&atom.type, str_size_alloc, atom.size); |
|
|
|
key, str, (char*)&atom.type, str_size_alloc, atom.size); |
|
|
|
|
|
|
|
|
|
|
|
av_freep(&str); |
|
|
|
av_freep(&str); |
|
|
|
@ -480,7 +480,7 @@ static int mov_read_dref(MOVContext *c, AVIOContext *pb, MOVAtom atom) |
|
|
|
|
|
|
|
|
|
|
|
dref->type = avio_rl32(pb); |
|
|
|
dref->type = avio_rl32(pb); |
|
|
|
avio_rb32(pb); // version + flags
|
|
|
|
avio_rb32(pb); // version + flags
|
|
|
|
av_dlog(c->fc, "type %.4s size %d\n", (char*)&dref->type, size); |
|
|
|
av_log(c->fc, AV_LOG_TRACE, "type %.4s size %d\n", (char*)&dref->type, size); |
|
|
|
|
|
|
|
|
|
|
|
if (dref->type == MKTAG('a','l','i','s') && size > 150) { |
|
|
|
if (dref->type == MKTAG('a','l','i','s') && size > 150) { |
|
|
|
/* macintosh alias record */ |
|
|
|
/* macintosh alias record */ |
|
|
|
@ -577,8 +577,8 @@ static int mov_read_hdlr(MOVContext *c, AVIOContext *pb, MOVAtom atom) |
|
|
|
ctype = avio_rl32(pb); |
|
|
|
ctype = avio_rl32(pb); |
|
|
|
type = avio_rl32(pb); /* component subtype */ |
|
|
|
type = avio_rl32(pb); /* component subtype */ |
|
|
|
|
|
|
|
|
|
|
|
av_dlog(c->fc, "ctype= %.4s (0x%08x)\n", (char*)&ctype, ctype); |
|
|
|
av_log(c->fc, AV_LOG_TRACE, "ctype= %.4s (0x%08x)\n", (char*)&ctype, ctype); |
|
|
|
av_dlog(c->fc, "stype= %.4s\n", (char*)&type); |
|
|
|
av_log(c->fc, AV_LOG_TRACE, "stype= %.4s\n", (char*)&type); |
|
|
|
|
|
|
|
|
|
|
|
if (type == MKTAG('v','i','d','e')) |
|
|
|
if (type == MKTAG('v','i','d','e')) |
|
|
|
st->codec->codec_type = AVMEDIA_TYPE_VIDEO; |
|
|
|
st->codec->codec_type = AVMEDIA_TYPE_VIDEO; |
|
|
|
@ -838,7 +838,7 @@ static int mov_read_moof(MOVContext *c, AVIOContext *pb, MOVAtom atom) |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
c->fragment.moof_offset = c->fragment.implicit_offset = avio_tell(pb) - 8; |
|
|
|
c->fragment.moof_offset = c->fragment.implicit_offset = avio_tell(pb) - 8; |
|
|
|
av_dlog(c->fc, "moof offset %"PRIx64"\n", c->fragment.moof_offset); |
|
|
|
av_log(c->fc, AV_LOG_TRACE, "moof offset %"PRIx64"\n", c->fragment.moof_offset); |
|
|
|
return mov_read_default(c, pb, atom); |
|
|
|
return mov_read_default(c, pb, atom); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
@ -919,7 +919,7 @@ static int mov_read_mvhd(MOVContext *c, AVIOContext *pb, MOVAtom atom) |
|
|
|
mov_metadata_creation_time(&c->fc->metadata, creation_time); |
|
|
|
mov_metadata_creation_time(&c->fc->metadata, creation_time); |
|
|
|
c->time_scale = avio_rb32(pb); /* time scale */ |
|
|
|
c->time_scale = avio_rb32(pb); /* time scale */ |
|
|
|
|
|
|
|
|
|
|
|
av_dlog(c->fc, "time scale = %i\n", c->time_scale); |
|
|
|
av_log(c->fc, AV_LOG_TRACE, "time scale = %i\n", c->time_scale); |
|
|
|
|
|
|
|
|
|
|
|
c->duration = (version == 1) ? avio_rb64(pb) : avio_rb32(pb); /* duration */ |
|
|
|
c->duration = (version == 1) ? avio_rb64(pb) : avio_rb32(pb); /* duration */ |
|
|
|
// set the AVCodecContext duration because the duration of individual tracks
|
|
|
|
// set the AVCodecContext duration because the duration of individual tracks
|
|
|
|
@ -954,7 +954,7 @@ static int mov_read_enda(MOVContext *c, AVIOContext *pb, MOVAtom atom) |
|
|
|
st = c->fc->streams[c->fc->nb_streams-1]; |
|
|
|
st = c->fc->streams[c->fc->nb_streams-1]; |
|
|
|
|
|
|
|
|
|
|
|
little_endian = avio_rb16(pb) & 0xFF; |
|
|
|
little_endian = avio_rb16(pb) & 0xFF; |
|
|
|
av_dlog(c->fc, "enda %d\n", little_endian); |
|
|
|
av_log(c->fc, AV_LOG_TRACE, "enda %d\n", little_endian); |
|
|
|
if (little_endian == 1) { |
|
|
|
if (little_endian == 1) { |
|
|
|
switch (st->codec->codec_id) { |
|
|
|
switch (st->codec->codec_id) { |
|
|
|
case AV_CODEC_ID_PCM_S24BE: |
|
|
|
case AV_CODEC_ID_PCM_S24BE: |
|
|
|
@ -998,12 +998,13 @@ static int mov_read_colr(MOVContext *c, AVIOContext *pb, MOVAtom atom) |
|
|
|
color_trc = avio_rb16(pb); |
|
|
|
color_trc = avio_rb16(pb); |
|
|
|
color_matrix = avio_rb16(pb); |
|
|
|
color_matrix = avio_rb16(pb); |
|
|
|
|
|
|
|
|
|
|
|
av_dlog(c->fc, "%s: pri %d trc %d matrix %d", |
|
|
|
av_log(c->fc, AV_LOG_TRACE, |
|
|
|
color_parameter_type, color_primaries, color_trc, color_matrix); |
|
|
|
"%s: pri %d trc %d matrix %d", |
|
|
|
|
|
|
|
color_parameter_type, color_primaries, color_trc, color_matrix); |
|
|
|
|
|
|
|
|
|
|
|
if (!strncmp(color_parameter_type, "nclx", 4)) { |
|
|
|
if (!strncmp(color_parameter_type, "nclx", 4)) { |
|
|
|
uint8_t color_range = avio_r8(pb) >> 7; |
|
|
|
uint8_t color_range = avio_r8(pb) >> 7; |
|
|
|
av_dlog(c->fc, " full %"PRIu8"", color_range); |
|
|
|
av_log(c->fc, AV_LOG_TRACE, " full %"PRIu8"", color_range); |
|
|
|
if (color_range) |
|
|
|
if (color_range) |
|
|
|
st->codec->color_range = AVCOL_RANGE_JPEG; |
|
|
|
st->codec->color_range = AVCOL_RANGE_JPEG; |
|
|
|
else |
|
|
|
else |
|
|
|
@ -1040,7 +1041,7 @@ static int mov_read_colr(MOVContext *c, AVIOContext *pb, MOVAtom atom) |
|
|
|
case 7: st->codec->colorspace = AVCOL_SPC_SMPTE240M; break; |
|
|
|
case 7: st->codec->colorspace = AVCOL_SPC_SMPTE240M; break; |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
av_dlog(c->fc, "\n"); |
|
|
|
av_log(c->fc, AV_LOG_TRACE, "\n"); |
|
|
|
|
|
|
|
|
|
|
|
return 0; |
|
|
|
return 0; |
|
|
|
} |
|
|
|
} |
|
|
|
@ -1497,7 +1498,7 @@ static void mov_parse_stsd_video(MOVContext *c, AVIOContext *pb, |
|
|
|
|
|
|
|
|
|
|
|
st->codec->bits_per_coded_sample = avio_rb16(pb); /* depth */ |
|
|
|
st->codec->bits_per_coded_sample = avio_rb16(pb); /* depth */ |
|
|
|
color_table_id = avio_rb16(pb); /* colortable id */ |
|
|
|
color_table_id = avio_rb16(pb); /* colortable id */ |
|
|
|
av_dlog(c->fc, "depth %d, ctab id %d\n", |
|
|
|
av_log(c->fc, AV_LOG_TRACE, "depth %d, ctab id %d\n", |
|
|
|
st->codec->bits_per_coded_sample, color_table_id); |
|
|
|
st->codec->bits_per_coded_sample, color_table_id); |
|
|
|
/* figure out the palette situation */ |
|
|
|
/* figure out the palette situation */ |
|
|
|
color_depth = st->codec->bits_per_coded_sample & 0x1F; |
|
|
|
color_depth = st->codec->bits_per_coded_sample & 0x1F; |
|
|
|
@ -1580,7 +1581,7 @@ static void mov_parse_stsd_audio(MOVContext *c, AVIOContext *pb, |
|
|
|
|
|
|
|
|
|
|
|
st->codec->channels = avio_rb16(pb); /* channel count */ |
|
|
|
st->codec->channels = avio_rb16(pb); /* channel count */ |
|
|
|
st->codec->bits_per_coded_sample = avio_rb16(pb); /* sample size */ |
|
|
|
st->codec->bits_per_coded_sample = avio_rb16(pb); /* sample size */ |
|
|
|
av_dlog(c->fc, "audio channels %d\n", st->codec->channels); |
|
|
|
av_log(c->fc, AV_LOG_TRACE, "audio channels %d\n", st->codec->channels); |
|
|
|
|
|
|
|
|
|
|
|
sc->audio_cid = avio_rb16(pb); |
|
|
|
sc->audio_cid = avio_rb16(pb); |
|
|
|
avio_rb16(pb); /* packet size = 0 */ |
|
|
|
avio_rb16(pb); /* packet size = 0 */ |
|
|
|
@ -1588,7 +1589,7 @@ static void mov_parse_stsd_audio(MOVContext *c, AVIOContext *pb, |
|
|
|
st->codec->sample_rate = ((avio_rb32(pb) >> 16)); |
|
|
|
st->codec->sample_rate = ((avio_rb32(pb) >> 16)); |
|
|
|
|
|
|
|
|
|
|
|
// Read QT version 1 fields. In version 0 these do not exist.
|
|
|
|
// Read QT version 1 fields. In version 0 these do not exist.
|
|
|
|
av_dlog(c->fc, "version =%d, isom =%d\n", version, c->isom); |
|
|
|
av_log(c->fc, AV_LOG_TRACE, "version =%d, isom =%d\n", version, c->isom); |
|
|
|
if (!c->isom || |
|
|
|
if (!c->isom || |
|
|
|
(compatible_brands && strstr(compatible_brands->value, "qt "))) { |
|
|
|
(compatible_brands && strstr(compatible_brands->value, "qt "))) { |
|
|
|
|
|
|
|
|
|
|
|
@ -1918,7 +1919,7 @@ int ff_mov_read_stsd_entries(MOVContext *c, AVIOContext *pb, int entries) |
|
|
|
|
|
|
|
|
|
|
|
id = mov_codec_id(st, format); |
|
|
|
id = mov_codec_id(st, format); |
|
|
|
|
|
|
|
|
|
|
|
av_dlog(c->fc, "size=%"PRId64" 4CC= %c%c%c%c codec_type=%d\n", size, |
|
|
|
av_log(c->fc, AV_LOG_TRACE, "size=%"PRId64" 4CC= %c%c%c%c codec_type=%d\n", size, |
|
|
|
(format >> 0) & 0xff, (format >> 8) & 0xff, (format >> 16) & 0xff, |
|
|
|
(format >> 0) & 0xff, (format >> 8) & 0xff, (format >> 16) & 0xff, |
|
|
|
(format >> 24) & 0xff, st->codec->codec_type); |
|
|
|
(format >> 24) & 0xff, st->codec->codec_type); |
|
|
|
|
|
|
|
|
|
|
|
@ -1980,7 +1981,7 @@ static int mov_read_stsc(MOVContext *c, AVIOContext *pb, MOVAtom atom) |
|
|
|
|
|
|
|
|
|
|
|
entries = avio_rb32(pb); |
|
|
|
entries = avio_rb32(pb); |
|
|
|
|
|
|
|
|
|
|
|
av_dlog(c->fc, "track[%i].stsc.entries = %i\n", c->fc->nb_streams-1, entries); |
|
|
|
av_log(c->fc, AV_LOG_TRACE, "track[%i].stsc.entries = %i\n", c->fc->nb_streams-1, entries); |
|
|
|
|
|
|
|
|
|
|
|
if (!entries) |
|
|
|
if (!entries) |
|
|
|
return 0; |
|
|
|
return 0; |
|
|
|
@ -2030,7 +2031,7 @@ static int mov_read_stps(MOVContext *c, AVIOContext *pb, MOVAtom atom) |
|
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < entries && !pb->eof_reached; i++) { |
|
|
|
for (i = 0; i < entries && !pb->eof_reached; i++) { |
|
|
|
sc->stps_data[i] = avio_rb32(pb); |
|
|
|
sc->stps_data[i] = avio_rb32(pb); |
|
|
|
//av_dlog(c->fc, "stps %d\n", sc->stps_data[i]);
|
|
|
|
//av_log(c->fc, AV_LOG_TRACE, "stps %d\n", sc->stps_data[i]);
|
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
sc->stps_count = i; |
|
|
|
sc->stps_count = i; |
|
|
|
@ -2057,7 +2058,7 @@ static int mov_read_stss(MOVContext *c, AVIOContext *pb, MOVAtom atom) |
|
|
|
|
|
|
|
|
|
|
|
entries = avio_rb32(pb); |
|
|
|
entries = avio_rb32(pb); |
|
|
|
|
|
|
|
|
|
|
|
av_dlog(c->fc, "keyframe_count = %d\n", entries); |
|
|
|
av_log(c->fc, AV_LOG_TRACE, "keyframe_count = %d\n", entries); |
|
|
|
|
|
|
|
|
|
|
|
if (!entries) |
|
|
|
if (!entries) |
|
|
|
{ |
|
|
|
{ |
|
|
|
@ -2078,7 +2079,7 @@ static int mov_read_stss(MOVContext *c, AVIOContext *pb, MOVAtom atom) |
|
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < entries && !pb->eof_reached; i++) { |
|
|
|
for (i = 0; i < entries && !pb->eof_reached; i++) { |
|
|
|
sc->keyframes[i] = avio_rb32(pb); |
|
|
|
sc->keyframes[i] = avio_rb32(pb); |
|
|
|
//av_dlog(c->fc, "keyframes[]=%d\n", sc->keyframes[i]);
|
|
|
|
//av_log(c->fc, AV_LOG_TRACE, "keyframes[]=%d\n", sc->keyframes[i]);
|
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
sc->keyframe_count = i; |
|
|
|
sc->keyframe_count = i; |
|
|
|
@ -2118,7 +2119,7 @@ static int mov_read_stsz(MOVContext *c, AVIOContext *pb, MOVAtom atom) |
|
|
|
} |
|
|
|
} |
|
|
|
entries = avio_rb32(pb); |
|
|
|
entries = avio_rb32(pb); |
|
|
|
|
|
|
|
|
|
|
|
av_dlog(c->fc, "sample_size = %d sample_count = %d\n", sc->sample_size, entries); |
|
|
|
av_log(c->fc, AV_LOG_TRACE, "sample_size = %d sample_count = %d\n", sc->sample_size, entries); |
|
|
|
|
|
|
|
|
|
|
|
sc->sample_count = entries; |
|
|
|
sc->sample_count = entries; |
|
|
|
if (sample_size) |
|
|
|
if (sample_size) |
|
|
|
@ -2188,7 +2189,7 @@ static int mov_read_stts(MOVContext *c, AVIOContext *pb, MOVAtom atom) |
|
|
|
avio_rb24(pb); /* flags */ |
|
|
|
avio_rb24(pb); /* flags */ |
|
|
|
entries = avio_rb32(pb); |
|
|
|
entries = avio_rb32(pb); |
|
|
|
|
|
|
|
|
|
|
|
av_dlog(c->fc, "track[%i].stts.entries = %i\n", |
|
|
|
av_log(c->fc, AV_LOG_TRACE, "track[%i].stts.entries = %i\n", |
|
|
|
c->fc->nb_streams-1, entries); |
|
|
|
c->fc->nb_streams-1, entries); |
|
|
|
|
|
|
|
|
|
|
|
if (sc->stts_data) |
|
|
|
if (sc->stts_data) |
|
|
|
@ -2219,7 +2220,7 @@ static int mov_read_stts(MOVContext *c, AVIOContext *pb, MOVAtom atom) |
|
|
|
sc->stts_data[i].count= sample_count; |
|
|
|
sc->stts_data[i].count= sample_count; |
|
|
|
sc->stts_data[i].duration= sample_duration; |
|
|
|
sc->stts_data[i].duration= sample_duration; |
|
|
|
|
|
|
|
|
|
|
|
av_dlog(c->fc, "sample_count=%d, sample_duration=%d\n", |
|
|
|
av_log(c->fc, AV_LOG_TRACE, "sample_count=%d, sample_duration=%d\n", |
|
|
|
sample_count, sample_duration); |
|
|
|
sample_count, sample_duration); |
|
|
|
|
|
|
|
|
|
|
|
if ( i+1 == entries |
|
|
|
if ( i+1 == entries |
|
|
|
@ -2269,7 +2270,7 @@ static int mov_read_ctts(MOVContext *c, AVIOContext *pb, MOVAtom atom) |
|
|
|
avio_rb24(pb); /* flags */ |
|
|
|
avio_rb24(pb); /* flags */ |
|
|
|
entries = avio_rb32(pb); |
|
|
|
entries = avio_rb32(pb); |
|
|
|
|
|
|
|
|
|
|
|
av_dlog(c->fc, "track[%i].ctts.entries = %i\n", c->fc->nb_streams-1, entries); |
|
|
|
av_log(c->fc, AV_LOG_TRACE, "track[%i].ctts.entries = %i\n", c->fc->nb_streams-1, entries); |
|
|
|
|
|
|
|
|
|
|
|
if (!entries) |
|
|
|
if (!entries) |
|
|
|
return 0; |
|
|
|
return 0; |
|
|
|
@ -2286,7 +2287,7 @@ static int mov_read_ctts(MOVContext *c, AVIOContext *pb, MOVAtom atom) |
|
|
|
sc->ctts_data[i].count = count; |
|
|
|
sc->ctts_data[i].count = count; |
|
|
|
sc->ctts_data[i].duration= duration; |
|
|
|
sc->ctts_data[i].duration= duration; |
|
|
|
|
|
|
|
|
|
|
|
av_dlog(c->fc, "count=%d, duration=%d\n", |
|
|
|
av_log(c->fc, AV_LOG_TRACE, "count=%d, duration=%d\n", |
|
|
|
count, duration); |
|
|
|
count, duration); |
|
|
|
|
|
|
|
|
|
|
|
if (FFABS(duration) > (1<<28) && i+2<entries) { |
|
|
|
if (FFABS(duration) > (1<<28) && i+2<entries) { |
|
|
|
@ -2305,7 +2306,7 @@ static int mov_read_ctts(MOVContext *c, AVIOContext *pb, MOVAtom atom) |
|
|
|
if (pb->eof_reached) |
|
|
|
if (pb->eof_reached) |
|
|
|
return AVERROR_EOF; |
|
|
|
return AVERROR_EOF; |
|
|
|
|
|
|
|
|
|
|
|
av_dlog(c->fc, "dts shift %d\n", sc->dts_shift); |
|
|
|
av_log(c->fc, AV_LOG_TRACE, "dts shift %d\n", sc->dts_shift); |
|
|
|
|
|
|
|
|
|
|
|
return 0; |
|
|
|
return 0; |
|
|
|
} |
|
|
|
} |
|
|
|
@ -2484,7 +2485,7 @@ static void mov_build_index(MOVContext *mov, AVStream *st) |
|
|
|
e->size = sample_size; |
|
|
|
e->size = sample_size; |
|
|
|
e->min_distance = distance; |
|
|
|
e->min_distance = distance; |
|
|
|
e->flags = keyframe ? AVINDEX_KEYFRAME : 0; |
|
|
|
e->flags = keyframe ? AVINDEX_KEYFRAME : 0; |
|
|
|
av_dlog(mov->fc, "AVIndex stream %d, sample %d, offset %"PRIx64", dts %"PRId64", " |
|
|
|
av_log(mov->fc, AV_LOG_TRACE, "AVIndex stream %d, sample %d, offset %"PRIx64", dts %"PRId64", " |
|
|
|
"size %d, distance %d, keyframe %d\n", st->index, current_sample, |
|
|
|
"size %d, distance %d, keyframe %d\n", st->index, current_sample, |
|
|
|
current_offset, current_dts, sample_size, distance, keyframe); |
|
|
|
current_offset, current_dts, sample_size, distance, keyframe); |
|
|
|
if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && st->nb_index_entries < 100) |
|
|
|
if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && st->nb_index_entries < 100) |
|
|
|
@ -2535,7 +2536,7 @@ static void mov_build_index(MOVContext *mov, AVStream *st) |
|
|
|
total += chunk_count * count; |
|
|
|
total += chunk_count * count; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
av_dlog(mov->fc, "chunk count %d\n", total); |
|
|
|
av_log(mov->fc, AV_LOG_TRACE, "chunk count %d\n", total); |
|
|
|
if (total >= UINT_MAX / sizeof(*st->index_entries) - st->nb_index_entries) |
|
|
|
if (total >= UINT_MAX / sizeof(*st->index_entries) - st->nb_index_entries) |
|
|
|
return; |
|
|
|
return; |
|
|
|
if (av_reallocp_array(&st->index_entries, |
|
|
|
if (av_reallocp_array(&st->index_entries, |
|
|
|
@ -2582,7 +2583,7 @@ static void mov_build_index(MOVContext *mov, AVStream *st) |
|
|
|
e->size = size; |
|
|
|
e->size = size; |
|
|
|
e->min_distance = 0; |
|
|
|
e->min_distance = 0; |
|
|
|
e->flags = AVINDEX_KEYFRAME; |
|
|
|
e->flags = AVINDEX_KEYFRAME; |
|
|
|
av_dlog(mov->fc, "AVIndex stream %d, chunk %d, offset %"PRIx64", dts %"PRId64", " |
|
|
|
av_log(mov->fc, AV_LOG_TRACE, "AVIndex stream %d, chunk %d, offset %"PRIx64", dts %"PRId64", " |
|
|
|
"size %d, duration %d\n", st->index, i, current_offset, current_dts, |
|
|
|
"size %d, duration %d\n", st->index, i, current_offset, current_dts, |
|
|
|
size, samples); |
|
|
|
size, samples); |
|
|
|
|
|
|
|
|
|
|
|
@ -3044,7 +3045,7 @@ static int mov_read_tfhd(MOVContext *c, AVIOContext *pb, MOVAtom atom) |
|
|
|
"%"PRId64"\n", frag->track_id, frag->implicit_offset); |
|
|
|
"%"PRId64"\n", frag->track_id, frag->implicit_offset); |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
av_dlog(c->fc, "frag flags 0x%x\n", frag->flags); |
|
|
|
av_log(c->fc, AV_LOG_TRACE, "frag flags 0x%x\n", frag->flags); |
|
|
|
return 0; |
|
|
|
return 0; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
@ -3138,7 +3139,7 @@ static int mov_read_trun(MOVContext *c, AVIOContext *pb, MOVAtom atom) |
|
|
|
avio_r8(pb); /* version */ |
|
|
|
avio_r8(pb); /* version */ |
|
|
|
flags = avio_rb24(pb); |
|
|
|
flags = avio_rb24(pb); |
|
|
|
entries = avio_rb32(pb); |
|
|
|
entries = avio_rb32(pb); |
|
|
|
av_dlog(c->fc, "flags 0x%x entries %d\n", flags, entries); |
|
|
|
av_log(c->fc, AV_LOG_TRACE, "flags 0x%x entries %d\n", flags, entries); |
|
|
|
|
|
|
|
|
|
|
|
/* Always assume the presence of composition time offsets.
|
|
|
|
/* Always assume the presence of composition time offsets.
|
|
|
|
* Without this assumption, for instance, we cannot deal with a track in fragmented movies that meet the following. |
|
|
|
* Without this assumption, for instance, we cannot deal with a track in fragmented movies that meet the following. |
|
|
|
@ -3168,7 +3169,7 @@ static int mov_read_trun(MOVContext *c, AVIOContext *pb, MOVAtom atom) |
|
|
|
dts = sc->track_end - sc->time_offset; |
|
|
|
dts = sc->track_end - sc->time_offset; |
|
|
|
offset = frag->base_data_offset + data_offset; |
|
|
|
offset = frag->base_data_offset + data_offset; |
|
|
|
distance = 0; |
|
|
|
distance = 0; |
|
|
|
av_dlog(c->fc, "first sample flags 0x%x\n", first_sample_flags); |
|
|
|
av_log(c->fc, AV_LOG_TRACE, "first sample flags 0x%x\n", first_sample_flags); |
|
|
|
for (i = 0; i < entries && !pb->eof_reached; i++) { |
|
|
|
for (i = 0; i < entries && !pb->eof_reached; i++) { |
|
|
|
unsigned sample_size = frag->size; |
|
|
|
unsigned sample_size = frag->size; |
|
|
|
int sample_flags = i ? frag->flags : first_sample_flags; |
|
|
|
int sample_flags = i ? frag->flags : first_sample_flags; |
|
|
|
@ -3218,7 +3219,7 @@ static int mov_read_trun(MOVContext *c, AVIOContext *pb, MOVAtom atom) |
|
|
|
if (err < 0) { |
|
|
|
if (err < 0) { |
|
|
|
av_log(c->fc, AV_LOG_ERROR, "Failed to add index entry\n"); |
|
|
|
av_log(c->fc, AV_LOG_ERROR, "Failed to add index entry\n"); |
|
|
|
} |
|
|
|
} |
|
|
|
av_dlog(c->fc, "AVIndex stream %d, sample %d, offset %"PRIx64", dts %"PRId64", " |
|
|
|
av_log(c->fc, AV_LOG_TRACE, "AVIndex stream %d, sample %d, offset %"PRIx64", dts %"PRId64", " |
|
|
|
"size %d, distance %d, keyframe %d\n", st->index, sc->sample_count+i, |
|
|
|
"size %d, distance %d, keyframe %d\n", st->index, sc->sample_count+i, |
|
|
|
offset, dts, sample_size, distance, keyframe); |
|
|
|
offset, dts, sample_size, distance, keyframe); |
|
|
|
distance++; |
|
|
|
distance++; |
|
|
|
@ -3332,7 +3333,7 @@ static int mov_read_elst(MOVContext *c, AVIOContext *pb, MOVAtom atom) |
|
|
|
if (!sc->elst_data) |
|
|
|
if (!sc->elst_data) |
|
|
|
return AVERROR(ENOMEM); |
|
|
|
return AVERROR(ENOMEM); |
|
|
|
|
|
|
|
|
|
|
|
av_dlog(c->fc, "track[%i].edit_count = %i\n", c->fc->nb_streams-1, edit_count); |
|
|
|
av_log(c->fc, AV_LOG_TRACE, "track[%i].edit_count = %i\n", c->fc->nb_streams-1, edit_count); |
|
|
|
for (i = 0; i < edit_count && !pb->eof_reached; i++) { |
|
|
|
for (i = 0; i < edit_count && !pb->eof_reached; i++) { |
|
|
|
MOVElst *e = &sc->elst_data[i]; |
|
|
|
MOVElst *e = &sc->elst_data[i]; |
|
|
|
|
|
|
|
|
|
|
|
@ -3344,7 +3345,7 @@ static int mov_read_elst(MOVContext *c, AVIOContext *pb, MOVAtom atom) |
|
|
|
e->time = (int32_t)avio_rb32(pb); /* media time */ |
|
|
|
e->time = (int32_t)avio_rb32(pb); /* media time */ |
|
|
|
} |
|
|
|
} |
|
|
|
e->rate = avio_rb32(pb) / 65536.0; |
|
|
|
e->rate = avio_rb32(pb) / 65536.0; |
|
|
|
av_dlog(c->fc, "duration=%"PRId64" time=%"PRId64" rate=%f\n", |
|
|
|
av_log(c->fc, AV_LOG_TRACE, "duration=%"PRId64" time=%"PRId64" rate=%f\n", |
|
|
|
e->duration, e->time, e->rate); |
|
|
|
e->duration, e->time, e->rate); |
|
|
|
} |
|
|
|
} |
|
|
|
sc->elst_count = i; |
|
|
|
sc->elst_count = i; |
|
|
|
@ -3576,7 +3577,7 @@ static int mov_read_default(MOVContext *c, AVIOContext *pb, MOVAtom atom) |
|
|
|
total_size += 8; |
|
|
|
total_size += 8; |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
av_dlog(c->fc, "type: %08x '%.4s' parent:'%.4s' sz: %"PRId64" %"PRId64" %"PRId64"\n", |
|
|
|
av_log(c->fc, AV_LOG_TRACE, "type: %08x '%.4s' parent:'%.4s' sz: %"PRId64" %"PRId64" %"PRId64"\n", |
|
|
|
a.type, (char*)&a.type, (char*)&atom.type, a.size, total_size, atom.size); |
|
|
|
a.type, (char*)&a.type, (char*)&atom.type, a.size, total_size, atom.size); |
|
|
|
if (a.size == 0) { |
|
|
|
if (a.size == 0) { |
|
|
|
a.size = atom.size - total_size + 8; |
|
|
|
a.size = atom.size - total_size + 8; |
|
|
|
@ -4058,7 +4059,7 @@ static int mov_read_header(AVFormatContext *s) |
|
|
|
mov_read_close(s); |
|
|
|
mov_read_close(s); |
|
|
|
return AVERROR_INVALIDDATA; |
|
|
|
return AVERROR_INVALIDDATA; |
|
|
|
} |
|
|
|
} |
|
|
|
av_dlog(mov->fc, "on_parse_exit_offset=%"PRId64"\n", avio_tell(pb)); |
|
|
|
av_log(mov->fc, AV_LOG_TRACE, "on_parse_exit_offset=%"PRId64"\n", avio_tell(pb)); |
|
|
|
|
|
|
|
|
|
|
|
if (pb->seekable) { |
|
|
|
if (pb->seekable) { |
|
|
|
if (mov->chapter_track > 0) |
|
|
|
if (mov->chapter_track > 0) |
|
|
|
@ -4187,7 +4188,7 @@ static AVIndexEntry *mov_find_next_sample(AVFormatContext *s, AVStream **st) |
|
|
|
if (msc->pb && msc->current_sample < avst->nb_index_entries) { |
|
|
|
if (msc->pb && msc->current_sample < avst->nb_index_entries) { |
|
|
|
AVIndexEntry *current_sample = &avst->index_entries[msc->current_sample]; |
|
|
|
AVIndexEntry *current_sample = &avst->index_entries[msc->current_sample]; |
|
|
|
int64_t dts = av_rescale(current_sample->timestamp, AV_TIME_BASE, msc->time_scale); |
|
|
|
int64_t dts = av_rescale(current_sample->timestamp, AV_TIME_BASE, msc->time_scale); |
|
|
|
av_dlog(s, "stream %d, sample %d, dts %"PRId64"\n", i, msc->current_sample, dts); |
|
|
|
av_log(s, AV_LOG_TRACE, "stream %d, sample %d, dts %"PRId64"\n", i, msc->current_sample, dts); |
|
|
|
if (!sample || (!s->pb->seekable && current_sample->pos < sample->pos) || |
|
|
|
if (!sample || (!s->pb->seekable && current_sample->pos < sample->pos) || |
|
|
|
(s->pb->seekable && |
|
|
|
(s->pb->seekable && |
|
|
|
((msc->pb != s->pb && dts < best_dts) || (msc->pb == s->pb && |
|
|
|
((msc->pb != s->pb && dts < best_dts) || (msc->pb == s->pb && |
|
|
|
@ -4221,7 +4222,7 @@ static int mov_read_packet(AVFormatContext *s, AVPacket *pkt) |
|
|
|
if (mov_read_default(mov, s->pb, (MOVAtom){ AV_RL32("root"), INT64_MAX }) < 0 || |
|
|
|
if (mov_read_default(mov, s->pb, (MOVAtom){ AV_RL32("root"), INT64_MAX }) < 0 || |
|
|
|
avio_feof(s->pb)) |
|
|
|
avio_feof(s->pb)) |
|
|
|
return AVERROR_EOF; |
|
|
|
return AVERROR_EOF; |
|
|
|
av_dlog(s, "read fragments, offset 0x%"PRIx64"\n", avio_tell(s->pb)); |
|
|
|
av_log(s, AV_LOG_TRACE, "read fragments, offset 0x%"PRIx64"\n", avio_tell(s->pb)); |
|
|
|
goto retry; |
|
|
|
goto retry; |
|
|
|
} |
|
|
|
} |
|
|
|
sc = st->priv_data; |
|
|
|
sc = st->priv_data; |
|
|
|
@ -4288,7 +4289,7 @@ static int mov_read_packet(AVFormatContext *s, AVPacket *pkt) |
|
|
|
goto retry; |
|
|
|
goto retry; |
|
|
|
pkt->flags |= sample->flags & AVINDEX_KEYFRAME ? AV_PKT_FLAG_KEY : 0; |
|
|
|
pkt->flags |= sample->flags & AVINDEX_KEYFRAME ? AV_PKT_FLAG_KEY : 0; |
|
|
|
pkt->pos = sample->pos; |
|
|
|
pkt->pos = sample->pos; |
|
|
|
av_dlog(s, "stream %d, pts %"PRId64", dts %"PRId64", pos 0x%"PRIx64", duration %d\n", |
|
|
|
av_log(s, AV_LOG_TRACE, "stream %d, pts %"PRId64", dts %"PRId64", pos 0x%"PRIx64", duration %d\n", |
|
|
|
pkt->stream_index, pkt->pts, pkt->dts, pkt->pos, pkt->duration); |
|
|
|
pkt->stream_index, pkt->pts, pkt->dts, pkt->pos, pkt->duration); |
|
|
|
return 0; |
|
|
|
return 0; |
|
|
|
} |
|
|
|
} |
|
|
|
@ -4300,13 +4301,13 @@ static int mov_seek_stream(AVFormatContext *s, AVStream *st, int64_t timestamp, |
|
|
|
int i; |
|
|
|
int i; |
|
|
|
|
|
|
|
|
|
|
|
sample = av_index_search_timestamp(st, timestamp, flags); |
|
|
|
sample = av_index_search_timestamp(st, timestamp, flags); |
|
|
|
av_dlog(s, "stream %d, timestamp %"PRId64", sample %d\n", st->index, timestamp, sample); |
|
|
|
av_log(s, AV_LOG_TRACE, "stream %d, timestamp %"PRId64", sample %d\n", st->index, timestamp, sample); |
|
|
|
if (sample < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp) |
|
|
|
if (sample < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp) |
|
|
|
sample = 0; |
|
|
|
sample = 0; |
|
|
|
if (sample < 0) /* not sure what to do */ |
|
|
|
if (sample < 0) /* not sure what to do */ |
|
|
|
return AVERROR_INVALIDDATA; |
|
|
|
return AVERROR_INVALIDDATA; |
|
|
|
sc->current_sample = sample; |
|
|
|
sc->current_sample = sample; |
|
|
|
av_dlog(s, "stream %d, found sample %d\n", st->index, sc->current_sample); |
|
|
|
av_log(s, AV_LOG_TRACE, "stream %d, found sample %d\n", st->index, sc->current_sample); |
|
|
|
/* adjust ctts index */ |
|
|
|
/* adjust ctts index */ |
|
|
|
if (sc->ctts_data) { |
|
|
|
if (sc->ctts_data) { |
|
|
|
time_sample = 0; |
|
|
|
time_sample = 0; |
|
|
|
|
Michael Niedermayer
10 years ago