Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * MOV demuxer
  3.  * Copyright (c) 2001 Fabrice Bellard
  4.  * Copyright (c) 2009 Baptiste Coudurier <baptiste dot coudurier at gmail dot com>
  5.  *
  6.  * first version by Francois Revol <revol@free.fr>
  7.  * seek function by Gael Chardon <gael.dev@4now.net>
  8.  *
  9.  * This file is part of FFmpeg.
  10.  *
  11.  * FFmpeg is free software; you can redistribute it and/or
  12.  * modify it under the terms of the GNU Lesser General Public
  13.  * License as published by the Free Software Foundation; either
  14.  * version 2.1 of the License, or (at your option) any later version.
  15.  *
  16.  * FFmpeg is distributed in the hope that it will be useful,
  17.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19.  * Lesser General Public License for more details.
  20.  *
  21.  * You should have received a copy of the GNU Lesser General Public
  22.  * License along with FFmpeg; if not, write to the Free Software
  23.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  24.  */
  25.  
  26. #include <limits.h>
  27.  
  28. //#define MOV_EXPORT_ALL_METADATA
  29.  
  30. #include "libavutil/attributes.h"
  31. #include "libavutil/channel_layout.h"
  32. #include "libavutil/intreadwrite.h"
  33. #include "libavutil/intfloat.h"
  34. #include "libavutil/mathematics.h"
  35. #include "libavutil/avstring.h"
  36. #include "libavutil/dict.h"
  37. #include "libavutil/opt.h"
  38. #include "libavutil/timecode.h"
  39. #include "libavcodec/ac3tab.h"
  40. #include "avformat.h"
  41. #include "internal.h"
  42. #include "avio_internal.h"
  43. #include "riff.h"
  44. #include "isom.h"
  45. #include "libavcodec/get_bits.h"
  46. #include "id3v1.h"
  47. #include "mov_chan.h"
  48.  
  49. #if CONFIG_ZLIB
  50. #include <zlib.h>
  51. #endif
  52.  
  53. #include "qtpalette.h"
  54.  
  55.  
  56. #undef NDEBUG
  57. #include <assert.h>
  58.  
  59. /* those functions parse an atom */
  60. /* links atom IDs to parse functions */
  61. typedef struct MOVParseTableEntry {
  62.     uint32_t type;
  63.     int (*parse)(MOVContext *ctx, AVIOContext *pb, MOVAtom atom);
  64. } MOVParseTableEntry;
  65.  
  66. static int mov_read_default(MOVContext *c, AVIOContext *pb, MOVAtom atom);
  67.  
  68. static int mov_metadata_track_or_disc_number(MOVContext *c, AVIOContext *pb,
  69.                                              unsigned len, const char *key)
  70. {
  71.     char buf[16];
  72.  
  73.     short current, total = 0;
  74.     avio_rb16(pb); // unknown
  75.     current = avio_rb16(pb);
  76.     if (len >= 6)
  77.         total = avio_rb16(pb);
  78.     if (!total)
  79.         snprintf(buf, sizeof(buf), "%d", current);
  80.     else
  81.         snprintf(buf, sizeof(buf), "%d/%d", current, total);
  82.     av_dict_set(&c->fc->metadata, key, buf, 0);
  83.  
  84.     return 0;
  85. }
  86.  
  87. static int mov_metadata_int8_bypass_padding(MOVContext *c, AVIOContext *pb,
  88.                                             unsigned len, const char *key)
  89. {
  90.     char buf[16];
  91.  
  92.     /* bypass padding bytes */
  93.     avio_r8(pb);
  94.     avio_r8(pb);
  95.     avio_r8(pb);
  96.  
  97.     snprintf(buf, sizeof(buf), "%d", avio_r8(pb));
  98.     av_dict_set(&c->fc->metadata, key, buf, 0);
  99.  
  100.     return 0;
  101. }
  102.  
  103. static int mov_metadata_int8_no_padding(MOVContext *c, AVIOContext *pb,
  104.                                         unsigned len, const char *key)
  105. {
  106.     char buf[16];
  107.  
  108.     snprintf(buf, sizeof(buf), "%d", avio_r8(pb));
  109.     av_dict_set(&c->fc->metadata, key, buf, 0);
  110.  
  111.     return 0;
  112. }
  113.  
  114. static int mov_metadata_gnre(MOVContext *c, AVIOContext *pb,
  115.                              unsigned len, const char *key)
  116. {
  117.     short genre;
  118.     char buf[20];
  119.  
  120.     avio_r8(pb); // unknown
  121.  
  122.     genre = avio_r8(pb);
  123.     if (genre < 1 || genre > ID3v1_GENRE_MAX)
  124.         return 0;
  125.     snprintf(buf, sizeof(buf), "%s", ff_id3v1_genre_str[genre-1]);
  126.     av_dict_set(&c->fc->metadata, key, buf, 0);
  127.  
  128.     return 0;
  129. }
  130.  
  131. static int mov_read_custom_metadata(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  132. {
  133.     char key[1024]={0}, data[1024]={0};
  134.     int i;
  135.     AVStream *st;
  136.     MOVStreamContext *sc;
  137.  
  138.     if (c->fc->nb_streams < 1)
  139.         return 0;
  140.     st = c->fc->streams[c->fc->nb_streams-1];
  141.     sc = st->priv_data;
  142.  
  143.     if (atom.size <= 8) return 0;
  144.  
  145.     for (i = 0; i < 3; i++) { // Parse up to three sub-atoms looking for name and data.
  146.         int data_size = avio_rb32(pb);
  147.         int tag = avio_rl32(pb);
  148.         int str_size = 0, skip_size = 0;
  149.         char *target = NULL;
  150.  
  151.         switch (tag) {
  152.         case MKTAG('n','a','m','e'):
  153.             avio_rb32(pb); // version/flags
  154.             str_size = skip_size = data_size - 12;
  155.             atom.size -= 12;
  156.             target = key;
  157.             break;
  158.         case MKTAG('d','a','t','a'):
  159.             avio_rb32(pb); // version/flags
  160.             avio_rb32(pb); // reserved (zero)
  161.             str_size = skip_size = data_size - 16;
  162.             atom.size -= 16;
  163.             target = data;
  164.             break;
  165.         default:
  166.             skip_size = data_size - 8;
  167.             str_size = 0;
  168.             break;
  169.         }
  170.  
  171.         if (target) {
  172.             str_size = FFMIN3(sizeof(data)-1, str_size, atom.size);
  173.             avio_read(pb, target, str_size);
  174.             target[str_size] = 0;
  175.         }
  176.         atom.size -= skip_size;
  177.  
  178.         // If we didn't read the full data chunk for the sub-atom, skip to the end of it.
  179.         if (skip_size > str_size) avio_skip(pb, skip_size - str_size);
  180.     }
  181.  
  182.     if (*key && *data) {
  183.         if (strcmp(key, "iTunSMPB") == 0) {
  184.             int priming, remainder, samples;
  185.             if(sscanf(data, "%*X %X %X %X", &priming, &remainder, &samples) == 3){
  186.                 if(priming>0 && priming<16384)
  187.                     sc->start_pad = priming;
  188.                 return 1;
  189.             }
  190.         }
  191.         if (strcmp(key, "cdec") == 0) {
  192. //             av_dict_set(&st->metadata, key, data, 0);
  193.             return 1;
  194.         }
  195.     }
  196.     return 0;
  197. }
  198.  
  199. static const uint32_t mac_to_unicode[128] = {
  200.     0x00C4,0x00C5,0x00C7,0x00C9,0x00D1,0x00D6,0x00DC,0x00E1,
  201.     0x00E0,0x00E2,0x00E4,0x00E3,0x00E5,0x00E7,0x00E9,0x00E8,
  202.     0x00EA,0x00EB,0x00ED,0x00EC,0x00EE,0x00EF,0x00F1,0x00F3,
  203.     0x00F2,0x00F4,0x00F6,0x00F5,0x00FA,0x00F9,0x00FB,0x00FC,
  204.     0x2020,0x00B0,0x00A2,0x00A3,0x00A7,0x2022,0x00B6,0x00DF,
  205.     0x00AE,0x00A9,0x2122,0x00B4,0x00A8,0x2260,0x00C6,0x00D8,
  206.     0x221E,0x00B1,0x2264,0x2265,0x00A5,0x00B5,0x2202,0x2211,
  207.     0x220F,0x03C0,0x222B,0x00AA,0x00BA,0x03A9,0x00E6,0x00F8,
  208.     0x00BF,0x00A1,0x00AC,0x221A,0x0192,0x2248,0x2206,0x00AB,
  209.     0x00BB,0x2026,0x00A0,0x00C0,0x00C3,0x00D5,0x0152,0x0153,
  210.     0x2013,0x2014,0x201C,0x201D,0x2018,0x2019,0x00F7,0x25CA,
  211.     0x00FF,0x0178,0x2044,0x20AC,0x2039,0x203A,0xFB01,0xFB02,
  212.     0x2021,0x00B7,0x201A,0x201E,0x2030,0x00C2,0x00CA,0x00C1,
  213.     0x00CB,0x00C8,0x00CD,0x00CE,0x00CF,0x00CC,0x00D3,0x00D4,
  214.     0xF8FF,0x00D2,0x00DA,0x00DB,0x00D9,0x0131,0x02C6,0x02DC,
  215.     0x00AF,0x02D8,0x02D9,0x02DA,0x00B8,0x02DD,0x02DB,0x02C7,
  216. };
  217.  
  218. static int mov_read_mac_string(MOVContext *c, AVIOContext *pb, int len,
  219.                                char *dst, int dstlen)
  220. {
  221.     char *p = dst;
  222.     char *end = dst+dstlen-1;
  223.     int i;
  224.  
  225.     for (i = 0; i < len; i++) {
  226.         uint8_t t, c = avio_r8(pb);
  227.         if (c < 0x80 && p < end)
  228.             *p++ = c;
  229.         else if (p < end)
  230.             PUT_UTF8(mac_to_unicode[c-0x80], t, if (p < end) *p++ = t;);
  231.     }
  232.     *p = 0;
  233.     return p - dst;
  234. }
  235.  
  236. static int mov_read_covr(MOVContext *c, AVIOContext *pb, int type, int len)
  237. {
  238.     AVPacket pkt;
  239.     AVStream *st;
  240.     MOVStreamContext *sc;
  241.     enum AVCodecID id;
  242.     int ret;
  243.  
  244.     switch (type) {
  245.     case 0xd:  id = AV_CODEC_ID_MJPEG; break;
  246.     case 0xe:  id = AV_CODEC_ID_PNG;   break;
  247.     case 0x1b: id = AV_CODEC_ID_BMP;   break;
  248.     default:
  249.         av_log(c->fc, AV_LOG_WARNING, "Unknown cover type: 0x%x.\n", type);
  250.         avio_skip(pb, len);
  251.         return 0;
  252.     }
  253.  
  254.     st = avformat_new_stream(c->fc, NULL);
  255.     if (!st)
  256.         return AVERROR(ENOMEM);
  257.     sc = av_mallocz(sizeof(*sc));
  258.     if (!sc)
  259.         return AVERROR(ENOMEM);
  260.     st->priv_data = sc;
  261.  
  262.     ret = av_get_packet(pb, &pkt, len);
  263.     if (ret < 0)
  264.         return ret;
  265.  
  266.     st->disposition              |= AV_DISPOSITION_ATTACHED_PIC;
  267.  
  268.     st->attached_pic              = pkt;
  269.     st->attached_pic.stream_index = st->index;
  270.     st->attached_pic.flags       |= AV_PKT_FLAG_KEY;
  271.  
  272.     st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
  273.     st->codec->codec_id   = id;
  274.  
  275.     return 0;
  276. }
  277.  
  278. static int mov_metadata_raw(MOVContext *c, AVIOContext *pb,
  279.                             unsigned len, const char *key)
  280. {
  281.     char *value = av_malloc(len + 1);
  282.     if (!value)
  283.         return AVERROR(ENOMEM);
  284.     avio_read(pb, value, len);
  285.     value[len] = 0;
  286.     return av_dict_set(&c->fc->metadata, key, value, AV_DICT_DONT_STRDUP_VAL);
  287. }
  288.  
  289. static int mov_read_udta_string(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  290. {
  291. #ifdef MOV_EXPORT_ALL_METADATA
  292.     char tmp_key[5];
  293. #endif
  294.     char str[1024], key2[16], language[4] = {0};
  295.     const char *key = NULL;
  296.     uint16_t langcode = 0;
  297.     uint32_t data_type = 0, str_size;
  298.     int (*parse)(MOVContext*, AVIOContext*, unsigned, const char*) = NULL;
  299.  
  300.     if (c->itunes_metadata && atom.type == MKTAG('-','-','-','-'))
  301.         return mov_read_custom_metadata(c, pb, atom);
  302.  
  303.     switch (atom.type) {
  304.     case MKTAG(0xa9,'n','a','m'): key = "title";     break;
  305.     case MKTAG(0xa9,'a','u','t'):
  306.     case MKTAG(0xa9,'A','R','T'): key = "artist";    break;
  307.     case MKTAG( 'a','A','R','T'): key = "album_artist";    break;
  308.     case MKTAG(0xa9,'w','r','t'): key = "composer";  break;
  309.     case MKTAG( 'c','p','r','t'):
  310.     case MKTAG(0xa9,'c','p','y'): key = "copyright"; break;
  311.     case MKTAG(0xa9,'g','r','p'): key = "grouping"; break;
  312.     case MKTAG(0xa9,'l','y','r'): key = "lyrics"; break;
  313.     case MKTAG(0xa9,'c','m','t'):
  314.     case MKTAG(0xa9,'i','n','f'): key = "comment";   break;
  315.     case MKTAG(0xa9,'a','l','b'): key = "album";     break;
  316.     case MKTAG(0xa9,'d','a','y'): key = "date";      break;
  317.     case MKTAG(0xa9,'g','e','n'): key = "genre";     break;
  318.     case MKTAG( 'g','n','r','e'): key = "genre";
  319.         parse = mov_metadata_gnre; break;
  320.     case MKTAG(0xa9,'t','o','o'):
  321.     case MKTAG(0xa9,'s','w','r'): key = "encoder";   break;
  322.     case MKTAG(0xa9,'e','n','c'): key = "encoder";   break;
  323.     case MKTAG(0xa9,'m','a','k'): key = "make";      break;
  324.     case MKTAG(0xa9,'m','o','d'): key = "model";     break;
  325.     case MKTAG(0xa9,'x','y','z'): key = "location";  break;
  326.     case MKTAG( 'd','e','s','c'): key = "description";break;
  327.     case MKTAG( 'l','d','e','s'): key = "synopsis";  break;
  328.     case MKTAG( 't','v','s','h'): key = "show";      break;
  329.     case MKTAG( 't','v','e','n'): key = "episode_id";break;
  330.     case MKTAG( 't','v','n','n'): key = "network";   break;
  331.     case MKTAG( 't','r','k','n'): key = "track";
  332.         parse = mov_metadata_track_or_disc_number; break;
  333.     case MKTAG( 'd','i','s','k'): key = "disc";
  334.         parse = mov_metadata_track_or_disc_number; break;
  335.     case MKTAG( 't','v','e','s'): key = "episode_sort";
  336.         parse = mov_metadata_int8_bypass_padding; break;
  337.     case MKTAG( 't','v','s','n'): key = "season_number";
  338.         parse = mov_metadata_int8_bypass_padding; break;
  339.     case MKTAG( 's','t','i','k'): key = "media_type";
  340.         parse = mov_metadata_int8_no_padding; break;
  341.     case MKTAG( 'h','d','v','d'): key = "hd_video";
  342.         parse = mov_metadata_int8_no_padding; break;
  343.     case MKTAG( 'p','g','a','p'): key = "gapless_playback";
  344.         parse = mov_metadata_int8_no_padding; break;
  345.     case MKTAG( '@','P','R','M'):
  346.         return mov_metadata_raw(c, pb, atom.size, "premiere_version");
  347.     case MKTAG( '@','P','R','Q'):
  348.         return mov_metadata_raw(c, pb, atom.size, "quicktime_version");
  349.     }
  350.  
  351.     if (c->itunes_metadata && atom.size > 8) {
  352.         int data_size = avio_rb32(pb);
  353.         int tag = avio_rl32(pb);
  354.         if (tag == MKTAG('d','a','t','a')) {
  355.             data_type = avio_rb32(pb); // type
  356.             avio_rb32(pb); // unknown
  357.             str_size = data_size - 16;
  358.             atom.size -= 16;
  359.  
  360.             if (atom.type == MKTAG('c', 'o', 'v', 'r')) {
  361.                 int ret = mov_read_covr(c, pb, data_type, str_size);
  362.                 if (ret < 0) {
  363.                     av_log(c->fc, AV_LOG_ERROR, "Error parsing cover art.\n");
  364.                     return ret;
  365.                 }
  366.             }
  367.         } else return 0;
  368.     } else if (atom.size > 4 && key && !c->itunes_metadata) {
  369.         str_size = avio_rb16(pb); // string length
  370.         langcode = avio_rb16(pb);
  371.         ff_mov_lang_to_iso639(langcode, language);
  372.         atom.size -= 4;
  373.     } else
  374.         str_size = atom.size;
  375.  
  376. #ifdef MOV_EXPORT_ALL_METADATA
  377.     if (!key) {
  378.         snprintf(tmp_key, 5, "%.4s", (char*)&atom.type);
  379.         key = tmp_key;
  380.     }
  381. #endif
  382.  
  383.     if (!key)
  384.         return 0;
  385.     if (atom.size < 0)
  386.         return AVERROR_INVALIDDATA;
  387.  
  388.     str_size = FFMIN3(sizeof(str)-1, str_size, atom.size);
  389.  
  390.     if (parse)
  391.         parse(c, pb, str_size, key);
  392.     else {
  393.         if (data_type == 3 || (data_type == 0 && (langcode < 0x400 || langcode == 0x7fff))) { // MAC Encoded
  394.             mov_read_mac_string(c, pb, str_size, str, sizeof(str));
  395.         } else {
  396.             avio_read(pb, str, str_size);
  397.             str[str_size] = 0;
  398.         }
  399.         av_dict_set(&c->fc->metadata, key, str, 0);
  400.         if (*language && strcmp(language, "und")) {
  401.             snprintf(key2, sizeof(key2), "%s-%s", key, language);
  402.             av_dict_set(&c->fc->metadata, key2, str, 0);
  403.         }
  404.     }
  405.     av_dlog(c->fc, "lang \"%3s\" ", language);
  406.     av_dlog(c->fc, "tag \"%s\" value \"%s\" atom \"%.4s\" %d %"PRId64"\n",
  407.             key, str, (char*)&atom.type, str_size, atom.size);
  408.  
  409.     return 0;
  410. }
  411.  
  412. static int mov_read_chpl(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  413. {
  414.     int64_t start;
  415.     int i, nb_chapters, str_len, version;
  416.     char str[256+1];
  417.  
  418.     if ((atom.size -= 5) < 0)
  419.         return 0;
  420.  
  421.     version = avio_r8(pb);
  422.     avio_rb24(pb);
  423.     if (version)
  424.         avio_rb32(pb); // ???
  425.     nb_chapters = avio_r8(pb);
  426.  
  427.     for (i = 0; i < nb_chapters; i++) {
  428.         if (atom.size < 9)
  429.             return 0;
  430.  
  431.         start = avio_rb64(pb);
  432.         str_len = avio_r8(pb);
  433.  
  434.         if ((atom.size -= 9+str_len) < 0)
  435.             return 0;
  436.  
  437.         avio_read(pb, str, str_len);
  438.         str[str_len] = 0;
  439.         avpriv_new_chapter(c->fc, i, (AVRational){1,10000000}, start, AV_NOPTS_VALUE, str);
  440.     }
  441.     return 0;
  442. }
  443.  
  444. #define MIN_DATA_ENTRY_BOX_SIZE 12
  445. static int mov_read_dref(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  446. {
  447.     AVStream *st;
  448.     MOVStreamContext *sc;
  449.     int entries, i, j;
  450.  
  451.     if (c->fc->nb_streams < 1)
  452.         return 0;
  453.     st = c->fc->streams[c->fc->nb_streams-1];
  454.     sc = st->priv_data;
  455.  
  456.     avio_rb32(pb); // version + flags
  457.     entries = avio_rb32(pb);
  458.     if (entries >  (atom.size - 1) / MIN_DATA_ENTRY_BOX_SIZE + 1 ||
  459.         entries >= UINT_MAX / sizeof(*sc->drefs))
  460.         return AVERROR_INVALIDDATA;
  461.     av_free(sc->drefs);
  462.     sc->drefs_count = 0;
  463.     sc->drefs = av_mallocz(entries * sizeof(*sc->drefs));
  464.     if (!sc->drefs)
  465.         return AVERROR(ENOMEM);
  466.     sc->drefs_count = entries;
  467.  
  468.     for (i = 0; i < sc->drefs_count; i++) {
  469.         MOVDref *dref = &sc->drefs[i];
  470.         uint32_t size = avio_rb32(pb);
  471.         int64_t next = avio_tell(pb) + size - 4;
  472.  
  473.         if (size < 12)
  474.             return AVERROR_INVALIDDATA;
  475.  
  476.         dref->type = avio_rl32(pb);
  477.         avio_rb32(pb); // version + flags
  478.         av_dlog(c->fc, "type %.4s size %d\n", (char*)&dref->type, size);
  479.  
  480.         if (dref->type == MKTAG('a','l','i','s') && size > 150) {
  481.             /* macintosh alias record */
  482.             uint16_t volume_len, len;
  483.             int16_t type;
  484.  
  485.             avio_skip(pb, 10);
  486.  
  487.             volume_len = avio_r8(pb);
  488.             volume_len = FFMIN(volume_len, 27);
  489.             avio_read(pb, dref->volume, 27);
  490.             dref->volume[volume_len] = 0;
  491.             av_log(c->fc, AV_LOG_DEBUG, "volume %s, len %d\n", dref->volume, volume_len);
  492.  
  493.             avio_skip(pb, 12);
  494.  
  495.             len = avio_r8(pb);
  496.             len = FFMIN(len, 63);
  497.             avio_read(pb, dref->filename, 63);
  498.             dref->filename[len] = 0;
  499.             av_log(c->fc, AV_LOG_DEBUG, "filename %s, len %d\n", dref->filename, len);
  500.  
  501.             avio_skip(pb, 16);
  502.  
  503.             /* read next level up_from_alias/down_to_target */
  504.             dref->nlvl_from = avio_rb16(pb);
  505.             dref->nlvl_to   = avio_rb16(pb);
  506.             av_log(c->fc, AV_LOG_DEBUG, "nlvl from %d, nlvl to %d\n",
  507.                    dref->nlvl_from, dref->nlvl_to);
  508.  
  509.             avio_skip(pb, 16);
  510.  
  511.             for (type = 0; type != -1 && avio_tell(pb) < next; ) {
  512.                 if(url_feof(pb))
  513.                     return AVERROR_EOF;
  514.                 type = avio_rb16(pb);
  515.                 len = avio_rb16(pb);
  516.                 av_log(c->fc, AV_LOG_DEBUG, "type %d, len %d\n", type, len);
  517.                 if (len&1)
  518.                     len += 1;
  519.                 if (type == 2) { // absolute path
  520.                     av_free(dref->path);
  521.                     dref->path = av_mallocz(len+1);
  522.                     if (!dref->path)
  523.                         return AVERROR(ENOMEM);
  524.                     avio_read(pb, dref->path, len);
  525.                     if (len > volume_len && !strncmp(dref->path, dref->volume, volume_len)) {
  526.                         len -= volume_len;
  527.                         memmove(dref->path, dref->path+volume_len, len);
  528.                         dref->path[len] = 0;
  529.                     }
  530.                     for (j = 0; j < len; j++)
  531.                         if (dref->path[j] == ':')
  532.                             dref->path[j] = '/';
  533.                     av_log(c->fc, AV_LOG_DEBUG, "path %s\n", dref->path);
  534.                 } else if (type == 0) { // directory name
  535.                     av_free(dref->dir);
  536.                     dref->dir = av_malloc(len+1);
  537.                     if (!dref->dir)
  538.                         return AVERROR(ENOMEM);
  539.                     avio_read(pb, dref->dir, len);
  540.                     dref->dir[len] = 0;
  541.                     for (j = 0; j < len; j++)
  542.                         if (dref->dir[j] == ':')
  543.                             dref->dir[j] = '/';
  544.                     av_log(c->fc, AV_LOG_DEBUG, "dir %s\n", dref->dir);
  545.                 } else
  546.                     avio_skip(pb, len);
  547.             }
  548.         }
  549.         avio_seek(pb, next, SEEK_SET);
  550.     }
  551.     return 0;
  552. }
  553.  
  554. static int mov_read_hdlr(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  555. {
  556.     AVStream *st;
  557.     uint32_t type;
  558.     uint32_t av_unused ctype;
  559.     int title_size;
  560.     char *title_str;
  561.  
  562.     if (c->fc->nb_streams < 1) // meta before first trak
  563.         return 0;
  564.  
  565.     st = c->fc->streams[c->fc->nb_streams-1];
  566.  
  567.     avio_r8(pb); /* version */
  568.     avio_rb24(pb); /* flags */
  569.  
  570.     /* component type */
  571.     ctype = avio_rl32(pb);
  572.     type = avio_rl32(pb); /* component subtype */
  573.  
  574.     av_dlog(c->fc, "ctype= %.4s (0x%08x)\n", (char*)&ctype, ctype);
  575.     av_dlog(c->fc, "stype= %.4s\n", (char*)&type);
  576.  
  577.     if     (type == MKTAG('v','i','d','e'))
  578.         st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
  579.     else if (type == MKTAG('s','o','u','n'))
  580.         st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
  581.     else if (type == MKTAG('m','1','a',' '))
  582.         st->codec->codec_id = AV_CODEC_ID_MP2;
  583.     else if ((type == MKTAG('s','u','b','p')) || (type == MKTAG('c','l','c','p')))
  584.         st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;
  585.  
  586.     avio_rb32(pb); /* component  manufacture */
  587.     avio_rb32(pb); /* component flags */
  588.     avio_rb32(pb); /* component flags mask */
  589.  
  590.     title_size = atom.size - 24;
  591.     if (title_size > 0) {
  592.         title_str = av_malloc(title_size + 1); /* Add null terminator */
  593.         if (!title_str)
  594.             return AVERROR(ENOMEM);
  595.         avio_read(pb, title_str, title_size);
  596.         title_str[title_size] = 0;
  597.         if (title_str[0])
  598.             av_dict_set(&st->metadata, "handler_name", title_str +
  599.                         (!c->isom && title_str[0] == title_size - 1), 0);
  600.         av_freep(&title_str);
  601.     }
  602.  
  603.     return 0;
  604. }
  605.  
  606. int ff_mov_read_esds(AVFormatContext *fc, AVIOContext *pb, MOVAtom atom)
  607. {
  608.     AVStream *st;
  609.     int tag;
  610.  
  611.     if (fc->nb_streams < 1)
  612.         return 0;
  613.     st = fc->streams[fc->nb_streams-1];
  614.  
  615.     avio_rb32(pb); /* version + flags */
  616.     ff_mp4_read_descr(fc, pb, &tag);
  617.     if (tag == MP4ESDescrTag) {
  618.         ff_mp4_parse_es_descr(pb, NULL);
  619.     } else
  620.         avio_rb16(pb); /* ID */
  621.  
  622.     ff_mp4_read_descr(fc, pb, &tag);
  623.     if (tag == MP4DecConfigDescrTag)
  624.         ff_mp4_read_dec_config_descr(fc, st, pb);
  625.     return 0;
  626. }
  627.  
  628. static int mov_read_esds(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  629. {
  630.     return ff_mov_read_esds(c->fc, pb, atom);
  631. }
  632.  
  633. static int mov_read_dac3(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  634. {
  635.     AVStream *st;
  636.     int ac3info, acmod, lfeon, bsmod;
  637.  
  638.     if (c->fc->nb_streams < 1)
  639.         return 0;
  640.     st = c->fc->streams[c->fc->nb_streams-1];
  641.  
  642.     ac3info = avio_rb24(pb);
  643.     bsmod = (ac3info >> 14) & 0x7;
  644.     acmod = (ac3info >> 11) & 0x7;
  645.     lfeon = (ac3info >> 10) & 0x1;
  646.     st->codec->channels = ((int[]){2,1,2,3,3,4,4,5})[acmod] + lfeon;
  647.     st->codec->channel_layout = avpriv_ac3_channel_layout_tab[acmod];
  648.     if (lfeon)
  649.         st->codec->channel_layout |= AV_CH_LOW_FREQUENCY;
  650.     st->codec->audio_service_type = bsmod;
  651.     if (st->codec->channels > 1 && bsmod == 0x7)
  652.         st->codec->audio_service_type = AV_AUDIO_SERVICE_TYPE_KARAOKE;
  653.  
  654.     return 0;
  655. }
  656.  
  657. static int mov_read_dec3(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  658. {
  659.     AVStream *st;
  660.     int eac3info, acmod, lfeon, bsmod;
  661.  
  662.     if (c->fc->nb_streams < 1)
  663.         return 0;
  664.     st = c->fc->streams[c->fc->nb_streams-1];
  665.  
  666.     /* No need to parse fields for additional independent substreams and its
  667.      * associated dependent substreams since libavcodec's E-AC-3 decoder
  668.      * does not support them yet. */
  669.     avio_rb16(pb); /* data_rate and num_ind_sub */
  670.     eac3info = avio_rb24(pb);
  671.     bsmod = (eac3info >> 12) & 0x1f;
  672.     acmod = (eac3info >>  9) & 0x7;
  673.     lfeon = (eac3info >>  8) & 0x1;
  674.     st->codec->channel_layout = avpriv_ac3_channel_layout_tab[acmod];
  675.     if (lfeon)
  676.         st->codec->channel_layout |= AV_CH_LOW_FREQUENCY;
  677.     st->codec->channels = av_get_channel_layout_nb_channels(st->codec->channel_layout);
  678.     st->codec->audio_service_type = bsmod;
  679.     if (st->codec->channels > 1 && bsmod == 0x7)
  680.         st->codec->audio_service_type = AV_AUDIO_SERVICE_TYPE_KARAOKE;
  681.  
  682.     return 0;
  683. }
  684.  
  685. static int mov_read_chan(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  686. {
  687.     AVStream *st;
  688.  
  689.     if (c->fc->nb_streams < 1)
  690.         return 0;
  691.     st = c->fc->streams[c->fc->nb_streams-1];
  692.  
  693.     if (atom.size < 16)
  694.         return 0;
  695.  
  696.     /* skip version and flags */
  697.     avio_skip(pb, 4);
  698.  
  699.     ff_mov_read_chan(c->fc, pb, st, atom.size - 4);
  700.  
  701.     return 0;
  702. }
  703.  
  704. static int mov_read_wfex(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  705. {
  706.     AVStream *st;
  707.  
  708.     if (c->fc->nb_streams < 1)
  709.         return 0;
  710.     st = c->fc->streams[c->fc->nb_streams-1];
  711.  
  712.     if (ff_get_wav_header(pb, st->codec, atom.size) < 0) {
  713.         av_log(c->fc, AV_LOG_WARNING, "get_wav_header failed\n");
  714.     }
  715.  
  716.     return 0;
  717. }
  718.  
  719. static int mov_read_pasp(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  720. {
  721.     const int num = avio_rb32(pb);
  722.     const int den = avio_rb32(pb);
  723.     AVStream *st;
  724.  
  725.     if (c->fc->nb_streams < 1)
  726.         return 0;
  727.     st = c->fc->streams[c->fc->nb_streams-1];
  728.  
  729.     if ((st->sample_aspect_ratio.den != 1 || st->sample_aspect_ratio.num) && // default
  730.         (den != st->sample_aspect_ratio.den || num != st->sample_aspect_ratio.num)) {
  731.         av_log(c->fc, AV_LOG_WARNING,
  732.                "sample aspect ratio already set to %d:%d, ignoring 'pasp' atom (%d:%d)\n",
  733.                st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
  734.                num, den);
  735.     } else if (den != 0) {
  736.         st->sample_aspect_ratio.num = num;
  737.         st->sample_aspect_ratio.den = den;
  738.     }
  739.     return 0;
  740. }
  741.  
  742. /* this atom contains actual media data */
  743. static int mov_read_mdat(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  744. {
  745.     if (atom.size == 0) /* wrong one (MP4) */
  746.         return 0;
  747.     c->found_mdat=1;
  748.     return 0; /* now go for moov */
  749. }
  750.  
  751. /* read major brand, minor version and compatible brands and store them as metadata */
  752. static int mov_read_ftyp(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  753. {
  754.     uint32_t minor_ver;
  755.     int comp_brand_size;
  756.     char minor_ver_str[11]; /* 32 bit integer -> 10 digits + null */
  757.     char* comp_brands_str;
  758.     uint8_t type[5] = {0};
  759.  
  760.     avio_read(pb, type, 4);
  761.     if (strcmp(type, "qt  "))
  762.         c->isom = 1;
  763.     av_log(c->fc, AV_LOG_DEBUG, "ISO: File Type Major Brand: %.4s\n",(char *)&type);
  764.     av_dict_set(&c->fc->metadata, "major_brand", type, 0);
  765.     minor_ver = avio_rb32(pb); /* minor version */
  766.     snprintf(minor_ver_str, sizeof(minor_ver_str), "%d", minor_ver);
  767.     av_dict_set(&c->fc->metadata, "minor_version", minor_ver_str, 0);
  768.  
  769.     comp_brand_size = atom.size - 8;
  770.     if (comp_brand_size < 0)
  771.         return AVERROR_INVALIDDATA;
  772.     comp_brands_str = av_malloc(comp_brand_size + 1); /* Add null terminator */
  773.     if (!comp_brands_str)
  774.         return AVERROR(ENOMEM);
  775.     avio_read(pb, comp_brands_str, comp_brand_size);
  776.     comp_brands_str[comp_brand_size] = 0;
  777.     av_dict_set(&c->fc->metadata, "compatible_brands", comp_brands_str, 0);
  778.     av_freep(&comp_brands_str);
  779.  
  780.     return 0;
  781. }
  782.  
  783. /* this atom should contain all header atoms */
  784. static int mov_read_moov(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  785. {
  786.     int ret;
  787.  
  788.     if (c->found_moov) {
  789.         av_log(c->fc, AV_LOG_WARNING, "Found duplicated MOOV Atom. Skipped it\n");
  790.         avio_skip(pb, atom.size);
  791.         return 0;
  792.     }
  793.  
  794.     if ((ret = mov_read_default(c, pb, atom)) < 0)
  795.         return ret;
  796.     /* we parsed the 'moov' atom, we can terminate the parsing as soon as we find the 'mdat' */
  797.     /* so we don't parse the whole file if over a network */
  798.     c->found_moov=1;
  799.     return 0; /* now go for mdat */
  800. }
  801.  
  802. static int mov_read_moof(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  803. {
  804.     c->fragment.moof_offset = avio_tell(pb) - 8;
  805.     av_dlog(c->fc, "moof offset %"PRIx64"\n", c->fragment.moof_offset);
  806.     return mov_read_default(c, pb, atom);
  807. }
  808.  
  809. static void mov_metadata_creation_time(AVDictionary **metadata, int64_t time)
  810. {
  811.     char buffer[32];
  812.     if (time) {
  813.         struct tm *ptm;
  814.         time_t timet;
  815.         if(time >= 2082844800)
  816.             time -= 2082844800;  /* seconds between 1904-01-01 and Epoch */
  817.         timet = time;
  818.         ptm = gmtime(&timet);
  819.         if (!ptm) return;
  820.         strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", ptm);
  821.         av_dict_set(metadata, "creation_time", buffer, 0);
  822.     }
  823. }
  824.  
  825. static int mov_read_mdhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  826. {
  827.     AVStream *st;
  828.     MOVStreamContext *sc;
  829.     int version;
  830.     char language[4] = {0};
  831.     unsigned lang;
  832.     int64_t creation_time;
  833.  
  834.     if (c->fc->nb_streams < 1)
  835.         return 0;
  836.     st = c->fc->streams[c->fc->nb_streams-1];
  837.     sc = st->priv_data;
  838.  
  839.     if (sc->time_scale) {
  840.         av_log(c->fc, AV_LOG_ERROR, "Multiple mdhd?\n");
  841.         return AVERROR_INVALIDDATA;
  842.     }
  843.  
  844.     version = avio_r8(pb);
  845.     if (version > 1) {
  846.         avpriv_request_sample(c->fc, "Version %d", version);
  847.         return AVERROR_PATCHWELCOME;
  848.     }
  849.     avio_rb24(pb); /* flags */
  850.     if (version == 1) {
  851.         creation_time = avio_rb64(pb);
  852.         avio_rb64(pb);
  853.     } else {
  854.         creation_time = avio_rb32(pb);
  855.         avio_rb32(pb); /* modification time */
  856.     }
  857.     mov_metadata_creation_time(&st->metadata, creation_time);
  858.  
  859.     sc->time_scale = avio_rb32(pb);
  860.     st->duration = (version == 1) ? avio_rb64(pb) : avio_rb32(pb); /* duration */
  861.  
  862.     lang = avio_rb16(pb); /* language */
  863.     if (ff_mov_lang_to_iso639(lang, language))
  864.         av_dict_set(&st->metadata, "language", language, 0);
  865.     avio_rb16(pb); /* quality */
  866.  
  867.     return 0;
  868. }
  869.  
  870. static int mov_read_mvhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  871. {
  872.     int64_t creation_time;
  873.     int version = avio_r8(pb); /* version */
  874.     avio_rb24(pb); /* flags */
  875.  
  876.     if (version == 1) {
  877.         creation_time = avio_rb64(pb);
  878.         avio_rb64(pb);
  879.     } else {
  880.         creation_time = avio_rb32(pb);
  881.         avio_rb32(pb); /* modification time */
  882.     }
  883.     mov_metadata_creation_time(&c->fc->metadata, creation_time);
  884.     c->time_scale = avio_rb32(pb); /* time scale */
  885.  
  886.     av_dlog(c->fc, "time scale = %i\n", c->time_scale);
  887.  
  888.     c->duration = (version == 1) ? avio_rb64(pb) : avio_rb32(pb); /* duration */
  889.     // set the AVCodecContext duration because the duration of individual tracks
  890.     // may be inaccurate
  891.     if (c->time_scale > 0 && !c->trex_data)
  892.         c->fc->duration = av_rescale(c->duration, AV_TIME_BASE, c->time_scale);
  893.     avio_rb32(pb); /* preferred scale */
  894.  
  895.     avio_rb16(pb); /* preferred volume */
  896.  
  897.     avio_skip(pb, 10); /* reserved */
  898.  
  899.     avio_skip(pb, 36); /* display matrix */
  900.  
  901.     avio_rb32(pb); /* preview time */
  902.     avio_rb32(pb); /* preview duration */
  903.     avio_rb32(pb); /* poster time */
  904.     avio_rb32(pb); /* selection time */
  905.     avio_rb32(pb); /* selection duration */
  906.     avio_rb32(pb); /* current time */
  907.     avio_rb32(pb); /* next track ID */
  908.     return 0;
  909. }
  910.  
  911. static int mov_read_enda(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  912. {
  913.     AVStream *st;
  914.     int little_endian;
  915.  
  916.     if (c->fc->nb_streams < 1)
  917.         return 0;
  918.     st = c->fc->streams[c->fc->nb_streams-1];
  919.  
  920.     little_endian = avio_rb16(pb) & 0xFF;
  921.     av_dlog(c->fc, "enda %d\n", little_endian);
  922.     if (little_endian == 1) {
  923.         switch (st->codec->codec_id) {
  924.         case AV_CODEC_ID_PCM_S24BE:
  925.             st->codec->codec_id = AV_CODEC_ID_PCM_S24LE;
  926.             break;
  927.         case AV_CODEC_ID_PCM_S32BE:
  928.             st->codec->codec_id = AV_CODEC_ID_PCM_S32LE;
  929.             break;
  930.         case AV_CODEC_ID_PCM_F32BE:
  931.             st->codec->codec_id = AV_CODEC_ID_PCM_F32LE;
  932.             break;
  933.         case AV_CODEC_ID_PCM_F64BE:
  934.             st->codec->codec_id = AV_CODEC_ID_PCM_F64LE;
  935.             break;
  936.         default:
  937.             break;
  938.         }
  939.     }
  940.     return 0;
  941. }
  942.  
  943. static int mov_read_fiel(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  944. {
  945.     AVStream *st;
  946.     unsigned mov_field_order;
  947.     enum AVFieldOrder decoded_field_order = AV_FIELD_UNKNOWN;
  948.  
  949.     if (c->fc->nb_streams < 1) // will happen with jp2 files
  950.         return 0;
  951.     st = c->fc->streams[c->fc->nb_streams-1];
  952.     if (atom.size < 2)
  953.         return AVERROR_INVALIDDATA;
  954.     mov_field_order = avio_rb16(pb);
  955.     if ((mov_field_order & 0xFF00) == 0x0100)
  956.         decoded_field_order = AV_FIELD_PROGRESSIVE;
  957.     else if ((mov_field_order & 0xFF00) == 0x0200) {
  958.         switch (mov_field_order & 0xFF) {
  959.         case 0x01: decoded_field_order = AV_FIELD_TT;
  960.                    break;
  961.         case 0x06: decoded_field_order = AV_FIELD_BB;
  962.                    break;
  963.         case 0x09: decoded_field_order = AV_FIELD_TB;
  964.                    break;
  965.         case 0x0E: decoded_field_order = AV_FIELD_BT;
  966.                    break;
  967.         }
  968.     }
  969.     if (decoded_field_order == AV_FIELD_UNKNOWN && mov_field_order) {
  970.         av_log(NULL, AV_LOG_ERROR, "Unknown MOV field order 0x%04x\n", mov_field_order);
  971.     }
  972.     st->codec->field_order = decoded_field_order;
  973.  
  974.     return 0;
  975. }
  976.  
  977. /* FIXME modify qdm2/svq3/h264 decoders to take full atom as extradata */
  978. static int mov_read_extradata(MOVContext *c, AVIOContext *pb, MOVAtom atom,
  979.                               enum AVCodecID codec_id)
  980. {
  981.     AVStream *st;
  982.     uint64_t size;
  983.     uint8_t *buf;
  984.     int err;
  985.  
  986.     if (c->fc->nb_streams < 1) // will happen with jp2 files
  987.         return 0;
  988.     st= c->fc->streams[c->fc->nb_streams-1];
  989.  
  990.     if (st->codec->codec_id != codec_id)
  991.         return 0; /* unexpected codec_id - don't mess with extradata */
  992.  
  993.     size= (uint64_t)st->codec->extradata_size + atom.size + 8 + FF_INPUT_BUFFER_PADDING_SIZE;
  994.     if (size > INT_MAX || (uint64_t)atom.size > INT_MAX)
  995.         return AVERROR_INVALIDDATA;
  996.     if ((err = av_reallocp(&st->codec->extradata, size)) < 0) {
  997.         st->codec->extradata_size = 0;
  998.         return err;
  999.     }
  1000.     buf = st->codec->extradata + st->codec->extradata_size;
  1001.     st->codec->extradata_size= size - FF_INPUT_BUFFER_PADDING_SIZE;
  1002.     AV_WB32(       buf    , atom.size + 8);
  1003.     AV_WL32(       buf + 4, atom.type);
  1004.     avio_read(pb, buf + 8, atom.size);
  1005.     return 0;
  1006. }
  1007.  
  1008. /* wrapper functions for reading ALAC/AVS/MJPEG/MJPEG2000 extradata atoms only for those codecs */
  1009. static int mov_read_alac(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  1010. {
  1011.     return mov_read_extradata(c, pb, atom, AV_CODEC_ID_ALAC);
  1012. }
  1013.  
  1014. static int mov_read_avss(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  1015. {
  1016.     return mov_read_extradata(c, pb, atom, AV_CODEC_ID_AVS);
  1017. }
  1018.  
  1019. static int mov_read_jp2h(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  1020. {
  1021.     return mov_read_extradata(c, pb, atom, AV_CODEC_ID_JPEG2000);
  1022. }
  1023.  
  1024. static int mov_read_avid(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  1025. {
  1026.     return mov_read_extradata(c, pb, atom, AV_CODEC_ID_AVUI);
  1027. }
  1028.  
  1029. static int mov_read_targa_y216(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  1030. {
  1031.     int ret = mov_read_extradata(c, pb, atom, AV_CODEC_ID_TARGA_Y216);
  1032.  
  1033.     if (!ret && c->fc->nb_streams >= 1) {
  1034.         AVCodecContext *avctx = c->fc->streams[c->fc->nb_streams-1]->codec;
  1035.         if (avctx->extradata_size >= 40) {
  1036.             avctx->height = AV_RB16(&avctx->extradata[36]);
  1037.             avctx->width  = AV_RB16(&avctx->extradata[38]);
  1038.         }
  1039.     }
  1040.     return ret;
  1041. }
  1042.  
  1043. static int mov_read_ares(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  1044. {
  1045.     AVCodecContext *codec = c->fc->streams[c->fc->nb_streams-1]->codec;
  1046.     if (codec->codec_tag == MKTAG('A', 'V', 'i', 'n') &&
  1047.         codec->codec_id == AV_CODEC_ID_H264 &&
  1048.         atom.size > 11) {
  1049.         avio_skip(pb, 10);
  1050.         /* For AVID AVCI50, force width of 1440 to be able to select the correct SPS and PPS */
  1051.         if (avio_rb16(pb) == 0xd4d)
  1052.             codec->width = 1440;
  1053.         return 0;
  1054.     }
  1055.  
  1056.     return mov_read_avid(c, pb, atom);
  1057. }
  1058.  
  1059. static int mov_read_svq3(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  1060. {
  1061.     return mov_read_extradata(c, pb, atom, AV_CODEC_ID_SVQ3);
  1062. }
  1063.  
  1064. static int mov_read_wave(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  1065. {
  1066.     AVStream *st;
  1067.  
  1068.     if (c->fc->nb_streams < 1)
  1069.         return 0;
  1070.     st = c->fc->streams[c->fc->nb_streams-1];
  1071.  
  1072.     if ((uint64_t)atom.size > (1<<30))
  1073.         return AVERROR_INVALIDDATA;
  1074.  
  1075.     if (st->codec->codec_id == AV_CODEC_ID_QDM2 ||
  1076.         st->codec->codec_id == AV_CODEC_ID_QDMC ||
  1077.         st->codec->codec_id == AV_CODEC_ID_SPEEX) {
  1078.         // pass all frma atom to codec, needed at least for QDMC and QDM2
  1079.         av_free(st->codec->extradata);
  1080.         if (ff_alloc_extradata(st->codec, atom.size))
  1081.             return AVERROR(ENOMEM);
  1082.         avio_read(pb, st->codec->extradata, atom.size);
  1083.     } else if (atom.size > 8) { /* to read frma, esds atoms */
  1084.         int ret;
  1085.         if ((ret = mov_read_default(c, pb, atom)) < 0)
  1086.             return ret;
  1087.     } else
  1088.         avio_skip(pb, atom.size);
  1089.     return 0;
  1090. }
  1091.  
  1092. /**
  1093.  * This function reads atom content and puts data in extradata without tag
  1094.  * nor size unlike mov_read_extradata.
  1095.  */
  1096. static int mov_read_glbl(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  1097. {
  1098.     AVStream *st;
  1099.  
  1100.     if (c->fc->nb_streams < 1)
  1101.         return 0;
  1102.     st = c->fc->streams[c->fc->nb_streams-1];
  1103.  
  1104.     if ((uint64_t)atom.size > (1<<30))
  1105.         return AVERROR_INVALIDDATA;
  1106.  
  1107.     if (atom.size >= 10) {
  1108.         // Broken files created by legacy versions of libavformat will
  1109.         // wrap a whole fiel atom inside of a glbl atom.
  1110.         unsigned size = avio_rb32(pb);
  1111.         unsigned type = avio_rl32(pb);
  1112.         avio_seek(pb, -8, SEEK_CUR);
  1113.         if (type == MKTAG('f','i','e','l') && size == atom.size)
  1114.             return mov_read_default(c, pb, atom);
  1115.     }
  1116.     av_free(st->codec->extradata);
  1117.     if (ff_alloc_extradata(st->codec, atom.size))
  1118.         return AVERROR(ENOMEM);
  1119.     avio_read(pb, st->codec->extradata, atom.size);
  1120.     return 0;
  1121. }
  1122.  
  1123. static int mov_read_dvc1(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  1124. {
  1125.     AVStream *st;
  1126.     uint8_t profile_level;
  1127.  
  1128.     if (c->fc->nb_streams < 1)
  1129.         return 0;
  1130.     st = c->fc->streams[c->fc->nb_streams-1];
  1131.  
  1132.     if (atom.size >= (1<<28) || atom.size < 7)
  1133.         return AVERROR_INVALIDDATA;
  1134.  
  1135.     profile_level = avio_r8(pb);
  1136.     if ((profile_level & 0xf0) != 0xc0)
  1137.         return 0;
  1138.  
  1139.     av_free(st->codec->extradata);
  1140.     if (ff_alloc_extradata(st->codec, atom.size - 7))
  1141.         return AVERROR(ENOMEM);
  1142.     avio_seek(pb, 6, SEEK_CUR);
  1143.     avio_read(pb, st->codec->extradata, st->codec->extradata_size);
  1144.     return 0;
  1145. }
  1146.  
  1147. /**
  1148.  * An strf atom is a BITMAPINFOHEADER struct. This struct is 40 bytes itself,
  1149.  * but can have extradata appended at the end after the 40 bytes belonging
  1150.  * to the struct.
  1151.  */
  1152. static int mov_read_strf(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  1153. {
  1154.     AVStream *st;
  1155.  
  1156.     if (c->fc->nb_streams < 1)
  1157.         return 0;
  1158.     if (atom.size <= 40)
  1159.         return 0;
  1160.     st = c->fc->streams[c->fc->nb_streams-1];
  1161.  
  1162.     if ((uint64_t)atom.size > (1<<30))
  1163.         return AVERROR_INVALIDDATA;
  1164.  
  1165.     av_free(st->codec->extradata);
  1166.     if (ff_alloc_extradata(st->codec, atom.size - 40))
  1167.         return AVERROR(ENOMEM);
  1168.     avio_skip(pb, 40);
  1169.     avio_read(pb, st->codec->extradata, atom.size - 40);
  1170.     return 0;
  1171. }
  1172.  
  1173. static int mov_read_stco(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  1174. {
  1175.     AVStream *st;
  1176.     MOVStreamContext *sc;
  1177.     unsigned int i, entries;
  1178.  
  1179.     if (c->fc->nb_streams < 1)
  1180.         return 0;
  1181.     st = c->fc->streams[c->fc->nb_streams-1];
  1182.     sc = st->priv_data;
  1183.  
  1184.     avio_r8(pb); /* version */
  1185.     avio_rb24(pb); /* flags */
  1186.  
  1187.     entries = avio_rb32(pb);
  1188.  
  1189.     if (!entries)
  1190.         return 0;
  1191.     if (entries >= UINT_MAX/sizeof(int64_t))
  1192.         return AVERROR_INVALIDDATA;
  1193.  
  1194.     sc->chunk_offsets = av_malloc(entries * sizeof(int64_t));
  1195.     if (!sc->chunk_offsets)
  1196.         return AVERROR(ENOMEM);
  1197.     sc->chunk_count = entries;
  1198.  
  1199.     if      (atom.type == MKTAG('s','t','c','o'))
  1200.         for (i = 0; i < entries && !pb->eof_reached; i++)
  1201.             sc->chunk_offsets[i] = avio_rb32(pb);
  1202.     else if (atom.type == MKTAG('c','o','6','4'))
  1203.         for (i = 0; i < entries && !pb->eof_reached; i++)
  1204.             sc->chunk_offsets[i] = avio_rb64(pb);
  1205.     else
  1206.         return AVERROR_INVALIDDATA;
  1207.  
  1208.     sc->chunk_count = i;
  1209.  
  1210.     if (pb->eof_reached)
  1211.         return AVERROR_EOF;
  1212.  
  1213.     return 0;
  1214. }
  1215.  
  1216. /**
  1217.  * Compute codec id for 'lpcm' tag.
  1218.  * See CoreAudioTypes and AudioStreamBasicDescription at Apple.
  1219.  */
  1220. enum AVCodecID ff_mov_get_lpcm_codec_id(int bps, int flags)
  1221. {
  1222.     /* lpcm flags:
  1223.      * 0x1 = float
  1224.      * 0x2 = big-endian
  1225.      * 0x4 = signed
  1226.      */
  1227.     return ff_get_pcm_codec_id(bps, flags & 1, flags & 2, flags & 4 ? -1 : 0);
  1228. }
  1229.  
  1230. static int mov_codec_id(AVStream *st, uint32_t format)
  1231. {
  1232.     int id = ff_codec_get_id(ff_codec_movaudio_tags, format);
  1233.  
  1234.     if (id <= 0 &&
  1235.         ((format & 0xFFFF) == 'm' + ('s' << 8) ||
  1236.          (format & 0xFFFF) == 'T' + ('S' << 8)))
  1237.         id = ff_codec_get_id(ff_codec_wav_tags, av_bswap32(format) & 0xFFFF);
  1238.  
  1239.     if (st->codec->codec_type != AVMEDIA_TYPE_VIDEO && id > 0) {
  1240.         st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
  1241.     } else if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO &&
  1242.                /* skip old asf mpeg4 tag */
  1243.                format && format != MKTAG('m','p','4','s')) {
  1244.         id = ff_codec_get_id(ff_codec_movvideo_tags, format);
  1245.         if (id <= 0)
  1246.             id = ff_codec_get_id(ff_codec_bmp_tags, format);
  1247.         if (id > 0)
  1248.             st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
  1249.         else if (st->codec->codec_type == AVMEDIA_TYPE_DATA ||
  1250.                     (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE &&
  1251.                     st->codec->codec_id == AV_CODEC_ID_NONE)) {
  1252.             id = ff_codec_get_id(ff_codec_movsubtitle_tags, format);
  1253.             if (id > 0)
  1254.                 st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;
  1255.         }
  1256.     }
  1257.  
  1258.     st->codec->codec_tag = format;
  1259.  
  1260.     return id;
  1261. }
  1262.  
  1263. static void mov_parse_stsd_video(MOVContext *c, AVIOContext *pb,
  1264.                                  AVStream *st, MOVStreamContext *sc)
  1265. {
  1266.     unsigned int color_depth, len, j;
  1267.     int color_greyscale;
  1268.     int color_table_id;
  1269.  
  1270.     avio_rb16(pb); /* version */
  1271.     avio_rb16(pb); /* revision level */
  1272.     avio_rb32(pb); /* vendor */
  1273.     avio_rb32(pb); /* temporal quality */
  1274.     avio_rb32(pb); /* spatial quality */
  1275.  
  1276.     st->codec->width  = avio_rb16(pb); /* width */
  1277.     st->codec->height = avio_rb16(pb); /* height */
  1278.  
  1279.     avio_rb32(pb); /* horiz resolution */
  1280.     avio_rb32(pb); /* vert resolution */
  1281.     avio_rb32(pb); /* data size, always 0 */
  1282.     avio_rb16(pb); /* frames per samples */
  1283.  
  1284.     len = avio_r8(pb); /* codec name, pascal string */
  1285.     if (len > 31)
  1286.         len = 31;
  1287.     mov_read_mac_string(c, pb, len, st->codec->codec_name, 32);
  1288.     if (len < 31)
  1289.         avio_skip(pb, 31 - len);
  1290.     /* codec_tag YV12 triggers an UV swap in rawdec.c */
  1291.     if (!memcmp(st->codec->codec_name, "Planar Y'CbCr 8-bit 4:2:0", 25)) {
  1292.         st->codec->codec_tag = MKTAG('I', '4', '2', '0');
  1293.         st->codec->width &= ~1;
  1294.         st->codec->height &= ~1;
  1295.     }
  1296.     /* Flash Media Server uses tag H263 with Sorenson Spark */
  1297.     if (st->codec->codec_tag == MKTAG('H','2','6','3') &&
  1298.         !memcmp(st->codec->codec_name, "Sorenson H263", 13))
  1299.         st->codec->codec_id = AV_CODEC_ID_FLV1;
  1300.  
  1301.     st->codec->bits_per_coded_sample = avio_rb16(pb); /* depth */
  1302.     color_table_id = avio_rb16(pb); /* colortable id */
  1303.     av_dlog(c->fc, "depth %d, ctab id %d\n",
  1304.             st->codec->bits_per_coded_sample, color_table_id);
  1305.     /* figure out the palette situation */
  1306.     color_depth     = st->codec->bits_per_coded_sample & 0x1F;
  1307.     color_greyscale = st->codec->bits_per_coded_sample & 0x20;
  1308.  
  1309.     /* if the depth is 2, 4, or 8 bpp, file is palettized */
  1310.     if ((color_depth == 2) || (color_depth == 4) || (color_depth == 8)) {
  1311.         /* for palette traversal */
  1312.         unsigned int color_start, color_count, color_end;
  1313.         unsigned char a, r, g, b;
  1314.  
  1315.         if (color_greyscale) {
  1316.             int color_index, color_dec;
  1317.             /* compute the greyscale palette */
  1318.             st->codec->bits_per_coded_sample = color_depth;
  1319.             color_count = 1 << color_depth;
  1320.             color_index = 255;
  1321.             color_dec   = 256 / (color_count - 1);
  1322.             for (j = 0; j < color_count; j++) {
  1323.                 if (st->codec->codec_id == AV_CODEC_ID_CINEPAK){
  1324.                     r = g = b = color_count - 1 - color_index;
  1325.                 } else
  1326.                 r = g = b = color_index;
  1327.                 sc->palette[j] = (0xFFU << 24) | (r << 16) | (g << 8) | (b);
  1328.                 color_index -= color_dec;
  1329.                 if (color_index < 0)
  1330.                     color_index = 0;
  1331.             }
  1332.         } else if (color_table_id) {
  1333.             const uint8_t *color_table;
  1334.             /* if flag bit 3 is set, use the default palette */
  1335.             color_count = 1 << color_depth;
  1336.             if (color_depth == 2)
  1337.                 color_table = ff_qt_default_palette_4;
  1338.             else if (color_depth == 4)
  1339.                 color_table = ff_qt_default_palette_16;
  1340.             else
  1341.                 color_table = ff_qt_default_palette_256;
  1342.  
  1343.             for (j = 0; j < color_count; j++) {
  1344.                 r = color_table[j * 3 + 0];
  1345.                 g = color_table[j * 3 + 1];
  1346.                 b = color_table[j * 3 + 2];
  1347.                 sc->palette[j] = (0xFFU << 24) | (r << 16) | (g << 8) | (b);
  1348.             }
  1349.         } else {
  1350.             /* load the palette from the file */
  1351.             color_start = avio_rb32(pb);
  1352.             color_count = avio_rb16(pb);
  1353.             color_end   = avio_rb16(pb);
  1354.             if ((color_start <= 255) && (color_end <= 255)) {
  1355.                 for (j = color_start; j <= color_end; j++) {
  1356.                     /* each A, R, G, or B component is 16 bits;
  1357.                         * only use the top 8 bits */
  1358.                     a = avio_r8(pb);
  1359.                     avio_r8(pb);
  1360.                     r = avio_r8(pb);
  1361.                     avio_r8(pb);
  1362.                     g = avio_r8(pb);
  1363.                     avio_r8(pb);
  1364.                     b = avio_r8(pb);
  1365.                     avio_r8(pb);
  1366.                     sc->palette[j] = (a << 24 ) | (r << 16) | (g << 8) | (b);
  1367.                 }
  1368.             }
  1369.         }
  1370.         sc->has_palette = 1;
  1371.     }
  1372. }
  1373.  
  1374. static void mov_parse_stsd_audio(MOVContext *c, AVIOContext *pb,
  1375.                                  AVStream *st, MOVStreamContext *sc)
  1376. {
  1377.     int bits_per_sample, flags;
  1378.     uint16_t version = avio_rb16(pb);
  1379.     AVDictionaryEntry *compatible_brands = av_dict_get(c->fc->metadata, "compatible_brands", NULL, AV_DICT_MATCH_CASE);
  1380.  
  1381.     avio_rb16(pb); /* revision level */
  1382.     avio_rb32(pb); /* vendor */
  1383.  
  1384.     st->codec->channels              = avio_rb16(pb); /* channel count */
  1385.     st->codec->bits_per_coded_sample = avio_rb16(pb); /* sample size */
  1386.     av_dlog(c->fc, "audio channels %d\n", st->codec->channels);
  1387.  
  1388.     sc->audio_cid = avio_rb16(pb);
  1389.     avio_rb16(pb); /* packet size = 0 */
  1390.  
  1391.     st->codec->sample_rate = ((avio_rb32(pb) >> 16));
  1392.  
  1393.     // Read QT version 1 fields. In version 0 these do not exist.
  1394.     av_dlog(c->fc, "version =%d, isom =%d\n", version, c->isom);
  1395.     if (!c->isom ||
  1396.         (compatible_brands && strstr(compatible_brands->value, "qt  "))) {
  1397.  
  1398.         if (version == 1) {
  1399.             sc->samples_per_frame = avio_rb32(pb);
  1400.             avio_rb32(pb); /* bytes per packet */
  1401.             sc->bytes_per_frame = avio_rb32(pb);
  1402.             avio_rb32(pb); /* bytes per sample */
  1403.         } else if (version == 2) {
  1404.             avio_rb32(pb); /* sizeof struct only */
  1405.             st->codec->sample_rate = av_int2double(avio_rb64(pb));
  1406.             st->codec->channels    = avio_rb32(pb);
  1407.             avio_rb32(pb); /* always 0x7F000000 */
  1408.             st->codec->bits_per_coded_sample = avio_rb32(pb);
  1409.  
  1410.             flags = avio_rb32(pb); /* lpcm format specific flag */
  1411.             sc->bytes_per_frame   = avio_rb32(pb);
  1412.             sc->samples_per_frame = avio_rb32(pb);
  1413.             if (st->codec->codec_tag == MKTAG('l','p','c','m'))
  1414.                 st->codec->codec_id =
  1415.                     ff_mov_get_lpcm_codec_id(st->codec->bits_per_coded_sample,
  1416.                                              flags);
  1417.         }
  1418.     }
  1419.  
  1420.     switch (st->codec->codec_id) {
  1421.     case AV_CODEC_ID_PCM_S8:
  1422.     case AV_CODEC_ID_PCM_U8:
  1423.         if (st->codec->bits_per_coded_sample == 16)
  1424.             st->codec->codec_id = AV_CODEC_ID_PCM_S16BE;
  1425.         break;
  1426.     case AV_CODEC_ID_PCM_S16LE:
  1427.     case AV_CODEC_ID_PCM_S16BE:
  1428.         if (st->codec->bits_per_coded_sample == 8)
  1429.             st->codec->codec_id = AV_CODEC_ID_PCM_S8;
  1430.         else if (st->codec->bits_per_coded_sample == 24)
  1431.             st->codec->codec_id =
  1432.                 st->codec->codec_id == AV_CODEC_ID_PCM_S16BE ?
  1433.                 AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
  1434.         break;
  1435.     /* set values for old format before stsd version 1 appeared */
  1436.     case AV_CODEC_ID_MACE3:
  1437.         sc->samples_per_frame = 6;
  1438.         sc->bytes_per_frame   = 2 * st->codec->channels;
  1439.         break;
  1440.     case AV_CODEC_ID_MACE6:
  1441.         sc->samples_per_frame = 6;
  1442.         sc->bytes_per_frame   = 1 * st->codec->channels;
  1443.         break;
  1444.     case AV_CODEC_ID_ADPCM_IMA_QT:
  1445.         sc->samples_per_frame = 64;
  1446.         sc->bytes_per_frame   = 34 * st->codec->channels;
  1447.         break;
  1448.     case AV_CODEC_ID_GSM:
  1449.         sc->samples_per_frame = 160;
  1450.         sc->bytes_per_frame   = 33;
  1451.         break;
  1452.     default:
  1453.         break;
  1454.     }
  1455.  
  1456.     bits_per_sample = av_get_bits_per_sample(st->codec->codec_id);
  1457.     if (bits_per_sample) {
  1458.         st->codec->bits_per_coded_sample = bits_per_sample;
  1459.         sc->sample_size = (bits_per_sample >> 3) * st->codec->channels;
  1460.     }
  1461. }
  1462.  
  1463. static void mov_parse_stsd_subtitle(MOVContext *c, AVIOContext *pb,
  1464.                                     AVStream *st, MOVStreamContext *sc,
  1465.                                     int size)
  1466. {
  1467.     // ttxt stsd contains display flags, justification, background
  1468.     // color, fonts, and default styles, so fake an atom to read it
  1469.     MOVAtom fake_atom = { .size = size };
  1470.     // mp4s contains a regular esds atom
  1471.     if (st->codec->codec_tag != AV_RL32("mp4s"))
  1472.         mov_read_glbl(c, pb, fake_atom);
  1473.     st->codec->width  = sc->width;
  1474.     st->codec->height = sc->height;
  1475. }
  1476.  
  1477. static int mov_parse_stsd_data(MOVContext *c, AVIOContext *pb,
  1478.                                 AVStream *st, MOVStreamContext *sc,
  1479.                                 int size)
  1480. {
  1481.     if (st->codec->codec_tag == MKTAG('t','m','c','d')) {
  1482.         if (ff_alloc_extradata(st->codec, size))
  1483.             return AVERROR(ENOMEM);
  1484.         avio_read(pb, st->codec->extradata, size);
  1485.         if (size > 16) {
  1486.             MOVStreamContext *tmcd_ctx = st->priv_data;
  1487.             int val;
  1488.             val = AV_RB32(st->codec->extradata + 4);
  1489.             tmcd_ctx->tmcd_flags = val;
  1490.             if (val & 1)
  1491.                 st->codec->flags2 |= CODEC_FLAG2_DROP_FRAME_TIMECODE;
  1492.             st->codec->time_base.den = st->codec->extradata[16]; /* number of frame */
  1493.             st->codec->time_base.num = 1;
  1494.         }
  1495.     } else {
  1496.         /* other codec type, just skip (rtp, mp4s ...) */
  1497.         avio_skip(pb, size);
  1498.     }
  1499.     return 0;
  1500. }
  1501.  
  1502. static int mov_finalize_stsd_codec(MOVContext *c, AVIOContext *pb,
  1503.                                    AVStream *st, MOVStreamContext *sc)
  1504. {
  1505.     if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
  1506.         !st->codec->sample_rate && sc->time_scale > 1)
  1507.         st->codec->sample_rate = sc->time_scale;
  1508.  
  1509.     /* special codec parameters handling */
  1510.     switch (st->codec->codec_id) {
  1511. #if CONFIG_DV_DEMUXER
  1512.     case AV_CODEC_ID_DVAUDIO:
  1513.         c->dv_fctx  = avformat_alloc_context();
  1514.         c->dv_demux = avpriv_dv_init_demux(c->dv_fctx);
  1515.         if (!c->dv_demux) {
  1516.             av_log(c->fc, AV_LOG_ERROR, "dv demux context init error\n");
  1517.             return AVERROR(ENOMEM);
  1518.         }
  1519.         sc->dv_audio_container = 1;
  1520.         st->codec->codec_id    = AV_CODEC_ID_PCM_S16LE;
  1521.         break;
  1522. #endif
  1523.     /* no ifdef since parameters are always those */
  1524.     case AV_CODEC_ID_QCELP:
  1525.         st->codec->channels = 1;
  1526.         // force sample rate for qcelp when not stored in mov
  1527.         if (st->codec->codec_tag != MKTAG('Q','c','l','p'))
  1528.             st->codec->sample_rate = 8000;
  1529.         break;
  1530.     case AV_CODEC_ID_AMR_NB:
  1531.         st->codec->channels    = 1;
  1532.         /* force sample rate for amr, stsd in 3gp does not store sample rate */
  1533.         st->codec->sample_rate = 8000;
  1534.         break;
  1535.     case AV_CODEC_ID_AMR_WB:
  1536.         st->codec->channels    = 1;
  1537.         st->codec->sample_rate = 16000;
  1538.         break;
  1539.     case AV_CODEC_ID_MP2:
  1540.     case AV_CODEC_ID_MP3:
  1541.         /* force type after stsd for m1a hdlr */
  1542.         st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
  1543.         st->need_parsing      = AVSTREAM_PARSE_FULL;
  1544.         break;
  1545.     case AV_CODEC_ID_GSM:
  1546.     case AV_CODEC_ID_ADPCM_MS:
  1547.     case AV_CODEC_ID_ADPCM_IMA_WAV:
  1548.     case AV_CODEC_ID_ILBC:
  1549.     case AV_CODEC_ID_MACE3:
  1550.     case AV_CODEC_ID_MACE6:
  1551.     case AV_CODEC_ID_QDM2:
  1552.         st->codec->block_align = sc->bytes_per_frame;
  1553.         break;
  1554.     case AV_CODEC_ID_ALAC:
  1555.         if (st->codec->extradata_size == 36) {
  1556.             st->codec->channels    = AV_RB8 (st->codec->extradata + 21);
  1557.             st->codec->sample_rate = AV_RB32(st->codec->extradata + 32);
  1558.         }
  1559.         break;
  1560.     case AV_CODEC_ID_AC3:
  1561.         st->need_parsing = AVSTREAM_PARSE_FULL;
  1562.         break;
  1563.     case AV_CODEC_ID_MPEG1VIDEO:
  1564.         st->need_parsing = AVSTREAM_PARSE_FULL;
  1565.         break;
  1566.     case AV_CODEC_ID_VC1:
  1567.         st->need_parsing = AVSTREAM_PARSE_FULL;
  1568.         break;
  1569.     default:
  1570.         break;
  1571.     }
  1572.     return 0;
  1573. }
  1574.  
  1575. static int mov_skip_multiple_stsd(MOVContext *c, AVIOContext *pb,
  1576.                                   int codec_tag, int format,
  1577.                                   int size)
  1578. {
  1579.     int video_codec_id = ff_codec_get_id(ff_codec_movvideo_tags, format);
  1580.  
  1581.     if (codec_tag &&
  1582.          (codec_tag != format &&
  1583.           (c->fc->video_codec_id ? video_codec_id != c->fc->video_codec_id
  1584.                                  : codec_tag != MKTAG('j','p','e','g')))) {
  1585.         /* Multiple fourcc, we skip JPEG. This is not correct, we should
  1586.          * export it as a separate AVStream but this needs a few changes
  1587.          * in the MOV demuxer, patch welcome. */
  1588.  
  1589.         av_log(c->fc, AV_LOG_WARNING, "multiple fourcc not supported\n");
  1590.         avio_skip(pb, size);
  1591.         return 1;
  1592.     }
  1593.     if ( codec_tag == AV_RL32("avc1") ||
  1594.          codec_tag == AV_RL32("hvc1") ||
  1595.          codec_tag == AV_RL32("hev1")
  1596.     )
  1597.         av_log(c->fc, AV_LOG_WARNING, "Concatenated H.264 or H.265 might not play correctly.\n");
  1598.  
  1599.     return 0;
  1600. }
  1601.  
  1602. int ff_mov_read_stsd_entries(MOVContext *c, AVIOContext *pb, int entries)
  1603. {
  1604.     AVStream *st;
  1605.     MOVStreamContext *sc;
  1606.     int pseudo_stream_id;
  1607.  
  1608.     if (c->fc->nb_streams < 1)
  1609.         return 0;
  1610.     st = c->fc->streams[c->fc->nb_streams-1];
  1611.     sc = st->priv_data;
  1612.  
  1613.     for (pseudo_stream_id = 0;
  1614.          pseudo_stream_id < entries && !pb->eof_reached;
  1615.          pseudo_stream_id++) {
  1616.         //Parsing Sample description table
  1617.         enum AVCodecID id;
  1618.         int ret, dref_id = 1;
  1619.         MOVAtom a = { AV_RL32("stsd") };
  1620.         int64_t start_pos = avio_tell(pb);
  1621.         int64_t size = avio_rb32(pb); /* size */
  1622.         uint32_t format = avio_rl32(pb); /* data format */
  1623.  
  1624.         if (size >= 16) {
  1625.             avio_rb32(pb); /* reserved */
  1626.             avio_rb16(pb); /* reserved */
  1627.             dref_id = avio_rb16(pb);
  1628.         }else if (size <= 7){
  1629.             av_log(c->fc, AV_LOG_ERROR, "invalid size %"PRId64" in stsd\n", size);
  1630.             return AVERROR_INVALIDDATA;
  1631.         }
  1632.  
  1633.         if (mov_skip_multiple_stsd(c, pb, st->codec->codec_tag, format,
  1634.                                    size - (avio_tell(pb) - start_pos)))
  1635.             continue;
  1636.  
  1637.         sc->pseudo_stream_id = st->codec->codec_tag ? -1 : pseudo_stream_id;
  1638.         sc->dref_id= dref_id;
  1639.  
  1640.         id = mov_codec_id(st, format);
  1641.  
  1642.         av_dlog(c->fc, "size=%"PRId64" 4CC= %c%c%c%c codec_type=%d\n", size,
  1643.                 (format >> 0) & 0xff, (format >> 8) & 0xff, (format >> 16) & 0xff,
  1644.                 (format >> 24) & 0xff, st->codec->codec_type);
  1645.  
  1646.         if (st->codec->codec_type==AVMEDIA_TYPE_VIDEO) {
  1647.             st->codec->codec_id = id;
  1648.             mov_parse_stsd_video(c, pb, st, sc);
  1649.         } else if (st->codec->codec_type==AVMEDIA_TYPE_AUDIO) {
  1650.             st->codec->codec_id = id;
  1651.             mov_parse_stsd_audio(c, pb, st, sc);
  1652.         } else if (st->codec->codec_type==AVMEDIA_TYPE_SUBTITLE){
  1653.             st->codec->codec_id = id;
  1654.             mov_parse_stsd_subtitle(c, pb, st, sc,
  1655.                                     size - (avio_tell(pb) - start_pos));
  1656.         } else {
  1657.             ret = mov_parse_stsd_data(c, pb, st, sc,
  1658.                                       size - (avio_tell(pb) - start_pos));
  1659.             if (ret < 0)
  1660.                 return ret;
  1661.         }
  1662.         /* this will read extra atoms at the end (wave, alac, damr, avcC, hvcC, SMI ...) */
  1663.         a.size = size - (avio_tell(pb) - start_pos);
  1664.         if (a.size > 8) {
  1665.             if ((ret = mov_read_default(c, pb, a)) < 0)
  1666.                 return ret;
  1667.         } else if (a.size > 0)
  1668.             avio_skip(pb, a.size);
  1669.     }
  1670.  
  1671.     if (pb->eof_reached)
  1672.         return AVERROR_EOF;
  1673.  
  1674.     return mov_finalize_stsd_codec(c, pb, st, sc);
  1675. }
  1676.  
  1677. static int mov_read_stsd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  1678. {
  1679.     int entries;
  1680.  
  1681.     avio_r8(pb); /* version */
  1682.     avio_rb24(pb); /* flags */
  1683.     entries = avio_rb32(pb);
  1684.  
  1685.     return ff_mov_read_stsd_entries(c, pb, entries);
  1686. }
  1687.  
  1688. static int mov_read_stsc(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  1689. {
  1690.     AVStream *st;
  1691.     MOVStreamContext *sc;
  1692.     unsigned int i, entries;
  1693.  
  1694.     if (c->fc->nb_streams < 1)
  1695.         return 0;
  1696.     st = c->fc->streams[c->fc->nb_streams-1];
  1697.     sc = st->priv_data;
  1698.  
  1699.     avio_r8(pb); /* version */
  1700.     avio_rb24(pb); /* flags */
  1701.  
  1702.     entries = avio_rb32(pb);
  1703.  
  1704.     av_dlog(c->fc, "track[%i].stsc.entries = %i\n", c->fc->nb_streams-1, entries);
  1705.  
  1706.     if (!entries)
  1707.         return 0;
  1708.     if (entries >= UINT_MAX / sizeof(*sc->stsc_data))
  1709.         return AVERROR_INVALIDDATA;
  1710.     sc->stsc_data = av_malloc(entries * sizeof(*sc->stsc_data));
  1711.     if (!sc->stsc_data)
  1712.         return AVERROR(ENOMEM);
  1713.  
  1714.     for (i = 0; i < entries && !pb->eof_reached; i++) {
  1715.         sc->stsc_data[i].first = avio_rb32(pb);
  1716.         sc->stsc_data[i].count = avio_rb32(pb);
  1717.         sc->stsc_data[i].id = avio_rb32(pb);
  1718.     }
  1719.  
  1720.     sc->stsc_count = i;
  1721.  
  1722.     if (pb->eof_reached)
  1723.         return AVERROR_EOF;
  1724.  
  1725.     return 0;
  1726. }
  1727.  
  1728. static int mov_read_stps(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  1729. {
  1730.     AVStream *st;
  1731.     MOVStreamContext *sc;
  1732.     unsigned i, entries;
  1733.  
  1734.     if (c->fc->nb_streams < 1)
  1735.         return 0;
  1736.     st = c->fc->streams[c->fc->nb_streams-1];
  1737.     sc = st->priv_data;
  1738.  
  1739.     avio_rb32(pb); // version + flags
  1740.  
  1741.     entries = avio_rb32(pb);
  1742.     if (entries >= UINT_MAX / sizeof(*sc->stps_data))
  1743.         return AVERROR_INVALIDDATA;
  1744.     sc->stps_data = av_malloc(entries * sizeof(*sc->stps_data));
  1745.     if (!sc->stps_data)
  1746.         return AVERROR(ENOMEM);
  1747.  
  1748.     for (i = 0; i < entries && !pb->eof_reached; i++) {
  1749.         sc->stps_data[i] = avio_rb32(pb);
  1750.         //av_dlog(c->fc, "stps %d\n", sc->stps_data[i]);
  1751.     }
  1752.  
  1753.     sc->stps_count = i;
  1754.  
  1755.     if (pb->eof_reached)
  1756.         return AVERROR_EOF;
  1757.  
  1758.     return 0;
  1759. }
  1760.  
  1761. static int mov_read_stss(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  1762. {
  1763.     AVStream *st;
  1764.     MOVStreamContext *sc;
  1765.     unsigned int i, entries;
  1766.  
  1767.     if (c->fc->nb_streams < 1)
  1768.         return 0;
  1769.     st = c->fc->streams[c->fc->nb_streams-1];
  1770.     sc = st->priv_data;
  1771.  
  1772.     avio_r8(pb); /* version */
  1773.     avio_rb24(pb); /* flags */
  1774.  
  1775.     entries = avio_rb32(pb);
  1776.  
  1777.     av_dlog(c->fc, "keyframe_count = %d\n", entries);
  1778.  
  1779.     if (!entries)
  1780.     {
  1781.         sc->keyframe_absent = 1;
  1782.         if (!st->need_parsing)
  1783.             st->need_parsing = AVSTREAM_PARSE_HEADERS;
  1784.         return 0;
  1785.     }
  1786.     if (entries >= UINT_MAX / sizeof(int))
  1787.         return AVERROR_INVALIDDATA;
  1788.     sc->keyframes = av_malloc(entries * sizeof(int));
  1789.     if (!sc->keyframes)
  1790.         return AVERROR(ENOMEM);
  1791.  
  1792.     for (i = 0; i < entries && !pb->eof_reached; i++) {
  1793.         sc->keyframes[i] = avio_rb32(pb);
  1794.         //av_dlog(c->fc, "keyframes[]=%d\n", sc->keyframes[i]);
  1795.     }
  1796.  
  1797.     sc->keyframe_count = i;
  1798.  
  1799.     if (pb->eof_reached)
  1800.         return AVERROR_EOF;
  1801.  
  1802.     return 0;
  1803. }
  1804.  
  1805. static int mov_read_stsz(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  1806. {
  1807.     AVStream *st;
  1808.     MOVStreamContext *sc;
  1809.     unsigned int i, entries, sample_size, field_size, num_bytes;
  1810.     GetBitContext gb;
  1811.     unsigned char* buf;
  1812.  
  1813.     if (c->fc->nb_streams < 1)
  1814.         return 0;
  1815.     st = c->fc->streams[c->fc->nb_streams-1];
  1816.     sc = st->priv_data;
  1817.  
  1818.     avio_r8(pb); /* version */
  1819.     avio_rb24(pb); /* flags */
  1820.  
  1821.     if (atom.type == MKTAG('s','t','s','z')) {
  1822.         sample_size = avio_rb32(pb);
  1823.         if (!sc->sample_size) /* do not overwrite value computed in stsd */
  1824.             sc->sample_size = sample_size;
  1825.         sc->stsz_sample_size = sample_size;
  1826.         field_size = 32;
  1827.     } else {
  1828.         sample_size = 0;
  1829.         avio_rb24(pb); /* reserved */
  1830.         field_size = avio_r8(pb);
  1831.     }
  1832.     entries = avio_rb32(pb);
  1833.  
  1834.     av_dlog(c->fc, "sample_size = %d sample_count = %d\n", sc->sample_size, entries);
  1835.  
  1836.     sc->sample_count = entries;
  1837.     if (sample_size)
  1838.         return 0;
  1839.  
  1840.     if (field_size != 4 && field_size != 8 && field_size != 16 && field_size != 32) {
  1841.         av_log(c->fc, AV_LOG_ERROR, "Invalid sample field size %d\n", field_size);
  1842.         return AVERROR_INVALIDDATA;
  1843.     }
  1844.  
  1845.     if (!entries)
  1846.         return 0;
  1847.     if (entries >= UINT_MAX / sizeof(int) || entries >= (UINT_MAX - 4) / field_size)
  1848.         return AVERROR_INVALIDDATA;
  1849.     sc->sample_sizes = av_malloc(entries * sizeof(int));
  1850.     if (!sc->sample_sizes)
  1851.         return AVERROR(ENOMEM);
  1852.  
  1853.     num_bytes = (entries*field_size+4)>>3;
  1854.  
  1855.     buf = av_malloc(num_bytes+FF_INPUT_BUFFER_PADDING_SIZE);
  1856.     if (!buf) {
  1857.         av_freep(&sc->sample_sizes);
  1858.         return AVERROR(ENOMEM);
  1859.     }
  1860.  
  1861.     if (avio_read(pb, buf, num_bytes) < num_bytes) {
  1862.         av_freep(&sc->sample_sizes);
  1863.         av_free(buf);
  1864.         return AVERROR_INVALIDDATA;
  1865.     }
  1866.  
  1867.     init_get_bits(&gb, buf, 8*num_bytes);
  1868.  
  1869.     for (i = 0; i < entries && !pb->eof_reached; i++) {
  1870.         sc->sample_sizes[i] = get_bits_long(&gb, field_size);
  1871.         sc->data_size += sc->sample_sizes[i];
  1872.     }
  1873.  
  1874.     sc->sample_count = i;
  1875.  
  1876.     if (pb->eof_reached)
  1877.         return AVERROR_EOF;
  1878.  
  1879.     av_free(buf);
  1880.     return 0;
  1881. }
  1882.  
  1883. static int mov_read_stts(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  1884. {
  1885.     AVStream *st;
  1886.     MOVStreamContext *sc;
  1887.     unsigned int i, entries;
  1888.     int64_t duration=0;
  1889.     int64_t total_sample_count=0;
  1890.  
  1891.     if (c->fc->nb_streams < 1)
  1892.         return 0;
  1893.     st = c->fc->streams[c->fc->nb_streams-1];
  1894.     sc = st->priv_data;
  1895.  
  1896.     avio_r8(pb); /* version */
  1897.     avio_rb24(pb); /* flags */
  1898.     entries = avio_rb32(pb);
  1899.  
  1900.     av_dlog(c->fc, "track[%i].stts.entries = %i\n",
  1901.             c->fc->nb_streams-1, entries);
  1902.  
  1903.     if (entries >= UINT_MAX / sizeof(*sc->stts_data))
  1904.         return -1;
  1905.  
  1906.     sc->stts_data = av_malloc(entries * sizeof(*sc->stts_data));
  1907.     if (!sc->stts_data)
  1908.         return AVERROR(ENOMEM);
  1909.  
  1910.     for (i = 0; i < entries && !pb->eof_reached; i++) {
  1911.         int sample_duration;
  1912.         int sample_count;
  1913.  
  1914.         sample_count=avio_rb32(pb);
  1915.         sample_duration = avio_rb32(pb);
  1916.  
  1917.         /* sample_duration < 0 is invalid based on the spec */
  1918.         if (sample_duration < 0) {
  1919.             av_log(c->fc, AV_LOG_ERROR, "Invalid SampleDelta in STTS %d\n", sample_duration);
  1920.             sample_duration = 1;
  1921.         }
  1922.         if (sample_count < 0) {
  1923.             av_log(c->fc, AV_LOG_ERROR, "Invalid sample_count=%d\n", sample_count);
  1924.             return AVERROR_INVALIDDATA;
  1925.         }
  1926.         sc->stts_data[i].count= sample_count;
  1927.         sc->stts_data[i].duration= sample_duration;
  1928.  
  1929.         av_dlog(c->fc, "sample_count=%d, sample_duration=%d\n",
  1930.                 sample_count, sample_duration);
  1931.  
  1932.         duration+=(int64_t)sample_duration*sample_count;
  1933.         total_sample_count+=sample_count;
  1934.     }
  1935.  
  1936.     sc->stts_count = i;
  1937.  
  1938.     if (pb->eof_reached)
  1939.         return AVERROR_EOF;
  1940.  
  1941.     st->nb_frames= total_sample_count;
  1942.     if (duration)
  1943.         st->duration= duration;
  1944.     sc->track_end = duration;
  1945.     return 0;
  1946. }
  1947.  
  1948. static void mov_update_dts_shift(MOVStreamContext *sc, int duration)
  1949. {
  1950.     if (duration < 0) {
  1951.         sc->dts_shift = FFMAX(sc->dts_shift, -duration);
  1952.     }
  1953. }
  1954.  
  1955. static int mov_read_ctts(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  1956. {
  1957.     AVStream *st;
  1958.     MOVStreamContext *sc;
  1959.     unsigned int i, entries;
  1960.  
  1961.     if (c->fc->nb_streams < 1)
  1962.         return 0;
  1963.     st = c->fc->streams[c->fc->nb_streams-1];
  1964.     sc = st->priv_data;
  1965.  
  1966.     avio_r8(pb); /* version */
  1967.     avio_rb24(pb); /* flags */
  1968.     entries = avio_rb32(pb);
  1969.  
  1970.     av_dlog(c->fc, "track[%i].ctts.entries = %i\n", c->fc->nb_streams-1, entries);
  1971.  
  1972.     if (!entries)
  1973.         return 0;
  1974.     if (entries >= UINT_MAX / sizeof(*sc->ctts_data))
  1975.         return AVERROR_INVALIDDATA;
  1976.     sc->ctts_data = av_malloc(entries * sizeof(*sc->ctts_data));
  1977.     if (!sc->ctts_data)
  1978.         return AVERROR(ENOMEM);
  1979.  
  1980.     for (i = 0; i < entries && !pb->eof_reached; i++) {
  1981.         int count    =avio_rb32(pb);
  1982.         int duration =avio_rb32(pb);
  1983.  
  1984.         sc->ctts_data[i].count   = count;
  1985.         sc->ctts_data[i].duration= duration;
  1986.  
  1987.         av_dlog(c->fc, "count=%d, duration=%d\n",
  1988.                 count, duration);
  1989.  
  1990.         if (FFABS(duration) > (1<<28) && i+2<entries) {
  1991.             av_log(c->fc, AV_LOG_WARNING, "CTTS invalid\n");
  1992.             av_freep(&sc->ctts_data);
  1993.             sc->ctts_count = 0;
  1994.             return 0;
  1995.         }
  1996.  
  1997.         if (i+2<entries)
  1998.             mov_update_dts_shift(sc, duration);
  1999.     }
  2000.  
  2001.     sc->ctts_count = i;
  2002.  
  2003.     if (pb->eof_reached)
  2004.         return AVERROR_EOF;
  2005.  
  2006.     av_dlog(c->fc, "dts shift %d\n", sc->dts_shift);
  2007.  
  2008.     return 0;
  2009. }
  2010.  
  2011. static int mov_read_sbgp(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  2012. {
  2013.     AVStream *st;
  2014.     MOVStreamContext *sc;
  2015.     unsigned int i, entries;
  2016.     uint8_t version;
  2017.     uint32_t grouping_type;
  2018.  
  2019.     if (c->fc->nb_streams < 1)
  2020.         return 0;
  2021.     st = c->fc->streams[c->fc->nb_streams-1];
  2022.     sc = st->priv_data;
  2023.  
  2024.     version = avio_r8(pb); /* version */
  2025.     avio_rb24(pb); /* flags */
  2026.     grouping_type = avio_rl32(pb);
  2027.     if (grouping_type != MKTAG( 'r','a','p',' '))
  2028.         return 0; /* only support 'rap ' grouping */
  2029.     if (version == 1)
  2030.         avio_rb32(pb); /* grouping_type_parameter */
  2031.  
  2032.     entries = avio_rb32(pb);
  2033.     if (!entries)
  2034.         return 0;
  2035.     if (entries >= UINT_MAX / sizeof(*sc->rap_group))
  2036.         return AVERROR_INVALIDDATA;
  2037.     sc->rap_group = av_malloc(entries * sizeof(*sc->rap_group));
  2038.     if (!sc->rap_group)
  2039.         return AVERROR(ENOMEM);
  2040.  
  2041.     for (i = 0; i < entries && !pb->eof_reached; i++) {
  2042.         sc->rap_group[i].count = avio_rb32(pb); /* sample_count */
  2043.         sc->rap_group[i].index = avio_rb32(pb); /* group_description_index */
  2044.     }
  2045.  
  2046.     sc->rap_group_count = i;
  2047.  
  2048.     return pb->eof_reached ? AVERROR_EOF : 0;
  2049. }
  2050.  
  2051. static void mov_build_index(MOVContext *mov, AVStream *st)
  2052. {
  2053.     MOVStreamContext *sc = st->priv_data;
  2054.     int64_t current_offset;
  2055.     int64_t current_dts = 0;
  2056.     unsigned int stts_index = 0;
  2057.     unsigned int stsc_index = 0;
  2058.     unsigned int stss_index = 0;
  2059.     unsigned int stps_index = 0;
  2060.     unsigned int i, j;
  2061.     uint64_t stream_size = 0;
  2062.  
  2063.     /* adjust first dts according to edit list */
  2064.     if ((sc->empty_duration || sc->start_time) && mov->time_scale > 0) {
  2065.         if (sc->empty_duration)
  2066.             sc->empty_duration = av_rescale(sc->empty_duration, sc->time_scale, mov->time_scale);
  2067.         sc->time_offset = sc->start_time - sc->empty_duration;
  2068.         current_dts = -sc->time_offset;
  2069.         if (sc->ctts_count>0 && sc->stts_count>0 &&
  2070.             sc->ctts_data[0].duration / FFMAX(sc->stts_data[0].duration, 1) > 16) {
  2071.             /* more than 16 frames delay, dts are likely wrong
  2072.                this happens with files created by iMovie */
  2073.             sc->wrong_dts = 1;
  2074.             st->codec->has_b_frames = 1;
  2075.         }
  2076.     }
  2077.  
  2078.     /* only use old uncompressed audio chunk demuxing when stts specifies it */
  2079.     if (!(st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
  2080.           sc->stts_count == 1 && sc->stts_data[0].duration == 1)) {
  2081.         unsigned int current_sample = 0;
  2082.         unsigned int stts_sample = 0;
  2083.         unsigned int sample_size;
  2084.         unsigned int distance = 0;
  2085.         unsigned int rap_group_index = 0;
  2086.         unsigned int rap_group_sample = 0;
  2087.         int rap_group_present = sc->rap_group_count && sc->rap_group;
  2088.         int key_off = (sc->keyframe_count && sc->keyframes[0] > 0) || (sc->stps_count && sc->stps_data[0] > 0);
  2089.  
  2090.         current_dts -= sc->dts_shift;
  2091.  
  2092.         if (!sc->sample_count || st->nb_index_entries)
  2093.             return;
  2094.         if (sc->sample_count >= UINT_MAX / sizeof(*st->index_entries) - st->nb_index_entries)
  2095.             return;
  2096.         if (av_reallocp_array(&st->index_entries,
  2097.                               st->nb_index_entries + sc->sample_count,
  2098.                               sizeof(*st->index_entries)) < 0) {
  2099.             st->nb_index_entries = 0;
  2100.             return;
  2101.         }
  2102.         st->index_entries_allocated_size = (st->nb_index_entries + sc->sample_count) * sizeof(*st->index_entries);
  2103.  
  2104.         for (i = 0; i < sc->chunk_count; i++) {
  2105.             int64_t next_offset = i+1 < sc->chunk_count ? sc->chunk_offsets[i+1] : INT64_MAX;
  2106.             current_offset = sc->chunk_offsets[i];
  2107.             while (stsc_index + 1 < sc->stsc_count &&
  2108.                 i + 1 == sc->stsc_data[stsc_index + 1].first)
  2109.                 stsc_index++;
  2110.  
  2111.             if (next_offset > current_offset && sc->sample_size>0 && sc->sample_size < sc->stsz_sample_size &&
  2112.                 sc->stsc_data[stsc_index].count * (int64_t)sc->stsz_sample_size > next_offset - current_offset) {
  2113.                 av_log(mov->fc, AV_LOG_WARNING, "STSZ sample size %d invalid (too large), ignoring\n", sc->stsz_sample_size);
  2114.                 sc->stsz_sample_size = sc->sample_size;
  2115.             }
  2116.             if (sc->stsz_sample_size>0 && sc->stsz_sample_size < sc->sample_size) {
  2117.                 av_log(mov->fc, AV_LOG_WARNING, "STSZ sample size %d invalid (too small), ignoring\n", sc->stsz_sample_size);
  2118.                 sc->stsz_sample_size = sc->sample_size;
  2119.             }
  2120.  
  2121.             for (j = 0; j < sc->stsc_data[stsc_index].count; j++) {
  2122.                 int keyframe = 0;
  2123.                 if (current_sample >= sc->sample_count) {
  2124.                     av_log(mov->fc, AV_LOG_ERROR, "wrong sample count\n");
  2125.                     return;
  2126.                 }
  2127.  
  2128.                 if (!sc->keyframe_absent && (!sc->keyframe_count || current_sample+key_off == sc->keyframes[stss_index])) {
  2129.                     keyframe = 1;
  2130.                     if (stss_index + 1 < sc->keyframe_count)
  2131.                         stss_index++;
  2132.                 } else if (sc->stps_count && current_sample+key_off == sc->stps_data[stps_index]) {
  2133.                     keyframe = 1;
  2134.                     if (stps_index + 1 < sc->stps_count)
  2135.                         stps_index++;
  2136.                 }
  2137.                 if (rap_group_present && rap_group_index < sc->rap_group_count) {
  2138.                     if (sc->rap_group[rap_group_index].index > 0)
  2139.                         keyframe = 1;
  2140.                     if (++rap_group_sample == sc->rap_group[rap_group_index].count) {
  2141.                         rap_group_sample = 0;
  2142.                         rap_group_index++;
  2143.                     }
  2144.                 }
  2145.                 if (keyframe)
  2146.                     distance = 0;
  2147.                 sample_size = sc->stsz_sample_size > 0 ? sc->stsz_sample_size : sc->sample_sizes[current_sample];
  2148.                 if (sc->pseudo_stream_id == -1 ||
  2149.                    sc->stsc_data[stsc_index].id - 1 == sc->pseudo_stream_id) {
  2150.                     AVIndexEntry *e = &st->index_entries[st->nb_index_entries++];
  2151.                     e->pos = current_offset;
  2152.                     e->timestamp = current_dts;
  2153.                     e->size = sample_size;
  2154.                     e->min_distance = distance;
  2155.                     e->flags = keyframe ? AVINDEX_KEYFRAME : 0;
  2156.                     av_dlog(mov->fc, "AVIndex stream %d, sample %d, offset %"PRIx64", dts %"PRId64", "
  2157.                             "size %d, distance %d, keyframe %d\n", st->index, current_sample,
  2158.                             current_offset, current_dts, sample_size, distance, keyframe);
  2159.                 }
  2160.  
  2161.                 current_offset += sample_size;
  2162.                 stream_size += sample_size;
  2163.                 current_dts += sc->stts_data[stts_index].duration;
  2164.                 distance++;
  2165.                 stts_sample++;
  2166.                 current_sample++;
  2167.                 if (stts_index + 1 < sc->stts_count && stts_sample == sc->stts_data[stts_index].count) {
  2168.                     stts_sample = 0;
  2169.                     stts_index++;
  2170.                 }
  2171.             }
  2172.         }
  2173.         if (st->duration > 0)
  2174.             st->codec->bit_rate = stream_size*8*sc->time_scale/st->duration;
  2175.     } else {
  2176.         unsigned chunk_samples, total = 0;
  2177.  
  2178.         // compute total chunk count
  2179.         for (i = 0; i < sc->stsc_count; i++) {
  2180.             unsigned count, chunk_count;
  2181.  
  2182.             chunk_samples = sc->stsc_data[i].count;
  2183.             if (i != sc->stsc_count - 1 &&
  2184.                 sc->samples_per_frame && chunk_samples % sc->samples_per_frame) {
  2185.                 av_log(mov->fc, AV_LOG_ERROR, "error unaligned chunk\n");
  2186.                 return;
  2187.             }
  2188.  
  2189.             if (sc->samples_per_frame >= 160) { // gsm
  2190.                 count = chunk_samples / sc->samples_per_frame;
  2191.             } else if (sc->samples_per_frame > 1) {
  2192.                 unsigned samples = (1024/sc->samples_per_frame)*sc->samples_per_frame;
  2193.                 count = (chunk_samples+samples-1) / samples;
  2194.             } else {
  2195.                 count = (chunk_samples+1023) / 1024;
  2196.             }
  2197.  
  2198.             if (i < sc->stsc_count - 1)
  2199.                 chunk_count = sc->stsc_data[i+1].first - sc->stsc_data[i].first;
  2200.             else
  2201.                 chunk_count = sc->chunk_count - (sc->stsc_data[i].first - 1);
  2202.             total += chunk_count * count;
  2203.         }
  2204.  
  2205.         av_dlog(mov->fc, "chunk count %d\n", total);
  2206.         if (total >= UINT_MAX / sizeof(*st->index_entries) - st->nb_index_entries)
  2207.             return;
  2208.         if (av_reallocp_array(&st->index_entries,
  2209.                               st->nb_index_entries + total,
  2210.                               sizeof(*st->index_entries)) < 0) {
  2211.             st->nb_index_entries = 0;
  2212.             return;
  2213.         }
  2214.         st->index_entries_allocated_size = (st->nb_index_entries + total) * sizeof(*st->index_entries);
  2215.  
  2216.         // populate index
  2217.         for (i = 0; i < sc->chunk_count; i++) {
  2218.             current_offset = sc->chunk_offsets[i];
  2219.             if (stsc_index + 1 < sc->stsc_count &&
  2220.                 i + 1 == sc->stsc_data[stsc_index + 1].first)
  2221.                 stsc_index++;
  2222.             chunk_samples = sc->stsc_data[stsc_index].count;
  2223.  
  2224.             while (chunk_samples > 0) {
  2225.                 AVIndexEntry *e;
  2226.                 unsigned size, samples;
  2227.  
  2228.                 if (sc->samples_per_frame >= 160) { // gsm
  2229.                     samples = sc->samples_per_frame;
  2230.                     size = sc->bytes_per_frame;
  2231.                 } else {
  2232.                     if (sc->samples_per_frame > 1) {
  2233.                         samples = FFMIN((1024 / sc->samples_per_frame)*
  2234.                                         sc->samples_per_frame, chunk_samples);
  2235.                         size = (samples / sc->samples_per_frame) * sc->bytes_per_frame;
  2236.                     } else {
  2237.                         samples = FFMIN(1024, chunk_samples);
  2238.                         size = samples * sc->sample_size;
  2239.                     }
  2240.                 }
  2241.  
  2242.                 if (st->nb_index_entries >= total) {
  2243.                     av_log(mov->fc, AV_LOG_ERROR, "wrong chunk count %d\n", total);
  2244.                     return;
  2245.                 }
  2246.                 e = &st->index_entries[st->nb_index_entries++];
  2247.                 e->pos = current_offset;
  2248.                 e->timestamp = current_dts;
  2249.                 e->size = size;
  2250.                 e->min_distance = 0;
  2251.                 e->flags = AVINDEX_KEYFRAME;
  2252.                 av_dlog(mov->fc, "AVIndex stream %d, chunk %d, offset %"PRIx64", dts %"PRId64", "
  2253.                         "size %d, duration %d\n", st->index, i, current_offset, current_dts,
  2254.                         size, samples);
  2255.  
  2256.                 current_offset += size;
  2257.                 current_dts += samples;
  2258.                 chunk_samples -= samples;
  2259.             }
  2260.         }
  2261.     }
  2262. }
  2263.  
  2264. static int mov_open_dref(AVIOContext **pb, const char *src, MOVDref *ref,
  2265.                          AVIOInterruptCB *int_cb, int use_absolute_path, AVFormatContext *fc)
  2266. {
  2267.     /* try relative path, we do not try the absolute because it can leak information about our
  2268.        system to an attacker */
  2269.     if (ref->nlvl_to > 0 && ref->nlvl_from > 0) {
  2270.         char filename[1024];
  2271.         const char *src_path;
  2272.         int i, l;
  2273.  
  2274.         /* find a source dir */
  2275.         src_path = strrchr(src, '/');
  2276.         if (src_path)
  2277.             src_path++;
  2278.         else
  2279.             src_path = src;
  2280.  
  2281.         /* find a next level down to target */
  2282.         for (i = 0, l = strlen(ref->path) - 1; l >= 0; l--)
  2283.             if (ref->path[l] == '/') {
  2284.                 if (i == ref->nlvl_to - 1)
  2285.                     break;
  2286.                 else
  2287.                     i++;
  2288.             }
  2289.  
  2290.         /* compose filename if next level down to target was found */
  2291.         if (i == ref->nlvl_to - 1 && src_path - src  < sizeof(filename)) {
  2292.             memcpy(filename, src, src_path - src);
  2293.             filename[src_path - src] = 0;
  2294.  
  2295.             for (i = 1; i < ref->nlvl_from; i++)
  2296.                 av_strlcat(filename, "../", 1024);
  2297.  
  2298.             av_strlcat(filename, ref->path + l + 1, 1024);
  2299.  
  2300.             if (!avio_open2(pb, filename, AVIO_FLAG_READ, int_cb, NULL))
  2301.                 return 0;
  2302.         }
  2303.     } else if (use_absolute_path) {
  2304.         av_log(fc, AV_LOG_WARNING, "Using absolute path on user request, "
  2305.                "this is a possible security issue\n");
  2306.         if (!avio_open2(pb, ref->path, AVIO_FLAG_READ, int_cb, NULL))
  2307.             return 0;
  2308.     }
  2309.  
  2310.     return AVERROR(ENOENT);
  2311. }
  2312.  
  2313. static void fix_timescale(MOVContext *c, MOVStreamContext *sc)
  2314. {
  2315.     if (sc->time_scale <= 0) {
  2316.         av_log(c->fc, AV_LOG_WARNING, "stream %d, timescale not set\n", sc->ffindex);
  2317.         sc->time_scale = c->time_scale;
  2318.         if (sc->time_scale <= 0)
  2319.             sc->time_scale = 1;
  2320.     }
  2321. }
  2322.  
  2323. static int mov_read_trak(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  2324. {
  2325.     AVStream *st;
  2326.     MOVStreamContext *sc;
  2327.     int ret;
  2328.  
  2329.     st = avformat_new_stream(c->fc, NULL);
  2330.     if (!st) return AVERROR(ENOMEM);
  2331.     st->id = c->fc->nb_streams;
  2332.     sc = av_mallocz(sizeof(MOVStreamContext));
  2333.     if (!sc) return AVERROR(ENOMEM);
  2334.  
  2335.     st->priv_data = sc;
  2336.     st->codec->codec_type = AVMEDIA_TYPE_DATA;
  2337.     sc->ffindex = st->index;
  2338.  
  2339.     if ((ret = mov_read_default(c, pb, atom)) < 0)
  2340.         return ret;
  2341.  
  2342.     /* sanity checks */
  2343.     if (sc->chunk_count && (!sc->stts_count || !sc->stsc_count ||
  2344.                             (!sc->sample_size && !sc->sample_count))) {
  2345.         av_log(c->fc, AV_LOG_ERROR, "stream %d, missing mandatory atoms, broken header\n",
  2346.                st->index);
  2347.         return 0;
  2348.     }
  2349.  
  2350.     fix_timescale(c, sc);
  2351.  
  2352.     avpriv_set_pts_info(st, 64, 1, sc->time_scale);
  2353.  
  2354.     mov_build_index(c, st);
  2355.  
  2356.     if (sc->dref_id-1 < sc->drefs_count && sc->drefs[sc->dref_id-1].path) {
  2357.         MOVDref *dref = &sc->drefs[sc->dref_id - 1];
  2358.         if (mov_open_dref(&sc->pb, c->fc->filename, dref, &c->fc->interrupt_callback,
  2359.             c->use_absolute_path, c->fc) < 0)
  2360.             av_log(c->fc, AV_LOG_ERROR,
  2361.                    "stream %d, error opening alias: path='%s', dir='%s', "
  2362.                    "filename='%s', volume='%s', nlvl_from=%d, nlvl_to=%d\n",
  2363.                    st->index, dref->path, dref->dir, dref->filename,
  2364.                    dref->volume, dref->nlvl_from, dref->nlvl_to);
  2365.     } else {
  2366.         sc->pb = c->fc->pb;
  2367.         sc->pb_is_copied = 1;
  2368.     }
  2369.  
  2370.     if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
  2371.         if (!st->sample_aspect_ratio.num &&
  2372.             (st->codec->width != sc->width || st->codec->height != sc->height)) {
  2373.             st->sample_aspect_ratio = av_d2q(((double)st->codec->height * sc->width) /
  2374.                                              ((double)st->codec->width * sc->height), INT_MAX);
  2375.         }
  2376.  
  2377.         if (st->duration > 0)
  2378.             av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
  2379.                       sc->time_scale*st->nb_frames, st->duration, INT_MAX);
  2380.  
  2381. #if FF_API_R_FRAME_RATE
  2382.         if (sc->stts_count == 1 || (sc->stts_count == 2 && sc->stts_data[1].count == 1))
  2383.             av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den,
  2384.                       sc->time_scale, sc->stts_data[0].duration, INT_MAX);
  2385. #endif
  2386.     }
  2387.  
  2388.     // done for ai5q, ai52, ai55, ai1q, ai12 and ai15.
  2389.     if (!st->codec->extradata_size && st->codec->codec_id == AV_CODEC_ID_H264 &&
  2390.         st->codec->codec_tag != MKTAG('a', 'v', 'c', '1')) {
  2391.         ff_generate_avci_extradata(st);
  2392.     }
  2393.  
  2394.     switch (st->codec->codec_id) {
  2395. #if CONFIG_H261_DECODER
  2396.     case AV_CODEC_ID_H261:
  2397. #endif
  2398. #if CONFIG_H263_DECODER
  2399.     case AV_CODEC_ID_H263:
  2400. #endif
  2401. #if CONFIG_MPEG4_DECODER
  2402.     case AV_CODEC_ID_MPEG4:
  2403. #endif
  2404.         st->codec->width = 0; /* let decoder init width/height */
  2405.         st->codec->height= 0;
  2406.         break;
  2407.     }
  2408.  
  2409.     /* Do not need those anymore. */
  2410.     av_freep(&sc->chunk_offsets);
  2411.     av_freep(&sc->stsc_data);
  2412.     av_freep(&sc->sample_sizes);
  2413.     av_freep(&sc->keyframes);
  2414.     av_freep(&sc->stts_data);
  2415.     av_freep(&sc->stps_data);
  2416.     av_freep(&sc->rap_group);
  2417.  
  2418.     return 0;
  2419. }
  2420.  
  2421. static int mov_read_ilst(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  2422. {
  2423.     int ret;
  2424.     c->itunes_metadata = 1;
  2425.     ret = mov_read_default(c, pb, atom);
  2426.     c->itunes_metadata = 0;
  2427.     return ret;
  2428. }
  2429.  
  2430. static int mov_read_meta(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  2431. {
  2432.     while (atom.size > 8) {
  2433.         uint32_t tag = avio_rl32(pb);
  2434.         atom.size -= 4;
  2435.         if (tag == MKTAG('h','d','l','r')) {
  2436.             avio_seek(pb, -8, SEEK_CUR);
  2437.             atom.size += 8;
  2438.             return mov_read_default(c, pb, atom);
  2439.         }
  2440.     }
  2441.     return 0;
  2442. }
  2443.  
  2444. static int mov_read_tkhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  2445. {
  2446.     int i;
  2447.     int width;
  2448.     int height;
  2449.     int64_t disp_transform[2];
  2450.     int display_matrix[3][2];
  2451.     AVStream *st;
  2452.     MOVStreamContext *sc;
  2453.     int version;
  2454.     int flags;
  2455.  
  2456.     if (c->fc->nb_streams < 1)
  2457.         return 0;
  2458.     st = c->fc->streams[c->fc->nb_streams-1];
  2459.     sc = st->priv_data;
  2460.  
  2461.     version = avio_r8(pb);
  2462.     flags = avio_rb24(pb);
  2463.     st->disposition |= (flags & MOV_TKHD_FLAG_ENABLED) ? AV_DISPOSITION_DEFAULT : 0;
  2464.  
  2465.     if (version == 1) {
  2466.         avio_rb64(pb);
  2467.         avio_rb64(pb);
  2468.     } else {
  2469.         avio_rb32(pb); /* creation time */
  2470.         avio_rb32(pb); /* modification time */
  2471.     }
  2472.     st->id = (int)avio_rb32(pb); /* track id (NOT 0 !)*/
  2473.     avio_rb32(pb); /* reserved */
  2474.  
  2475.     /* highlevel (considering edits) duration in movie timebase */
  2476.     (version == 1) ? avio_rb64(pb) : avio_rb32(pb);
  2477.     avio_rb32(pb); /* reserved */
  2478.     avio_rb32(pb); /* reserved */
  2479.  
  2480.     avio_rb16(pb); /* layer */
  2481.     avio_rb16(pb); /* alternate group */
  2482.     avio_rb16(pb); /* volume */
  2483.     avio_rb16(pb); /* reserved */
  2484.  
  2485.     //read in the display matrix (outlined in ISO 14496-12, Section 6.2.2)
  2486.     // they're kept in fixed point format through all calculations
  2487.     // ignore u,v,z b/c we don't need the scale factor to calc aspect ratio
  2488.     for (i = 0; i < 3; i++) {
  2489.         display_matrix[i][0] = avio_rb32(pb);   // 16.16 fixed point
  2490.         display_matrix[i][1] = avio_rb32(pb);   // 16.16 fixed point
  2491.         avio_rb32(pb);           // 2.30 fixed point (not used)
  2492.     }
  2493.  
  2494.     width = avio_rb32(pb);       // 16.16 fixed point track width
  2495.     height = avio_rb32(pb);      // 16.16 fixed point track height
  2496.     sc->width = width >> 16;
  2497.     sc->height = height >> 16;
  2498.  
  2499.     //Assign clockwise rotate values based on transform matrix so that
  2500.     //we can compensate for iPhone orientation during capture.
  2501.  
  2502.     if (display_matrix[1][0] == -65536 && display_matrix[0][1] == 65536) {
  2503.          av_dict_set(&st->metadata, "rotate", "90", 0);
  2504.     }
  2505.  
  2506.     if (display_matrix[0][0] == -65536 && display_matrix[1][1] == -65536) {
  2507.          av_dict_set(&st->metadata, "rotate", "180", 0);
  2508.     }
  2509.  
  2510.     if (display_matrix[1][0] == 65536 && display_matrix[0][1] == -65536) {
  2511.          av_dict_set(&st->metadata, "rotate", "270", 0);
  2512.     }
  2513.  
  2514.     // transform the display width/height according to the matrix
  2515.     // skip this if the display matrix is the default identity matrix
  2516.     // or if it is rotating the picture, ex iPhone 3GS
  2517.     // to keep the same scale, use [width height 1<<16]
  2518.     if (width && height &&
  2519.         ((display_matrix[0][0] != 65536  ||
  2520.           display_matrix[1][1] != 65536) &&
  2521.          !display_matrix[0][1] &&
  2522.          !display_matrix[1][0] &&
  2523.          !display_matrix[2][0] && !display_matrix[2][1])) {
  2524.         for (i = 0; i < 2; i++)
  2525.             disp_transform[i] =
  2526.                 (int64_t)  width  * display_matrix[0][i] +
  2527.                 (int64_t)  height * display_matrix[1][i] +
  2528.                 ((int64_t) display_matrix[2][i] << 16);
  2529.  
  2530.         //sample aspect ratio is new width/height divided by old width/height
  2531.         st->sample_aspect_ratio = av_d2q(
  2532.             ((double) disp_transform[0] * height) /
  2533.             ((double) disp_transform[1] * width), INT_MAX);
  2534.     }
  2535.     return 0;
  2536. }
  2537.  
  2538. static int mov_read_tfhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  2539. {
  2540.     MOVFragment *frag = &c->fragment;
  2541.     MOVTrackExt *trex = NULL;
  2542.     int flags, track_id, i;
  2543.  
  2544.     avio_r8(pb); /* version */
  2545.     flags = avio_rb24(pb);
  2546.  
  2547.     track_id = avio_rb32(pb);
  2548.     if (!track_id)
  2549.         return AVERROR_INVALIDDATA;
  2550.     frag->track_id = track_id;
  2551.     for (i = 0; i < c->trex_count; i++)
  2552.         if (c->trex_data[i].track_id == frag->track_id) {
  2553.             trex = &c->trex_data[i];
  2554.             break;
  2555.         }
  2556.     if (!trex) {
  2557.         av_log(c->fc, AV_LOG_ERROR, "could not find corresponding trex\n");
  2558.         return AVERROR_INVALIDDATA;
  2559.     }
  2560.  
  2561.     frag->base_data_offset = flags & MOV_TFHD_BASE_DATA_OFFSET ?
  2562.                              avio_rb64(pb) : frag->moof_offset;
  2563.     frag->stsd_id  = flags & MOV_TFHD_STSD_ID ? avio_rb32(pb) : trex->stsd_id;
  2564.  
  2565.     frag->duration = flags & MOV_TFHD_DEFAULT_DURATION ?
  2566.                      avio_rb32(pb) : trex->duration;
  2567.     frag->size     = flags & MOV_TFHD_DEFAULT_SIZE ?
  2568.                      avio_rb32(pb) : trex->size;
  2569.     frag->flags    = flags & MOV_TFHD_DEFAULT_FLAGS ?
  2570.                      avio_rb32(pb) : trex->flags;
  2571.     av_dlog(c->fc, "frag flags 0x%x\n", frag->flags);
  2572.     return 0;
  2573. }
  2574.  
  2575. static int mov_read_chap(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  2576. {
  2577.     c->chapter_track = avio_rb32(pb);
  2578.     return 0;
  2579. }
  2580.  
  2581. static int mov_read_trex(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  2582. {
  2583.     MOVTrackExt *trex;
  2584.     int err;
  2585.  
  2586.     if ((uint64_t)c->trex_count+1 >= UINT_MAX / sizeof(*c->trex_data))
  2587.         return AVERROR_INVALIDDATA;
  2588.     if ((err = av_reallocp_array(&c->trex_data, c->trex_count + 1,
  2589.                                  sizeof(*c->trex_data))) < 0) {
  2590.         c->trex_count = 0;
  2591.         return err;
  2592.     }
  2593.  
  2594.     c->fc->duration = AV_NOPTS_VALUE; // the duration from mvhd is not representing the whole file when fragments are used.
  2595.  
  2596.     trex = &c->trex_data[c->trex_count++];
  2597.     avio_r8(pb); /* version */
  2598.     avio_rb24(pb); /* flags */
  2599.     trex->track_id = avio_rb32(pb);
  2600.     trex->stsd_id  = avio_rb32(pb);
  2601.     trex->duration = avio_rb32(pb);
  2602.     trex->size     = avio_rb32(pb);
  2603.     trex->flags    = avio_rb32(pb);
  2604.     return 0;
  2605. }
  2606.  
  2607. static int mov_read_trun(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  2608. {
  2609.     MOVFragment *frag = &c->fragment;
  2610.     AVStream *st = NULL;
  2611.     MOVStreamContext *sc;
  2612.     MOVStts *ctts_data;
  2613.     uint64_t offset;
  2614.     int64_t dts;
  2615.     int data_offset = 0;
  2616.     unsigned entries, first_sample_flags = frag->flags;
  2617.     int flags, distance, i, found_keyframe = 0, err;
  2618.  
  2619.     for (i = 0; i < c->fc->nb_streams; i++) {
  2620.         if (c->fc->streams[i]->id == frag->track_id) {
  2621.             st = c->fc->streams[i];
  2622.             break;
  2623.         }
  2624.     }
  2625.     if (!st) {
  2626.         av_log(c->fc, AV_LOG_ERROR, "could not find corresponding track id %d\n", frag->track_id);
  2627.         return AVERROR_INVALIDDATA;
  2628.     }
  2629.     sc = st->priv_data;
  2630.     if (sc->pseudo_stream_id+1 != frag->stsd_id && sc->pseudo_stream_id != -1)
  2631.         return 0;
  2632.     avio_r8(pb); /* version */
  2633.     flags = avio_rb24(pb);
  2634.     entries = avio_rb32(pb);
  2635.     av_dlog(c->fc, "flags 0x%x entries %d\n", flags, entries);
  2636.  
  2637.     /* Always assume the presence of composition time offsets.
  2638.      * Without this assumption, for instance, we cannot deal with a track in fragmented movies that meet the following.
  2639.      *  1) in the initial movie, there are no samples.
  2640.      *  2) in the first movie fragment, there is only one sample without composition time offset.
  2641.      *  3) in the subsequent movie fragments, there are samples with composition time offset. */
  2642.     if (!sc->ctts_count && sc->sample_count)
  2643.     {
  2644.         /* Complement ctts table if moov atom doesn't have ctts atom. */
  2645.         ctts_data = av_realloc(NULL, sizeof(*sc->ctts_data));
  2646.         if (!ctts_data)
  2647.             return AVERROR(ENOMEM);
  2648.         sc->ctts_data = ctts_data;
  2649.         sc->ctts_data[sc->ctts_count].count = sc->sample_count;
  2650.         sc->ctts_data[sc->ctts_count].duration = 0;
  2651.         sc->ctts_count++;
  2652.     }
  2653.     if ((uint64_t)entries+sc->ctts_count >= UINT_MAX/sizeof(*sc->ctts_data))
  2654.         return AVERROR_INVALIDDATA;
  2655.     if ((err = av_reallocp_array(&sc->ctts_data, entries + sc->ctts_count,
  2656.                                  sizeof(*sc->ctts_data))) < 0) {
  2657.         sc->ctts_count = 0;
  2658.         return err;
  2659.     }
  2660.     if (flags & MOV_TRUN_DATA_OFFSET)        data_offset        = avio_rb32(pb);
  2661.     if (flags & MOV_TRUN_FIRST_SAMPLE_FLAGS) first_sample_flags = avio_rb32(pb);
  2662.     dts    = sc->track_end - sc->time_offset;
  2663.     offset = frag->base_data_offset + data_offset;
  2664.     distance = 0;
  2665.     av_dlog(c->fc, "first sample flags 0x%x\n", first_sample_flags);
  2666.     for (i = 0; i < entries && !pb->eof_reached; i++) {
  2667.         unsigned sample_size = frag->size;
  2668.         int sample_flags = i ? frag->flags : first_sample_flags;
  2669.         unsigned sample_duration = frag->duration;
  2670.         int keyframe = 0;
  2671.  
  2672.         if (flags & MOV_TRUN_SAMPLE_DURATION) sample_duration = avio_rb32(pb);
  2673.         if (flags & MOV_TRUN_SAMPLE_SIZE)     sample_size     = avio_rb32(pb);
  2674.         if (flags & MOV_TRUN_SAMPLE_FLAGS)    sample_flags    = avio_rb32(pb);
  2675.         sc->ctts_data[sc->ctts_count].count = 1;
  2676.         sc->ctts_data[sc->ctts_count].duration = (flags & MOV_TRUN_SAMPLE_CTS) ?
  2677.                                                   avio_rb32(pb) : 0;
  2678.         mov_update_dts_shift(sc, sc->ctts_data[sc->ctts_count].duration);
  2679.         sc->ctts_count++;
  2680.         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
  2681.             keyframe = 1;
  2682.         else if (!found_keyframe)
  2683.             keyframe = found_keyframe =
  2684.                 !(sample_flags & (MOV_FRAG_SAMPLE_FLAG_IS_NON_SYNC |
  2685.                                   MOV_FRAG_SAMPLE_FLAG_DEPENDS_YES));
  2686.         if (keyframe)
  2687.             distance = 0;
  2688.         av_add_index_entry(st, offset, dts, sample_size, distance,
  2689.                            keyframe ? AVINDEX_KEYFRAME : 0);
  2690.         av_dlog(c->fc, "AVIndex stream %d, sample %d, offset %"PRIx64", dts %"PRId64", "
  2691.                 "size %d, distance %d, keyframe %d\n", st->index, sc->sample_count+i,
  2692.                 offset, dts, sample_size, distance, keyframe);
  2693.         distance++;
  2694.         dts += sample_duration;
  2695.         offset += sample_size;
  2696.         sc->data_size += sample_size;
  2697.     }
  2698.  
  2699.     if (pb->eof_reached)
  2700.         return AVERROR_EOF;
  2701.  
  2702.     frag->moof_offset = offset;
  2703.     st->duration = sc->track_end = dts + sc->time_offset;
  2704.     return 0;
  2705. }
  2706.  
  2707. /* this atom should be null (from specs), but some buggy files put the 'moov' atom inside it... */
  2708. /* like the files created with Adobe Premiere 5.0, for samples see */
  2709. /* http://graphics.tudelft.nl/~wouter/publications/soundtests/ */
  2710. static int mov_read_wide(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  2711. {
  2712.     int err;
  2713.  
  2714.     if (atom.size < 8)
  2715.         return 0; /* continue */
  2716.     if (avio_rb32(pb) != 0) { /* 0 sized mdat atom... use the 'wide' atom size */
  2717.         avio_skip(pb, atom.size - 4);
  2718.         return 0;
  2719.     }
  2720.     atom.type = avio_rl32(pb);
  2721.     atom.size -= 8;
  2722.     if (atom.type != MKTAG('m','d','a','t')) {
  2723.         avio_skip(pb, atom.size);
  2724.         return 0;
  2725.     }
  2726.     err = mov_read_mdat(c, pb, atom);
  2727.     return err;
  2728. }
  2729.  
  2730. static int mov_read_cmov(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  2731. {
  2732. #if CONFIG_ZLIB
  2733.     AVIOContext ctx;
  2734.     uint8_t *cmov_data;
  2735.     uint8_t *moov_data; /* uncompressed data */
  2736.     long cmov_len, moov_len;
  2737.     int ret = -1;
  2738.  
  2739.     avio_rb32(pb); /* dcom atom */
  2740.     if (avio_rl32(pb) != MKTAG('d','c','o','m'))
  2741.         return AVERROR_INVALIDDATA;
  2742.     if (avio_rl32(pb) != MKTAG('z','l','i','b')) {
  2743.         av_log(c->fc, AV_LOG_ERROR, "unknown compression for cmov atom !\n");
  2744.         return AVERROR_INVALIDDATA;
  2745.     }
  2746.     avio_rb32(pb); /* cmvd atom */
  2747.     if (avio_rl32(pb) != MKTAG('c','m','v','d'))
  2748.         return AVERROR_INVALIDDATA;
  2749.     moov_len = avio_rb32(pb); /* uncompressed size */
  2750.     cmov_len = atom.size - 6 * 4;
  2751.  
  2752.     cmov_data = av_malloc(cmov_len);
  2753.     if (!cmov_data)
  2754.         return AVERROR(ENOMEM);
  2755.     moov_data = av_malloc(moov_len);
  2756.     if (!moov_data) {
  2757.         av_free(cmov_data);
  2758.         return AVERROR(ENOMEM);
  2759.     }
  2760.     avio_read(pb, cmov_data, cmov_len);
  2761.     if (uncompress (moov_data, (uLongf *) &moov_len, (const Bytef *)cmov_data, cmov_len) != Z_OK)
  2762.         goto free_and_return;
  2763.     if (ffio_init_context(&ctx, moov_data, moov_len, 0, NULL, NULL, NULL, NULL) != 0)
  2764.         goto free_and_return;
  2765.     atom.type = MKTAG('m','o','o','v');
  2766.     atom.size = moov_len;
  2767.     ret = mov_read_default(c, &ctx, atom);
  2768. free_and_return:
  2769.     av_free(moov_data);
  2770.     av_free(cmov_data);
  2771.     return ret;
  2772. #else
  2773.     av_log(c->fc, AV_LOG_ERROR, "this file requires zlib support compiled in\n");
  2774.     return AVERROR(ENOSYS);
  2775. #endif
  2776. }
  2777.  
  2778. /* edit list atom */
  2779. static int mov_read_elst(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  2780. {
  2781.     MOVStreamContext *sc;
  2782.     int i, edit_count, version, edit_start_index = 0;
  2783.     int unsupported = 0;
  2784.  
  2785.     if (c->fc->nb_streams < 1 || c->ignore_editlist)
  2786.         return 0;
  2787.     sc = c->fc->streams[c->fc->nb_streams-1]->priv_data;
  2788.  
  2789.     version = avio_r8(pb); /* version */
  2790.     avio_rb24(pb); /* flags */
  2791.     edit_count = avio_rb32(pb); /* entries */
  2792.  
  2793.     if ((uint64_t)edit_count*12+8 > atom.size)
  2794.         return AVERROR_INVALIDDATA;
  2795.  
  2796.     av_dlog(c->fc, "track[%i].edit_count = %i\n", c->fc->nb_streams-1, edit_count);
  2797.     for (i=0; i<edit_count; i++){
  2798.         int64_t time;
  2799.         int64_t duration;
  2800.         int rate;
  2801.         if (version == 1) {
  2802.             duration = avio_rb64(pb);
  2803.             time     = avio_rb64(pb);
  2804.         } else {
  2805.             duration = avio_rb32(pb); /* segment duration */
  2806.             time     = (int32_t)avio_rb32(pb); /* media time */
  2807.         }
  2808.         rate = avio_rb32(pb);
  2809.         if (i == 0 && time == -1) {
  2810.             sc->empty_duration = duration;
  2811.             edit_start_index = 1;
  2812.         } else if (i == edit_start_index && time >= 0)
  2813.             sc->start_time = time;
  2814.         else
  2815.             unsupported = 1;
  2816.  
  2817.         av_dlog(c->fc, "duration=%"PRId64" time=%"PRId64" rate=%f\n",
  2818.                 duration, time, rate / 65536.0);
  2819.     }
  2820.  
  2821.     if (unsupported)
  2822.         av_log(c->fc, AV_LOG_WARNING, "multiple edit list entries, "
  2823.                "a/v desync might occur, patch welcome\n");
  2824.  
  2825.     return 0;
  2826. }
  2827.  
  2828. static int mov_read_tmcd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  2829. {
  2830.     MOVStreamContext *sc;
  2831.  
  2832.     if (c->fc->nb_streams < 1)
  2833.         return AVERROR_INVALIDDATA;
  2834.     sc = c->fc->streams[c->fc->nb_streams - 1]->priv_data;
  2835.     sc->timecode_track = avio_rb32(pb);
  2836.     return 0;
  2837. }
  2838.  
  2839. static int mov_read_uuid(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  2840. {
  2841.     int ret;
  2842.     uint8_t uuid[16];
  2843.     static const uint8_t uuid_isml_manifest[] = {
  2844.         0xa5, 0xd4, 0x0b, 0x30, 0xe8, 0x14, 0x11, 0xdd,
  2845.         0xba, 0x2f, 0x08, 0x00, 0x20, 0x0c, 0x9a, 0x66
  2846.     };
  2847.  
  2848.     if (atom.size < sizeof(uuid) || atom.size == INT64_MAX)
  2849.         return AVERROR_INVALIDDATA;
  2850.  
  2851.     ret = avio_read(pb, uuid, sizeof(uuid));
  2852.     if (ret < 0) {
  2853.         return ret;
  2854.     } else if (ret != sizeof(uuid)) {
  2855.         return AVERROR_INVALIDDATA;
  2856.     }
  2857.     if (!memcmp(uuid, uuid_isml_manifest, sizeof(uuid))) {
  2858.         uint8_t *buffer, *ptr;
  2859.         char *endptr;
  2860.         size_t len = atom.size - sizeof(uuid);
  2861.  
  2862.         if (len < 4) {
  2863.             return AVERROR_INVALIDDATA;
  2864.         }
  2865.         ret = avio_skip(pb, 4); // zeroes
  2866.         len -= 4;
  2867.  
  2868.         buffer = av_mallocz(len + 1);
  2869.         if (!buffer) {
  2870.             return AVERROR(ENOMEM);
  2871.         }
  2872.         ret = avio_read(pb, buffer, len);
  2873.         if (ret < 0) {
  2874.             av_free(buffer);
  2875.             return ret;
  2876.         } else if (ret != len) {
  2877.             av_free(buffer);
  2878.             return AVERROR_INVALIDDATA;
  2879.         }
  2880.  
  2881.         ptr = buffer;
  2882.         while ((ptr = av_stristr(ptr, "systemBitrate=\"")) != NULL) {
  2883.             ptr += sizeof("systemBitrate=\"") - 1;
  2884.             c->bitrates_count++;
  2885.             c->bitrates = av_realloc_f(c->bitrates, c->bitrates_count, sizeof(*c->bitrates));
  2886.             if (!c->bitrates) {
  2887.                 c->bitrates_count = 0;
  2888.                 av_free(buffer);
  2889.                 return AVERROR(ENOMEM);
  2890.             }
  2891.             errno = 0;
  2892.             ret = strtol(ptr, &endptr, 10);
  2893.             if (ret < 0 || errno || *endptr != '"') {
  2894.                 c->bitrates[c->bitrates_count - 1] = 0;
  2895.             } else {
  2896.                 c->bitrates[c->bitrates_count - 1] = ret;
  2897.             }
  2898.         }
  2899.  
  2900.         av_free(buffer);
  2901.     }
  2902.     return 0;
  2903. }
  2904.  
  2905. static const MOVParseTableEntry mov_default_parse_table[] = {
  2906. { MKTAG('A','C','L','R'), mov_read_avid },
  2907. { MKTAG('A','P','R','G'), mov_read_avid },
  2908. { MKTAG('A','A','L','P'), mov_read_avid },
  2909. { MKTAG('A','R','E','S'), mov_read_ares },
  2910. { MKTAG('a','v','s','s'), mov_read_avss },
  2911. { MKTAG('c','h','p','l'), mov_read_chpl },
  2912. { MKTAG('c','o','6','4'), mov_read_stco },
  2913. { MKTAG('c','t','t','s'), mov_read_ctts }, /* composition time to sample */
  2914. { MKTAG('d','i','n','f'), mov_read_default },
  2915. { MKTAG('d','r','e','f'), mov_read_dref },
  2916. { MKTAG('e','d','t','s'), mov_read_default },
  2917. { MKTAG('e','l','s','t'), mov_read_elst },
  2918. { MKTAG('e','n','d','a'), mov_read_enda },
  2919. { MKTAG('f','i','e','l'), mov_read_fiel },
  2920. { MKTAG('f','t','y','p'), mov_read_ftyp },
  2921. { MKTAG('g','l','b','l'), mov_read_glbl },
  2922. { MKTAG('h','d','l','r'), mov_read_hdlr },
  2923. { MKTAG('i','l','s','t'), mov_read_ilst },
  2924. { MKTAG('j','p','2','h'), mov_read_jp2h },
  2925. { MKTAG('m','d','a','t'), mov_read_mdat },
  2926. { MKTAG('m','d','h','d'), mov_read_mdhd },
  2927. { MKTAG('m','d','i','a'), mov_read_default },
  2928. { MKTAG('m','e','t','a'), mov_read_meta },
  2929. { MKTAG('m','i','n','f'), mov_read_default },
  2930. { MKTAG('m','o','o','f'), mov_read_moof },
  2931. { MKTAG('m','o','o','v'), mov_read_moov },
  2932. { MKTAG('m','v','e','x'), mov_read_default },
  2933. { MKTAG('m','v','h','d'), mov_read_mvhd },
  2934. { MKTAG('S','M','I',' '), mov_read_svq3 },
  2935. { MKTAG('a','l','a','c'), mov_read_alac }, /* alac specific atom */
  2936. { MKTAG('a','v','c','C'), mov_read_glbl },
  2937. { MKTAG('p','a','s','p'), mov_read_pasp },
  2938. { MKTAG('s','t','b','l'), mov_read_default },
  2939. { MKTAG('s','t','c','o'), mov_read_stco },
  2940. { MKTAG('s','t','p','s'), mov_read_stps },
  2941. { MKTAG('s','t','r','f'), mov_read_strf },
  2942. { MKTAG('s','t','s','c'), mov_read_stsc },
  2943. { MKTAG('s','t','s','d'), mov_read_stsd }, /* sample description */
  2944. { MKTAG('s','t','s','s'), mov_read_stss }, /* sync sample */
  2945. { MKTAG('s','t','s','z'), mov_read_stsz }, /* sample size */
  2946. { MKTAG('s','t','t','s'), mov_read_stts },
  2947. { MKTAG('s','t','z','2'), mov_read_stsz }, /* compact sample size */
  2948. { MKTAG('t','k','h','d'), mov_read_tkhd }, /* track header */
  2949. { MKTAG('t','f','h','d'), mov_read_tfhd }, /* track fragment header */
  2950. { MKTAG('t','r','a','k'), mov_read_trak },
  2951. { MKTAG('t','r','a','f'), mov_read_default },
  2952. { MKTAG('t','r','e','f'), mov_read_default },
  2953. { MKTAG('t','m','c','d'), mov_read_tmcd },
  2954. { MKTAG('c','h','a','p'), mov_read_chap },
  2955. { MKTAG('t','r','e','x'), mov_read_trex },
  2956. { MKTAG('t','r','u','n'), mov_read_trun },
  2957. { MKTAG('u','d','t','a'), mov_read_default },
  2958. { MKTAG('w','a','v','e'), mov_read_wave },
  2959. { MKTAG('e','s','d','s'), mov_read_esds },
  2960. { MKTAG('d','a','c','3'), mov_read_dac3 }, /* AC-3 info */
  2961. { MKTAG('d','e','c','3'), mov_read_dec3 }, /* EAC-3 info */
  2962. { MKTAG('w','i','d','e'), mov_read_wide }, /* place holder */
  2963. { MKTAG('w','f','e','x'), mov_read_wfex },
  2964. { MKTAG('c','m','o','v'), mov_read_cmov },
  2965. { MKTAG('c','h','a','n'), mov_read_chan }, /* channel layout */
  2966. { MKTAG('d','v','c','1'), mov_read_dvc1 },
  2967. { MKTAG('s','b','g','p'), mov_read_sbgp },
  2968. { MKTAG('h','v','c','C'), mov_read_glbl },
  2969. { MKTAG('u','u','i','d'), mov_read_uuid },
  2970. { MKTAG('C','i','n', 0x8e), mov_read_targa_y216 },
  2971. { 0, NULL }
  2972. };
  2973.  
  2974. static int mov_read_default(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  2975. {
  2976.     int64_t total_size = 0;
  2977.     MOVAtom a;
  2978.     int i;
  2979.  
  2980.     if (atom.size < 0)
  2981.         atom.size = INT64_MAX;
  2982.     while (total_size + 8 <= atom.size && !url_feof(pb)) {
  2983.         int (*parse)(MOVContext*, AVIOContext*, MOVAtom) = NULL;
  2984.         a.size = atom.size;
  2985.         a.type=0;
  2986.         if (atom.size >= 8) {
  2987.             a.size = avio_rb32(pb);
  2988.             a.type = avio_rl32(pb);
  2989.             if (atom.type != MKTAG('r','o','o','t') &&
  2990.                 atom.type != MKTAG('m','o','o','v'))
  2991.             {
  2992.                 if (a.type == MKTAG('t','r','a','k') || a.type == MKTAG('m','d','a','t'))
  2993.                 {
  2994.                     av_log(c->fc, AV_LOG_ERROR, "Broken file, trak/mdat not at top-level\n");
  2995.                     avio_skip(pb, -8);
  2996.                     return 0;
  2997.                 }
  2998.             }
  2999.             total_size += 8;
  3000.             if (a.size == 1) { /* 64 bit extended size */
  3001.                 a.size = avio_rb64(pb) - 8;
  3002.                 total_size += 8;
  3003.             }
  3004.         }
  3005.         av_dlog(c->fc, "type: %08x '%.4s' parent:'%.4s' sz: %"PRId64" %"PRId64" %"PRId64"\n",
  3006.                 a.type, (char*)&a.type, (char*)&atom.type, a.size, total_size, atom.size);
  3007.         if (a.size == 0) {
  3008.             a.size = atom.size - total_size + 8;
  3009.         }
  3010.         a.size -= 8;
  3011.         if (a.size < 0)
  3012.             break;
  3013.         a.size = FFMIN(a.size, atom.size - total_size);
  3014.  
  3015.         for (i = 0; mov_default_parse_table[i].type; i++)
  3016.             if (mov_default_parse_table[i].type == a.type) {
  3017.                 parse = mov_default_parse_table[i].parse;
  3018.                 break;
  3019.             }
  3020.  
  3021.         // container is user data
  3022.         if (!parse && (atom.type == MKTAG('u','d','t','a') ||
  3023.                        atom.type == MKTAG('i','l','s','t')))
  3024.             parse = mov_read_udta_string;
  3025.  
  3026.         if (!parse) { /* skip leaf atoms data */
  3027.             avio_skip(pb, a.size);
  3028.         } else {
  3029.             int64_t start_pos = avio_tell(pb);
  3030.             int64_t left;
  3031.             int err = parse(c, pb, a);
  3032.             if (err < 0)
  3033.                 return err;
  3034.             if (c->found_moov && c->found_mdat &&
  3035.                 ((!pb->seekable || c->fc->flags & AVFMT_FLAG_IGNIDX) ||
  3036.                  start_pos + a.size == avio_size(pb))) {
  3037.                 if (!pb->seekable || c->fc->flags & AVFMT_FLAG_IGNIDX)
  3038.                     c->next_root_atom = start_pos + a.size;
  3039.                 return 0;
  3040.             }
  3041.             left = a.size - avio_tell(pb) + start_pos;
  3042.             if (left > 0) /* skip garbage at atom end */
  3043.                 avio_skip(pb, left);
  3044.             else if (left < 0) {
  3045.                 av_log(c->fc, AV_LOG_WARNING,
  3046.                        "overread end of atom '%.4s' by %"PRId64" bytes\n",
  3047.                        (char*)&a.type, -left);
  3048.                 avio_seek(pb, left, SEEK_CUR);
  3049.             }
  3050.         }
  3051.  
  3052.         total_size += a.size;
  3053.     }
  3054.  
  3055.     if (total_size < atom.size && atom.size < 0x7ffff)
  3056.         avio_skip(pb, atom.size - total_size);
  3057.  
  3058.     return 0;
  3059. }
  3060.  
  3061. static int mov_probe(AVProbeData *p)
  3062. {
  3063.     int64_t offset;
  3064.     uint32_t tag;
  3065.     int score = 0;
  3066.     int moov_offset = -1;
  3067.  
  3068.     /* check file header */
  3069.     offset = 0;
  3070.     for (;;) {
  3071.         /* ignore invalid offset */
  3072.         if ((offset + 8) > (unsigned int)p->buf_size)
  3073.             break;
  3074.         tag = AV_RL32(p->buf + offset + 4);
  3075.         switch(tag) {
  3076.         /* check for obvious tags */
  3077.         case MKTAG('m','o','o','v'):
  3078.             moov_offset = offset + 4;
  3079.         case MKTAG('j','P',' ',' '): /* jpeg 2000 signature */
  3080.         case MKTAG('m','d','a','t'):
  3081.         case MKTAG('p','n','o','t'): /* detect movs with preview pics like ew.mov and april.mov */
  3082.         case MKTAG('u','d','t','a'): /* Packet Video PVAuthor adds this and a lot of more junk */
  3083.         case MKTAG('f','t','y','p'):
  3084.             if (AV_RB32(p->buf+offset) < 8 &&
  3085.                 (AV_RB32(p->buf+offset) != 1 ||
  3086.                  offset + 12 > (unsigned int)p->buf_size ||
  3087.                  AV_RB64(p->buf+offset + 8) == 0)) {
  3088.                 score = FFMAX(score, AVPROBE_SCORE_EXTENSION);
  3089.             } else {
  3090.                 score = AVPROBE_SCORE_MAX;
  3091.             }
  3092.             offset = FFMAX(4, AV_RB32(p->buf+offset)) + offset;
  3093.             break;
  3094.         /* those are more common words, so rate then a bit less */
  3095.         case MKTAG('e','d','i','w'): /* xdcam files have reverted first tags */
  3096.         case MKTAG('w','i','d','e'):
  3097.         case MKTAG('f','r','e','e'):
  3098.         case MKTAG('j','u','n','k'):
  3099.         case MKTAG('p','i','c','t'):
  3100.             score  = FFMAX(score, AVPROBE_SCORE_MAX - 5);
  3101.             offset = FFMAX(4, AV_RB32(p->buf+offset)) + offset;
  3102.             break;
  3103.         case MKTAG(0x82,0x82,0x7f,0x7d):
  3104.         case MKTAG('s','k','i','p'):
  3105.         case MKTAG('u','u','i','d'):
  3106.         case MKTAG('p','r','f','l'):
  3107.             /* if we only find those cause probedata is too small at least rate them */
  3108.             score  = FFMAX(score, AVPROBE_SCORE_EXTENSION);
  3109.             offset = FFMAX(4, AV_RB32(p->buf+offset)) + offset;
  3110.             break;
  3111.         default:
  3112.             offset = FFMAX(4, AV_RB32(p->buf+offset)) + offset;
  3113.         }
  3114.     }
  3115.     if(score > AVPROBE_SCORE_MAX - 50 && moov_offset != -1) {
  3116.         /* moov atom in the header - we should make sure that this is not a
  3117.          * MOV-packed MPEG-PS */
  3118.         offset = moov_offset;
  3119.  
  3120.         while(offset < (p->buf_size - 16)){ /* Sufficient space */
  3121.                /* We found an actual hdlr atom */
  3122.             if(AV_RL32(p->buf + offset     ) == MKTAG('h','d','l','r') &&
  3123.                AV_RL32(p->buf + offset +  8) == MKTAG('m','h','l','r') &&
  3124.                AV_RL32(p->buf + offset + 12) == MKTAG('M','P','E','G')){
  3125.                 av_log(NULL, AV_LOG_WARNING, "Found media data tag MPEG indicating this is a MOV-packed MPEG-PS.\n");
  3126.                 /* We found a media handler reference atom describing an
  3127.                  * MPEG-PS-in-MOV, return a
  3128.                  * low score to force expanding the probe window until
  3129.                  * mpegps_probe finds what it needs */
  3130.                 return 5;
  3131.             }else
  3132.                 /* Keep looking */
  3133.                 offset+=2;
  3134.         }
  3135.     }
  3136.  
  3137.     return score;
  3138. }
  3139.  
  3140. // must be done after parsing all trak because there's no order requirement
  3141. static void mov_read_chapters(AVFormatContext *s)
  3142. {
  3143.     MOVContext *mov = s->priv_data;
  3144.     AVStream *st = NULL;
  3145.     MOVStreamContext *sc;
  3146.     int64_t cur_pos;
  3147.     int i;
  3148.  
  3149.     for (i = 0; i < s->nb_streams; i++)
  3150.         if (s->streams[i]->id == mov->chapter_track) {
  3151.             st = s->streams[i];
  3152.             break;
  3153.         }
  3154.     if (!st) {
  3155.         av_log(s, AV_LOG_ERROR, "Referenced QT chapter track not found\n");
  3156.         return;
  3157.     }
  3158.  
  3159.     st->discard = AVDISCARD_ALL;
  3160.     sc = st->priv_data;
  3161.     cur_pos = avio_tell(sc->pb);
  3162.  
  3163.     for (i = 0; i < st->nb_index_entries; i++) {
  3164.         AVIndexEntry *sample = &st->index_entries[i];
  3165.         int64_t end = i+1 < st->nb_index_entries ? st->index_entries[i+1].timestamp : st->duration;
  3166.         uint8_t *title;
  3167.         uint16_t ch;
  3168.         int len, title_len;
  3169.  
  3170.         if (avio_seek(sc->pb, sample->pos, SEEK_SET) != sample->pos) {
  3171.             av_log(s, AV_LOG_ERROR, "Chapter %d not found in file\n", i);
  3172.             goto finish;
  3173.         }
  3174.  
  3175.         // the first two bytes are the length of the title
  3176.         len = avio_rb16(sc->pb);
  3177.         if (len > sample->size-2)
  3178.             continue;
  3179.         title_len = 2*len + 1;
  3180.         if (!(title = av_mallocz(title_len)))
  3181.             goto finish;
  3182.  
  3183.         // The samples could theoretically be in any encoding if there's an encd
  3184.         // atom following, but in practice are only utf-8 or utf-16, distinguished
  3185.         // instead by the presence of a BOM
  3186.         if (!len) {
  3187.             title[0] = 0;
  3188.         } else {
  3189.             ch = avio_rb16(sc->pb);
  3190.             if (ch == 0xfeff)
  3191.                 avio_get_str16be(sc->pb, len, title, title_len);
  3192.             else if (ch == 0xfffe)
  3193.                 avio_get_str16le(sc->pb, len, title, title_len);
  3194.             else {
  3195.                 AV_WB16(title, ch);
  3196.                 if (len == 1 || len == 2)
  3197.                     title[len] = 0;
  3198.                 else
  3199.                     avio_get_str(sc->pb, INT_MAX, title + 2, len - 1);
  3200.             }
  3201.         }
  3202.  
  3203.         avpriv_new_chapter(s, i, st->time_base, sample->timestamp, end, title);
  3204.         av_freep(&title);
  3205.     }
  3206. finish:
  3207.     avio_seek(sc->pb, cur_pos, SEEK_SET);
  3208. }
  3209.  
  3210. static int parse_timecode_in_framenum_format(AVFormatContext *s, AVStream *st,
  3211.                                              uint32_t value, int flags)
  3212. {
  3213.     AVTimecode tc;
  3214.     char buf[AV_TIMECODE_STR_SIZE];
  3215.     AVRational rate = {st->codec->time_base.den,
  3216.                        st->codec->time_base.num};
  3217.     int ret = av_timecode_init(&tc, rate, flags, 0, s);
  3218.     if (ret < 0)
  3219.         return ret;
  3220.     av_dict_set(&st->metadata, "timecode",
  3221.                 av_timecode_make_string(&tc, buf, value), 0);
  3222.     return 0;
  3223. }
  3224.  
  3225. static int mov_read_timecode_track(AVFormatContext *s, AVStream *st)
  3226. {
  3227.     MOVStreamContext *sc = st->priv_data;
  3228.     int flags = 0;
  3229.     int64_t cur_pos = avio_tell(sc->pb);
  3230.     uint32_t value;
  3231.  
  3232.     if (!st->nb_index_entries)
  3233.         return -1;
  3234.  
  3235.     avio_seek(sc->pb, st->index_entries->pos, SEEK_SET);
  3236.     value = avio_rb32(s->pb);
  3237.  
  3238.     if (sc->tmcd_flags & 0x0001) flags |= AV_TIMECODE_FLAG_DROPFRAME;
  3239.     if (sc->tmcd_flags & 0x0002) flags |= AV_TIMECODE_FLAG_24HOURSMAX;
  3240.     if (sc->tmcd_flags & 0x0004) flags |= AV_TIMECODE_FLAG_ALLOWNEGATIVE;
  3241.  
  3242.     /* Assume Counter flag is set to 1 in tmcd track (even though it is likely
  3243.      * not the case) and thus assume "frame number format" instead of QT one.
  3244.      * No sample with tmcd track can be found with a QT timecode at the moment,
  3245.      * despite what the tmcd track "suggests" (Counter flag set to 0 means QT
  3246.      * format). */
  3247.     parse_timecode_in_framenum_format(s, st, value, flags);
  3248.  
  3249.     avio_seek(sc->pb, cur_pos, SEEK_SET);
  3250.     return 0;
  3251. }
  3252.  
  3253. static int mov_read_close(AVFormatContext *s)
  3254. {
  3255.     MOVContext *mov = s->priv_data;
  3256.     int i, j;
  3257.  
  3258.     for (i = 0; i < s->nb_streams; i++) {
  3259.         AVStream *st = s->streams[i];
  3260.         MOVStreamContext *sc = st->priv_data;
  3261.  
  3262.         av_freep(&sc->ctts_data);
  3263.         for (j = 0; j < sc->drefs_count; j++) {
  3264.             av_freep(&sc->drefs[j].path);
  3265.             av_freep(&sc->drefs[j].dir);
  3266.         }
  3267.         av_freep(&sc->drefs);
  3268.         if (!sc->pb_is_copied)
  3269.             avio_close(sc->pb);
  3270.         sc->pb = NULL;
  3271.         av_freep(&sc->chunk_offsets);
  3272.         av_freep(&sc->keyframes);
  3273.         av_freep(&sc->sample_sizes);
  3274.         av_freep(&sc->stps_data);
  3275.         av_freep(&sc->stsc_data);
  3276.         av_freep(&sc->stts_data);
  3277.     }
  3278.  
  3279.     if (mov->dv_demux) {
  3280.         for (i = 0; i < mov->dv_fctx->nb_streams; i++) {
  3281.             av_freep(&mov->dv_fctx->streams[i]->codec);
  3282.             av_freep(&mov->dv_fctx->streams[i]);
  3283.         }
  3284.         av_freep(&mov->dv_fctx);
  3285.         av_freep(&mov->dv_demux);
  3286.     }
  3287.  
  3288.     av_freep(&mov->trex_data);
  3289.     av_freep(&mov->bitrates);
  3290.  
  3291.     return 0;
  3292. }
  3293.  
  3294. static int tmcd_is_referenced(AVFormatContext *s, int tmcd_id)
  3295. {
  3296.     int i;
  3297.  
  3298.     for (i = 0; i < s->nb_streams; i++) {
  3299.         AVStream *st = s->streams[i];
  3300.         MOVStreamContext *sc = st->priv_data;
  3301.  
  3302.         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
  3303.             sc->timecode_track == tmcd_id)
  3304.             return 1;
  3305.     }
  3306.     return 0;
  3307. }
  3308.  
  3309. /* look for a tmcd track not referenced by any video track, and export it globally */
  3310. static void export_orphan_timecode(AVFormatContext *s)
  3311. {
  3312.     int i;
  3313.  
  3314.     for (i = 0; i < s->nb_streams; i++) {
  3315.         AVStream *st = s->streams[i];
  3316.  
  3317.         if (st->codec->codec_tag  == MKTAG('t','m','c','d') &&
  3318.             !tmcd_is_referenced(s, i + 1)) {
  3319.             AVDictionaryEntry *tcr = av_dict_get(st->metadata, "timecode", NULL, 0);
  3320.             if (tcr) {
  3321.                 av_dict_set(&s->metadata, "timecode", tcr->value, 0);
  3322.                 break;
  3323.             }
  3324.         }
  3325.     }
  3326. }
  3327.  
  3328. static int mov_read_header(AVFormatContext *s)
  3329. {
  3330.     MOVContext *mov = s->priv_data;
  3331.     AVIOContext *pb = s->pb;
  3332.     int i, j, err;
  3333.     MOVAtom atom = { AV_RL32("root") };
  3334.  
  3335.     mov->fc = s;
  3336.     /* .mov and .mp4 aren't streamable anyway (only progressive download if moov is before mdat) */
  3337.     if (pb->seekable)
  3338.         atom.size = avio_size(pb);
  3339.     else
  3340.         atom.size = INT64_MAX;
  3341.  
  3342.     /* check MOV header */
  3343.     if ((err = mov_read_default(mov, pb, atom)) < 0) {
  3344.         av_log(s, AV_LOG_ERROR, "error reading header: %d\n", err);
  3345.         mov_read_close(s);
  3346.         return err;
  3347.     }
  3348.     if (!mov->found_moov) {
  3349.         av_log(s, AV_LOG_ERROR, "moov atom not found\n");
  3350.         mov_read_close(s);
  3351.         return AVERROR_INVALIDDATA;
  3352.     }
  3353.     av_dlog(mov->fc, "on_parse_exit_offset=%"PRId64"\n", avio_tell(pb));
  3354.  
  3355.     if (pb->seekable) {
  3356.         if (mov->chapter_track > 0)
  3357.             mov_read_chapters(s);
  3358.         for (i = 0; i < s->nb_streams; i++)
  3359.             if (s->streams[i]->codec->codec_tag == AV_RL32("tmcd"))
  3360.                 mov_read_timecode_track(s, s->streams[i]);
  3361.     }
  3362.  
  3363.     /* copy timecode metadata from tmcd tracks to the related video streams */
  3364.     for (i = 0; i < s->nb_streams; i++) {
  3365.         AVStream *st = s->streams[i];
  3366.         MOVStreamContext *sc = st->priv_data;
  3367.         if (sc->timecode_track > 0) {
  3368.             AVDictionaryEntry *tcr;
  3369.             int tmcd_st_id = -1;
  3370.  
  3371.             for (j = 0; j < s->nb_streams; j++)
  3372.                 if (s->streams[j]->id == sc->timecode_track)
  3373.                     tmcd_st_id = j;
  3374.  
  3375.             if (tmcd_st_id < 0 || tmcd_st_id == i)
  3376.                 continue;
  3377.             tcr = av_dict_get(s->streams[tmcd_st_id]->metadata, "timecode", NULL, 0);
  3378.             if (tcr)
  3379.                 av_dict_set(&st->metadata, "timecode", tcr->value, 0);
  3380.         }
  3381.     }
  3382.     export_orphan_timecode(s);
  3383.  
  3384.     for (i = 0; i < s->nb_streams; i++) {
  3385.         AVStream *st = s->streams[i];
  3386.         MOVStreamContext *sc = st->priv_data;
  3387.         fix_timescale(mov, sc);
  3388.         if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && st->codec->codec_id == AV_CODEC_ID_AAC) {
  3389.             st->skip_samples = sc->start_pad;
  3390.         }
  3391.     }
  3392.  
  3393.     if (mov->trex_data) {
  3394.         for (i = 0; i < s->nb_streams; i++) {
  3395.             AVStream *st = s->streams[i];
  3396.             MOVStreamContext *sc = st->priv_data;
  3397.             if (st->duration > 0)
  3398.                 st->codec->bit_rate = sc->data_size * 8 * sc->time_scale / st->duration;
  3399.         }
  3400.     }
  3401.  
  3402.     for (i = 0; i < mov->bitrates_count && i < s->nb_streams; i++) {
  3403.         if (mov->bitrates[i]) {
  3404.             s->streams[i]->codec->bit_rate = mov->bitrates[i];
  3405.         }
  3406.     }
  3407.  
  3408.     return 0;
  3409. }
  3410.  
  3411. static AVIndexEntry *mov_find_next_sample(AVFormatContext *s, AVStream **st)
  3412. {
  3413.     AVIndexEntry *sample = NULL;
  3414.     int64_t best_dts = INT64_MAX;
  3415.     int i;
  3416.     for (i = 0; i < s->nb_streams; i++) {
  3417.         AVStream *avst = s->streams[i];
  3418.         MOVStreamContext *msc = avst->priv_data;
  3419.         if (msc->pb && msc->current_sample < avst->nb_index_entries) {
  3420.             AVIndexEntry *current_sample = &avst->index_entries[msc->current_sample];
  3421.             int64_t dts = av_rescale(current_sample->timestamp, AV_TIME_BASE, msc->time_scale);
  3422.             av_dlog(s, "stream %d, sample %d, dts %"PRId64"\n", i, msc->current_sample, dts);
  3423.             if (!sample || (!s->pb->seekable && current_sample->pos < sample->pos) ||
  3424.                 (s->pb->seekable &&
  3425.                  ((msc->pb != s->pb && dts < best_dts) || (msc->pb == s->pb &&
  3426.                  ((FFABS(best_dts - dts) <= AV_TIME_BASE && current_sample->pos < sample->pos) ||
  3427.                   (FFABS(best_dts - dts) > AV_TIME_BASE && dts < best_dts)))))) {
  3428.                 sample = current_sample;
  3429.                 best_dts = dts;
  3430.                 *st = avst;
  3431.             }
  3432.         }
  3433.     }
  3434.     return sample;
  3435. }
  3436.  
  3437. static int mov_read_packet(AVFormatContext *s, AVPacket *pkt)
  3438. {
  3439.     MOVContext *mov = s->priv_data;
  3440.     MOVStreamContext *sc;
  3441.     AVIndexEntry *sample;
  3442.     AVStream *st = NULL;
  3443.     int ret;
  3444.     mov->fc = s;
  3445.  retry:
  3446.     sample = mov_find_next_sample(s, &st);
  3447.     if (!sample) {
  3448.         mov->found_mdat = 0;
  3449.         if (!mov->next_root_atom)
  3450.             return AVERROR_EOF;
  3451.         avio_seek(s->pb, mov->next_root_atom, SEEK_SET);
  3452.         mov->next_root_atom = 0;
  3453.         if (mov_read_default(mov, s->pb, (MOVAtom){ AV_RL32("root"), INT64_MAX }) < 0 ||
  3454.             url_feof(s->pb))
  3455.             return AVERROR_EOF;
  3456.         av_dlog(s, "read fragments, offset 0x%"PRIx64"\n", avio_tell(s->pb));
  3457.         goto retry;
  3458.     }
  3459.     sc = st->priv_data;
  3460.     /* must be done just before reading, to avoid infinite loop on sample */
  3461.     sc->current_sample++;
  3462.  
  3463.     if (mov->next_root_atom) {
  3464.         sample->pos = FFMIN(sample->pos, mov->next_root_atom);
  3465.         sample->size = FFMIN(sample->size, (mov->next_root_atom - sample->pos));
  3466.     }
  3467.  
  3468.     if (st->discard != AVDISCARD_ALL) {
  3469.         if (avio_seek(sc->pb, sample->pos, SEEK_SET) != sample->pos) {
  3470.             av_log(mov->fc, AV_LOG_ERROR, "stream %d, offset 0x%"PRIx64": partial file\n",
  3471.                    sc->ffindex, sample->pos);
  3472.             return AVERROR_INVALIDDATA;
  3473.         }
  3474.         ret = av_get_packet(sc->pb, pkt, sample->size);
  3475.         if (ret < 0)
  3476.             return ret;
  3477.         if (sc->has_palette) {
  3478.             uint8_t *pal;
  3479.  
  3480.             pal = av_packet_new_side_data(pkt, AV_PKT_DATA_PALETTE, AVPALETTE_SIZE);
  3481.             if (!pal) {
  3482.                 av_log(mov->fc, AV_LOG_ERROR, "Cannot append palette to packet\n");
  3483.             } else {
  3484.                 memcpy(pal, sc->palette, AVPALETTE_SIZE);
  3485.                 sc->has_palette = 0;
  3486.             }
  3487.         }
  3488. #if CONFIG_DV_DEMUXER
  3489.         if (mov->dv_demux && sc->dv_audio_container) {
  3490.             avpriv_dv_produce_packet(mov->dv_demux, pkt, pkt->data, pkt->size, pkt->pos);
  3491.             av_free(pkt->data);
  3492.             pkt->size = 0;
  3493.             ret = avpriv_dv_get_packet(mov->dv_demux, pkt);
  3494.             if (ret < 0)
  3495.                 return ret;
  3496.         }
  3497. #endif
  3498.     }
  3499.  
  3500.     pkt->stream_index = sc->ffindex;
  3501.     pkt->dts = sample->timestamp;
  3502.     if (sc->ctts_data && sc->ctts_index < sc->ctts_count) {
  3503.         pkt->pts = pkt->dts + sc->dts_shift + sc->ctts_data[sc->ctts_index].duration;
  3504.         /* update ctts context */
  3505.         sc->ctts_sample++;
  3506.         if (sc->ctts_index < sc->ctts_count &&
  3507.             sc->ctts_data[sc->ctts_index].count == sc->ctts_sample) {
  3508.             sc->ctts_index++;
  3509.             sc->ctts_sample = 0;
  3510.         }
  3511.         if (sc->wrong_dts)
  3512.             pkt->dts = AV_NOPTS_VALUE;
  3513.     } else {
  3514.         int64_t next_dts = (sc->current_sample < st->nb_index_entries) ?
  3515.             st->index_entries[sc->current_sample].timestamp : st->duration;
  3516.         pkt->duration = next_dts - pkt->dts;
  3517.         pkt->pts = pkt->dts;
  3518.     }
  3519.     if (st->discard == AVDISCARD_ALL)
  3520.         goto retry;
  3521.     pkt->flags |= sample->flags & AVINDEX_KEYFRAME ? AV_PKT_FLAG_KEY : 0;
  3522.     pkt->pos = sample->pos;
  3523.     av_dlog(s, "stream %d, pts %"PRId64", dts %"PRId64", pos 0x%"PRIx64", duration %d\n",
  3524.             pkt->stream_index, pkt->pts, pkt->dts, pkt->pos, pkt->duration);
  3525.     return 0;
  3526. }
  3527.  
  3528. static int mov_seek_stream(AVFormatContext *s, AVStream *st, int64_t timestamp, int flags)
  3529. {
  3530.     MOVStreamContext *sc = st->priv_data;
  3531.     int sample, time_sample;
  3532.     int i;
  3533.  
  3534.     sample = av_index_search_timestamp(st, timestamp, flags);
  3535.     av_dlog(s, "stream %d, timestamp %"PRId64", sample %d\n", st->index, timestamp, sample);
  3536.     if (sample < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
  3537.         sample = 0;
  3538.     if (sample < 0) /* not sure what to do */
  3539.         return AVERROR_INVALIDDATA;
  3540.     sc->current_sample = sample;
  3541.     av_dlog(s, "stream %d, found sample %d\n", st->index, sc->current_sample);
  3542.     /* adjust ctts index */
  3543.     if (sc->ctts_data) {
  3544.         time_sample = 0;
  3545.         for (i = 0; i < sc->ctts_count; i++) {
  3546.             int next = time_sample + sc->ctts_data[i].count;
  3547.             if (next > sc->current_sample) {
  3548.                 sc->ctts_index = i;
  3549.                 sc->ctts_sample = sc->current_sample - time_sample;
  3550.                 break;
  3551.             }
  3552.             time_sample = next;
  3553.         }
  3554.     }
  3555.     return sample;
  3556. }
  3557.  
  3558. static int mov_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
  3559. {
  3560.     AVStream *st;
  3561.     int64_t seek_timestamp, timestamp;
  3562.     int sample;
  3563.     int i;
  3564.  
  3565.     if (stream_index >= s->nb_streams)
  3566.         return AVERROR_INVALIDDATA;
  3567.  
  3568.     st = s->streams[stream_index];
  3569.     sample = mov_seek_stream(s, st, sample_time, flags);
  3570.     if (sample < 0)
  3571.         return sample;
  3572.  
  3573.     /* adjust seek timestamp to found sample timestamp */
  3574.     seek_timestamp = st->index_entries[sample].timestamp;
  3575.  
  3576.     for (i = 0; i < s->nb_streams; i++) {
  3577.         MOVStreamContext *sc = s->streams[i]->priv_data;
  3578.         st = s->streams[i];
  3579.         st->skip_samples = (sample_time <= 0) ? sc->start_pad : 0;
  3580.  
  3581.         if (stream_index == i)
  3582.             continue;
  3583.  
  3584.         timestamp = av_rescale_q(seek_timestamp, s->streams[stream_index]->time_base, st->time_base);
  3585.         mov_seek_stream(s, st, timestamp, flags);
  3586.     }
  3587.     return 0;
  3588. }
  3589.  
  3590. static const AVOption options[] = {
  3591.     {"use_absolute_path",
  3592.         "allow using absolute path when opening alias, this is a possible security issue",
  3593.         offsetof(MOVContext, use_absolute_path), FF_OPT_TYPE_INT, {.i64 = 0},
  3594.         0, 1, AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_DECODING_PARAM},
  3595.     {"ignore_editlist", "", offsetof(MOVContext, ignore_editlist), FF_OPT_TYPE_INT, {.i64 = 0},
  3596.         0, 1, AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_DECODING_PARAM},
  3597.     {NULL}
  3598. };
  3599.  
  3600. static const AVClass mov_class = {
  3601.     .class_name = "mov,mp4,m4a,3gp,3g2,mj2",
  3602.     .item_name  = av_default_item_name,
  3603.     .option     = options,
  3604.     .version    = LIBAVUTIL_VERSION_INT,
  3605. };
  3606.  
  3607. AVInputFormat ff_mov_demuxer = {
  3608.     .name           = "mov,mp4,m4a,3gp,3g2,mj2",
  3609.     .long_name      = NULL_IF_CONFIG_SMALL("QuickTime / MOV"),
  3610.     .priv_data_size = sizeof(MOVContext),
  3611.     .read_probe     = mov_probe,
  3612.     .read_header    = mov_read_header,
  3613.     .read_packet    = mov_read_packet,
  3614.     .read_close     = mov_read_close,
  3615.     .read_seek      = mov_read_seek,
  3616.     .priv_class     = &mov_class,
  3617.     .flags          = AVFMT_NO_BYTE_SEEK,
  3618. };
  3619.