00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023 #include <limits.h>
00024
00025
00026
00027
00028 #include "libavutil/attributes.h"
00029 #include "libavutil/channel_layout.h"
00030 #include "libavutil/intreadwrite.h"
00031 #include "libavutil/intfloat.h"
00032 #include "libavutil/mathematics.h"
00033 #include "libavutil/avstring.h"
00034 #include "libavutil/dict.h"
00035 #include "libavutil/opt.h"
00036 #include "libavutil/timecode.h"
00037 #include "libavcodec/ac3tab.h"
00038 #include "avformat.h"
00039 #include "internal.h"
00040 #include "avio_internal.h"
00041 #include "riff.h"
00042 #include "isom.h"
00043 #include "libavcodec/get_bits.h"
00044 #include "id3v1.h"
00045 #include "mov_chan.h"
00046
00047 #if CONFIG_ZLIB
00048 #include <zlib.h>
00049 #endif
00050
00051
00052
00053
00054
00055
00056 #include "qtpalette.h"
00057
00058
00059 #undef NDEBUG
00060 #include <assert.h>
00061
00062
00063
00064 typedef struct MOVParseTableEntry {
00065 uint32_t type;
00066 int (*parse)(MOVContext *ctx, AVIOContext *pb, MOVAtom atom);
00067 } MOVParseTableEntry;
00068
00069 static int mov_read_default(MOVContext *c, AVIOContext *pb, MOVAtom atom);
00070
00071 static int mov_metadata_track_or_disc_number(MOVContext *c, AVIOContext *pb,
00072 unsigned len, const char *key)
00073 {
00074 char buf[16];
00075
00076 short current, total = 0;
00077 avio_rb16(pb);
00078 current = avio_rb16(pb);
00079 if (len >= 6)
00080 total = avio_rb16(pb);
00081 if (!total)
00082 snprintf(buf, sizeof(buf), "%d", current);
00083 else
00084 snprintf(buf, sizeof(buf), "%d/%d", current, total);
00085 av_dict_set(&c->fc->metadata, key, buf, 0);
00086
00087 return 0;
00088 }
00089
00090 static int mov_metadata_int8_bypass_padding(MOVContext *c, AVIOContext *pb,
00091 unsigned len, const char *key)
00092 {
00093 char buf[16];
00094
00095
00096 avio_r8(pb);
00097 avio_r8(pb);
00098 avio_r8(pb);
00099
00100 snprintf(buf, sizeof(buf), "%d", avio_r8(pb));
00101 av_dict_set(&c->fc->metadata, key, buf, 0);
00102
00103 return 0;
00104 }
00105
00106 static int mov_metadata_int8_no_padding(MOVContext *c, AVIOContext *pb,
00107 unsigned len, const char *key)
00108 {
00109 char buf[16];
00110
00111 snprintf(buf, sizeof(buf), "%d", avio_r8(pb));
00112 av_dict_set(&c->fc->metadata, key, buf, 0);
00113
00114 return 0;
00115 }
00116
00117 static int mov_metadata_gnre(MOVContext *c, AVIOContext *pb,
00118 unsigned len, const char *key)
00119 {
00120 short genre;
00121 char buf[20];
00122
00123 avio_r8(pb);
00124
00125 genre = avio_r8(pb);
00126 if (genre < 1 || genre > ID3v1_GENRE_MAX)
00127 return 0;
00128 snprintf(buf, sizeof(buf), "%s", ff_id3v1_genre_str[genre-1]);
00129 av_dict_set(&c->fc->metadata, key, buf, 0);
00130
00131 return 0;
00132 }
00133
00134 static int mov_read_custom_metadata(MOVContext *c, AVIOContext *pb, MOVAtom atom)
00135 {
00136 char key[1024]={0}, data[1024]={0};
00137 int i;
00138 AVStream *st;
00139 MOVStreamContext *sc;
00140
00141 if (c->fc->nb_streams < 1)
00142 return 0;
00143 st = c->fc->streams[c->fc->nb_streams-1];
00144 sc = st->priv_data;
00145
00146 if (atom.size <= 8) return 0;
00147
00148 for (i = 0; i < 3; i++) {
00149 int data_size = avio_rb32(pb);
00150 int tag = avio_rl32(pb);
00151 int str_size = 0, skip_size = 0;
00152 char *target = NULL;
00153
00154 switch (tag) {
00155 case MKTAG('n','a','m','e'):
00156 avio_rb32(pb);
00157 str_size = skip_size = data_size - 12;
00158 atom.size -= 12;
00159 target = key;
00160 break;
00161 case MKTAG('d','a','t','a'):
00162 avio_rb32(pb);
00163 avio_rb32(pb);
00164 str_size = skip_size = data_size - 16;
00165 atom.size -= 16;
00166 target = data;
00167 break;
00168 default:
00169 skip_size = data_size - 8;
00170 str_size = 0;
00171 break;
00172 }
00173
00174 if (target) {
00175 str_size = FFMIN3(sizeof(data)-1, str_size, atom.size);
00176 avio_read(pb, target, str_size);
00177 target[str_size] = 0;
00178 }
00179 atom.size -= skip_size;
00180
00181
00182 if (skip_size > str_size) avio_skip(pb, skip_size - str_size);
00183 }
00184
00185 if (*key && *data) {
00186 if (strcmp(key, "iTunSMPB") == 0) {
00187 int priming, remainder, samples;
00188 if(sscanf(data, "%*X %X %X %X", &priming, &remainder, &samples) == 3){
00189 if(priming>0 && priming<16384)
00190 sc->start_pad = priming;
00191 return 1;
00192 }
00193 }
00194 if (strcmp(key, "cdec") == 0) {
00195
00196 return 1;
00197 }
00198 }
00199 return 0;
00200 }
00201
00202 static const uint32_t mac_to_unicode[128] = {
00203 0x00C4,0x00C5,0x00C7,0x00C9,0x00D1,0x00D6,0x00DC,0x00E1,
00204 0x00E0,0x00E2,0x00E4,0x00E3,0x00E5,0x00E7,0x00E9,0x00E8,
00205 0x00EA,0x00EB,0x00ED,0x00EC,0x00EE,0x00EF,0x00F1,0x00F3,
00206 0x00F2,0x00F4,0x00F6,0x00F5,0x00FA,0x00F9,0x00FB,0x00FC,
00207 0x2020,0x00B0,0x00A2,0x00A3,0x00A7,0x2022,0x00B6,0x00DF,
00208 0x00AE,0x00A9,0x2122,0x00B4,0x00A8,0x2260,0x00C6,0x00D8,
00209 0x221E,0x00B1,0x2264,0x2265,0x00A5,0x00B5,0x2202,0x2211,
00210 0x220F,0x03C0,0x222B,0x00AA,0x00BA,0x03A9,0x00E6,0x00F8,
00211 0x00BF,0x00A1,0x00AC,0x221A,0x0192,0x2248,0x2206,0x00AB,
00212 0x00BB,0x2026,0x00A0,0x00C0,0x00C3,0x00D5,0x0152,0x0153,
00213 0x2013,0x2014,0x201C,0x201D,0x2018,0x2019,0x00F7,0x25CA,
00214 0x00FF,0x0178,0x2044,0x20AC,0x2039,0x203A,0xFB01,0xFB02,
00215 0x2021,0x00B7,0x201A,0x201E,0x2030,0x00C2,0x00CA,0x00C1,
00216 0x00CB,0x00C8,0x00CD,0x00CE,0x00CF,0x00CC,0x00D3,0x00D4,
00217 0xF8FF,0x00D2,0x00DA,0x00DB,0x00D9,0x0131,0x02C6,0x02DC,
00218 0x00AF,0x02D8,0x02D9,0x02DA,0x00B8,0x02DD,0x02DB,0x02C7,
00219 };
00220
00221 static int mov_read_mac_string(MOVContext *c, AVIOContext *pb, int len,
00222 char *dst, int dstlen)
00223 {
00224 char *p = dst;
00225 char *end = dst+dstlen-1;
00226 int i;
00227
00228 for (i = 0; i < len; i++) {
00229 uint8_t t, c = avio_r8(pb);
00230 if (c < 0x80 && p < end)
00231 *p++ = c;
00232 else if (p < end)
00233 PUT_UTF8(mac_to_unicode[c-0x80], t, if (p < end) *p++ = t;);
00234 }
00235 *p = 0;
00236 return p - dst;
00237 }
00238
00239 static int mov_read_covr(MOVContext *c, AVIOContext *pb, int type, int len)
00240 {
00241 AVPacket pkt;
00242 AVStream *st;
00243 MOVStreamContext *sc;
00244 enum AVCodecID id;
00245 int ret;
00246
00247 switch (type) {
00248 case 0xd: id = AV_CODEC_ID_MJPEG; break;
00249 case 0xe: id = AV_CODEC_ID_PNG; break;
00250 case 0x1b: id = AV_CODEC_ID_BMP; break;
00251 default:
00252 av_log(c->fc, AV_LOG_WARNING, "Unknown cover type: 0x%x.\n", type);
00253 avio_skip(pb, len);
00254 return 0;
00255 }
00256
00257 st = avformat_new_stream(c->fc, NULL);
00258 if (!st)
00259 return AVERROR(ENOMEM);
00260 sc = av_mallocz(sizeof(*sc));
00261 if (!sc)
00262 return AVERROR(ENOMEM);
00263 st->priv_data = sc;
00264
00265 ret = av_get_packet(pb, &pkt, len);
00266 if (ret < 0)
00267 return ret;
00268
00269 st->disposition |= AV_DISPOSITION_ATTACHED_PIC;
00270
00271 st->attached_pic = pkt;
00272 st->attached_pic.stream_index = st->index;
00273 st->attached_pic.flags |= AV_PKT_FLAG_KEY;
00274
00275 st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
00276 st->codec->codec_id = id;
00277
00278 return 0;
00279 }
00280
00281 static int mov_metadata_raw(MOVContext *c, AVIOContext *pb,
00282 unsigned len, const char *key)
00283 {
00284 char *value = av_malloc(len + 1);
00285 if (!value)
00286 return AVERROR(ENOMEM);
00287 avio_read(pb, value, len);
00288 value[len] = 0;
00289 return av_dict_set(&c->fc->metadata, key, value, AV_DICT_DONT_STRDUP_VAL);
00290 }
00291
00292 static int mov_read_udta_string(MOVContext *c, AVIOContext *pb, MOVAtom atom)
00293 {
00294 #ifdef MOV_EXPORT_ALL_METADATA
00295 char tmp_key[5];
00296 #endif
00297 char str[1024], key2[16], language[4] = {0};
00298 const char *key = NULL;
00299 uint16_t langcode = 0;
00300 uint32_t data_type = 0, str_size;
00301 int (*parse)(MOVContext*, AVIOContext*, unsigned, const char*) = NULL;
00302
00303 if (c->itunes_metadata && atom.type == MKTAG('-','-','-','-'))
00304 return mov_read_custom_metadata(c, pb, atom);
00305
00306 switch (atom.type) {
00307 case MKTAG(0xa9,'n','a','m'): key = "title"; break;
00308 case MKTAG(0xa9,'a','u','t'):
00309 case MKTAG(0xa9,'A','R','T'): key = "artist"; break;
00310 case MKTAG( 'a','A','R','T'): key = "album_artist"; break;
00311 case MKTAG(0xa9,'w','r','t'): key = "composer"; break;
00312 case MKTAG( 'c','p','r','t'):
00313 case MKTAG(0xa9,'c','p','y'): key = "copyright"; break;
00314 case MKTAG(0xa9,'g','r','p'): key = "grouping"; break;
00315 case MKTAG(0xa9,'l','y','r'): key = "lyrics"; break;
00316 case MKTAG(0xa9,'c','m','t'):
00317 case MKTAG(0xa9,'i','n','f'): key = "comment"; break;
00318 case MKTAG(0xa9,'a','l','b'): key = "album"; break;
00319 case MKTAG(0xa9,'d','a','y'): key = "date"; break;
00320 case MKTAG(0xa9,'g','e','n'): key = "genre"; break;
00321 case MKTAG( 'g','n','r','e'): key = "genre";
00322 parse = mov_metadata_gnre; break;
00323 case MKTAG(0xa9,'t','o','o'):
00324 case MKTAG(0xa9,'s','w','r'): key = "encoder"; break;
00325 case MKTAG(0xa9,'e','n','c'): key = "encoder"; break;
00326 case MKTAG(0xa9,'m','a','k'): key = "make"; break;
00327 case MKTAG(0xa9,'m','o','d'): key = "model"; break;
00328 case MKTAG(0xa9,'x','y','z'): key = "location"; break;
00329 case MKTAG( 'd','e','s','c'): key = "description";break;
00330 case MKTAG( 'l','d','e','s'): key = "synopsis"; break;
00331 case MKTAG( 't','v','s','h'): key = "show"; break;
00332 case MKTAG( 't','v','e','n'): key = "episode_id";break;
00333 case MKTAG( 't','v','n','n'): key = "network"; break;
00334 case MKTAG( 't','r','k','n'): key = "track";
00335 parse = mov_metadata_track_or_disc_number; break;
00336 case MKTAG( 'd','i','s','k'): key = "disc";
00337 parse = mov_metadata_track_or_disc_number; break;
00338 case MKTAG( 't','v','e','s'): key = "episode_sort";
00339 parse = mov_metadata_int8_bypass_padding; break;
00340 case MKTAG( 't','v','s','n'): key = "season_number";
00341 parse = mov_metadata_int8_bypass_padding; break;
00342 case MKTAG( 's','t','i','k'): key = "media_type";
00343 parse = mov_metadata_int8_no_padding; break;
00344 case MKTAG( 'h','d','v','d'): key = "hd_video";
00345 parse = mov_metadata_int8_no_padding; break;
00346 case MKTAG( 'p','g','a','p'): key = "gapless_playback";
00347 parse = mov_metadata_int8_no_padding; break;
00348 case MKTAG( '@','P','R','M'):
00349 return mov_metadata_raw(c, pb, atom.size, "premiere_version");
00350 case MKTAG( '@','P','R','Q'):
00351 return mov_metadata_raw(c, pb, atom.size, "quicktime_version");
00352 }
00353
00354 if (c->itunes_metadata && atom.size > 8) {
00355 int data_size = avio_rb32(pb);
00356 int tag = avio_rl32(pb);
00357 if (tag == MKTAG('d','a','t','a')) {
00358 data_type = avio_rb32(pb);
00359 avio_rb32(pb);
00360 str_size = data_size - 16;
00361 atom.size -= 16;
00362
00363 if (atom.type == MKTAG('c', 'o', 'v', 'r')) {
00364 int ret = mov_read_covr(c, pb, data_type, str_size);
00365 if (ret < 0) {
00366 av_log(c->fc, AV_LOG_ERROR, "Error parsing cover art.\n");
00367 return ret;
00368 }
00369 }
00370 } else return 0;
00371 } else if (atom.size > 4 && key && !c->itunes_metadata) {
00372 str_size = avio_rb16(pb);
00373 langcode = avio_rb16(pb);
00374 ff_mov_lang_to_iso639(langcode, language);
00375 atom.size -= 4;
00376 } else
00377 str_size = atom.size;
00378
00379 #ifdef MOV_EXPORT_ALL_METADATA
00380 if (!key) {
00381 snprintf(tmp_key, 5, "%.4s", (char*)&atom.type);
00382 key = tmp_key;
00383 }
00384 #endif
00385
00386 if (!key)
00387 return 0;
00388 if (atom.size < 0)
00389 return AVERROR_INVALIDDATA;
00390
00391 str_size = FFMIN3(sizeof(str)-1, str_size, atom.size);
00392
00393 if (parse)
00394 parse(c, pb, str_size, key);
00395 else {
00396 if (data_type == 3 || (data_type == 0 && (langcode < 0x400 || langcode == 0x7fff))) {
00397 mov_read_mac_string(c, pb, str_size, str, sizeof(str));
00398 } else {
00399 avio_read(pb, str, str_size);
00400 str[str_size] = 0;
00401 }
00402 av_dict_set(&c->fc->metadata, key, str, 0);
00403 if (*language && strcmp(language, "und")) {
00404 snprintf(key2, sizeof(key2), "%s-%s", key, language);
00405 av_dict_set(&c->fc->metadata, key2, str, 0);
00406 }
00407 }
00408 av_dlog(c->fc, "lang \"%3s\" ", language);
00409 av_dlog(c->fc, "tag \"%s\" value \"%s\" atom \"%.4s\" %d %"PRId64"\n",
00410 key, str, (char*)&atom.type, str_size, atom.size);
00411
00412 return 0;
00413 }
00414
00415 static int mov_read_chpl(MOVContext *c, AVIOContext *pb, MOVAtom atom)
00416 {
00417 int64_t start;
00418 int i, nb_chapters, str_len, version;
00419 char str[256+1];
00420
00421 if ((atom.size -= 5) < 0)
00422 return 0;
00423
00424 version = avio_r8(pb);
00425 avio_rb24(pb);
00426 if (version)
00427 avio_rb32(pb);
00428 nb_chapters = avio_r8(pb);
00429
00430 for (i = 0; i < nb_chapters; i++) {
00431 if (atom.size < 9)
00432 return 0;
00433
00434 start = avio_rb64(pb);
00435 str_len = avio_r8(pb);
00436
00437 if ((atom.size -= 9+str_len) < 0)
00438 return 0;
00439
00440 avio_read(pb, str, str_len);
00441 str[str_len] = 0;
00442 avpriv_new_chapter(c->fc, i, (AVRational){1,10000000}, start, AV_NOPTS_VALUE, str);
00443 }
00444 return 0;
00445 }
00446
00447 #define MIN_DATA_ENTRY_BOX_SIZE 12
00448 static int mov_read_dref(MOVContext *c, AVIOContext *pb, MOVAtom atom)
00449 {
00450 AVStream *st;
00451 MOVStreamContext *sc;
00452 int entries, i, j;
00453
00454 if (c->fc->nb_streams < 1)
00455 return 0;
00456 st = c->fc->streams[c->fc->nb_streams-1];
00457 sc = st->priv_data;
00458
00459 avio_rb32(pb);
00460 entries = avio_rb32(pb);
00461 if (entries > (atom.size - 1) / MIN_DATA_ENTRY_BOX_SIZE + 1 ||
00462 entries >= UINT_MAX / sizeof(*sc->drefs))
00463 return AVERROR_INVALIDDATA;
00464 av_free(sc->drefs);
00465 sc->drefs_count = 0;
00466 sc->drefs = av_mallocz(entries * sizeof(*sc->drefs));
00467 if (!sc->drefs)
00468 return AVERROR(ENOMEM);
00469 sc->drefs_count = entries;
00470
00471 for (i = 0; i < sc->drefs_count; i++) {
00472 MOVDref *dref = &sc->drefs[i];
00473 uint32_t size = avio_rb32(pb);
00474 int64_t next = avio_tell(pb) + size - 4;
00475
00476 if (size < 12)
00477 return AVERROR_INVALIDDATA;
00478
00479 dref->type = avio_rl32(pb);
00480 avio_rb32(pb);
00481 av_dlog(c->fc, "type %.4s size %d\n", (char*)&dref->type, size);
00482
00483 if (dref->type == MKTAG('a','l','i','s') && size > 150) {
00484
00485 uint16_t volume_len, len;
00486 int16_t type;
00487
00488 avio_skip(pb, 10);
00489
00490 volume_len = avio_r8(pb);
00491 volume_len = FFMIN(volume_len, 27);
00492 avio_read(pb, dref->volume, 27);
00493 dref->volume[volume_len] = 0;
00494 av_log(c->fc, AV_LOG_DEBUG, "volume %s, len %d\n", dref->volume, volume_len);
00495
00496 avio_skip(pb, 12);
00497
00498 len = avio_r8(pb);
00499 len = FFMIN(len, 63);
00500 avio_read(pb, dref->filename, 63);
00501 dref->filename[len] = 0;
00502 av_log(c->fc, AV_LOG_DEBUG, "filename %s, len %d\n", dref->filename, len);
00503
00504 avio_skip(pb, 16);
00505
00506
00507 dref->nlvl_from = avio_rb16(pb);
00508 dref->nlvl_to = avio_rb16(pb);
00509 av_log(c->fc, AV_LOG_DEBUG, "nlvl from %d, nlvl to %d\n",
00510 dref->nlvl_from, dref->nlvl_to);
00511
00512 avio_skip(pb, 16);
00513
00514 for (type = 0; type != -1 && avio_tell(pb) < next; ) {
00515 if(url_feof(pb))
00516 return AVERROR_EOF;
00517 type = avio_rb16(pb);
00518 len = avio_rb16(pb);
00519 av_log(c->fc, AV_LOG_DEBUG, "type %d, len %d\n", type, len);
00520 if (len&1)
00521 len += 1;
00522 if (type == 2) {
00523 av_free(dref->path);
00524 dref->path = av_mallocz(len+1);
00525 if (!dref->path)
00526 return AVERROR(ENOMEM);
00527 avio_read(pb, dref->path, len);
00528 if (len > volume_len && !strncmp(dref->path, dref->volume, volume_len)) {
00529 len -= volume_len;
00530 memmove(dref->path, dref->path+volume_len, len);
00531 dref->path[len] = 0;
00532 }
00533 for (j = 0; j < len; j++)
00534 if (dref->path[j] == ':')
00535 dref->path[j] = '/';
00536 av_log(c->fc, AV_LOG_DEBUG, "path %s\n", dref->path);
00537 } else if (type == 0) {
00538 av_free(dref->dir);
00539 dref->dir = av_malloc(len+1);
00540 if (!dref->dir)
00541 return AVERROR(ENOMEM);
00542 avio_read(pb, dref->dir, len);
00543 dref->dir[len] = 0;
00544 for (j = 0; j < len; j++)
00545 if (dref->dir[j] == ':')
00546 dref->dir[j] = '/';
00547 av_log(c->fc, AV_LOG_DEBUG, "dir %s\n", dref->dir);
00548 } else
00549 avio_skip(pb, len);
00550 }
00551 }
00552 avio_seek(pb, next, SEEK_SET);
00553 }
00554 return 0;
00555 }
00556
00557 static int mov_read_hdlr(MOVContext *c, AVIOContext *pb, MOVAtom atom)
00558 {
00559 AVStream *st;
00560 uint32_t type;
00561 uint32_t av_unused ctype;
00562 int title_size;
00563 char *title_str;
00564
00565 if (c->fc->nb_streams < 1)
00566 return 0;
00567
00568 st = c->fc->streams[c->fc->nb_streams-1];
00569
00570 avio_r8(pb);
00571 avio_rb24(pb);
00572
00573
00574 ctype = avio_rl32(pb);
00575 type = avio_rl32(pb);
00576
00577 av_dlog(c->fc, "ctype= %.4s (0x%08x)\n", (char*)&ctype, ctype);
00578 av_dlog(c->fc, "stype= %.4s\n", (char*)&type);
00579
00580 if (type == MKTAG('v','i','d','e'))
00581 st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
00582 else if (type == MKTAG('s','o','u','n'))
00583 st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
00584 else if (type == MKTAG('m','1','a',' '))
00585 st->codec->codec_id = AV_CODEC_ID_MP2;
00586 else if ((type == MKTAG('s','u','b','p')) || (type == MKTAG('c','l','c','p')))
00587 st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;
00588
00589 avio_rb32(pb);
00590 avio_rb32(pb);
00591 avio_rb32(pb);
00592
00593 title_size = atom.size - 24;
00594 if (title_size > 0) {
00595 title_str = av_malloc(title_size + 1);
00596 if (!title_str)
00597 return AVERROR(ENOMEM);
00598 avio_read(pb, title_str, title_size);
00599 title_str[title_size] = 0;
00600 if (title_str[0])
00601 av_dict_set(&st->metadata, "handler_name", title_str +
00602 (!c->isom && title_str[0] == title_size - 1), 0);
00603 av_freep(&title_str);
00604 }
00605
00606 return 0;
00607 }
00608
00609 int ff_mov_read_esds(AVFormatContext *fc, AVIOContext *pb, MOVAtom atom)
00610 {
00611 AVStream *st;
00612 int tag;
00613
00614 if (fc->nb_streams < 1)
00615 return 0;
00616 st = fc->streams[fc->nb_streams-1];
00617
00618 avio_rb32(pb);
00619 ff_mp4_read_descr(fc, pb, &tag);
00620 if (tag == MP4ESDescrTag) {
00621 ff_mp4_parse_es_descr(pb, NULL);
00622 } else
00623 avio_rb16(pb);
00624
00625 ff_mp4_read_descr(fc, pb, &tag);
00626 if (tag == MP4DecConfigDescrTag)
00627 ff_mp4_read_dec_config_descr(fc, st, pb);
00628 return 0;
00629 }
00630
00631 static int mov_read_esds(MOVContext *c, AVIOContext *pb, MOVAtom atom)
00632 {
00633 return ff_mov_read_esds(c->fc, pb, atom);
00634 }
00635
00636 static int mov_read_dac3(MOVContext *c, AVIOContext *pb, MOVAtom atom)
00637 {
00638 AVStream *st;
00639 int ac3info, acmod, lfeon, bsmod;
00640
00641 if (c->fc->nb_streams < 1)
00642 return 0;
00643 st = c->fc->streams[c->fc->nb_streams-1];
00644
00645 ac3info = avio_rb24(pb);
00646 bsmod = (ac3info >> 14) & 0x7;
00647 acmod = (ac3info >> 11) & 0x7;
00648 lfeon = (ac3info >> 10) & 0x1;
00649 st->codec->channels = ((int[]){2,1,2,3,3,4,4,5})[acmod] + lfeon;
00650 st->codec->channel_layout = avpriv_ac3_channel_layout_tab[acmod];
00651 if (lfeon)
00652 st->codec->channel_layout |= AV_CH_LOW_FREQUENCY;
00653 st->codec->audio_service_type = bsmod;
00654 if (st->codec->channels > 1 && bsmod == 0x7)
00655 st->codec->audio_service_type = AV_AUDIO_SERVICE_TYPE_KARAOKE;
00656
00657 return 0;
00658 }
00659
00660 static int mov_read_dec3(MOVContext *c, AVIOContext *pb, MOVAtom atom)
00661 {
00662 AVStream *st;
00663 int eac3info, acmod, lfeon, bsmod;
00664
00665 if (c->fc->nb_streams < 1)
00666 return 0;
00667 st = c->fc->streams[c->fc->nb_streams-1];
00668
00669
00670
00671
00672 avio_rb16(pb);
00673 eac3info = avio_rb24(pb);
00674 bsmod = (eac3info >> 12) & 0x1f;
00675 acmod = (eac3info >> 9) & 0x7;
00676 lfeon = (eac3info >> 8) & 0x1;
00677 st->codec->channel_layout = avpriv_ac3_channel_layout_tab[acmod];
00678 if (lfeon)
00679 st->codec->channel_layout |= AV_CH_LOW_FREQUENCY;
00680 st->codec->channels = av_get_channel_layout_nb_channels(st->codec->channel_layout);
00681 st->codec->audio_service_type = bsmod;
00682 if (st->codec->channels > 1 && bsmod == 0x7)
00683 st->codec->audio_service_type = AV_AUDIO_SERVICE_TYPE_KARAOKE;
00684
00685 return 0;
00686 }
00687
00688 static int mov_read_chan(MOVContext *c, AVIOContext *pb, MOVAtom atom)
00689 {
00690 AVStream *st;
00691
00692 if (c->fc->nb_streams < 1)
00693 return 0;
00694 st = c->fc->streams[c->fc->nb_streams-1];
00695
00696 if (atom.size < 16)
00697 return 0;
00698
00699 ff_mov_read_chan(c->fc, pb, st, atom.size - 4);
00700
00701 return 0;
00702 }
00703
00704 static int mov_read_wfex(MOVContext *c, AVIOContext *pb, MOVAtom atom)
00705 {
00706 AVStream *st;
00707
00708 if (c->fc->nb_streams < 1)
00709 return 0;
00710 st = c->fc->streams[c->fc->nb_streams-1];
00711
00712 if (ff_get_wav_header(pb, st->codec, atom.size) < 0) {
00713 av_log(c->fc, AV_LOG_WARNING, "get_wav_header failed\n");
00714 }
00715
00716 return 0;
00717 }
00718
00719 static int mov_read_pasp(MOVContext *c, AVIOContext *pb, MOVAtom atom)
00720 {
00721 const int num = avio_rb32(pb);
00722 const int den = avio_rb32(pb);
00723 AVStream *st;
00724
00725 if (c->fc->nb_streams < 1)
00726 return 0;
00727 st = c->fc->streams[c->fc->nb_streams-1];
00728
00729 if ((st->sample_aspect_ratio.den != 1 || st->sample_aspect_ratio.num) &&
00730 (den != st->sample_aspect_ratio.den || num != st->sample_aspect_ratio.num)) {
00731 av_log(c->fc, AV_LOG_WARNING,
00732 "sample aspect ratio already set to %d:%d, ignoring 'pasp' atom (%d:%d)\n",
00733 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
00734 num, den);
00735 } else if (den != 0) {
00736 st->sample_aspect_ratio.num = num;
00737 st->sample_aspect_ratio.den = den;
00738 }
00739 return 0;
00740 }
00741
00742
00743 static int mov_read_mdat(MOVContext *c, AVIOContext *pb, MOVAtom atom)
00744 {
00745 if (atom.size == 0)
00746 return 0;
00747 c->found_mdat=1;
00748 return 0;
00749 }
00750
00751
00752 static int mov_read_ftyp(MOVContext *c, AVIOContext *pb, MOVAtom atom)
00753 {
00754 uint32_t minor_ver;
00755 int comp_brand_size;
00756 char minor_ver_str[11];
00757 char* comp_brands_str;
00758 uint8_t type[5] = {0};
00759
00760 avio_read(pb, type, 4);
00761 if (strcmp(type, "qt "))
00762 c->isom = 1;
00763 av_log(c->fc, AV_LOG_DEBUG, "ISO: File Type Major Brand: %.4s\n",(char *)&type);
00764 av_dict_set(&c->fc->metadata, "major_brand", type, 0);
00765 minor_ver = avio_rb32(pb);
00766 snprintf(minor_ver_str, sizeof(minor_ver_str), "%d", minor_ver);
00767 av_dict_set(&c->fc->metadata, "minor_version", minor_ver_str, 0);
00768
00769 comp_brand_size = atom.size - 8;
00770 if (comp_brand_size < 0)
00771 return AVERROR_INVALIDDATA;
00772 comp_brands_str = av_malloc(comp_brand_size + 1);
00773 if (!comp_brands_str)
00774 return AVERROR(ENOMEM);
00775 avio_read(pb, comp_brands_str, comp_brand_size);
00776 comp_brands_str[comp_brand_size] = 0;
00777 av_dict_set(&c->fc->metadata, "compatible_brands", comp_brands_str, 0);
00778 av_freep(&comp_brands_str);
00779
00780 return 0;
00781 }
00782
00783
00784 static int mov_read_moov(MOVContext *c, AVIOContext *pb, MOVAtom atom)
00785 {
00786 int ret;
00787
00788 if ((ret = mov_read_default(c, pb, atom)) < 0)
00789 return ret;
00790
00791
00792 c->found_moov=1;
00793 return 0;
00794 }
00795
00796 static int mov_read_moof(MOVContext *c, AVIOContext *pb, MOVAtom atom)
00797 {
00798 c->fragment.moof_offset = avio_tell(pb) - 8;
00799 av_dlog(c->fc, "moof offset %"PRIx64"\n", c->fragment.moof_offset);
00800 return mov_read_default(c, pb, atom);
00801 }
00802
00803 static void mov_metadata_creation_time(AVDictionary **metadata, int64_t time)
00804 {
00805 char buffer[32];
00806 if (time) {
00807 struct tm *ptm;
00808 time_t timet;
00809 if(time >= 2082844800)
00810 time -= 2082844800;
00811 timet = time;
00812 ptm = gmtime(&timet);
00813 if (!ptm) return;
00814 strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", ptm);
00815 av_dict_set(metadata, "creation_time", buffer, 0);
00816 }
00817 }
00818
00819 static int mov_read_mdhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
00820 {
00821 AVStream *st;
00822 MOVStreamContext *sc;
00823 int version;
00824 char language[4] = {0};
00825 unsigned lang;
00826 int64_t creation_time;
00827
00828 if (c->fc->nb_streams < 1)
00829 return 0;
00830 st = c->fc->streams[c->fc->nb_streams-1];
00831 sc = st->priv_data;
00832
00833 version = avio_r8(pb);
00834 if (version > 1) {
00835 av_log_ask_for_sample(c, "unsupported version %d\n", version);
00836 return AVERROR_PATCHWELCOME;
00837 }
00838 avio_rb24(pb);
00839 if (version == 1) {
00840 creation_time = avio_rb64(pb);
00841 avio_rb64(pb);
00842 } else {
00843 creation_time = avio_rb32(pb);
00844 avio_rb32(pb);
00845 }
00846 mov_metadata_creation_time(&st->metadata, creation_time);
00847
00848 sc->time_scale = avio_rb32(pb);
00849 st->duration = (version == 1) ? avio_rb64(pb) : avio_rb32(pb);
00850
00851 lang = avio_rb16(pb);
00852 if (ff_mov_lang_to_iso639(lang, language))
00853 av_dict_set(&st->metadata, "language", language, 0);
00854 avio_rb16(pb);
00855
00856 return 0;
00857 }
00858
00859 static int mov_read_mvhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
00860 {
00861 int64_t creation_time;
00862 int version = avio_r8(pb);
00863 avio_rb24(pb);
00864
00865 if (version == 1) {
00866 creation_time = avio_rb64(pb);
00867 avio_rb64(pb);
00868 } else {
00869 creation_time = avio_rb32(pb);
00870 avio_rb32(pb);
00871 }
00872 mov_metadata_creation_time(&c->fc->metadata, creation_time);
00873 c->time_scale = avio_rb32(pb);
00874
00875 av_dlog(c->fc, "time scale = %i\n", c->time_scale);
00876
00877 c->duration = (version == 1) ? avio_rb64(pb) : avio_rb32(pb);
00878
00879
00880 if (c->time_scale > 0)
00881 c->fc->duration = av_rescale(c->duration, AV_TIME_BASE, c->time_scale);
00882 avio_rb32(pb);
00883
00884 avio_rb16(pb);
00885
00886 avio_skip(pb, 10);
00887
00888 avio_skip(pb, 36);
00889
00890 avio_rb32(pb);
00891 avio_rb32(pb);
00892 avio_rb32(pb);
00893 avio_rb32(pb);
00894 avio_rb32(pb);
00895 avio_rb32(pb);
00896 avio_rb32(pb);
00897 return 0;
00898 }
00899
00900 static int mov_read_enda(MOVContext *c, AVIOContext *pb, MOVAtom atom)
00901 {
00902 AVStream *st;
00903 int little_endian;
00904
00905 if (c->fc->nb_streams < 1)
00906 return 0;
00907 st = c->fc->streams[c->fc->nb_streams-1];
00908
00909 little_endian = avio_rb16(pb) & 0xFF;
00910 av_dlog(c->fc, "enda %d\n", little_endian);
00911 if (little_endian == 1) {
00912 switch (st->codec->codec_id) {
00913 case AV_CODEC_ID_PCM_S24BE:
00914 st->codec->codec_id = AV_CODEC_ID_PCM_S24LE;
00915 break;
00916 case AV_CODEC_ID_PCM_S32BE:
00917 st->codec->codec_id = AV_CODEC_ID_PCM_S32LE;
00918 break;
00919 case AV_CODEC_ID_PCM_F32BE:
00920 st->codec->codec_id = AV_CODEC_ID_PCM_F32LE;
00921 break;
00922 case AV_CODEC_ID_PCM_F64BE:
00923 st->codec->codec_id = AV_CODEC_ID_PCM_F64LE;
00924 break;
00925 default:
00926 break;
00927 }
00928 }
00929 return 0;
00930 }
00931
00932 static int mov_read_fiel(MOVContext *c, AVIOContext *pb, MOVAtom atom)
00933 {
00934 AVStream *st;
00935 unsigned mov_field_order;
00936 enum AVFieldOrder decoded_field_order = AV_FIELD_UNKNOWN;
00937
00938 if (c->fc->nb_streams < 1)
00939 return 0;
00940 st = c->fc->streams[c->fc->nb_streams-1];
00941 if (atom.size < 2)
00942 return AVERROR_INVALIDDATA;
00943 mov_field_order = avio_rb16(pb);
00944 if ((mov_field_order & 0xFF00) == 0x0100)
00945 decoded_field_order = AV_FIELD_PROGRESSIVE;
00946 else if ((mov_field_order & 0xFF00) == 0x0200) {
00947 switch (mov_field_order & 0xFF) {
00948 case 0x01: decoded_field_order = AV_FIELD_TT;
00949 break;
00950 case 0x06: decoded_field_order = AV_FIELD_BB;
00951 break;
00952 case 0x09: decoded_field_order = AV_FIELD_TB;
00953 break;
00954 case 0x0E: decoded_field_order = AV_FIELD_BT;
00955 break;
00956 }
00957 }
00958 if (decoded_field_order == AV_FIELD_UNKNOWN && mov_field_order) {
00959 av_log(NULL, AV_LOG_ERROR, "Unknown MOV field order 0x%04x\n", mov_field_order);
00960 }
00961 st->codec->field_order = decoded_field_order;
00962
00963 return 0;
00964 }
00965
00966
00967 static int mov_read_extradata(MOVContext *c, AVIOContext *pb, MOVAtom atom,
00968 enum AVCodecID codec_id)
00969 {
00970 AVStream *st;
00971 uint64_t size;
00972 uint8_t *buf;
00973
00974 if (c->fc->nb_streams < 1)
00975 return 0;
00976 st= c->fc->streams[c->fc->nb_streams-1];
00977
00978 if (st->codec->codec_id != codec_id)
00979 return 0;
00980
00981 size= (uint64_t)st->codec->extradata_size + atom.size + 8 + FF_INPUT_BUFFER_PADDING_SIZE;
00982 if (size > INT_MAX || (uint64_t)atom.size > INT_MAX)
00983 return AVERROR_INVALIDDATA;
00984 buf= av_realloc(st->codec->extradata, size);
00985 if (!buf)
00986 return AVERROR(ENOMEM);
00987 st->codec->extradata= buf;
00988 buf+= st->codec->extradata_size;
00989 st->codec->extradata_size= size - FF_INPUT_BUFFER_PADDING_SIZE;
00990 AV_WB32( buf , atom.size + 8);
00991 AV_WL32( buf + 4, atom.type);
00992 avio_read(pb, buf + 8, atom.size);
00993 return 0;
00994 }
00995
00996
00997 static int mov_read_alac(MOVContext *c, AVIOContext *pb, MOVAtom atom)
00998 {
00999 return mov_read_extradata(c, pb, atom, AV_CODEC_ID_ALAC);
01000 }
01001
01002 static int mov_read_avss(MOVContext *c, AVIOContext *pb, MOVAtom atom)
01003 {
01004 return mov_read_extradata(c, pb, atom, AV_CODEC_ID_AVS);
01005 }
01006
01007 static int mov_read_jp2h(MOVContext *c, AVIOContext *pb, MOVAtom atom)
01008 {
01009 return mov_read_extradata(c, pb, atom, AV_CODEC_ID_JPEG2000);
01010 }
01011
01012 static int mov_read_avid(MOVContext *c, AVIOContext *pb, MOVAtom atom)
01013 {
01014 return mov_read_extradata(c, pb, atom, AV_CODEC_ID_AVUI);
01015 }
01016
01017 static int mov_read_svq3(MOVContext *c, AVIOContext *pb, MOVAtom atom)
01018 {
01019 return mov_read_extradata(c, pb, atom, AV_CODEC_ID_SVQ3);
01020 }
01021
01022 static int mov_read_wave(MOVContext *c, AVIOContext *pb, MOVAtom atom)
01023 {
01024 AVStream *st;
01025
01026 if (c->fc->nb_streams < 1)
01027 return 0;
01028 st = c->fc->streams[c->fc->nb_streams-1];
01029
01030 if ((uint64_t)atom.size > (1<<30))
01031 return AVERROR_INVALIDDATA;
01032
01033 if (st->codec->codec_id == AV_CODEC_ID_QDM2 || st->codec->codec_id == AV_CODEC_ID_QDMC) {
01034
01035 av_free(st->codec->extradata);
01036 st->codec->extradata_size = 0;
01037 st->codec->extradata = av_mallocz(atom.size + FF_INPUT_BUFFER_PADDING_SIZE);
01038 if (!st->codec->extradata)
01039 return AVERROR(ENOMEM);
01040 st->codec->extradata_size = atom.size;
01041 avio_read(pb, st->codec->extradata, atom.size);
01042 } else if (atom.size > 8) {
01043 int ret;
01044 if ((ret = mov_read_default(c, pb, atom)) < 0)
01045 return ret;
01046 } else
01047 avio_skip(pb, atom.size);
01048 return 0;
01049 }
01050
01055 static int mov_read_glbl(MOVContext *c, AVIOContext *pb, MOVAtom atom)
01056 {
01057 AVStream *st;
01058
01059 if (c->fc->nb_streams < 1)
01060 return 0;
01061 st = c->fc->streams[c->fc->nb_streams-1];
01062
01063 if ((uint64_t)atom.size > (1<<30))
01064 return AVERROR_INVALIDDATA;
01065
01066 if (atom.size >= 10) {
01067
01068
01069 unsigned size = avio_rb32(pb);
01070 unsigned type = avio_rl32(pb);
01071 avio_seek(pb, -8, SEEK_CUR);
01072 if (type == MKTAG('f','i','e','l') && size == atom.size)
01073 return mov_read_default(c, pb, atom);
01074 }
01075 av_free(st->codec->extradata);
01076 st->codec->extradata_size = 0;
01077 st->codec->extradata = av_mallocz(atom.size + FF_INPUT_BUFFER_PADDING_SIZE);
01078 if (!st->codec->extradata)
01079 return AVERROR(ENOMEM);
01080 st->codec->extradata_size = atom.size;
01081 avio_read(pb, st->codec->extradata, atom.size);
01082 return 0;
01083 }
01084
01085 static int mov_read_dvc1(MOVContext *c, AVIOContext *pb, MOVAtom atom)
01086 {
01087 AVStream *st;
01088 uint8_t profile_level;
01089
01090 if (c->fc->nb_streams < 1)
01091 return 0;
01092 st = c->fc->streams[c->fc->nb_streams-1];
01093
01094 if (atom.size >= (1<<28) || atom.size < 7)
01095 return AVERROR_INVALIDDATA;
01096
01097 profile_level = avio_r8(pb);
01098 if ((profile_level & 0xf0) != 0xc0)
01099 return 0;
01100
01101 av_free(st->codec->extradata);
01102 st->codec->extradata_size = 0;
01103 st->codec->extradata = av_mallocz(atom.size - 7 + FF_INPUT_BUFFER_PADDING_SIZE);
01104 if (!st->codec->extradata)
01105 return AVERROR(ENOMEM);
01106 st->codec->extradata_size = atom.size - 7;
01107 avio_seek(pb, 6, SEEK_CUR);
01108 avio_read(pb, st->codec->extradata, st->codec->extradata_size);
01109 return 0;
01110 }
01111
01117 static int mov_read_strf(MOVContext *c, AVIOContext *pb, MOVAtom atom)
01118 {
01119 AVStream *st;
01120
01121 if (c->fc->nb_streams < 1)
01122 return 0;
01123 if (atom.size <= 40)
01124 return 0;
01125 st = c->fc->streams[c->fc->nb_streams-1];
01126
01127 if ((uint64_t)atom.size > (1<<30))
01128 return AVERROR_INVALIDDATA;
01129
01130 av_free(st->codec->extradata);
01131 st->codec->extradata_size = 0;
01132 st->codec->extradata = av_mallocz(atom.size - 40 + FF_INPUT_BUFFER_PADDING_SIZE);
01133 if (!st->codec->extradata)
01134 return AVERROR(ENOMEM);
01135 st->codec->extradata_size = atom.size - 40;
01136 avio_skip(pb, 40);
01137 avio_read(pb, st->codec->extradata, atom.size - 40);
01138 return 0;
01139 }
01140
01141 static int mov_read_stco(MOVContext *c, AVIOContext *pb, MOVAtom atom)
01142 {
01143 AVStream *st;
01144 MOVStreamContext *sc;
01145 unsigned int i, entries;
01146
01147 if (c->fc->nb_streams < 1)
01148 return 0;
01149 st = c->fc->streams[c->fc->nb_streams-1];
01150 sc = st->priv_data;
01151
01152 avio_r8(pb);
01153 avio_rb24(pb);
01154
01155 entries = avio_rb32(pb);
01156
01157 if (!entries)
01158 return 0;
01159 if (entries >= UINT_MAX/sizeof(int64_t))
01160 return AVERROR_INVALIDDATA;
01161
01162 sc->chunk_offsets = av_malloc(entries * sizeof(int64_t));
01163 if (!sc->chunk_offsets)
01164 return AVERROR(ENOMEM);
01165 sc->chunk_count = entries;
01166
01167 if (atom.type == MKTAG('s','t','c','o'))
01168 for (i = 0; i < entries && !pb->eof_reached; i++)
01169 sc->chunk_offsets[i] = avio_rb32(pb);
01170 else if (atom.type == MKTAG('c','o','6','4'))
01171 for (i = 0; i < entries && !pb->eof_reached; i++)
01172 sc->chunk_offsets[i] = avio_rb64(pb);
01173 else
01174 return AVERROR_INVALIDDATA;
01175
01176 sc->chunk_count = i;
01177
01178 if (pb->eof_reached)
01179 return AVERROR_EOF;
01180
01181 return 0;
01182 }
01183
01188 enum AVCodecID ff_mov_get_lpcm_codec_id(int bps, int flags)
01189 {
01190
01191
01192
01193
01194
01195 return ff_get_pcm_codec_id(bps, flags & 1, flags & 2, flags & 4 ? -1 : 0);
01196 }
01197
01198 int ff_mov_read_stsd_entries(MOVContext *c, AVIOContext *pb, int entries)
01199 {
01200 AVStream *st;
01201 MOVStreamContext *sc;
01202 int j, pseudo_stream_id;
01203
01204 if (c->fc->nb_streams < 1)
01205 return 0;
01206 st = c->fc->streams[c->fc->nb_streams-1];
01207 sc = st->priv_data;
01208
01209 for (pseudo_stream_id = 0;
01210 pseudo_stream_id < entries && !pb->eof_reached;
01211 pseudo_stream_id++) {
01212
01213 enum AVCodecID id;
01214 int dref_id = 1;
01215 MOVAtom a = { AV_RL32("stsd") };
01216 int64_t start_pos = avio_tell(pb);
01217 int64_t size = avio_rb32(pb);
01218 uint32_t format = avio_rl32(pb);
01219
01220 if (size >= 16) {
01221 avio_rb32(pb);
01222 avio_rb16(pb);
01223 dref_id = avio_rb16(pb);
01224 }else if (size <= 7){
01225 av_log(c->fc, AV_LOG_ERROR, "invalid size %"PRId64" in stsd\n", size);
01226 return AVERROR_INVALIDDATA;
01227 }
01228
01229 if (st->codec->codec_tag &&
01230 st->codec->codec_tag != format &&
01231 (c->fc->video_codec_id ? ff_codec_get_id(ff_codec_movvideo_tags, format) != c->fc->video_codec_id
01232 : st->codec->codec_tag != MKTAG('j','p','e','g'))
01233 ){
01234
01235
01236
01237 av_log(c->fc, AV_LOG_WARNING, "multiple fourcc not supported\n");
01238 avio_skip(pb, size - (avio_tell(pb) - start_pos));
01239 continue;
01240 }
01241
01242 if (st->codec->codec_tag && st->codec->codec_tag == AV_RL32("avc1"))
01243 av_log(c->fc, AV_LOG_WARNING, "Concatenated H.264 might not play corrently.\n");
01244 sc->pseudo_stream_id = st->codec->codec_tag ? -1 : pseudo_stream_id;
01245 sc->dref_id= dref_id;
01246
01247 st->codec->codec_tag = format;
01248 id = ff_codec_get_id(ff_codec_movaudio_tags, format);
01249 if (id<=0 && ((format&0xFFFF) == 'm'+('s'<<8) || (format&0xFFFF) == 'T'+('S'<<8)))
01250 id = ff_codec_get_id(ff_codec_wav_tags, av_bswap32(format)&0xFFFF);
01251
01252 if (st->codec->codec_type != AVMEDIA_TYPE_VIDEO && id > 0) {
01253 st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
01254 } else if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO &&
01255 format && format != MKTAG('m','p','4','s')) {
01256 id = ff_codec_get_id(ff_codec_movvideo_tags, format);
01257 if (id <= 0)
01258 id = ff_codec_get_id(ff_codec_bmp_tags, format);
01259 if (id > 0)
01260 st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
01261 else if (st->codec->codec_type == AVMEDIA_TYPE_DATA ||
01262 (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE &&
01263 st->codec->codec_id == AV_CODEC_ID_NONE)){
01264 id = ff_codec_get_id(ff_codec_movsubtitle_tags, format);
01265 if (id > 0)
01266 st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;
01267 }
01268 }
01269
01270 av_dlog(c->fc, "size=%"PRId64" 4CC= %c%c%c%c codec_type=%d\n", size,
01271 (format >> 0) & 0xff, (format >> 8) & 0xff, (format >> 16) & 0xff,
01272 (format >> 24) & 0xff, st->codec->codec_type);
01273
01274 if (st->codec->codec_type==AVMEDIA_TYPE_VIDEO) {
01275 unsigned int color_depth, len;
01276 int color_greyscale;
01277 int color_table_id;
01278
01279 avio_rb16(pb);
01280 avio_rb16(pb);
01281 avio_rb32(pb);
01282 avio_rb32(pb);
01283 avio_rb32(pb);
01284
01285 st->codec->width = avio_rb16(pb);
01286 st->codec->height = avio_rb16(pb);
01287
01288 avio_rb32(pb);
01289 avio_rb32(pb);
01290 avio_rb32(pb);
01291 avio_rb16(pb);
01292
01293 len = avio_r8(pb);
01294 if (len > 31)
01295 len = 31;
01296 mov_read_mac_string(c, pb, len, st->codec->codec_name, 32);
01297 if (len < 31)
01298 avio_skip(pb, 31 - len);
01299
01300 if (!memcmp(st->codec->codec_name, "Planar Y'CbCr 8-bit 4:2:0", 25))
01301 st->codec->codec_tag=MKTAG('I', '4', '2', '0');
01302
01303 if (!memcmp(st->codec->codec_name, "Sorenson H263", 13)
01304 && format == MKTAG('H','2','6','3'))
01305 id = AV_CODEC_ID_FLV1;
01306 st->codec->codec_id = id;
01307
01308 st->codec->bits_per_coded_sample = avio_rb16(pb);
01309 color_table_id = avio_rb16(pb);
01310 av_dlog(c->fc, "depth %d, ctab id %d\n",
01311 st->codec->bits_per_coded_sample, color_table_id);
01312
01313 color_depth = st->codec->bits_per_coded_sample & 0x1F;
01314 color_greyscale = st->codec->bits_per_coded_sample & 0x20;
01315
01316
01317 if ((color_depth == 2) || (color_depth == 4) ||
01318 (color_depth == 8)) {
01319
01320 unsigned int color_start, color_count, color_end;
01321 unsigned char a, r, g, b;
01322
01323 if (color_greyscale) {
01324 int color_index, color_dec;
01325
01326 st->codec->bits_per_coded_sample = color_depth;
01327 color_count = 1 << color_depth;
01328 color_index = 255;
01329 color_dec = 256 / (color_count - 1);
01330 for (j = 0; j < color_count; j++) {
01331 if (id == AV_CODEC_ID_CINEPAK){
01332 r = g = b = color_count - 1 - color_index;
01333 }else
01334 r = g = b = color_index;
01335 sc->palette[j] =
01336 (0xFFU << 24) | (r << 16) | (g << 8) | (b);
01337 color_index -= color_dec;
01338 if (color_index < 0)
01339 color_index = 0;
01340 }
01341 } else if (color_table_id) {
01342 const uint8_t *color_table;
01343
01344 color_count = 1 << color_depth;
01345 if (color_depth == 2)
01346 color_table = ff_qt_default_palette_4;
01347 else if (color_depth == 4)
01348 color_table = ff_qt_default_palette_16;
01349 else
01350 color_table = ff_qt_default_palette_256;
01351
01352 for (j = 0; j < color_count; j++) {
01353 r = color_table[j * 3 + 0];
01354 g = color_table[j * 3 + 1];
01355 b = color_table[j * 3 + 2];
01356 sc->palette[j] =
01357 (0xFFU << 24) | (r << 16) | (g << 8) | (b);
01358 }
01359 } else {
01360
01361 color_start = avio_rb32(pb);
01362 color_count = avio_rb16(pb);
01363 color_end = avio_rb16(pb);
01364 if ((color_start <= 255) &&
01365 (color_end <= 255)) {
01366 for (j = color_start; j <= color_end; j++) {
01367
01368
01369 a = avio_r8(pb);
01370 avio_r8(pb);
01371 r = avio_r8(pb);
01372 avio_r8(pb);
01373 g = avio_r8(pb);
01374 avio_r8(pb);
01375 b = avio_r8(pb);
01376 avio_r8(pb);
01377 sc->palette[j] =
01378 (a << 24 ) | (r << 16) | (g << 8) | (b);
01379 }
01380 }
01381 }
01382 sc->has_palette = 1;
01383 }
01384 } else if (st->codec->codec_type==AVMEDIA_TYPE_AUDIO) {
01385 int bits_per_sample, flags;
01386 uint16_t version = avio_rb16(pb);
01387 AVDictionaryEntry *compatible_brands = av_dict_get(c->fc->metadata, "compatible_brands", NULL, AV_DICT_MATCH_CASE);
01388
01389 st->codec->codec_id = id;
01390 avio_rb16(pb);
01391 avio_rb32(pb);
01392
01393 st->codec->channels = avio_rb16(pb);
01394 av_dlog(c->fc, "audio channels %d\n", st->codec->channels);
01395 st->codec->bits_per_coded_sample = avio_rb16(pb);
01396
01397 sc->audio_cid = avio_rb16(pb);
01398 avio_rb16(pb);
01399
01400 st->codec->sample_rate = ((avio_rb32(pb) >> 16));
01401
01402
01403 av_dlog(c->fc, "version =%d, isom =%d\n",version,c->isom);
01404 if (!c->isom ||
01405 (compatible_brands && strstr(compatible_brands->value, "qt "))) {
01406 if (version==1) {
01407 sc->samples_per_frame = avio_rb32(pb);
01408 avio_rb32(pb);
01409 sc->bytes_per_frame = avio_rb32(pb);
01410 avio_rb32(pb);
01411 } else if (version==2) {
01412 avio_rb32(pb);
01413 st->codec->sample_rate = av_int2double(avio_rb64(pb));
01414 st->codec->channels = avio_rb32(pb);
01415 avio_rb32(pb);
01416 st->codec->bits_per_coded_sample = avio_rb32(pb);
01417 flags = avio_rb32(pb);
01418 sc->bytes_per_frame = avio_rb32(pb);
01419 sc->samples_per_frame = avio_rb32(pb);
01420 if (format == MKTAG('l','p','c','m'))
01421 st->codec->codec_id = ff_mov_get_lpcm_codec_id(st->codec->bits_per_coded_sample, flags);
01422 }
01423 }
01424
01425 switch (st->codec->codec_id) {
01426 case AV_CODEC_ID_PCM_S8:
01427 case AV_CODEC_ID_PCM_U8:
01428 if (st->codec->bits_per_coded_sample == 16)
01429 st->codec->codec_id = AV_CODEC_ID_PCM_S16BE;
01430 break;
01431 case AV_CODEC_ID_PCM_S16LE:
01432 case AV_CODEC_ID_PCM_S16BE:
01433 if (st->codec->bits_per_coded_sample == 8)
01434 st->codec->codec_id = AV_CODEC_ID_PCM_S8;
01435 else if (st->codec->bits_per_coded_sample == 24)
01436 st->codec->codec_id =
01437 st->codec->codec_id == AV_CODEC_ID_PCM_S16BE ?
01438 AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
01439 break;
01440
01441 case AV_CODEC_ID_MACE3:
01442 sc->samples_per_frame = 6;
01443 sc->bytes_per_frame = 2*st->codec->channels;
01444 break;
01445 case AV_CODEC_ID_MACE6:
01446 sc->samples_per_frame = 6;
01447 sc->bytes_per_frame = 1*st->codec->channels;
01448 break;
01449 case AV_CODEC_ID_ADPCM_IMA_QT:
01450 sc->samples_per_frame = 64;
01451 sc->bytes_per_frame = 34*st->codec->channels;
01452 break;
01453 case AV_CODEC_ID_GSM:
01454 sc->samples_per_frame = 160;
01455 sc->bytes_per_frame = 33;
01456 break;
01457 default:
01458 break;
01459 }
01460
01461 bits_per_sample = av_get_bits_per_sample(st->codec->codec_id);
01462 if (bits_per_sample) {
01463 st->codec->bits_per_coded_sample = bits_per_sample;
01464 sc->sample_size = (bits_per_sample >> 3) * st->codec->channels;
01465 }
01466 } else if (st->codec->codec_type==AVMEDIA_TYPE_SUBTITLE){
01467
01468
01469 MOVAtom fake_atom = { .size = size - (avio_tell(pb) - start_pos) };
01470 if (format != AV_RL32("mp4s"))
01471 mov_read_glbl(c, pb, fake_atom);
01472 st->codec->codec_id= id;
01473 st->codec->width = sc->width;
01474 st->codec->height = sc->height;
01475 } else {
01476 if (st->codec->codec_tag == MKTAG('t','m','c','d')) {
01477 MOVStreamContext *tmcd_ctx = st->priv_data;
01478 int val;
01479 avio_rb32(pb);
01480 val = avio_rb32(pb);
01481 tmcd_ctx->tmcd_flags = val;
01482 if (val & 1)
01483 st->codec->flags2 |= CODEC_FLAG2_DROP_FRAME_TIMECODE;
01484 avio_rb32(pb);
01485 avio_rb32(pb);
01486 st->codec->time_base.den = avio_r8(pb);
01487 st->codec->time_base.num = 1;
01488 }
01489
01490 avio_skip(pb, size - (avio_tell(pb) - start_pos));
01491 }
01492
01493 a.size = size - (avio_tell(pb) - start_pos);
01494 if (a.size > 8) {
01495 int ret;
01496 if ((ret = mov_read_default(c, pb, a)) < 0)
01497 return ret;
01498 } else if (a.size > 0)
01499 avio_skip(pb, a.size);
01500 }
01501
01502 if (pb->eof_reached)
01503 return AVERROR_EOF;
01504
01505 if (st->codec->codec_type==AVMEDIA_TYPE_AUDIO && st->codec->sample_rate==0 && sc->time_scale>1)
01506 st->codec->sample_rate= sc->time_scale;
01507
01508
01509 switch (st->codec->codec_id) {
01510 #if CONFIG_DV_DEMUXER
01511 case AV_CODEC_ID_DVAUDIO:
01512 c->dv_fctx = avformat_alloc_context();
01513 c->dv_demux = avpriv_dv_init_demux(c->dv_fctx);
01514 if (!c->dv_demux) {
01515 av_log(c->fc, AV_LOG_ERROR, "dv demux context init error\n");
01516 return AVERROR(ENOMEM);
01517 }
01518 sc->dv_audio_container = 1;
01519 st->codec->codec_id = AV_CODEC_ID_PCM_S16LE;
01520 break;
01521 #endif
01522
01523 case AV_CODEC_ID_QCELP:
01524
01525 if (st->codec->codec_tag != MKTAG('Q','c','l','p'))
01526 st->codec->sample_rate = 8000;
01527 st->codec->channels= 1;
01528 break;
01529 case AV_CODEC_ID_AMR_NB:
01530 st->codec->channels= 1;
01531
01532 st->codec->sample_rate = 8000;
01533 break;
01534 case AV_CODEC_ID_AMR_WB:
01535 st->codec->channels = 1;
01536 st->codec->sample_rate = 16000;
01537 break;
01538 case AV_CODEC_ID_MP2:
01539 case AV_CODEC_ID_MP3:
01540 st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
01541 st->need_parsing = AVSTREAM_PARSE_FULL;
01542 break;
01543 case AV_CODEC_ID_GSM:
01544 case AV_CODEC_ID_ADPCM_MS:
01545 case AV_CODEC_ID_ADPCM_IMA_WAV:
01546 case AV_CODEC_ID_ILBC:
01547 st->codec->block_align = sc->bytes_per_frame;
01548 break;
01549 case AV_CODEC_ID_ALAC:
01550 if (st->codec->extradata_size == 36) {
01551 st->codec->channels = AV_RB8 (st->codec->extradata+21);
01552 st->codec->sample_rate = AV_RB32(st->codec->extradata+32);
01553 }
01554 break;
01555 case AV_CODEC_ID_AC3:
01556 st->need_parsing = AVSTREAM_PARSE_FULL;
01557 break;
01558 case AV_CODEC_ID_MPEG1VIDEO:
01559 st->need_parsing = AVSTREAM_PARSE_FULL;
01560 break;
01561 case AV_CODEC_ID_VC1:
01562 st->need_parsing = AVSTREAM_PARSE_FULL;
01563 break;
01564 default:
01565 break;
01566 }
01567
01568 return 0;
01569 }
01570
01571 static int mov_read_stsd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
01572 {
01573 int entries;
01574
01575 avio_r8(pb);
01576 avio_rb24(pb);
01577 entries = avio_rb32(pb);
01578
01579 return ff_mov_read_stsd_entries(c, pb, entries);
01580 }
01581
01582 static int mov_read_stsc(MOVContext *c, AVIOContext *pb, MOVAtom atom)
01583 {
01584 AVStream *st;
01585 MOVStreamContext *sc;
01586 unsigned int i, entries;
01587
01588 if (c->fc->nb_streams < 1)
01589 return 0;
01590 st = c->fc->streams[c->fc->nb_streams-1];
01591 sc = st->priv_data;
01592
01593 avio_r8(pb);
01594 avio_rb24(pb);
01595
01596 entries = avio_rb32(pb);
01597
01598 av_dlog(c->fc, "track[%i].stsc.entries = %i\n", c->fc->nb_streams-1, entries);
01599
01600 if (!entries)
01601 return 0;
01602 if (entries >= UINT_MAX / sizeof(*sc->stsc_data))
01603 return AVERROR_INVALIDDATA;
01604 sc->stsc_data = av_malloc(entries * sizeof(*sc->stsc_data));
01605 if (!sc->stsc_data)
01606 return AVERROR(ENOMEM);
01607
01608 for (i = 0; i < entries && !pb->eof_reached; i++) {
01609 sc->stsc_data[i].first = avio_rb32(pb);
01610 sc->stsc_data[i].count = avio_rb32(pb);
01611 sc->stsc_data[i].id = avio_rb32(pb);
01612 }
01613
01614 sc->stsc_count = i;
01615
01616 if (pb->eof_reached)
01617 return AVERROR_EOF;
01618
01619 return 0;
01620 }
01621
01622 static int mov_read_stps(MOVContext *c, AVIOContext *pb, MOVAtom atom)
01623 {
01624 AVStream *st;
01625 MOVStreamContext *sc;
01626 unsigned i, entries;
01627
01628 if (c->fc->nb_streams < 1)
01629 return 0;
01630 st = c->fc->streams[c->fc->nb_streams-1];
01631 sc = st->priv_data;
01632
01633 avio_rb32(pb);
01634
01635 entries = avio_rb32(pb);
01636 if (entries >= UINT_MAX / sizeof(*sc->stps_data))
01637 return AVERROR_INVALIDDATA;
01638 sc->stps_data = av_malloc(entries * sizeof(*sc->stps_data));
01639 if (!sc->stps_data)
01640 return AVERROR(ENOMEM);
01641
01642 for (i = 0; i < entries && !pb->eof_reached; i++) {
01643 sc->stps_data[i] = avio_rb32(pb);
01644
01645 }
01646
01647 sc->stps_count = i;
01648
01649 if (pb->eof_reached)
01650 return AVERROR_EOF;
01651
01652 return 0;
01653 }
01654
01655 static int mov_read_stss(MOVContext *c, AVIOContext *pb, MOVAtom atom)
01656 {
01657 AVStream *st;
01658 MOVStreamContext *sc;
01659 unsigned int i, entries;
01660
01661 if (c->fc->nb_streams < 1)
01662 return 0;
01663 st = c->fc->streams[c->fc->nb_streams-1];
01664 sc = st->priv_data;
01665
01666 avio_r8(pb);
01667 avio_rb24(pb);
01668
01669 entries = avio_rb32(pb);
01670
01671 av_dlog(c->fc, "keyframe_count = %d\n", entries);
01672
01673 if (!entries)
01674 {
01675 sc->keyframe_absent = 1;
01676 return 0;
01677 }
01678 if (entries >= UINT_MAX / sizeof(int))
01679 return AVERROR_INVALIDDATA;
01680 sc->keyframes = av_malloc(entries * sizeof(int));
01681 if (!sc->keyframes)
01682 return AVERROR(ENOMEM);
01683
01684 for (i = 0; i < entries && !pb->eof_reached; i++) {
01685 sc->keyframes[i] = avio_rb32(pb);
01686
01687 }
01688
01689 sc->keyframe_count = i;
01690
01691 if (pb->eof_reached)
01692 return AVERROR_EOF;
01693
01694 return 0;
01695 }
01696
01697 static int mov_read_stsz(MOVContext *c, AVIOContext *pb, MOVAtom atom)
01698 {
01699 AVStream *st;
01700 MOVStreamContext *sc;
01701 unsigned int i, entries, sample_size, field_size, num_bytes;
01702 GetBitContext gb;
01703 unsigned char* buf;
01704
01705 if (c->fc->nb_streams < 1)
01706 return 0;
01707 st = c->fc->streams[c->fc->nb_streams-1];
01708 sc = st->priv_data;
01709
01710 avio_r8(pb);
01711 avio_rb24(pb);
01712
01713 if (atom.type == MKTAG('s','t','s','z')) {
01714 sample_size = avio_rb32(pb);
01715 if (!sc->sample_size)
01716 sc->sample_size = sample_size;
01717 sc->alt_sample_size = sample_size;
01718 field_size = 32;
01719 } else {
01720 sample_size = 0;
01721 avio_rb24(pb);
01722 field_size = avio_r8(pb);
01723 }
01724 entries = avio_rb32(pb);
01725
01726 av_dlog(c->fc, "sample_size = %d sample_count = %d\n", sc->sample_size, entries);
01727
01728 sc->sample_count = entries;
01729 if (sample_size)
01730 return 0;
01731
01732 if (field_size != 4 && field_size != 8 && field_size != 16 && field_size != 32) {
01733 av_log(c->fc, AV_LOG_ERROR, "Invalid sample field size %d\n", field_size);
01734 return AVERROR_INVALIDDATA;
01735 }
01736
01737 if (!entries)
01738 return 0;
01739 if (entries >= UINT_MAX / sizeof(int) || entries >= (UINT_MAX - 4) / field_size)
01740 return AVERROR_INVALIDDATA;
01741 sc->sample_sizes = av_malloc(entries * sizeof(int));
01742 if (!sc->sample_sizes)
01743 return AVERROR(ENOMEM);
01744
01745 num_bytes = (entries*field_size+4)>>3;
01746
01747 buf = av_malloc(num_bytes+FF_INPUT_BUFFER_PADDING_SIZE);
01748 if (!buf) {
01749 av_freep(&sc->sample_sizes);
01750 return AVERROR(ENOMEM);
01751 }
01752
01753 if (avio_read(pb, buf, num_bytes) < num_bytes) {
01754 av_freep(&sc->sample_sizes);
01755 av_free(buf);
01756 return AVERROR_INVALIDDATA;
01757 }
01758
01759 init_get_bits(&gb, buf, 8*num_bytes);
01760
01761 for (i = 0; i < entries && !pb->eof_reached; i++) {
01762 sc->sample_sizes[i] = get_bits_long(&gb, field_size);
01763 sc->data_size += sc->sample_sizes[i];
01764 }
01765
01766 sc->sample_count = i;
01767
01768 if (pb->eof_reached)
01769 return AVERROR_EOF;
01770
01771 av_free(buf);
01772 return 0;
01773 }
01774
01775 static int mov_read_stts(MOVContext *c, AVIOContext *pb, MOVAtom atom)
01776 {
01777 AVStream *st;
01778 MOVStreamContext *sc;
01779 unsigned int i, entries;
01780 int64_t duration=0;
01781 int64_t total_sample_count=0;
01782
01783 if (c->fc->nb_streams < 1)
01784 return 0;
01785 st = c->fc->streams[c->fc->nb_streams-1];
01786 sc = st->priv_data;
01787
01788 avio_r8(pb);
01789 avio_rb24(pb);
01790 entries = avio_rb32(pb);
01791
01792 av_dlog(c->fc, "track[%i].stts.entries = %i\n",
01793 c->fc->nb_streams-1, entries);
01794
01795 if (entries >= UINT_MAX / sizeof(*sc->stts_data))
01796 return -1;
01797
01798 sc->stts_data = av_malloc(entries * sizeof(*sc->stts_data));
01799 if (!sc->stts_data)
01800 return AVERROR(ENOMEM);
01801
01802 for (i = 0; i < entries && !pb->eof_reached; i++) {
01803 int sample_duration;
01804 int sample_count;
01805
01806 sample_count=avio_rb32(pb);
01807 sample_duration = avio_rb32(pb);
01808
01809 if (sample_duration < 0) {
01810 av_log(c->fc, AV_LOG_ERROR, "Invalid SampleDelta in STTS %d\n", sample_duration);
01811 sample_duration = 1;
01812 }
01813 sc->stts_data[i].count= sample_count;
01814 sc->stts_data[i].duration= sample_duration;
01815
01816 av_dlog(c->fc, "sample_count=%d, sample_duration=%d\n",
01817 sample_count, sample_duration);
01818
01819 duration+=(int64_t)sample_duration*sample_count;
01820 total_sample_count+=sample_count;
01821 }
01822
01823 sc->stts_count = i;
01824
01825 if (pb->eof_reached)
01826 return AVERROR_EOF;
01827
01828 st->nb_frames= total_sample_count;
01829 if (duration)
01830 st->duration= duration;
01831 sc->track_end = duration;
01832 return 0;
01833 }
01834
01835 static int mov_read_ctts(MOVContext *c, AVIOContext *pb, MOVAtom atom)
01836 {
01837 AVStream *st;
01838 MOVStreamContext *sc;
01839 unsigned int i, entries;
01840
01841 if (c->fc->nb_streams < 1)
01842 return 0;
01843 st = c->fc->streams[c->fc->nb_streams-1];
01844 sc = st->priv_data;
01845
01846 avio_r8(pb);
01847 avio_rb24(pb);
01848 entries = avio_rb32(pb);
01849
01850 av_dlog(c->fc, "track[%i].ctts.entries = %i\n", c->fc->nb_streams-1, entries);
01851
01852 if (!entries)
01853 return 0;
01854 if (entries >= UINT_MAX / sizeof(*sc->ctts_data))
01855 return AVERROR_INVALIDDATA;
01856 sc->ctts_data = av_malloc(entries * sizeof(*sc->ctts_data));
01857 if (!sc->ctts_data)
01858 return AVERROR(ENOMEM);
01859
01860 for (i = 0; i < entries && !pb->eof_reached; i++) {
01861 int count =avio_rb32(pb);
01862 int duration =avio_rb32(pb);
01863
01864 sc->ctts_data[i].count = count;
01865 sc->ctts_data[i].duration= duration;
01866
01867 av_dlog(c->fc, "count=%d, duration=%d\n",
01868 count, duration);
01869
01870 if (FFABS(duration) > (1<<28) && i+2<entries) {
01871 av_log(c->fc, AV_LOG_WARNING, "CTTS invalid\n");
01872 av_freep(&sc->ctts_data);
01873 sc->ctts_count = 0;
01874 return 0;
01875 }
01876
01877 if (duration < 0 && i+2<entries)
01878 sc->dts_shift = FFMAX(sc->dts_shift, -duration);
01879 }
01880
01881 sc->ctts_count = i;
01882
01883 if (pb->eof_reached)
01884 return AVERROR_EOF;
01885
01886 av_dlog(c->fc, "dts shift %d\n", sc->dts_shift);
01887
01888 return 0;
01889 }
01890
01891 static int mov_read_sbgp(MOVContext *c, AVIOContext *pb, MOVAtom atom)
01892 {
01893 AVStream *st;
01894 MOVStreamContext *sc;
01895 unsigned int i, entries;
01896 uint8_t version;
01897 uint32_t grouping_type;
01898
01899 if (c->fc->nb_streams < 1)
01900 return 0;
01901 st = c->fc->streams[c->fc->nb_streams-1];
01902 sc = st->priv_data;
01903
01904 version = avio_r8(pb);
01905 avio_rb24(pb);
01906 grouping_type = avio_rl32(pb);
01907 if (grouping_type != MKTAG( 'r','a','p',' '))
01908 return 0;
01909 if (version == 1)
01910 avio_rb32(pb);
01911
01912 entries = avio_rb32(pb);
01913 if (!entries)
01914 return 0;
01915 if (entries >= UINT_MAX / sizeof(*sc->rap_group))
01916 return AVERROR_INVALIDDATA;
01917 sc->rap_group = av_malloc(entries * sizeof(*sc->rap_group));
01918 if (!sc->rap_group)
01919 return AVERROR(ENOMEM);
01920
01921 for (i = 0; i < entries && !pb->eof_reached; i++) {
01922 sc->rap_group[i].count = avio_rb32(pb);
01923 sc->rap_group[i].index = avio_rb32(pb);
01924 }
01925
01926 sc->rap_group_count = i;
01927
01928 return pb->eof_reached ? AVERROR_EOF : 0;
01929 }
01930
01931 static void mov_build_index(MOVContext *mov, AVStream *st)
01932 {
01933 MOVStreamContext *sc = st->priv_data;
01934 int64_t current_offset;
01935 int64_t current_dts = 0;
01936 unsigned int stts_index = 0;
01937 unsigned int stsc_index = 0;
01938 unsigned int stss_index = 0;
01939 unsigned int stps_index = 0;
01940 unsigned int i, j;
01941 uint64_t stream_size = 0;
01942 AVIndexEntry *mem;
01943
01944
01945 if ((sc->empty_duration || sc->start_time) && mov->time_scale > 0) {
01946 if (sc->empty_duration)
01947 sc->empty_duration = av_rescale(sc->empty_duration, sc->time_scale, mov->time_scale);
01948 sc->time_offset = sc->start_time - sc->empty_duration;
01949 current_dts = -sc->time_offset;
01950 if (sc->ctts_count>0 && sc->stts_count>0 &&
01951 sc->ctts_data[0].duration / FFMAX(sc->stts_data[0].duration, 1) > 16) {
01952
01953
01954 sc->wrong_dts = 1;
01955 st->codec->has_b_frames = 1;
01956 }
01957 }
01958
01959
01960 if (!(st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
01961 sc->stts_count == 1 && sc->stts_data[0].duration == 1)) {
01962 unsigned int current_sample = 0;
01963 unsigned int stts_sample = 0;
01964 unsigned int sample_size;
01965 unsigned int distance = 0;
01966 unsigned int rap_group_index = 0;
01967 unsigned int rap_group_sample = 0;
01968 int rap_group_present = sc->rap_group_count && sc->rap_group;
01969 int key_off = (sc->keyframe_count && sc->keyframes[0] > 0) || (sc->stps_count && sc->stps_data[0] > 0);
01970
01971 current_dts -= sc->dts_shift;
01972
01973 if (!sc->sample_count || st->nb_index_entries)
01974 return;
01975 if (sc->sample_count >= UINT_MAX / sizeof(*st->index_entries) - st->nb_index_entries)
01976 return;
01977 mem = av_realloc(st->index_entries, (st->nb_index_entries + sc->sample_count) * sizeof(*st->index_entries));
01978 if (!mem)
01979 return;
01980 st->index_entries = mem;
01981 st->index_entries_allocated_size = (st->nb_index_entries + sc->sample_count) * sizeof(*st->index_entries);
01982
01983 for (i = 0; i < sc->chunk_count; i++) {
01984 current_offset = sc->chunk_offsets[i];
01985 while (stsc_index + 1 < sc->stsc_count &&
01986 i + 1 == sc->stsc_data[stsc_index + 1].first)
01987 stsc_index++;
01988 for (j = 0; j < sc->stsc_data[stsc_index].count; j++) {
01989 int keyframe = 0;
01990 if (current_sample >= sc->sample_count) {
01991 av_log(mov->fc, AV_LOG_ERROR, "wrong sample count\n");
01992 return;
01993 }
01994
01995 if (!sc->keyframe_absent && (!sc->keyframe_count || current_sample+key_off == sc->keyframes[stss_index])) {
01996 keyframe = 1;
01997 if (stss_index + 1 < sc->keyframe_count)
01998 stss_index++;
01999 } else if (sc->stps_count && current_sample+key_off == sc->stps_data[stps_index]) {
02000 keyframe = 1;
02001 if (stps_index + 1 < sc->stps_count)
02002 stps_index++;
02003 }
02004 if (rap_group_present && rap_group_index < sc->rap_group_count) {
02005 if (sc->rap_group[rap_group_index].index > 0)
02006 keyframe = 1;
02007 if (++rap_group_sample == sc->rap_group[rap_group_index].count) {
02008 rap_group_sample = 0;
02009 rap_group_index++;
02010 }
02011 }
02012 if (keyframe)
02013 distance = 0;
02014 sample_size = sc->alt_sample_size > 0 ? sc->alt_sample_size : sc->sample_sizes[current_sample];
02015 if (sc->pseudo_stream_id == -1 ||
02016 sc->stsc_data[stsc_index].id - 1 == sc->pseudo_stream_id) {
02017 AVIndexEntry *e = &st->index_entries[st->nb_index_entries++];
02018 e->pos = current_offset;
02019 e->timestamp = current_dts;
02020 e->size = sample_size;
02021 e->min_distance = distance;
02022 e->flags = keyframe ? AVINDEX_KEYFRAME : 0;
02023 av_dlog(mov->fc, "AVIndex stream %d, sample %d, offset %"PRIx64", dts %"PRId64", "
02024 "size %d, distance %d, keyframe %d\n", st->index, current_sample,
02025 current_offset, current_dts, sample_size, distance, keyframe);
02026 }
02027
02028 current_offset += sample_size;
02029 stream_size += sample_size;
02030 current_dts += sc->stts_data[stts_index].duration;
02031 distance++;
02032 stts_sample++;
02033 current_sample++;
02034 if (stts_index + 1 < sc->stts_count && stts_sample == sc->stts_data[stts_index].count) {
02035 stts_sample = 0;
02036 stts_index++;
02037 }
02038 }
02039 }
02040 if (st->duration > 0)
02041 st->codec->bit_rate = stream_size*8*sc->time_scale/st->duration;
02042 } else {
02043 unsigned chunk_samples, total = 0;
02044
02045
02046 for (i = 0; i < sc->stsc_count; i++) {
02047 unsigned count, chunk_count;
02048
02049 chunk_samples = sc->stsc_data[i].count;
02050 if (i != sc->stsc_count - 1 &&
02051 sc->samples_per_frame && chunk_samples % sc->samples_per_frame) {
02052 av_log(mov->fc, AV_LOG_ERROR, "error unaligned chunk\n");
02053 return;
02054 }
02055
02056 if (sc->samples_per_frame >= 160) {
02057 count = chunk_samples / sc->samples_per_frame;
02058 } else if (sc->samples_per_frame > 1) {
02059 unsigned samples = (1024/sc->samples_per_frame)*sc->samples_per_frame;
02060 count = (chunk_samples+samples-1) / samples;
02061 } else {
02062 count = (chunk_samples+1023) / 1024;
02063 }
02064
02065 if (i < sc->stsc_count - 1)
02066 chunk_count = sc->stsc_data[i+1].first - sc->stsc_data[i].first;
02067 else
02068 chunk_count = sc->chunk_count - (sc->stsc_data[i].first - 1);
02069 total += chunk_count * count;
02070 }
02071
02072 av_dlog(mov->fc, "chunk count %d\n", total);
02073 if (total >= UINT_MAX / sizeof(*st->index_entries) - st->nb_index_entries)
02074 return;
02075 mem = av_realloc(st->index_entries, (st->nb_index_entries + total) * sizeof(*st->index_entries));
02076 if (!mem)
02077 return;
02078 st->index_entries = mem;
02079 st->index_entries_allocated_size = (st->nb_index_entries + total) * sizeof(*st->index_entries);
02080
02081
02082 for (i = 0; i < sc->chunk_count; i++) {
02083 current_offset = sc->chunk_offsets[i];
02084 if (stsc_index + 1 < sc->stsc_count &&
02085 i + 1 == sc->stsc_data[stsc_index + 1].first)
02086 stsc_index++;
02087 chunk_samples = sc->stsc_data[stsc_index].count;
02088
02089 while (chunk_samples > 0) {
02090 AVIndexEntry *e;
02091 unsigned size, samples;
02092
02093 if (sc->samples_per_frame >= 160) {
02094 samples = sc->samples_per_frame;
02095 size = sc->bytes_per_frame;
02096 } else {
02097 if (sc->samples_per_frame > 1) {
02098 samples = FFMIN((1024 / sc->samples_per_frame)*
02099 sc->samples_per_frame, chunk_samples);
02100 size = (samples / sc->samples_per_frame) * sc->bytes_per_frame;
02101 } else {
02102 samples = FFMIN(1024, chunk_samples);
02103 size = samples * sc->sample_size;
02104 }
02105 }
02106
02107 if (st->nb_index_entries >= total) {
02108 av_log(mov->fc, AV_LOG_ERROR, "wrong chunk count %d\n", total);
02109 return;
02110 }
02111 e = &st->index_entries[st->nb_index_entries++];
02112 e->pos = current_offset;
02113 e->timestamp = current_dts;
02114 e->size = size;
02115 e->min_distance = 0;
02116 e->flags = AVINDEX_KEYFRAME;
02117 av_dlog(mov->fc, "AVIndex stream %d, chunk %d, offset %"PRIx64", dts %"PRId64", "
02118 "size %d, duration %d\n", st->index, i, current_offset, current_dts,
02119 size, samples);
02120
02121 current_offset += size;
02122 current_dts += samples;
02123 chunk_samples -= samples;
02124 }
02125 }
02126 }
02127 }
02128
02129 static int mov_open_dref(AVIOContext **pb, const char *src, MOVDref *ref,
02130 AVIOInterruptCB *int_cb, int use_absolute_path, AVFormatContext *fc)
02131 {
02132
02133
02134 if (ref->nlvl_to > 0 && ref->nlvl_from > 0) {
02135 char filename[1024];
02136 const char *src_path;
02137 int i, l;
02138
02139
02140 src_path = strrchr(src, '/');
02141 if (src_path)
02142 src_path++;
02143 else
02144 src_path = src;
02145
02146
02147 for (i = 0, l = strlen(ref->path) - 1; l >= 0; l--)
02148 if (ref->path[l] == '/') {
02149 if (i == ref->nlvl_to - 1)
02150 break;
02151 else
02152 i++;
02153 }
02154
02155
02156 if (i == ref->nlvl_to - 1 && src_path - src < sizeof(filename)) {
02157 memcpy(filename, src, src_path - src);
02158 filename[src_path - src] = 0;
02159
02160 for (i = 1; i < ref->nlvl_from; i++)
02161 av_strlcat(filename, "../", 1024);
02162
02163 av_strlcat(filename, ref->path + l + 1, 1024);
02164
02165 if (!avio_open2(pb, filename, AVIO_FLAG_READ, int_cb, NULL))
02166 return 0;
02167 }
02168 } else if (use_absolute_path) {
02169 av_log(fc, AV_LOG_WARNING, "Using absolute path on user request, "
02170 "this is a possible security issue\n");
02171 if (!avio_open2(pb, ref->path, AVIO_FLAG_READ, int_cb, NULL))
02172 return 0;
02173 }
02174
02175 return AVERROR(ENOENT);
02176 }
02177
02178 static void fix_timescale(MOVContext *c, MOVStreamContext *sc)
02179 {
02180 if (sc->time_scale <= 0) {
02181 av_log(c->fc, AV_LOG_WARNING, "stream %d, timescale not set\n", sc->ffindex);
02182 sc->time_scale = c->time_scale;
02183 if (sc->time_scale <= 0)
02184 sc->time_scale = 1;
02185 }
02186 }
02187
02188 static int mov_read_trak(MOVContext *c, AVIOContext *pb, MOVAtom atom)
02189 {
02190 AVStream *st;
02191 MOVStreamContext *sc;
02192 int ret;
02193
02194 st = avformat_new_stream(c->fc, NULL);
02195 if (!st) return AVERROR(ENOMEM);
02196 st->id = c->fc->nb_streams;
02197 sc = av_mallocz(sizeof(MOVStreamContext));
02198 if (!sc) return AVERROR(ENOMEM);
02199
02200 st->priv_data = sc;
02201 st->codec->codec_type = AVMEDIA_TYPE_DATA;
02202 sc->ffindex = st->index;
02203
02204 if ((ret = mov_read_default(c, pb, atom)) < 0)
02205 return ret;
02206
02207
02208 if (sc->chunk_count && (!sc->stts_count || !sc->stsc_count ||
02209 (!sc->sample_size && !sc->sample_count))) {
02210 av_log(c->fc, AV_LOG_ERROR, "stream %d, missing mandatory atoms, broken header\n",
02211 st->index);
02212 return 0;
02213 }
02214
02215 fix_timescale(c, sc);
02216
02217 avpriv_set_pts_info(st, 64, 1, sc->time_scale);
02218
02219 mov_build_index(c, st);
02220
02221 if (sc->dref_id-1 < sc->drefs_count && sc->drefs[sc->dref_id-1].path) {
02222 MOVDref *dref = &sc->drefs[sc->dref_id - 1];
02223 if (mov_open_dref(&sc->pb, c->fc->filename, dref, &c->fc->interrupt_callback,
02224 c->use_absolute_path, c->fc) < 0)
02225 av_log(c->fc, AV_LOG_ERROR,
02226 "stream %d, error opening alias: path='%s', dir='%s', "
02227 "filename='%s', volume='%s', nlvl_from=%d, nlvl_to=%d\n",
02228 st->index, dref->path, dref->dir, dref->filename,
02229 dref->volume, dref->nlvl_from, dref->nlvl_to);
02230 } else
02231 sc->pb = c->fc->pb;
02232
02233 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
02234 if (!st->sample_aspect_ratio.num &&
02235 (st->codec->width != sc->width || st->codec->height != sc->height)) {
02236 st->sample_aspect_ratio = av_d2q(((double)st->codec->height * sc->width) /
02237 ((double)st->codec->width * sc->height), INT_MAX);
02238 }
02239
02240 if (st->duration > 0)
02241 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
02242 sc->time_scale*st->nb_frames, st->duration, INT_MAX);
02243
02244 #if FF_API_R_FRAME_RATE
02245 if (sc->stts_count == 1 || (sc->stts_count == 2 && sc->stts_data[1].count == 1))
02246 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den,
02247 sc->time_scale, sc->stts_data[0].duration, INT_MAX);
02248 #endif
02249 }
02250
02251 switch (st->codec->codec_id) {
02252 #if CONFIG_H261_DECODER
02253 case AV_CODEC_ID_H261:
02254 #endif
02255 #if CONFIG_H263_DECODER
02256 case AV_CODEC_ID_H263:
02257 #endif
02258 #if CONFIG_MPEG4_DECODER
02259 case AV_CODEC_ID_MPEG4:
02260 #endif
02261 st->codec->width = 0;
02262 st->codec->height= 0;
02263 break;
02264 }
02265
02266
02267 av_freep(&sc->chunk_offsets);
02268 av_freep(&sc->stsc_data);
02269 av_freep(&sc->sample_sizes);
02270 av_freep(&sc->keyframes);
02271 av_freep(&sc->stts_data);
02272 av_freep(&sc->stps_data);
02273 av_freep(&sc->rap_group);
02274
02275 return 0;
02276 }
02277
02278 static int mov_read_ilst(MOVContext *c, AVIOContext *pb, MOVAtom atom)
02279 {
02280 int ret;
02281 c->itunes_metadata = 1;
02282 ret = mov_read_default(c, pb, atom);
02283 c->itunes_metadata = 0;
02284 return ret;
02285 }
02286
02287 static int mov_read_meta(MOVContext *c, AVIOContext *pb, MOVAtom atom)
02288 {
02289 while (atom.size > 8) {
02290 uint32_t tag = avio_rl32(pb);
02291 atom.size -= 4;
02292 if (tag == MKTAG('h','d','l','r')) {
02293 avio_seek(pb, -8, SEEK_CUR);
02294 atom.size += 8;
02295 return mov_read_default(c, pb, atom);
02296 }
02297 }
02298 return 0;
02299 }
02300
02301 static int mov_read_tkhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
02302 {
02303 int i;
02304 int width;
02305 int height;
02306 int64_t disp_transform[2];
02307 int display_matrix[3][2];
02308 AVStream *st;
02309 MOVStreamContext *sc;
02310 int version;
02311
02312 if (c->fc->nb_streams < 1)
02313 return 0;
02314 st = c->fc->streams[c->fc->nb_streams-1];
02315 sc = st->priv_data;
02316
02317 version = avio_r8(pb);
02318 avio_rb24(pb);
02319
02320
02321
02322
02323
02324
02325
02326 if (version == 1) {
02327 avio_rb64(pb);
02328 avio_rb64(pb);
02329 } else {
02330 avio_rb32(pb);
02331 avio_rb32(pb);
02332 }
02333 st->id = (int)avio_rb32(pb);
02334 avio_rb32(pb);
02335
02336
02337 (version == 1) ? avio_rb64(pb) : avio_rb32(pb);
02338 avio_rb32(pb);
02339 avio_rb32(pb);
02340
02341 avio_rb16(pb);
02342 avio_rb16(pb);
02343 avio_rb16(pb);
02344 avio_rb16(pb);
02345
02346
02347
02348
02349 for (i = 0; i < 3; i++) {
02350 display_matrix[i][0] = avio_rb32(pb);
02351 display_matrix[i][1] = avio_rb32(pb);
02352 avio_rb32(pb);
02353 }
02354
02355 width = avio_rb32(pb);
02356 height = avio_rb32(pb);
02357 sc->width = width >> 16;
02358 sc->height = height >> 16;
02359
02360
02361
02362
02363 if (display_matrix[1][0] == -65536 && display_matrix[0][1] == 65536) {
02364 av_dict_set(&st->metadata, "rotate", "90", 0);
02365 }
02366
02367 if (display_matrix[0][0] == -65536 && display_matrix[1][1] == -65536) {
02368 av_dict_set(&st->metadata, "rotate", "180", 0);
02369 }
02370
02371 if (display_matrix[1][0] == 65536 && display_matrix[0][1] == -65536) {
02372 av_dict_set(&st->metadata, "rotate", "270", 0);
02373 }
02374
02375
02376
02377
02378
02379 if (width && height &&
02380 ((display_matrix[0][0] != 65536 ||
02381 display_matrix[1][1] != 65536) &&
02382 !display_matrix[0][1] &&
02383 !display_matrix[1][0] &&
02384 !display_matrix[2][0] && !display_matrix[2][1])) {
02385 for (i = 0; i < 2; i++)
02386 disp_transform[i] =
02387 (int64_t) width * display_matrix[0][i] +
02388 (int64_t) height * display_matrix[1][i] +
02389 ((int64_t) display_matrix[2][i] << 16);
02390
02391
02392 st->sample_aspect_ratio = av_d2q(
02393 ((double) disp_transform[0] * height) /
02394 ((double) disp_transform[1] * width), INT_MAX);
02395 }
02396 return 0;
02397 }
02398
02399 static int mov_read_tfhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
02400 {
02401 MOVFragment *frag = &c->fragment;
02402 MOVTrackExt *trex = NULL;
02403 int flags, track_id, i;
02404
02405 avio_r8(pb);
02406 flags = avio_rb24(pb);
02407
02408 track_id = avio_rb32(pb);
02409 if (!track_id)
02410 return AVERROR_INVALIDDATA;
02411 frag->track_id = track_id;
02412 for (i = 0; i < c->trex_count; i++)
02413 if (c->trex_data[i].track_id == frag->track_id) {
02414 trex = &c->trex_data[i];
02415 break;
02416 }
02417 if (!trex) {
02418 av_log(c->fc, AV_LOG_ERROR, "could not find corresponding trex\n");
02419 return AVERROR_INVALIDDATA;
02420 }
02421
02422 frag->base_data_offset = flags & MOV_TFHD_BASE_DATA_OFFSET ?
02423 avio_rb64(pb) : frag->moof_offset;
02424 frag->stsd_id = flags & MOV_TFHD_STSD_ID ? avio_rb32(pb) : trex->stsd_id;
02425
02426 frag->duration = flags & MOV_TFHD_DEFAULT_DURATION ?
02427 avio_rb32(pb) : trex->duration;
02428 frag->size = flags & MOV_TFHD_DEFAULT_SIZE ?
02429 avio_rb32(pb) : trex->size;
02430 frag->flags = flags & MOV_TFHD_DEFAULT_FLAGS ?
02431 avio_rb32(pb) : trex->flags;
02432 av_dlog(c->fc, "frag flags 0x%x\n", frag->flags);
02433 return 0;
02434 }
02435
02436 static int mov_read_chap(MOVContext *c, AVIOContext *pb, MOVAtom atom)
02437 {
02438 c->chapter_track = avio_rb32(pb);
02439 return 0;
02440 }
02441
02442 static int mov_read_trex(MOVContext *c, AVIOContext *pb, MOVAtom atom)
02443 {
02444 MOVTrackExt *trex;
02445
02446 if ((uint64_t)c->trex_count+1 >= UINT_MAX / sizeof(*c->trex_data))
02447 return AVERROR_INVALIDDATA;
02448 trex = av_realloc(c->trex_data, (c->trex_count+1)*sizeof(*c->trex_data));
02449 if (!trex)
02450 return AVERROR(ENOMEM);
02451
02452 c->fc->duration = AV_NOPTS_VALUE;
02453
02454 c->trex_data = trex;
02455 trex = &c->trex_data[c->trex_count++];
02456 avio_r8(pb);
02457 avio_rb24(pb);
02458 trex->track_id = avio_rb32(pb);
02459 trex->stsd_id = avio_rb32(pb);
02460 trex->duration = avio_rb32(pb);
02461 trex->size = avio_rb32(pb);
02462 trex->flags = avio_rb32(pb);
02463 return 0;
02464 }
02465
02466 static int mov_read_trun(MOVContext *c, AVIOContext *pb, MOVAtom atom)
02467 {
02468 MOVFragment *frag = &c->fragment;
02469 AVStream *st = NULL;
02470 MOVStreamContext *sc;
02471 MOVStts *ctts_data;
02472 uint64_t offset;
02473 int64_t dts;
02474 int data_offset = 0;
02475 unsigned entries, first_sample_flags = frag->flags;
02476 int flags, distance, i, found_keyframe = 0;
02477
02478 for (i = 0; i < c->fc->nb_streams; i++) {
02479 if (c->fc->streams[i]->id == frag->track_id) {
02480 st = c->fc->streams[i];
02481 break;
02482 }
02483 }
02484 if (!st) {
02485 av_log(c->fc, AV_LOG_ERROR, "could not find corresponding track id %d\n", frag->track_id);
02486 return AVERROR_INVALIDDATA;
02487 }
02488 sc = st->priv_data;
02489 if (sc->pseudo_stream_id+1 != frag->stsd_id)
02490 return 0;
02491 avio_r8(pb);
02492 flags = avio_rb24(pb);
02493 entries = avio_rb32(pb);
02494 av_dlog(c->fc, "flags 0x%x entries %d\n", flags, entries);
02495
02496
02497
02498
02499
02500
02501 if (!sc->ctts_count && sc->sample_count)
02502 {
02503
02504 ctts_data = av_malloc(sizeof(*sc->ctts_data));
02505 if (!ctts_data)
02506 return AVERROR(ENOMEM);
02507 sc->ctts_data = ctts_data;
02508 sc->ctts_data[sc->ctts_count].count = sc->sample_count;
02509 sc->ctts_data[sc->ctts_count].duration = 0;
02510 sc->ctts_count++;
02511 }
02512 if ((uint64_t)entries+sc->ctts_count >= UINT_MAX/sizeof(*sc->ctts_data))
02513 return AVERROR_INVALIDDATA;
02514 ctts_data = av_realloc(sc->ctts_data,
02515 (entries+sc->ctts_count)*sizeof(*sc->ctts_data));
02516 if (!ctts_data)
02517 return AVERROR(ENOMEM);
02518 sc->ctts_data = ctts_data;
02519
02520 if (flags & MOV_TRUN_DATA_OFFSET) data_offset = avio_rb32(pb);
02521 if (flags & MOV_TRUN_FIRST_SAMPLE_FLAGS) first_sample_flags = avio_rb32(pb);
02522 dts = sc->track_end - sc->time_offset;
02523 offset = frag->base_data_offset + data_offset;
02524 distance = 0;
02525 av_dlog(c->fc, "first sample flags 0x%x\n", first_sample_flags);
02526 for (i = 0; i < entries && !pb->eof_reached; i++) {
02527 unsigned sample_size = frag->size;
02528 int sample_flags = i ? frag->flags : first_sample_flags;
02529 unsigned sample_duration = frag->duration;
02530 int keyframe = 0;
02531
02532 if (flags & MOV_TRUN_SAMPLE_DURATION) sample_duration = avio_rb32(pb);
02533 if (flags & MOV_TRUN_SAMPLE_SIZE) sample_size = avio_rb32(pb);
02534 if (flags & MOV_TRUN_SAMPLE_FLAGS) sample_flags = avio_rb32(pb);
02535 sc->ctts_data[sc->ctts_count].count = 1;
02536 sc->ctts_data[sc->ctts_count].duration = (flags & MOV_TRUN_SAMPLE_CTS) ?
02537 avio_rb32(pb) : 0;
02538 sc->ctts_count++;
02539 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
02540 keyframe = 1;
02541 else if (!found_keyframe)
02542 keyframe = found_keyframe =
02543 !(sample_flags & (MOV_FRAG_SAMPLE_FLAG_IS_NON_SYNC |
02544 MOV_FRAG_SAMPLE_FLAG_DEPENDS_YES));
02545 if (keyframe)
02546 distance = 0;
02547 av_add_index_entry(st, offset, dts, sample_size, distance,
02548 keyframe ? AVINDEX_KEYFRAME : 0);
02549 av_dlog(c->fc, "AVIndex stream %d, sample %d, offset %"PRIx64", dts %"PRId64", "
02550 "size %d, distance %d, keyframe %d\n", st->index, sc->sample_count+i,
02551 offset, dts, sample_size, distance, keyframe);
02552 distance++;
02553 dts += sample_duration;
02554 offset += sample_size;
02555 sc->data_size += sample_size;
02556 }
02557
02558 if (pb->eof_reached)
02559 return AVERROR_EOF;
02560
02561 frag->moof_offset = offset;
02562 st->duration = sc->track_end = dts + sc->time_offset;
02563 return 0;
02564 }
02565
02566
02567
02568
02569 static int mov_read_wide(MOVContext *c, AVIOContext *pb, MOVAtom atom)
02570 {
02571 int err;
02572
02573 if (atom.size < 8)
02574 return 0;
02575 if (avio_rb32(pb) != 0) {
02576 avio_skip(pb, atom.size - 4);
02577 return 0;
02578 }
02579 atom.type = avio_rl32(pb);
02580 atom.size -= 8;
02581 if (atom.type != MKTAG('m','d','a','t')) {
02582 avio_skip(pb, atom.size);
02583 return 0;
02584 }
02585 err = mov_read_mdat(c, pb, atom);
02586 return err;
02587 }
02588
02589 static int mov_read_cmov(MOVContext *c, AVIOContext *pb, MOVAtom atom)
02590 {
02591 #if CONFIG_ZLIB
02592 AVIOContext ctx;
02593 uint8_t *cmov_data;
02594 uint8_t *moov_data;
02595 long cmov_len, moov_len;
02596 int ret = -1;
02597
02598 avio_rb32(pb);
02599 if (avio_rl32(pb) != MKTAG('d','c','o','m'))
02600 return AVERROR_INVALIDDATA;
02601 if (avio_rl32(pb) != MKTAG('z','l','i','b')) {
02602 av_log(c->fc, AV_LOG_ERROR, "unknown compression for cmov atom !\n");
02603 return AVERROR_INVALIDDATA;
02604 }
02605 avio_rb32(pb);
02606 if (avio_rl32(pb) != MKTAG('c','m','v','d'))
02607 return AVERROR_INVALIDDATA;
02608 moov_len = avio_rb32(pb);
02609 cmov_len = atom.size - 6 * 4;
02610
02611 cmov_data = av_malloc(cmov_len);
02612 if (!cmov_data)
02613 return AVERROR(ENOMEM);
02614 moov_data = av_malloc(moov_len);
02615 if (!moov_data) {
02616 av_free(cmov_data);
02617 return AVERROR(ENOMEM);
02618 }
02619 avio_read(pb, cmov_data, cmov_len);
02620 if (uncompress (moov_data, (uLongf *) &moov_len, (const Bytef *)cmov_data, cmov_len) != Z_OK)
02621 goto free_and_return;
02622 if (ffio_init_context(&ctx, moov_data, moov_len, 0, NULL, NULL, NULL, NULL) != 0)
02623 goto free_and_return;
02624 atom.type = MKTAG('m','o','o','v');
02625 atom.size = moov_len;
02626 ret = mov_read_default(c, &ctx, atom);
02627 free_and_return:
02628 av_free(moov_data);
02629 av_free(cmov_data);
02630 return ret;
02631 #else
02632 av_log(c->fc, AV_LOG_ERROR, "this file requires zlib support compiled in\n");
02633 return AVERROR(ENOSYS);
02634 #endif
02635 }
02636
02637
02638 static int mov_read_elst(MOVContext *c, AVIOContext *pb, MOVAtom atom)
02639 {
02640 MOVStreamContext *sc;
02641 int i, edit_count, version, edit_start_index = 0;
02642 int unsupported = 0;
02643
02644 if (c->fc->nb_streams < 1 || c->ignore_editlist)
02645 return 0;
02646 sc = c->fc->streams[c->fc->nb_streams-1]->priv_data;
02647
02648 version = avio_r8(pb);
02649 avio_rb24(pb);
02650 edit_count = avio_rb32(pb);
02651
02652 if ((uint64_t)edit_count*12+8 > atom.size)
02653 return AVERROR_INVALIDDATA;
02654
02655 av_dlog(c->fc, "track[%i].edit_count = %i\n", c->fc->nb_streams-1, edit_count);
02656 for (i=0; i<edit_count; i++){
02657 int64_t time;
02658 int64_t duration;
02659 int rate;
02660 if (version == 1) {
02661 duration = avio_rb64(pb);
02662 time = avio_rb64(pb);
02663 } else {
02664 duration = avio_rb32(pb);
02665 time = (int32_t)avio_rb32(pb);
02666 }
02667 rate = avio_rb32(pb);
02668 if (i == 0 && time == -1) {
02669 sc->empty_duration = duration;
02670 edit_start_index = 1;
02671 } else if (i == edit_start_index && time >= 0)
02672 sc->start_time = time;
02673 else
02674 unsupported = 1;
02675
02676 av_dlog(c->fc, "duration=%"PRId64" time=%"PRId64" rate=%f\n",
02677 duration, time, rate / 65536.0);
02678 }
02679
02680 if (unsupported)
02681 av_log(c->fc, AV_LOG_WARNING, "multiple edit list entries, "
02682 "a/v desync might occur, patch welcome\n");
02683
02684 return 0;
02685 }
02686
02687 static int mov_read_chan2(MOVContext *c, AVIOContext *pb, MOVAtom atom)
02688 {
02689 if (atom.size < 16)
02690 return 0;
02691 avio_skip(pb, 4);
02692 ff_mov_read_chan(c->fc, pb, c->fc->streams[0], atom.size - 4);
02693 return 0;
02694 }
02695
02696 static int mov_read_tref(MOVContext *c, AVIOContext *pb, MOVAtom atom)
02697 {
02698 uint32_t i, size;
02699 MOVStreamContext *sc;
02700
02701 if (c->fc->nb_streams < 1)
02702 return AVERROR_INVALIDDATA;
02703 sc = c->fc->streams[c->fc->nb_streams - 1]->priv_data;
02704
02705 size = avio_rb32(pb);
02706 if (size < 12)
02707 return 0;
02708
02709 sc->trefs_count = (size - 4) / 8;
02710 sc->trefs = av_malloc(sc->trefs_count * sizeof(*sc->trefs));
02711 if (!sc->trefs)
02712 return AVERROR(ENOMEM);
02713
02714 sc->tref_type = avio_rl32(pb);
02715 for (i = 0; i < sc->trefs_count; i++)
02716 sc->trefs[i] = avio_rb32(pb);
02717 return 0;
02718 }
02719
02720 static const MOVParseTableEntry mov_default_parse_table[] = {
02721 { MKTAG('A','C','L','R'), mov_read_avid },
02722 { MKTAG('A','P','R','G'), mov_read_avid },
02723 { MKTAG('A','A','L','P'), mov_read_avid },
02724 { MKTAG('A','R','E','S'), mov_read_avid },
02725 { MKTAG('a','v','s','s'), mov_read_avss },
02726 { MKTAG('c','h','p','l'), mov_read_chpl },
02727 { MKTAG('c','o','6','4'), mov_read_stco },
02728 { MKTAG('c','t','t','s'), mov_read_ctts },
02729 { MKTAG('d','i','n','f'), mov_read_default },
02730 { MKTAG('d','r','e','f'), mov_read_dref },
02731 { MKTAG('e','d','t','s'), mov_read_default },
02732 { MKTAG('e','l','s','t'), mov_read_elst },
02733 { MKTAG('e','n','d','a'), mov_read_enda },
02734 { MKTAG('f','i','e','l'), mov_read_fiel },
02735 { MKTAG('f','t','y','p'), mov_read_ftyp },
02736 { MKTAG('g','l','b','l'), mov_read_glbl },
02737 { MKTAG('h','d','l','r'), mov_read_hdlr },
02738 { MKTAG('i','l','s','t'), mov_read_ilst },
02739 { MKTAG('j','p','2','h'), mov_read_jp2h },
02740 { MKTAG('m','d','a','t'), mov_read_mdat },
02741 { MKTAG('m','d','h','d'), mov_read_mdhd },
02742 { MKTAG('m','d','i','a'), mov_read_default },
02743 { MKTAG('m','e','t','a'), mov_read_meta },
02744 { MKTAG('m','i','n','f'), mov_read_default },
02745 { MKTAG('m','o','o','f'), mov_read_moof },
02746 { MKTAG('m','o','o','v'), mov_read_moov },
02747 { MKTAG('m','v','e','x'), mov_read_default },
02748 { MKTAG('m','v','h','d'), mov_read_mvhd },
02749 { MKTAG('S','M','I',' '), mov_read_svq3 },
02750 { MKTAG('a','l','a','c'), mov_read_alac },
02751 { MKTAG('a','v','c','C'), mov_read_glbl },
02752 { MKTAG('p','a','s','p'), mov_read_pasp },
02753 { MKTAG('s','t','b','l'), mov_read_default },
02754 { MKTAG('s','t','c','o'), mov_read_stco },
02755 { MKTAG('s','t','p','s'), mov_read_stps },
02756 { MKTAG('s','t','r','f'), mov_read_strf },
02757 { MKTAG('s','t','s','c'), mov_read_stsc },
02758 { MKTAG('s','t','s','d'), mov_read_stsd },
02759 { MKTAG('s','t','s','s'), mov_read_stss },
02760 { MKTAG('s','t','s','z'), mov_read_stsz },
02761 { MKTAG('s','t','t','s'), mov_read_stts },
02762 { MKTAG('s','t','z','2'), mov_read_stsz },
02763 { MKTAG('t','k','h','d'), mov_read_tkhd },
02764 { MKTAG('t','f','h','d'), mov_read_tfhd },
02765 { MKTAG('t','r','a','k'), mov_read_trak },
02766 { MKTAG('t','r','a','f'), mov_read_default },
02767 { MKTAG('t','r','e','f'), mov_read_tref },
02768 { MKTAG('c','h','a','p'), mov_read_chap },
02769 { MKTAG('t','r','e','x'), mov_read_trex },
02770 { MKTAG('t','r','u','n'), mov_read_trun },
02771 { MKTAG('u','d','t','a'), mov_read_default },
02772 { MKTAG('w','a','v','e'), mov_read_wave },
02773 { MKTAG('e','s','d','s'), mov_read_esds },
02774 { MKTAG('d','a','c','3'), mov_read_dac3 },
02775 { MKTAG('d','e','c','3'), mov_read_dec3 },
02776 { MKTAG('w','i','d','e'), mov_read_wide },
02777 { MKTAG('w','f','e','x'), mov_read_wfex },
02778 { MKTAG('c','m','o','v'), mov_read_cmov },
02779 { MKTAG('c','h','a','n'), mov_read_chan },
02780 { MKTAG('d','v','c','1'), mov_read_dvc1 },
02781 { MKTAG('s','b','g','p'), mov_read_sbgp },
02782 { 0, NULL }
02783 };
02784
02785 static int mov_read_default(MOVContext *c, AVIOContext *pb, MOVAtom atom)
02786 {
02787 int64_t total_size = 0;
02788 MOVAtom a;
02789 int i;
02790
02791 if (atom.size < 0)
02792 atom.size = INT64_MAX;
02793 while (total_size + 8 <= atom.size && !url_feof(pb)) {
02794 int (*parse)(MOVContext*, AVIOContext*, MOVAtom) = NULL;
02795 a.size = atom.size;
02796 a.type=0;
02797 if (atom.size >= 8) {
02798 a.size = avio_rb32(pb);
02799 a.type = avio_rl32(pb);
02800 if (atom.type != MKTAG('r','o','o','t') &&
02801 atom.type != MKTAG('m','o','o','v'))
02802 {
02803 if (a.type == MKTAG('t','r','a','k') || a.type == MKTAG('m','d','a','t'))
02804 {
02805 av_log(c->fc, AV_LOG_ERROR, "Broken file, trak/mdat not at top-level\n");
02806 avio_skip(pb, -8);
02807 return 0;
02808 }
02809 }
02810 total_size += 8;
02811 if (a.size == 1) {
02812 a.size = avio_rb64(pb) - 8;
02813 total_size += 8;
02814 }
02815 }
02816 av_dlog(c->fc, "type: %08x '%.4s' parent:'%.4s' sz: %"PRId64" %"PRId64" %"PRId64"\n",
02817 a.type, (char*)&a.type, (char*)&atom.type, a.size, total_size, atom.size);
02818 if (a.size == 0) {
02819 a.size = atom.size - total_size + 8;
02820 }
02821 a.size -= 8;
02822 if (a.size < 0)
02823 break;
02824 a.size = FFMIN(a.size, atom.size - total_size);
02825
02826 for (i = 0; mov_default_parse_table[i].type; i++)
02827 if (mov_default_parse_table[i].type == a.type) {
02828 parse = mov_default_parse_table[i].parse;
02829 break;
02830 }
02831
02832
02833 if (!parse && (atom.type == MKTAG('u','d','t','a') ||
02834 atom.type == MKTAG('i','l','s','t')))
02835 parse = mov_read_udta_string;
02836
02837 if (!parse) {
02838 avio_skip(pb, a.size);
02839 } else {
02840 int64_t start_pos = avio_tell(pb);
02841 int64_t left;
02842 int err = parse(c, pb, a);
02843 if (err < 0)
02844 return err;
02845 if (c->found_moov && c->found_mdat &&
02846 ((!pb->seekable || c->fc->flags & AVFMT_FLAG_IGNIDX) ||
02847 start_pos + a.size == avio_size(pb))) {
02848 if (!pb->seekable || c->fc->flags & AVFMT_FLAG_IGNIDX)
02849 c->next_root_atom = start_pos + a.size;
02850 return 0;
02851 }
02852 left = a.size - avio_tell(pb) + start_pos;
02853 if (left > 0)
02854 avio_skip(pb, left);
02855 else if(left < 0) {
02856 av_log(c->fc, AV_LOG_DEBUG, "undoing overread of %"PRId64" in '%.4s'\n", -left, (char*)&a.type);
02857 avio_seek(pb, left, SEEK_CUR);
02858 }
02859 }
02860
02861 total_size += a.size;
02862 }
02863
02864 if (total_size < atom.size && atom.size < 0x7ffff)
02865 avio_skip(pb, atom.size - total_size);
02866
02867 return 0;
02868 }
02869
02870 static int mov_probe(AVProbeData *p)
02871 {
02872 int64_t offset;
02873 uint32_t tag;
02874 int score = 0;
02875 int moov_offset = -1;
02876
02877
02878 offset = 0;
02879 for (;;) {
02880
02881 if ((offset + 8) > (unsigned int)p->buf_size)
02882 break;
02883 tag = AV_RL32(p->buf + offset + 4);
02884 switch(tag) {
02885
02886 case MKTAG('m','o','o','v'):
02887 moov_offset = offset + 4;
02888 case MKTAG('j','P',' ',' '):
02889 case MKTAG('m','d','a','t'):
02890 case MKTAG('p','n','o','t'):
02891 case MKTAG('u','d','t','a'):
02892 case MKTAG('f','t','y','p'):
02893 if (AV_RB32(p->buf+offset) < 8 &&
02894 (AV_RB32(p->buf+offset) != 1 ||
02895 offset + 12 > (unsigned int)p->buf_size ||
02896 AV_RB64(p->buf+offset + 8) == 0)) {
02897 score = FFMAX(score, AVPROBE_SCORE_MAX - 50);
02898 } else {
02899 score = AVPROBE_SCORE_MAX;
02900 }
02901 offset = FFMAX(4, AV_RB32(p->buf+offset)) + offset;
02902 break;
02903
02904 case MKTAG('e','d','i','w'):
02905 case MKTAG('w','i','d','e'):
02906 case MKTAG('f','r','e','e'):
02907 case MKTAG('j','u','n','k'):
02908 case MKTAG('p','i','c','t'):
02909 score = FFMAX(score, AVPROBE_SCORE_MAX - 5);
02910 offset = FFMAX(4, AV_RB32(p->buf+offset)) + offset;
02911 break;
02912 case MKTAG(0x82,0x82,0x7f,0x7d):
02913 case MKTAG('s','k','i','p'):
02914 case MKTAG('u','u','i','d'):
02915 case MKTAG('p','r','f','l'):
02916
02917 score = FFMAX(score, AVPROBE_SCORE_MAX - 50);
02918 offset = FFMAX(4, AV_RB32(p->buf+offset)) + offset;
02919 break;
02920 default:
02921 offset = FFMAX(4, AV_RB32(p->buf+offset)) + offset;
02922 }
02923 }
02924 if(score > AVPROBE_SCORE_MAX - 50 && moov_offset != -1) {
02925
02926
02927 offset = moov_offset;
02928
02929 while(offset < (p->buf_size - 16)){
02930
02931 if(AV_RL32(p->buf + offset ) == MKTAG('h','d','l','r') &&
02932 AV_RL32(p->buf + offset + 8) == MKTAG('m','h','l','r') &&
02933 AV_RL32(p->buf + offset + 12) == MKTAG('M','P','E','G')){
02934 av_log(NULL, AV_LOG_WARNING, "Found media data tag MPEG indicating this is a MOV-packed MPEG-PS.\n");
02935
02936
02937
02938
02939 return 5;
02940 }else
02941
02942 offset+=2;
02943 }
02944 }
02945
02946 return score;
02947 }
02948
02949
02950 static void mov_read_chapters(AVFormatContext *s)
02951 {
02952 MOVContext *mov = s->priv_data;
02953 AVStream *st = NULL;
02954 MOVStreamContext *sc;
02955 int64_t cur_pos;
02956 int i;
02957
02958 for (i = 0; i < s->nb_streams; i++)
02959 if (s->streams[i]->id == mov->chapter_track) {
02960 st = s->streams[i];
02961 break;
02962 }
02963 if (!st) {
02964 av_log(s, AV_LOG_ERROR, "Referenced QT chapter track not found\n");
02965 return;
02966 }
02967
02968 st->discard = AVDISCARD_ALL;
02969 sc = st->priv_data;
02970 cur_pos = avio_tell(sc->pb);
02971
02972 for (i = 0; i < st->nb_index_entries; i++) {
02973 AVIndexEntry *sample = &st->index_entries[i];
02974 int64_t end = i+1 < st->nb_index_entries ? st->index_entries[i+1].timestamp : st->duration;
02975 uint8_t *title;
02976 uint16_t ch;
02977 int len, title_len;
02978
02979 if (avio_seek(sc->pb, sample->pos, SEEK_SET) != sample->pos) {
02980 av_log(s, AV_LOG_ERROR, "Chapter %d not found in file\n", i);
02981 goto finish;
02982 }
02983
02984
02985 len = avio_rb16(sc->pb);
02986 if (len > sample->size-2)
02987 continue;
02988 title_len = 2*len + 1;
02989 if (!(title = av_mallocz(title_len)))
02990 goto finish;
02991
02992
02993
02994
02995 if (!len) {
02996 title[0] = 0;
02997 } else {
02998 ch = avio_rb16(sc->pb);
02999 if (ch == 0xfeff)
03000 avio_get_str16be(sc->pb, len, title, title_len);
03001 else if (ch == 0xfffe)
03002 avio_get_str16le(sc->pb, len, title, title_len);
03003 else {
03004 AV_WB16(title, ch);
03005 if (len == 1 || len == 2)
03006 title[len] = 0;
03007 else
03008 avio_get_str(sc->pb, INT_MAX, title + 2, len - 1);
03009 }
03010 }
03011
03012 avpriv_new_chapter(s, i, st->time_base, sample->timestamp, end, title);
03013 av_freep(&title);
03014 }
03015 finish:
03016 avio_seek(sc->pb, cur_pos, SEEK_SET);
03017 }
03018
03019 static int parse_timecode_in_framenum_format(AVFormatContext *s, AVStream *st,
03020 uint32_t value, int flags)
03021 {
03022 AVTimecode tc;
03023 char buf[AV_TIMECODE_STR_SIZE];
03024 AVRational rate = {st->codec->time_base.den,
03025 st->codec->time_base.num};
03026 int ret = av_timecode_init(&tc, rate, flags, 0, s);
03027 if (ret < 0)
03028 return ret;
03029 av_dict_set(&st->metadata, "timecode",
03030 av_timecode_make_string(&tc, buf, value), 0);
03031 return 0;
03032 }
03033
03034 static int mov_read_timecode_track(AVFormatContext *s, AVStream *st)
03035 {
03036 MOVStreamContext *sc = st->priv_data;
03037 int flags = 0;
03038 int64_t cur_pos = avio_tell(sc->pb);
03039 uint32_t value;
03040
03041 if (!st->nb_index_entries)
03042 return -1;
03043
03044 avio_seek(sc->pb, st->index_entries->pos, SEEK_SET);
03045 value = avio_rb32(s->pb);
03046
03047 if (sc->tmcd_flags & 0x0001) flags |= AV_TIMECODE_FLAG_DROPFRAME;
03048 if (sc->tmcd_flags & 0x0002) flags |= AV_TIMECODE_FLAG_24HOURSMAX;
03049 if (sc->tmcd_flags & 0x0004) flags |= AV_TIMECODE_FLAG_ALLOWNEGATIVE;
03050
03051
03052
03053
03054
03055
03056 parse_timecode_in_framenum_format(s, st, value, flags);
03057
03058 avio_seek(sc->pb, cur_pos, SEEK_SET);
03059 return 0;
03060 }
03061
03062 static int mov_read_close(AVFormatContext *s)
03063 {
03064 MOVContext *mov = s->priv_data;
03065 int i, j;
03066
03067 for (i = 0; i < s->nb_streams; i++) {
03068 AVStream *st = s->streams[i];
03069 MOVStreamContext *sc = st->priv_data;
03070
03071 av_freep(&sc->ctts_data);
03072 for (j = 0; j < sc->drefs_count; j++) {
03073 av_freep(&sc->drefs[j].path);
03074 av_freep(&sc->drefs[j].dir);
03075 }
03076 av_freep(&sc->drefs);
03077 av_freep(&sc->trefs);
03078 if (sc->pb && sc->pb != s->pb)
03079 avio_close(sc->pb);
03080 sc->pb = NULL;
03081 av_freep(&sc->chunk_offsets);
03082 av_freep(&sc->keyframes);
03083 av_freep(&sc->sample_sizes);
03084 av_freep(&sc->stps_data);
03085 av_freep(&sc->stsc_data);
03086 av_freep(&sc->stts_data);
03087 }
03088
03089 if (mov->dv_demux) {
03090 for (i = 0; i < mov->dv_fctx->nb_streams; i++) {
03091 av_freep(&mov->dv_fctx->streams[i]->codec);
03092 av_freep(&mov->dv_fctx->streams[i]);
03093 }
03094 av_freep(&mov->dv_fctx);
03095 av_freep(&mov->dv_demux);
03096 }
03097
03098 av_freep(&mov->trex_data);
03099
03100 return 0;
03101 }
03102
03103 static int tmcd_is_referenced(AVFormatContext *s, int tmcd_id)
03104 {
03105 int i, j;
03106
03107 for (i = 0; i < s->nb_streams; i++) {
03108 AVStream *st = s->streams[i];
03109 MOVStreamContext *sc = st->priv_data;
03110
03111 if (s->streams[i]->codec->codec_type != AVMEDIA_TYPE_VIDEO)
03112 continue;
03113 for (j = 0; j < sc->trefs_count; j++)
03114 if (tmcd_id == sc->trefs[j])
03115 return 1;
03116 }
03117 return 0;
03118 }
03119
03120
03121 static void export_orphan_timecode(AVFormatContext *s)
03122 {
03123 int i;
03124
03125 for (i = 0; i < s->nb_streams; i++) {
03126 AVStream *st = s->streams[i];
03127
03128 if (st->codec->codec_tag == MKTAG('t','m','c','d') &&
03129 !tmcd_is_referenced(s, i + 1)) {
03130 AVDictionaryEntry *tcr = av_dict_get(st->metadata, "timecode", NULL, 0);
03131 if (tcr) {
03132 av_dict_set(&s->metadata, "timecode", tcr->value, 0);
03133 break;
03134 }
03135 }
03136 }
03137 }
03138
03139 static int mov_read_header(AVFormatContext *s)
03140 {
03141 MOVContext *mov = s->priv_data;
03142 AVIOContext *pb = s->pb;
03143 int i, err;
03144 MOVAtom atom = { AV_RL32("root") };
03145
03146 mov->fc = s;
03147
03148 if (pb->seekable)
03149 atom.size = avio_size(pb);
03150 else
03151 atom.size = INT64_MAX;
03152
03153
03154 if ((err = mov_read_default(mov, pb, atom)) < 0) {
03155 av_log(s, AV_LOG_ERROR, "error reading header: %d\n", err);
03156 mov_read_close(s);
03157 return err;
03158 }
03159 if (!mov->found_moov) {
03160 av_log(s, AV_LOG_ERROR, "moov atom not found\n");
03161 mov_read_close(s);
03162 return AVERROR_INVALIDDATA;
03163 }
03164 av_dlog(mov->fc, "on_parse_exit_offset=%"PRId64"\n", avio_tell(pb));
03165
03166 if (pb->seekable) {
03167 if (mov->chapter_track > 0)
03168 mov_read_chapters(s);
03169 for (i = 0; i < s->nb_streams; i++)
03170 if (s->streams[i]->codec->codec_tag == AV_RL32("tmcd"))
03171 mov_read_timecode_track(s, s->streams[i]);
03172 }
03173
03174
03175 for (i = 0; i < s->nb_streams; i++) {
03176 AVStream *st = s->streams[i];
03177 MOVStreamContext *sc = st->priv_data;
03178 if (sc->tref_type == AV_RL32("tmcd") && sc->trefs_count) {
03179 AVDictionaryEntry *tcr;
03180 int tmcd_st_id = sc->trefs[0] - 1;
03181
03182 if (tmcd_st_id < 0 || tmcd_st_id >= s->nb_streams)
03183 continue;
03184 tcr = av_dict_get(s->streams[tmcd_st_id]->metadata, "timecode", NULL, 0);
03185 if (tcr)
03186 av_dict_set(&st->metadata, "timecode", tcr->value, 0);
03187 }
03188 }
03189 export_orphan_timecode(s);
03190
03191 for (i = 0; i < s->nb_streams; i++) {
03192 AVStream *st = s->streams[i];
03193 MOVStreamContext *sc = st->priv_data;
03194 fix_timescale(mov, sc);
03195 if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && st->codec->codec_id == AV_CODEC_ID_AAC) {
03196 st->skip_samples = sc->start_pad;
03197 }
03198 }
03199
03200 if (mov->trex_data) {
03201 for (i = 0; i < s->nb_streams; i++) {
03202 AVStream *st = s->streams[i];
03203 MOVStreamContext *sc = st->priv_data;
03204 if (st->duration)
03205 st->codec->bit_rate = sc->data_size * 8 * sc->time_scale / st->duration;
03206 }
03207 }
03208
03209 return 0;
03210 }
03211
03212 static AVIndexEntry *mov_find_next_sample(AVFormatContext *s, AVStream **st)
03213 {
03214 AVIndexEntry *sample = NULL;
03215 int64_t best_dts = INT64_MAX;
03216 int i;
03217 for (i = 0; i < s->nb_streams; i++) {
03218 AVStream *avst = s->streams[i];
03219 MOVStreamContext *msc = avst->priv_data;
03220 if (msc->pb && msc->current_sample < avst->nb_index_entries) {
03221 AVIndexEntry *current_sample = &avst->index_entries[msc->current_sample];
03222 int64_t dts = av_rescale(current_sample->timestamp, AV_TIME_BASE, msc->time_scale);
03223 av_dlog(s, "stream %d, sample %d, dts %"PRId64"\n", i, msc->current_sample, dts);
03224 if (!sample || (!s->pb->seekable && current_sample->pos < sample->pos) ||
03225 (s->pb->seekable &&
03226 ((msc->pb != s->pb && dts < best_dts) || (msc->pb == s->pb &&
03227 ((FFABS(best_dts - dts) <= AV_TIME_BASE && current_sample->pos < sample->pos) ||
03228 (FFABS(best_dts - dts) > AV_TIME_BASE && dts < best_dts)))))) {
03229 sample = current_sample;
03230 best_dts = dts;
03231 *st = avst;
03232 }
03233 }
03234 }
03235 return sample;
03236 }
03237
03238 static int mov_read_packet(AVFormatContext *s, AVPacket *pkt)
03239 {
03240 MOVContext *mov = s->priv_data;
03241 MOVStreamContext *sc;
03242 AVIndexEntry *sample;
03243 AVStream *st = NULL;
03244 int ret;
03245 mov->fc = s;
03246 retry:
03247 sample = mov_find_next_sample(s, &st);
03248 if (!sample) {
03249 mov->found_mdat = 0;
03250 if (!mov->next_root_atom)
03251 return AVERROR_EOF;
03252 avio_seek(s->pb, mov->next_root_atom, SEEK_SET);
03253 mov->next_root_atom = 0;
03254 if (mov_read_default(mov, s->pb, (MOVAtom){ AV_RL32("root"), INT64_MAX }) < 0 ||
03255 url_feof(s->pb))
03256 return AVERROR_EOF;
03257 av_dlog(s, "read fragments, offset 0x%"PRIx64"\n", avio_tell(s->pb));
03258 goto retry;
03259 }
03260 sc = st->priv_data;
03261
03262 sc->current_sample++;
03263
03264 if (st->discard != AVDISCARD_ALL) {
03265 if (avio_seek(sc->pb, sample->pos, SEEK_SET) != sample->pos) {
03266 av_log(mov->fc, AV_LOG_ERROR, "stream %d, offset 0x%"PRIx64": partial file\n",
03267 sc->ffindex, sample->pos);
03268 return AVERROR_INVALIDDATA;
03269 }
03270 ret = av_get_packet(sc->pb, pkt, sample->size);
03271 if (ret < 0)
03272 return ret;
03273 if (sc->has_palette) {
03274 uint8_t *pal;
03275
03276 pal = av_packet_new_side_data(pkt, AV_PKT_DATA_PALETTE, AVPALETTE_SIZE);
03277 if (!pal) {
03278 av_log(mov->fc, AV_LOG_ERROR, "Cannot append palette to packet\n");
03279 } else {
03280 memcpy(pal, sc->palette, AVPALETTE_SIZE);
03281 sc->has_palette = 0;
03282 }
03283 }
03284 #if CONFIG_DV_DEMUXER
03285 if (mov->dv_demux && sc->dv_audio_container) {
03286 avpriv_dv_produce_packet(mov->dv_demux, pkt, pkt->data, pkt->size, pkt->pos);
03287 av_free(pkt->data);
03288 pkt->size = 0;
03289 ret = avpriv_dv_get_packet(mov->dv_demux, pkt);
03290 if (ret < 0)
03291 return ret;
03292 }
03293 #endif
03294 }
03295
03296 pkt->stream_index = sc->ffindex;
03297 pkt->dts = sample->timestamp;
03298 if (sc->ctts_data && sc->ctts_index < sc->ctts_count) {
03299 pkt->pts = pkt->dts + sc->dts_shift + sc->ctts_data[sc->ctts_index].duration;
03300
03301 sc->ctts_sample++;
03302 if (sc->ctts_index < sc->ctts_count &&
03303 sc->ctts_data[sc->ctts_index].count == sc->ctts_sample) {
03304 sc->ctts_index++;
03305 sc->ctts_sample = 0;
03306 }
03307 if (sc->wrong_dts)
03308 pkt->dts = AV_NOPTS_VALUE;
03309 } else {
03310 int64_t next_dts = (sc->current_sample < st->nb_index_entries) ?
03311 st->index_entries[sc->current_sample].timestamp : st->duration;
03312 pkt->duration = next_dts - pkt->dts;
03313 pkt->pts = pkt->dts;
03314 }
03315 if (st->discard == AVDISCARD_ALL)
03316 goto retry;
03317 pkt->flags |= sample->flags & AVINDEX_KEYFRAME ? AV_PKT_FLAG_KEY : 0;
03318 pkt->pos = sample->pos;
03319 av_dlog(s, "stream %d, pts %"PRId64", dts %"PRId64", pos 0x%"PRIx64", duration %d\n",
03320 pkt->stream_index, pkt->pts, pkt->dts, pkt->pos, pkt->duration);
03321 return 0;
03322 }
03323
03324 static int mov_seek_stream(AVFormatContext *s, AVStream *st, int64_t timestamp, int flags)
03325 {
03326 MOVStreamContext *sc = st->priv_data;
03327 int sample, time_sample;
03328 int i;
03329
03330 sample = av_index_search_timestamp(st, timestamp, flags);
03331 av_dlog(s, "stream %d, timestamp %"PRId64", sample %d\n", st->index, timestamp, sample);
03332 if (sample < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
03333 sample = 0;
03334 if (sample < 0)
03335 return AVERROR_INVALIDDATA;
03336 sc->current_sample = sample;
03337 av_dlog(s, "stream %d, found sample %d\n", st->index, sc->current_sample);
03338
03339 if (sc->ctts_data) {
03340 time_sample = 0;
03341 for (i = 0; i < sc->ctts_count; i++) {
03342 int next = time_sample + sc->ctts_data[i].count;
03343 if (next > sc->current_sample) {
03344 sc->ctts_index = i;
03345 sc->ctts_sample = sc->current_sample - time_sample;
03346 break;
03347 }
03348 time_sample = next;
03349 }
03350 }
03351 return sample;
03352 }
03353
03354 static int mov_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
03355 {
03356 AVStream *st;
03357 int64_t seek_timestamp, timestamp;
03358 int sample;
03359 int i;
03360
03361 if (stream_index >= s->nb_streams)
03362 return AVERROR_INVALIDDATA;
03363
03364 st = s->streams[stream_index];
03365 sample = mov_seek_stream(s, st, sample_time, flags);
03366 if (sample < 0)
03367 return sample;
03368
03369
03370 seek_timestamp = st->index_entries[sample].timestamp;
03371
03372 for (i = 0; i < s->nb_streams; i++) {
03373 MOVStreamContext *sc = s->streams[i]->priv_data;
03374 st = s->streams[i];
03375 st->skip_samples = (sample_time <= 0) ? sc->start_pad : 0;
03376
03377 if (stream_index == i)
03378 continue;
03379
03380 timestamp = av_rescale_q(seek_timestamp, s->streams[stream_index]->time_base, st->time_base);
03381 mov_seek_stream(s, st, timestamp, flags);
03382 }
03383 return 0;
03384 }
03385
03386 static const AVOption options[] = {
03387 {"use_absolute_path",
03388 "allow using absolute path when opening alias, this is a possible security issue",
03389 offsetof(MOVContext, use_absolute_path), FF_OPT_TYPE_INT, {.i64 = 0},
03390 0, 1, AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_DECODING_PARAM},
03391 {"ignore_editlist", "", offsetof(MOVContext, ignore_editlist), FF_OPT_TYPE_INT, {.i64 = 0},
03392 0, 1, AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_DECODING_PARAM},
03393 {NULL}
03394 };
03395
03396 static const AVClass class = {
03397 .class_name = "mov,mp4,m4a,3gp,3g2,mj2",
03398 .item_name = av_default_item_name,
03399 .option = options,
03400 .version = LIBAVUTIL_VERSION_INT,
03401 };
03402
03403 AVInputFormat ff_mov_demuxer = {
03404 .name = "mov,mp4,m4a,3gp,3g2,mj2",
03405 .long_name = NULL_IF_CONFIG_SMALL("QuickTime / MOV"),
03406 .priv_data_size = sizeof(MOVContext),
03407 .read_probe = mov_probe,
03408 .read_header = mov_read_header,
03409 .read_packet = mov_read_packet,
03410 .read_close = mov_read_close,
03411 .read_seek = mov_read_seek,
03412 .priv_class = &class,
03413 .flags = AVFMT_NO_BYTE_SEEK,
03414 };