Mercurial > libavformat.hg

comparison mov.c @ 4560:284c22e8f739 libavformat

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
return AVERROR(ENOMEM) if alloc failed, set count after alloc, use variable when reallocing, based on patch by Netgem
author bcoudurier
date Sun, 22 Feb 2009 00:20:07 +0000
parents 7590f1edf959
children 86bbca6f1738
comparison
equal deleted inserted replaced
4559:ee5d7f52e4bc 4560:284c22e8f739
244 244
245 get_be32(pb); // version + flags 245 get_be32(pb); // version + flags
246 entries = get_be32(pb); 246 entries = get_be32(pb);
247 if (entries >= UINT_MAX / sizeof(*sc->drefs)) 247 if (entries >= UINT_MAX / sizeof(*sc->drefs))
248 return -1; 248 return -1;
249 sc->drefs = av_mallocz(entries * sizeof(*sc->drefs));
250 if (!sc->drefs)
251 return AVERROR(ENOMEM);
249 sc->drefs_count = entries; 252 sc->drefs_count = entries;
250 sc->drefs = av_mallocz(entries * sizeof(*sc->drefs));
251 253
252 for (i = 0; i < sc->drefs_count; i++) { 254 for (i = 0; i < sc->drefs_count; i++) {
253 MOVDref *dref = &sc->drefs[i]; 255 MOVDref *dref = &sc->drefs[i];
254 uint32_t size = get_be32(pb); 256 uint32_t size = get_be32(pb);
255 int64_t next = url_ftell(pb) + size - 4; 257 int64_t next = url_ftell(pb) + size - 4;
684 entries = get_be32(pb); 686 entries = get_be32(pb);
685 687
686 if(entries >= UINT_MAX/sizeof(int64_t)) 688 if(entries >= UINT_MAX/sizeof(int64_t))
687 return -1; 689 return -1;
688 690
689 sc->chunk_count = entries;
690 sc->chunk_offsets = av_malloc(entries * sizeof(int64_t)); 691 sc->chunk_offsets = av_malloc(entries * sizeof(int64_t));
691 if (!sc->chunk_offsets) 692 if (!sc->chunk_offsets)
692 return -1; 693 return AVERROR(ENOMEM);
694 sc->chunk_count = entries;
695
693 if (atom.type == MKTAG('s','t','c','o')) 696 if (atom.type == MKTAG('s','t','c','o'))
694 for(i=0; i<entries; i++) 697 for(i=0; i<entries; i++)
695 sc->chunk_offsets[i] = get_be32(pb); 698 sc->chunk_offsets[i] = get_be32(pb);
696 else if (atom.type == MKTAG('c','o','6','4')) 699 else if (atom.type == MKTAG('c','o','6','4'))
697 for(i=0; i<entries; i++) 700 for(i=0; i<entries; i++)
1068 get_byte(pb); /* version */ 1071 get_byte(pb); /* version */
1069 get_be24(pb); /* flags */ 1072 get_be24(pb); /* flags */
1070 1073
1071 entries = get_be32(pb); 1074 entries = get_be32(pb);
1072 1075
1076 dprintf(c->fc, "track[%i].stsc.entries = %i\n", c->fc->nb_streams-1, entries);
1077
1073 if(entries >= UINT_MAX / sizeof(*sc->stsc_data)) 1078 if(entries >= UINT_MAX / sizeof(*sc->stsc_data))
1074 return -1; 1079 return -1;
1075
1076 dprintf(c->fc, "track[%i].stsc.entries = %i\n", c->fc->nb_streams-1, entries);
1077
1078 sc->stsc_count = entries;
1079 sc->stsc_data = av_malloc(entries * sizeof(*sc->stsc_data)); 1080 sc->stsc_data = av_malloc(entries * sizeof(*sc->stsc_data));
1080 if (!sc->stsc_data) 1081 if (!sc->stsc_data)
1081 return -1; 1082 return AVERROR(ENOMEM);
1083 sc->stsc_count = entries;
1084
1082 for(i=0; i<entries; i++) { 1085 for(i=0; i<entries; i++) {
1083 sc->stsc_data[i].first = get_be32(pb); 1086 sc->stsc_data[i].first = get_be32(pb);
1084 sc->stsc_data[i].count = get_be32(pb); 1087 sc->stsc_data[i].count = get_be32(pb);
1085 sc->stsc_data[i].id = get_be32(pb); 1088 sc->stsc_data[i].id = get_be32(pb);
1086 } 1089 }
1096 get_byte(pb); /* version */ 1099 get_byte(pb); /* version */
1097 get_be24(pb); /* flags */ 1100 get_be24(pb); /* flags */
1098 1101
1099 entries = get_be32(pb); 1102 entries = get_be32(pb);
1100 1103
1104 dprintf(c->fc, "keyframe_count = %d\n", entries);
1105
1101 if(entries >= UINT_MAX / sizeof(int)) 1106 if(entries >= UINT_MAX / sizeof(int))
1102 return -1; 1107 return -1;
1103
1104 sc->keyframe_count = entries;
1105
1106 dprintf(c->fc, "keyframe_count = %d\n", sc->keyframe_count);
1107
1108 sc->keyframes = av_malloc(entries * sizeof(int)); 1108 sc->keyframes = av_malloc(entries * sizeof(int));
1109 if (!sc->keyframes) 1109 if (!sc->keyframes)
1110 return -1; 1110 return AVERROR(ENOMEM);
1111 sc->keyframe_count = entries;
1112
1111 for(i=0; i<entries; i++) { 1113 for(i=0; i<entries; i++) {
1112 sc->keyframes[i] = get_be32(pb); 1114 sc->keyframes[i] = get_be32(pb);
1113 //dprintf(c->fc, "keyframes[]=%d\n", sc->keyframes[i]); 1115 //dprintf(c->fc, "keyframes[]=%d\n", sc->keyframes[i]);
1114 } 1116 }
1115 return 0; 1117 return 0;
1126 1128
1127 sample_size = get_be32(pb); 1129 sample_size = get_be32(pb);
1128 if (!sc->sample_size) /* do not overwrite value computed in stsd */ 1130 if (!sc->sample_size) /* do not overwrite value computed in stsd */
1129 sc->sample_size = sample_size; 1131 sc->sample_size = sample_size;
1130 entries = get_be32(pb); 1132 entries = get_be32(pb);
1131 if(entries >= UINT_MAX / sizeof(int)) 1133
1132 return -1; 1134 dprintf(c->fc, "sample_size = %d sample_count = %d\n", sc->sample_size, entries);
1133 1135
1134 sc->sample_count = entries; 1136 sc->sample_count = entries;
1135 if (sample_size) 1137 if (sample_size)
1136 return 0; 1138 return 0;
1137 1139
1138 dprintf(c->fc, "sample_size = %d sample_count = %d\n", sc->sample_size, sc->sample_count); 1140 if(entries >= UINT_MAX / sizeof(int))
1139 1141 return -1;
1140 sc->sample_sizes = av_malloc(entries * sizeof(int)); 1142 sc->sample_sizes = av_malloc(entries * sizeof(int));
1141 if (!sc->sample_sizes) 1143 if (!sc->sample_sizes)
1142 return -1; 1144 return AVERROR(ENOMEM);
1145
1143 for(i=0; i<entries; i++) 1146 for(i=0; i<entries; i++)
1144 sc->sample_sizes[i] = get_be32(pb); 1147 sc->sample_sizes[i] = get_be32(pb);
1145 return 0; 1148 return 0;
1146 } 1149 }
1147 1150
1154 int64_t total_sample_count=0; 1157 int64_t total_sample_count=0;
1155 1158
1156 get_byte(pb); /* version */ 1159 get_byte(pb); /* version */
1157 get_be24(pb); /* flags */ 1160 get_be24(pb); /* flags */
1158 entries = get_be32(pb); 1161 entries = get_be32(pb);
1162
1163 dprintf(c->fc, "track[%i].stts.entries = %i\n", c->fc->nb_streams-1, entries);
1164
1159 if(entries >= UINT_MAX / sizeof(*sc->stts_data)) 1165 if(entries >= UINT_MAX / sizeof(*sc->stts_data))
1160 return -1; 1166 return -1;
1161
1162 sc->stts_count = entries;
1163 sc->stts_data = av_malloc(entries * sizeof(*sc->stts_data)); 1167 sc->stts_data = av_malloc(entries * sizeof(*sc->stts_data));
1164 if (!sc->stts_data) 1168 if (!sc->stts_data)
1165 return -1; 1169 return AVERROR(ENOMEM);
1166 dprintf(c->fc, "track[%i].stts.entries = %i\n", c->fc->nb_streams-1, entries); 1170 sc->stts_count = entries;
1167 1171
1168 for(i=0; i<entries; i++) { 1172 for(i=0; i<entries; i++) {
1169 int sample_duration; 1173 int sample_duration;
1170 int sample_count; 1174 int sample_count;
1171 1175
1195 unsigned int i, entries; 1199 unsigned int i, entries;
1196 1200
1197 get_byte(pb); /* version */ 1201 get_byte(pb); /* version */
1198 get_be24(pb); /* flags */ 1202 get_be24(pb); /* flags */
1199 entries = get_be32(pb); 1203 entries = get_be32(pb);
1204
1205 dprintf(c->fc, "track[%i].ctts.entries = %i\n", c->fc->nb_streams-1, entries);
1206
1200 if(entries >= UINT_MAX / sizeof(*sc->ctts_data)) 1207 if(entries >= UINT_MAX / sizeof(*sc->ctts_data))
1201 return -1; 1208 return -1;
1202
1203 sc->ctts_count = entries;
1204 sc->ctts_data = av_malloc(entries * sizeof(*sc->ctts_data)); 1209 sc->ctts_data = av_malloc(entries * sizeof(*sc->ctts_data));
1205 if (!sc->ctts_data) 1210 if (!sc->ctts_data)
1206 return -1; 1211 return AVERROR(ENOMEM);
1207 dprintf(c->fc, "track[%i].ctts.entries = %i\n", c->fc->nb_streams-1, entries); 1212 sc->ctts_count = entries;
1208 1213
1209 for(i=0; i<entries; i++) { 1214 for(i=0; i<entries; i++) {
1210 int count =get_be32(pb); 1215 int count =get_be32(pb);
1211 int duration =get_be32(pb); 1216 int duration =get_be32(pb);
1212 1217
1603 { 1608 {
1604 MOVTrackExt *trex; 1609 MOVTrackExt *trex;
1605 1610
1606 if ((uint64_t)c->trex_count+1 >= UINT_MAX / sizeof(*c->trex_data)) 1611 if ((uint64_t)c->trex_count+1 >= UINT_MAX / sizeof(*c->trex_data))
1607 return -1; 1612 return -1;
1608 c->trex_data = av_realloc(c->trex_data, (c->trex_count+1)*sizeof(*c->trex_data)); 1613 trex = av_realloc(c->trex_data, (c->trex_count+1)*sizeof(*c->trex_data));
1609 if (!c->trex_data) 1614 if (!trex)
1610 return AVERROR(ENOMEM); 1615 return AVERROR(ENOMEM);
1616 c->trex_data = trex;
1611 trex = &c->trex_data[c->trex_count++]; 1617 trex = &c->trex_data[c->trex_count++];
1612 get_byte(pb); /* version */ 1618 get_byte(pb); /* version */
1613 get_be24(pb); /* flags */ 1619 get_be24(pb); /* flags */
1614 trex->track_id = get_be32(pb); 1620 trex->track_id = get_be32(pb);
1615 trex->stsd_id = get_be32(pb); 1621 trex->stsd_id = get_be32(pb);
1641 entries = get_be32(pb); 1647 entries = get_be32(pb);
1642 dprintf(c->fc, "flags 0x%x entries %d\n", flags, entries); 1648 dprintf(c->fc, "flags 0x%x entries %d\n", flags, entries);
1643 if (flags & 0x001) data_offset = get_be32(pb); 1649 if (flags & 0x001) data_offset = get_be32(pb);
1644 if (flags & 0x004) first_sample_flags = get_be32(pb); 1650 if (flags & 0x004) first_sample_flags = get_be32(pb);
1645 if (flags & 0x800) { 1651 if (flags & 0x800) {
1652 MOVStts *ctts_data;
1646 if ((uint64_t)entries+sc->ctts_count >= UINT_MAX/sizeof(*sc->ctts_data)) 1653 if ((uint64_t)entries+sc->ctts_count >= UINT_MAX/sizeof(*sc->ctts_data))
1647 return -1; 1654 return -1;
1648 sc->ctts_data = av_realloc(sc->ctts_data, 1655 ctts_data = av_realloc(sc->ctts_data,
1649 (entries+sc->ctts_count)*sizeof(*sc->ctts_data)); 1656 (entries+sc->ctts_count)*sizeof(*sc->ctts_data));
1650 if (!sc->ctts_data) 1657 if (!ctts_data)
1651 return AVERROR(ENOMEM); 1658 return AVERROR(ENOMEM);
1659 sc->ctts_data = ctts_data;
1652 } 1660 }
1653 dts = st->duration; 1661 dts = st->duration;
1654 offset = frag->base_data_offset + data_offset; 1662 offset = frag->base_data_offset + data_offset;
1655 distance = 0; 1663 distance = 0;
1656 dprintf(c->fc, "first sample flags 0x%x\n", first_sample_flags); 1664 dprintf(c->fc, "first sample flags 0x%x\n", first_sample_flags);
1733 moov_len = get_be32(pb); /* uncompressed size */ 1741 moov_len = get_be32(pb); /* uncompressed size */
1734 cmov_len = atom.size - 6 * 4; 1742 cmov_len = atom.size - 6 * 4;
1735 1743
1736 cmov_data = av_malloc(cmov_len); 1744 cmov_data = av_malloc(cmov_len);
1737 if (!cmov_data) 1745 if (!cmov_data)
1738 return -1; 1746 return AVERROR(ENOMEM);
1739 moov_data = av_malloc(moov_len); 1747 moov_data = av_malloc(moov_len);
1740 if (!moov_data) { 1748 if (!moov_data) {
1741 av_free(cmov_data); 1749 av_free(cmov_data);
1742 return -1; 1750 return AVERROR(ENOMEM);
1743 } 1751 }
1744 get_buffer(pb, cmov_data, cmov_len); 1752 get_buffer(pb, cmov_data, cmov_len);
1745 if(uncompress (moov_data, (uLongf *) &moov_len, (const Bytef *)cmov_data, cmov_len) != Z_OK) 1753 if(uncompress (moov_data, (uLongf *) &moov_len, (const Bytef *)cmov_data, cmov_len) != Z_OK)
1746 goto free_and_return; 1754 goto free_and_return;
1747 if(init_put_byte(&ctx, moov_data, moov_len, 0, NULL, NULL, NULL, NULL) != 0) 1755 if(init_put_byte(&ctx, moov_data, moov_len, 0, NULL, NULL, NULL, NULL) != 0)