xref: /third_party/ffmpeg/libavformat/mov.c

630     int entries, i, j;
638     entries = avio_rb32(pb);
639     if (!entries ||
640         entries >  (atom.size - 1) / MIN_DATA_ENTRY_BOX_SIZE + 1 ||
641         entries >= UINT_MAX / sizeof(*sc->drefs))
651     sc->drefs = av_mallocz(entries * sizeof(*sc->drefs));
654     sc->drefs_count = entries;
656     for (i = 0; i < entries; i++) {
762             entries--;
1298     // Optimize for appending new entries
1445                                    int id, int entries)
1455             frag_stream_info->index_entry += entries;
2115     unsigned int i, entries;
2129     entries = avio_rb32(pb);
2131     if (!entries)
2140     sc->chunk_offsets = av_malloc_array(entries, sizeof(*sc->chunk_offsets));
2143     sc->chunk_count = entries;
2146         for (i = 0; i < entries && !pb->eof_reached; i++)
2149         for (i = 0; i < entries && !pb->eof_reached; i++)
2671 int ff_mov_read_stsd_entries(MOVContext *c, AVIOContext *pb, int entries)
2683          pseudo_stream_id < entries && !pb->eof_reached;
2787     int ret, entries;
2796     entries = avio_rb32(pb);
2799     if (entries <= 0 || entries > atom.size / 8 || entries > 1024) {
2800         av_log(c->fc, AV_LOG_ERROR, "invalid STSD entries %d\n", entries);
2811     sc->extradata = av_calloc(entries, sizeof(*sc->extradata));
2815     sc->extradata_size = av_calloc(entries, sizeof(*sc->extradata_size));
2821     ret = ff_mov_read_stsd_entries(c, pb, entries);
2852     unsigned int i, entries;
2862     entries = avio_rb32(pb);
2863     if ((uint64_t)entries * 12 + 4 > atom.size)
2866     av_log(c->fc, AV_LOG_TRACE, "track[%u].stsc.entries = %u\n", c->fc->nb_streams - 1, entries);
2868     if (!entries)
2876     sc->stsc_data = av_malloc_array(entries, sizeof(*sc->stsc_data));
2880     for (i = 0; i < entries && !pb->eof_reached; i++) {
2948     unsigned i, entries;
2957     entries = avio_rb32(pb);
2962     sc->stps_data = av_malloc_array(entries, sizeof(*sc->stps_data));
2966     for (i = 0; i < entries && !pb->eof_reached; i++) {
2985     unsigned int i, entries;
2996     entries = avio_rb32(pb);
2998     av_log(c->fc, AV_LOG_TRACE, "keyframe_count = %u\n", entries);
3000     if (!entries) {
3008     if (entries >= UINT_MAX / sizeof(int))
3012     sc->keyframes = av_malloc_array(entries, sizeof(*sc->keyframes));
3016     for (i = 0; i < entries && !pb->eof_reached; i++) {
3034     unsigned int i, entries, sample_size, field_size, num_bytes;
3058     entries = avio_rb32(pb);
3060     av_log(c->fc, AV_LOG_TRACE, "sample_size = %u sample_count = %u\n", sc->sample_size, entries);
3062     sc->sample_count = entries;
3071     if (!entries)
3073     if (entries >= (INT_MAX - 4 - 8 * AV_INPUT_BUFFER_PADDING_SIZE) / field_size)
3079     sc->sample_sizes = av_malloc_array(entries, sizeof(*sc->sample_sizes));
3083     num_bytes = (entries*field_size+4)>>3;
3101     for (i = 0; i < entries; i++) {
3122     unsigned int i, entries, alloc_size = 0;
3135     entries = avio_rb32(pb);
3137     av_log(c->fc, AV_LOG_TRACE, "track[%u].stts.entries = %u\n",
3138             c->fc->nb_streams-1, entries);
3144     if (entries >= INT_MAX / sizeof(*sc->stts_data))
3147     for (i = 0; i < entries && !pb->eof_reached; i++) {
3150         unsigned int min_entries = FFMIN(FFMAX(i + 1, 1024 * 1024), entries);
3235     int64_t i, entries;
3244     entries = atom.size - 4;
3246     av_log(c->fc, AV_LOG_TRACE, "track[%u].sdtp.entries = %" PRId64 "\n",
3247            c->fc->nb_streams - 1, entries);
3254     sc->sdtp_data = av_malloc(entries);
3258     for (i = 0; i < entries && !pb->eof_reached; i++)
3280     unsigned int i, entries, ctts_count = 0;
3289     entries = avio_rb32(pb);
3291     av_log(c->fc, AV_LOG_TRACE, "track[%u].ctts.entries = %u\n", c->fc->nb_streams - 1, entries);
3293     if (!entries)
3295     if (entries >= UINT_MAX / sizeof(*sc->ctts_data))
3298     sc->ctts_data = av_fast_realloc(NULL, &sc->ctts_allocated_size, entries * sizeof(*sc->ctts_data));
3302     for (i = 0; i < entries && !pb->eof_reached; i++) {
3319         if (FFNABS(duration) < -(1<<28) && i+2<entries) {
3326         if (i+2<entries)
3415     unsigned int i, entries;
3443     entries = avio_rb32(pb);
3444     if (!entries)
3449     table = av_malloc_array(entries, sizeof(*table));
3454     for (i = 0; i < entries && !pb->eof_reached; i++) {
3501  * entries. Searching for just any frame / just key frames can be controlled by
3508  * the timestamp of index entries are considered to be decoding timestamps.
3549     // Keep going backwards in the index entries until the timestamp is the same.
3610  * the end, instead of searching the entries list and skipping the add if
3619     AVIndexEntry *entries, *ie;
3633     entries = av_fast_realloc(sti->index_entries,
3636     if (!entries)
3639     sti->index_entries = entries;
3642     ie= &entries[index];
3653  * Rewrite timestamps of index entries in the range [end_index - frame_duration_buffer_size, end_index)
3803  * Fix ffstream(st)->index_entries, so that it contains only the entries (and the entries
3805  * Also fixes the timestamps of the index entries to match the timeline
4221             av_log(mov->fc, AV_LOG_WARNING, "multiple edit list entries, "
4271             // Expand ctts entries such that we have a 1-1 mapping with samples
5165     unsigned entries, first_sample_flags = frag->flags;
5199     // New index entries will be inserted before the index_entry found.
5213     entries = avio_rb32(pb);
5214     av_log(c->fc, AV_LOG_TRACE, "flags 0x%x entries %u\n", flags, entries);
5216     if ((uint64_t)entries+sc->ctts_count >= UINT_MAX/sizeof(*sc->ctts_data))
5273     // realloc space for new index entries
5274     if ((uint64_t)sti->nb_index_entries + entries >= UINT_MAX / sizeof(AVIndexEntry)) {
5275         entries = UINT_MAX / sizeof(AVIndexEntry) - sti->nb_index_entries;
5278     if (entries == 0)
5281     requested_size = (sti->nb_index_entries + entries) * sizeof(AVIndexEntry);
5289     requested_size = (sti->nb_index_entries + entries) * sizeof(*sc->ctts_data);
5297     // In case there were samples without ctts entries, ensure they get
5298     // zero valued entries. This ensures clips which mix boxes with and
5299     // without ctts entries don't pickup uninitialized data.
5305         memmove(sti->index_entries + index_entry_pos + entries,
5309         memmove(sc->ctts_data + index_entry_pos + entries,
5313             sc->current_sample += entries;
5317     sti->nb_index_entries += entries;
5327     for (i = 0; i < entries && !pb->eof_reached; i++) {
5405     if (i < entries) {
5406         // EOF found before reading all entries.  Fix the hole this would
5408         int gap = entries - i;
5423         entries = i;
5440     // be incremented by the number of entries inserted.
5442                            frag->track_id, entries);
5680     edit_count = avio_rb32(pb); /* entries */
5692                 av_log(c->fc, AV_LOG_WARNING, "ELST atom of %"PRId64" bytes, bigger than %d entries.\n", atom.size, edit_count);
9425     { "export_all", "Export unrecognized metadata entries", OFFSET(export_all),

Indexes created Thu Nov 07 10:32:03 CST 2024