From 739985a09c0df50a6c2bbcb481a129d018c74391 Mon Sep 17 00:00:00 2001
From: Nariman-Sayed <narimansayed28@gmail.com>
Date: Wed, 21 Jan 2026 14:30:25 +0200
Subject: [PATCH] Fix: calculate bit_rate over entire fragmented MP4

---
 libavformat/isom.h |  150 +-
 libavformat/mov.c  | 3757 ++++++++++++++++++++++----------------------
 2 files changed, 1933 insertions(+), 1974 deletions(-)

diff --git a/libavformat/isom.h b/libavformat/isom.h
index 55bc2827b4..b8a0252724 100644
--- a/libavformat/isom.h
+++ b/libavformat/isom.h
@@ -37,7 +37,7 @@
 #include "internal.h"
 #include "dv.h"
 
-/* isom.c */
+ /* isom.c */
 extern const AVCodecTag ff_mp4_obj_type[];
 extern const AVCodecTag ff_codec_movvideo_tags[];
 extern const AVCodecTag ff_codec_movaudio_tags[];
@@ -84,8 +84,8 @@ typedef struct MOVElst {
 
 typedef struct MOVDref {
     uint32_t type;
-    char *path;
-    char *dir;
+    char* path;
+    char* dir;
     char volume[28];
     char filename[64];
     int16_t nlvl_to, nlvl_from;
@@ -127,7 +127,7 @@ typedef struct MOVEncryptionIndex {
     // Individual encrypted samples.  If there are no elements, then the default
     // settings will be used.
     unsigned int nb_encrypted_samples;
-    AVEncryptionInfo **encrypted_samples;
+    AVEncryptionInfo** encrypted_samples;
 
     uint8_t* auxiliary_info_sizes;
     size_t auxiliary_info_sample_count;
@@ -145,7 +145,7 @@ typedef struct MOVFragmentStreamInfo {
     // Index of the first sample/trun in the fragment.
     int index_base;
     int index_entry;
-    MOVEncryptionIndex *encryption_index;
+    MOVEncryptionIndex* encryption_index;
     int stsd_id; // current fragment stsd_id
 } MOVFragmentStreamInfo;
 
@@ -154,7 +154,7 @@ typedef struct MOVFragmentIndexItem {
     int headers_read;
     int current;
     int nb_stream_info;
-    MOVFragmentStreamInfo * stream_info;
+    MOVFragmentStreamInfo* stream_info;
 } MOVFragmentIndexItem;
 
 typedef struct MOVFragmentIndex {
@@ -162,7 +162,7 @@ typedef struct MOVFragmentIndex {
     int complete;
     int current;
     int nb_items;
-    MOVFragmentIndexItem * item;
+    MOVFragmentIndexItem* item;
 } MOVFragmentIndex;
 
 typedef struct MOVIndexRange {
@@ -171,42 +171,45 @@ typedef struct MOVIndexRange {
 } MOVIndexRange;
 
 typedef struct MOVStreamContext {
-    AVIOContext *pb;
+    int64_t fragment_duration_sum;
+    int64_t fragment_size_sum;
+    int64_t total_data_size;
+    AVIOContext* pb;
     int refcount;
     int pb_is_copied;
     int id;               ///< AVStream id
     int ffindex;          ///< AVStream index
     int next_chunk;
     unsigned int chunk_count;
-    int64_t *chunk_offsets;
+    int64_t* chunk_offsets;
     unsigned int tts_count;
     unsigned int tts_allocated_size;
-    MOVTimeToSample *tts_data;
+    MOVTimeToSample* tts_data;
     unsigned int stts_count;
     unsigned int stts_allocated_size;
-    MOVStts *stts_data;
+    MOVStts* stts_data;
     unsigned int sdtp_count;
-    uint8_t *sdtp_data;
+    uint8_t* sdtp_data;
     unsigned int ctts_count;
     unsigned int ctts_allocated_size;
-    MOVCtts *ctts_data;
+    MOVCtts* ctts_data;
     unsigned int stsc_count;
-    MOVStsc *stsc_data;
+    MOVStsc* stsc_data;
     unsigned int stsc_index;
     int stsc_sample;
     unsigned int stps_count;
-    unsigned *stps_data;  ///< partial sync sample for mpeg-2 open gop
-    MOVElst *elst_data;
+    unsigned* stps_data;  ///< partial sync sample for mpeg-2 open gop
+    MOVElst* elst_data;
     unsigned int elst_count;
     int tts_index;
     int tts_sample;
     unsigned int sample_size; ///< may contain value calculated from stsd or value from stsz atom
     unsigned int stsz_sample_size; ///< always contains sample size from stsz atom
     unsigned int sample_count;
-    unsigned int *sample_sizes;
+    unsigned int* sample_sizes;
     int keyframe_absent;
     unsigned int keyframe_count;
-    int *keyframes;
+    int* keyframes;
     int time_scale;
     int64_t time_offset;  ///< time offset of the edit list entries
     int64_t min_corrected_pts;  ///< minimum Composition time shown by the edits excluding empty edits.
@@ -220,7 +223,7 @@ typedef struct MOVStreamContext {
     int pseudo_stream_id; ///< -1 means demux all ids
     int16_t audio_cid;    ///< stsd audio compression id
     unsigned drefs_count;
-    MOVDref *drefs;
+    MOVDref* drefs;
     int dref_id;
     unsigned tref_flags;
     int tref_id;
@@ -238,14 +241,14 @@ typedef struct MOVStreamContext {
     int64_t track_end;    ///< used for dts generation in fragmented movie files
     int start_pad;        ///< amount of samples to skip due to enc-dec delay
     unsigned int rap_group_count;
-    MOVSbgp *rap_group;
+    MOVSbgp* rap_group;
     unsigned int sync_group_count;
-    MOVSbgp *sync_group;
-    uint8_t *sgpd_sync;
+    MOVSbgp* sync_group;
+    uint8_t* sgpd_sync;
     uint32_t sgpd_sync_count;
-    int32_t *sample_offsets;
+    int32_t* sample_offsets;
     int sample_offsets_count;
-    int *open_key_samples;
+    int* open_key_samples;
     int open_key_samples_count;
     uint32_t min_sample_duration;
 
@@ -253,22 +256,22 @@ typedef struct MOVStreamContext {
     int64_t duration_for_fps;
 
     /** extradata array (and size) for multiple stsd */
-    uint8_t **extradata;
-    int *extradata_size;
+    uint8_t** extradata;
+    int* extradata_size;
     int last_stsd_index;
     int stsd_count;
     int stsd_version;
 
-    int32_t *display_matrix;
-    AVStereo3D *stereo3d;
+    int32_t* display_matrix;
+    AVStereo3D* stereo3d;
     size_t stereo3d_size;
-    AVSphericalMapping *spherical;
+    AVSphericalMapping* spherical;
     size_t spherical_size;
-    AVMasteringDisplayMetadata *mastering;
+    AVMasteringDisplayMetadata* mastering;
     size_t mastering_size;
-    AVContentLightMetadata *coll;
+    AVContentLightMetadata* coll;
     size_t coll_size;
-    AVAmbientViewingEnvironment *ambient;
+    AVAmbientViewingEnvironment* ambient;
     size_t ambient_size;
 
     uint32_t format;
@@ -276,26 +279,19 @@ typedef struct MOVStreamContext {
     int has_sidx;  // If there is an sidx entry for this stream.
     struct {
         struct AVAESCTR* aes_ctr;
-        struct AVAES *aes_ctx;
+        struct AVAES* aes_ctx;
         unsigned int per_sample_iv_size;  // Either 0, 8, or 16.
-        AVEncryptionInfo *default_encrypted_sample;
-        MOVEncryptionIndex *encryption_index;
+        AVEncryptionInfo* default_encrypted_sample;
+        MOVEncryptionIndex* encryption_index;
     } cenc;
 
-    struct IAMFDemuxContext *iamf;
+    struct IAMFDemuxContext* iamf;
     int iamf_stream_offset;
 } MOVStreamContext;
 
-typedef struct HEIFItemRef {
-    uint32_t type;
-    int item_id;
-} HEIFItemRef;
-
 typedef struct HEIFItem {
-    AVStream *st;
-    HEIFItemRef *iref_list;
-    int nb_iref_list;
-    char *name;
+    AVStream* st;
+    char* name;
     int item_id;
     int64_t extent_length;
     int64_t extent_offset;
@@ -306,21 +302,21 @@ typedef struct HEIFItem {
     int vflip;
     int type;
     int is_idat_relative;
-    uint8_t *icc_profile;
+    uint8_t* icc_profile;
     size_t icc_profile_size;
 } HEIFItem;
 
 typedef struct HEIFGrid {
-    HEIFItem *item;
-    HEIFItem **tile_item_list;
-    int16_t *tile_id_list;
-    unsigned *tile_idx_list;
+    HEIFItem* item;
+    HEIFItem** tile_item_list;
+    int16_t* tile_id_list;
+    unsigned* tile_idx_list;
     int nb_tiles;
 } HEIFGrid;
 
 typedef struct MOVContext {
-    const AVClass *class; ///< class for private options
-    AVFormatContext *fc;
+    const AVClass* class; ///< class for private options
+    AVFormatContext* fc;
     int time_scale;
     int64_t duration;     ///< duration of the longest track
     int found_moov;       ///< 'moov' atom has been found
@@ -329,17 +325,17 @@ typedef struct MOVContext {
     int found_mdat;       ///< 'mdat' atom has been found
     int found_hdlr_mdta;  ///< 'hdlr' atom with type 'mdta' has been found
     int trak_index;       ///< Index of the current 'trak'
-    char **meta_keys;
+    char** meta_keys;
     unsigned meta_keys_count;
-    DVDemuxContext *dv_demux;
-    AVFormatContext *dv_fctx;
+    DVDemuxContext* dv_demux;
+    AVFormatContext* dv_fctx;
     int isom;             ///< 1 if file is ISO Media (mp4/3gp)
     MOVFragment fragment; ///< current fragment in moof atom
-    MOVTrackExt *trex_data;
+    MOVTrackExt* trex_data;
     unsigned trex_count;
     int itunes_metadata;  ///< metadata are itunes style
     int handbrake_version;
-    int *chapter_tracks;
+    int* chapter_tracks;
     unsigned int nb_chapter_tracks;
     int use_absolute_path;
     int ignore_editlist;
@@ -350,7 +346,7 @@ typedef struct MOVContext {
     int64_t next_root_atom; ///< offset of the next root atom
     int export_all;
     int export_xmp;
-    int *bitrates;          ///< bitrates read before streams creation
+    int* bitrates;          ///< bitrates read before streams creation
     int bitrates_count;
     int moov_retry;
     int use_mfra_for;
@@ -361,16 +357,16 @@ typedef struct MOVContext {
     unsigned int aax_mode;  ///< 'aax' file has been detected
     uint8_t file_key[20];
     uint8_t file_iv[20];
-    void *activation_bytes;
+    void* activation_bytes;
     int activation_bytes_size;
-    void *audible_fixed_key;
+    void* audible_fixed_key;
     int audible_fixed_key_size;
-    void *audible_key;
+    void* audible_key;
     int audible_key_size;
-    void *audible_iv;
+    void* audible_iv;
     int audible_iv_size;
-    struct AVAES *aes_decrypt;
-    uint8_t *decryption_key;
+    struct AVAES* aes_decrypt;
+    uint8_t* decryption_key;
     int decryption_key_len;
     int enable_drefs;
     int32_t movie_display_matrix[3][3]; ///< display matrix from mvhd
@@ -379,18 +375,20 @@ typedef struct MOVContext {
     uint32_t max_stts_delta;
     int primary_item_id;
     int cur_item_id;
-    HEIFItem **heif_item;
+    HEIFItem** heif_item;
     int nb_heif_item;
-    HEIFGrid *heif_grid;
+    HEIFGrid* heif_grid;
     int nb_heif_grid;
+    int* thmb_item_id;
+    int nb_thmb_item;
     int64_t idat_offset;
     int interleaved_read;
 } MOVContext;
 
-int ff_mp4_read_descr_len(AVIOContext *pb);
-int ff_mp4_read_descr(void *logctx, AVIOContext *pb, int *tag);
-int ff_mp4_read_dec_config_descr(void *logctx, AVStream *st, AVIOContext *pb);
-void ff_mp4_parse_es_descr(AVIOContext *pb, int *es_id);
+int ff_mp4_read_descr_len(AVIOContext* pb);
+int ff_mp4_read_descr(void* logctx, AVIOContext* pb, int* tag);
+int ff_mp4_read_dec_config_descr(void* logctx, AVStream* st, AVIOContext* pb);
+void ff_mp4_parse_es_descr(AVIOContext* pb, int* es_id);
 
 #define MP4ODescrTag                    0x01
 #define MP4IODescrTag                   0x02
@@ -452,10 +450,10 @@ void ff_mp4_parse_es_descr(AVIOContext *pb, int *es_id);
      (tag) == MKTAG('A', 'V', 'i', 'n'))
 
 
-int ff_mov_read_esds(AVFormatContext *fc, AVIOContext *pb);
+int ff_mov_read_esds(AVFormatContext* fc, AVIOContext* pb);
 
-int ff_mov_read_stsd_entries(MOVContext *c, AVIOContext *pb, int entries);
-void ff_mov_write_chan(AVIOContext *pb, int64_t channel_layout);
+int ff_mov_read_stsd_entries(MOVContext* c, AVIOContext* pb, int entries);
+void ff_mov_write_chan(AVIOContext* pb, int64_t channel_layout);
 
 #define FF_MOV_FLAG_MFRA_AUTO -1
 #define FF_MOV_FLAG_MFRA_DTS 1
@@ -482,12 +480,12 @@ static inline enum AVCodecID ff_mov_get_lpcm_codec_id(int bps, int flags)
 
 struct MP4TrackKindValueMapping {
     int         disposition;
-    const char *value;
+    const char* value;
 };
 
 struct MP4TrackKindMapping {
-    const char   *scheme_uri;
-    const struct  MP4TrackKindValueMapping *value_maps;
+    const char* scheme_uri;
+    const struct  MP4TrackKindValueMapping* value_maps;
 };
 
 extern const struct MP4TrackKindMapping ff_mov_track_kind_table[];
diff --git a/libavformat/mov.c b/libavformat/mov.c
index d19b213ffa..e006e77338 100644
--- a/libavformat/mov.c
+++ b/libavformat/mov.c
@@ -51,7 +51,6 @@
 #include "libavutil/timecode.h"
 #include "libavutil/uuid.h"
 #include "libavcodec/ac3tab.h"
-#include "libavcodec/exif.h"
 #include "libavcodec/flac.h"
 #include "libavcodec/hevc/hevc.h"
 #include "libavcodec/mpegaudiodecheader.h"
@@ -77,19 +76,19 @@
 
 #include "qtpalette.h"
 
-/* those functions parse an atom */
-/* links atom IDs to parse functions */
+ /* those functions parse an atom */
+ /* links atom IDs to parse functions */
 typedef struct MOVParseTableEntry {
     uint32_t type;
-    int (*parse)(MOVContext *ctx, AVIOContext *pb, MOVAtom atom);
+    int (*parse)(MOVContext* ctx, AVIOContext* pb, MOVAtom atom);
 } MOVParseTableEntry;
 
-static int mov_read_default(MOVContext *c, AVIOContext *pb, MOVAtom atom);
-static int mov_read_mfra(MOVContext *c, AVIOContext *f);
-static void mov_free_stream_context(AVFormatContext *s, AVStream *st);
+static int mov_read_default(MOVContext* c, AVIOContext* pb, MOVAtom atom);
+static int mov_read_mfra(MOVContext* c, AVIOContext* f);
+static void mov_free_stream_context(AVFormatContext* s, AVStream* st);
 
-static int mov_metadata_track_or_disc_number(MOVContext *c, AVIOContext *pb,
-                                             unsigned len, const char *key)
+static int mov_metadata_track_or_disc_number(MOVContext* c, AVIOContext* pb,
+    unsigned len, const char* key)
 {
     char buf[16];
 
@@ -108,8 +107,8 @@ static int mov_metadata_track_or_disc_number(MOVContext *c, AVIOContext *pb,
     return 0;
 }
 
-static int mov_metadata_int8_bypass_padding(MOVContext *c, AVIOContext *pb,
-                                            unsigned len, const char *key)
+static int mov_metadata_int8_bypass_padding(MOVContext* c, AVIOContext* pb,
+    unsigned len, const char* key)
 {
     /* bypass padding bytes */
     avio_r8(pb);
@@ -122,8 +121,8 @@ static int mov_metadata_int8_bypass_padding(MOVContext *c, AVIOContext *pb,
     return 0;
 }
 
-static int mov_metadata_int8_no_padding(MOVContext *c, AVIOContext *pb,
-                                        unsigned len, const char *key)
+static int mov_metadata_int8_no_padding(MOVContext* c, AVIOContext* pb,
+    unsigned len, const char* key)
 {
     c->fc->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
     av_dict_set_int(&c->fc->metadata, key, avio_r8(pb), 0);
@@ -131,8 +130,8 @@ static int mov_metadata_int8_no_padding(MOVContext *c, AVIOContext *pb,
     return 0;
 }
 
-static int mov_metadata_gnre(MOVContext *c, AVIOContext *pb,
-                             unsigned len, const char *key)
+static int mov_metadata_gnre(MOVContext* c, AVIOContext* pb,
+    unsigned len, const char* key)
 {
     short genre;
 
@@ -142,7 +141,7 @@ static int mov_metadata_gnre(MOVContext *c, AVIOContext *pb,
     if (genre < 1 || genre > ID3v1_GENRE_MAX)
         return 0;
     c->fc->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
-    av_dict_set(&c->fc->metadata, key, ff_id3v1_genre_str[genre-1], 0);
+    av_dict_set(&c->fc->metadata, key, ff_id3v1_genre_str[genre - 1], 0);
 
     return 0;
 }
@@ -166,11 +165,11 @@ static const uint32_t mac_to_unicode[128] = {
     0x00AF,0x02D8,0x02D9,0x02DA,0x00B8,0x02DD,0x02DB,0x02C7,
 };
 
-static int mov_read_mac_string(MOVContext *c, AVIOContext *pb, int len,
-                               char *dst, int dstlen)
+static int mov_read_mac_string(MOVContext* c, AVIOContext* pb, int len,
+    char* dst, int dstlen)
 {
-    char *p = dst;
-    char *end = dst+dstlen-1;
+    char* p = dst;
+    char* end = dst + dstlen - 1;
     int i;
 
     for (i = 0; i < len; i++) {
@@ -182,21 +181,21 @@ static int mov_read_mac_string(MOVContext *c, AVIOContext *pb, int len,
         if (c < 0x80)
             *p++ = c;
         else if (p < end)
-            PUT_UTF8(mac_to_unicode[c-0x80], t, if (p < end) *p++ = t;);
+            PUT_UTF8(mac_to_unicode[c - 0x80], t, if (p < end) *p++ = t;);
     }
     *p = 0;
     return p - dst;
 }
 
 /**
- * Get the requested item.
+ * Get the current item in the parsing process.
  */
-static HEIFItem *get_heif_item(MOVContext *c, unsigned id)
+static HEIFItem* heif_cur_item(MOVContext* c)
 {
-    HEIFItem *item = NULL;
+    HEIFItem* item = NULL;
 
     for (int i = 0; i < c->nb_heif_item; i++) {
-        if (!c->heif_item[i] || c->heif_item[i]->item_id != id)
+        if (!c->heif_item[i] || c->heif_item[i]->item_id != c->cur_item_id)
             continue;
 
         item = c->heif_item[i];
@@ -210,28 +209,28 @@ static HEIFItem *get_heif_item(MOVContext *c, unsigned id)
  * Get the current stream in the parsing process. This can either be the
  * latest stream added to the context, or the stream referenced by an item.
  */
-static AVStream *get_curr_st(MOVContext *c)
+static AVStream* get_curr_st(MOVContext* c)
 {
-    AVStream *st = NULL;
-    HEIFItem *item;
+    AVStream* st = NULL;
+    HEIFItem* item;
 
     if (c->fc->nb_streams < 1)
         return NULL;
 
     if (c->cur_item_id == -1)
-        return c->fc->streams[c->fc->nb_streams-1];
+        return c->fc->streams[c->fc->nb_streams - 1];
 
-    item = get_heif_item(c, c->cur_item_id);
+    item = heif_cur_item(c);
     if (item)
         st = item->st;
 
     return st;
 }
 
-static int mov_read_covr(MOVContext *c, AVIOContext *pb, int type, int len)
+static int mov_read_covr(MOVContext* c, AVIOContext* pb, int type, int len)
 {
-    AVStream *st;
-    MOVStreamContext *sc;
+    AVStream* st;
+    MOVStreamContext* sc;
     enum AVCodecID id;
     int ret;
 
@@ -261,23 +260,24 @@ static int mov_read_covr(MOVContext *c, AVIOContext *pb, int type, int len)
     if (st->attached_pic.size >= 8 && id != AV_CODEC_ID_BMP) {
         if (AV_RB64(st->attached_pic.data) == 0x89504e470d0a1a0a) {
             id = AV_CODEC_ID_PNG;
-        } else {
+        }
+        else {
             id = AV_CODEC_ID_MJPEG;
         }
     }
-    st->codecpar->codec_id   = id;
+    st->codecpar->codec_id = id;
 
     return 0;
 }
 
 // 3GPP TS 26.244
-static int mov_metadata_loci(MOVContext *c, AVIOContext *pb, unsigned len)
+static int mov_metadata_loci(MOVContext* c, AVIOContext* pb, unsigned len)
 {
     char language[4] = { 0 };
     char buf[200], place[100];
     uint16_t langcode = 0;
     double longitude, latitude, altitude;
-    const char *key = "location";
+    const char* key = "location";
 
     if (len < 4 + 2 + 1 + 1 + 4 + 4 + 4) {
         av_log(c->fc, AV_LOG_ERROR, "loci too short\n");
@@ -299,15 +299,15 @@ static int mov_metadata_loci(MOVContext *c, AVIOContext *pb, unsigned len)
 
     if (len < 12) {
         av_log(c->fc, AV_LOG_ERROR,
-               "loci too short (%u bytes left, need at least %d)\n", len, 12);
+            "loci too short (%u bytes left, need at least %d)\n", len, 12);
         return AVERROR_INVALIDDATA;
     }
-    longitude = ((int32_t) avio_rb32(pb)) / (float) (1 << 16);
-    latitude  = ((int32_t) avio_rb32(pb)) / (float) (1 << 16);
-    altitude  = ((int32_t) avio_rb32(pb)) / (float) (1 << 16);
+    longitude = ((int32_t)avio_rb32(pb)) / (float)(1 << 16);
+    latitude = ((int32_t)avio_rb32(pb)) / (float)(1 << 16);
+    altitude = ((int32_t)avio_rb32(pb)) / (float)(1 << 16);
 
     // Try to output in the same format as the ?xyz field
-    snprintf(buf, sizeof(buf), "%+08.4f%+09.4f",  latitude, longitude);
+    snprintf(buf, sizeof(buf), "%+08.4f%+09.4f", latitude, longitude);
     if (altitude)
         av_strlcatf(buf, sizeof(buf), "%+f", altitude);
     av_strlcatf(buf, sizeof(buf), "/%s", place);
@@ -321,7 +321,7 @@ static int mov_metadata_loci(MOVContext *c, AVIOContext *pb, unsigned len)
     return av_dict_set(&c->fc->metadata, key, buf, 0);
 }
 
-static int mov_metadata_hmmt(MOVContext *c, AVIOContext *pb, unsigned len)
+static int mov_metadata_hmmt(MOVContext* c, AVIOContext* pb, unsigned len)
 {
     int i, n_hmmt;
 
@@ -342,19 +342,19 @@ static int mov_metadata_hmmt(MOVContext *c, AVIOContext *pb, unsigned len)
     return 0;
 }
 
-static int mov_read_udta_string(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_udta_string(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    char tmp_key[AV_FOURCC_MAX_STRING_SIZE] = {0};
-    char key2[32], language[4] = {0};
-    char *str = NULL;
-    const char *key = NULL;
+    char tmp_key[AV_FOURCC_MAX_STRING_SIZE] = { 0 };
+    char key2[32], language[4] = { 0 };
+    char* str = NULL;
+    const char* key = NULL;
     uint16_t langcode = 0;
     uint32_t data_type = 0, str_size_alloc;
     uint64_t str_size;
     int (*parse)(MOVContext*, AVIOContext*, unsigned, const char*) = NULL;
     int raw = 0;
     int num = 0;
-    AVDictionary **metadata;
+    AVDictionary** metadata;
 
     if (c->trak_index >= 0 && c->trak_index < c->fc->nb_streams)
         metadata = &c->fc->streams[c->trak_index]->metadata;
@@ -362,102 +362,101 @@ static int mov_read_udta_string(MOVContext *c, AVIOContext *pb, MOVAtom atom)
         metadata = &c->fc->metadata;
 
     switch (atom.type) {
-    case MKTAG( '@','P','R','M'): key = "premiere_version"; raw = 1; break;
-    case MKTAG( '@','P','R','Q'): key = "quicktime_version"; raw = 1; break;
-    case MKTAG( 'X','M','P','_'):
+    case MKTAG('@', 'P', 'R', 'M'): key = "premiere_version"; raw = 1; break;
+    case MKTAG('@', 'P', 'R', 'Q'): key = "quicktime_version"; raw = 1; break;
+    case MKTAG('X', 'M', 'P', '_'):
         if (c->export_xmp) { key = "xmp"; raw = 1; } break;
-    case MKTAG( 'a','A','R','T'): key = "album_artist";    break;
-    case MKTAG( 'a','k','I','D'): key = "account_type";
+    case MKTAG('a', 'A', 'R', 'T'): key = "album_artist";    break;
+    case MKTAG('a', 'k', 'I', 'D'): key = "account_type";
         parse = mov_metadata_int8_no_padding; break;
-    case MKTAG( 'a','p','I','D'): key = "account_id"; break;
-    case MKTAG( 'c','a','t','g'): key = "category"; break;
-    case MKTAG( 'c','p','i','l'): key = "compilation";
+    case MKTAG('a', 'p', 'I', 'D'): key = "account_id"; break;
+    case MKTAG('c', 'a', 't', 'g'): key = "category"; break;
+    case MKTAG('c', 'p', 'i', 'l'): key = "compilation";
         parse = mov_metadata_int8_no_padding; break;
-    case MKTAG( 'c','p','r','t'): key = "copyright"; break;
-    case MKTAG( 'd','e','s','c'): key = "description"; break;
-    case MKTAG( 'd','i','s','k'): key = "disc";
+    case MKTAG('c', 'p', 'r', 't'): key = "copyright"; break;
+    case MKTAG('d', 'e', 's', 'c'): key = "description"; break;
+    case MKTAG('d', 'i', 's', 'k'): key = "disc";
         parse = mov_metadata_track_or_disc_number; break;
-    case MKTAG( 'e','g','i','d'): key = "episode_uid";
+    case MKTAG('e', 'g', 'i', 'd'): key = "episode_uid";
         parse = mov_metadata_int8_no_padding; break;
-    case MKTAG( 'F','I','R','M'): key = "firmware"; raw = 1; break;
-    case MKTAG( 'g','n','r','e'): key = "genre";
+    case MKTAG('F', 'I', 'R', 'M'): key = "firmware"; raw = 1; break;
+    case MKTAG('g', 'n', 'r', 'e'): key = "genre";
         parse = mov_metadata_gnre; break;
-    case MKTAG( 'h','d','v','d'): key = "hd_video";
+    case MKTAG('h', 'd', 'v', 'd'): key = "hd_video";
         parse = mov_metadata_int8_no_padding; break;
-    case MKTAG( 'H','M','M','T'):
+    case MKTAG('H', 'M', 'M', 'T'):
         return mov_metadata_hmmt(c, pb, atom.size);
-    case MKTAG( 'k','e','y','w'): key = "keywords";  break;
-    case MKTAG( 'l','d','e','s'): key = "synopsis";  break;
-    case MKTAG( 'l','o','c','i'):
+    case MKTAG('k', 'e', 'y', 'w'): key = "keywords";  break;
+    case MKTAG('l', 'd', 'e', 's'): key = "synopsis";  break;
+    case MKTAG('l', 'o', 'c', 'i'):
         return mov_metadata_loci(c, pb, atom.size);
-    case MKTAG( 'm','a','n','u'): key = "make"; break;
-    case MKTAG( 'm','o','d','l'): key = "model"; break;
-    case MKTAG( 'n','a','m','e'): key = "name"; break;
-    case MKTAG( 'p','c','s','t'): key = "podcast";
+    case MKTAG('m', 'a', 'n', 'u'): key = "make"; break;
+    case MKTAG('m', 'o', 'd', 'l'): key = "model"; break;
+    case MKTAG('p', 'c', 's', 't'): key = "podcast";
         parse = mov_metadata_int8_no_padding; break;
-    case MKTAG( 'p','g','a','p'): key = "gapless_playback";
+    case MKTAG('p', 'g', 'a', 'p'): key = "gapless_playback";
         parse = mov_metadata_int8_no_padding; break;
-    case MKTAG( 'p','u','r','d'): key = "purchase_date"; break;
-    case MKTAG( 'r','t','n','g'): key = "rating";
+    case MKTAG('p', 'u', 'r', 'd'): key = "purchase_date"; break;
+    case MKTAG('r', 't', 'n', 'g'): key = "rating";
         parse = mov_metadata_int8_no_padding; break;
-    case MKTAG( 's','o','a','a'): key = "sort_album_artist"; break;
-    case MKTAG( 's','o','a','l'): key = "sort_album";   break;
-    case MKTAG( 's','o','a','r'): key = "sort_artist";  break;
-    case MKTAG( 's','o','c','o'): key = "sort_composer"; break;
-    case MKTAG( 's','o','n','m'): key = "sort_name";    break;
-    case MKTAG( 's','o','s','n'): key = "sort_show";    break;
-    case MKTAG( 's','t','i','k'): key = "media_type";
+    case MKTAG('s', 'o', 'a', 'a'): key = "sort_album_artist"; break;
+    case MKTAG('s', 'o', 'a', 'l'): key = "sort_album";   break;
+    case MKTAG('s', 'o', 'a', 'r'): key = "sort_artist";  break;
+    case MKTAG('s', 'o', 'c', 'o'): key = "sort_composer"; break;
+    case MKTAG('s', 'o', 'n', 'm'): key = "sort_name";    break;
+    case MKTAG('s', 'o', 's', 'n'): key = "sort_show";    break;
+    case MKTAG('s', 't', 'i', 'k'): key = "media_type";
         parse = mov_metadata_int8_no_padding; break;
-    case MKTAG( 't','r','k','n'): key = "track";
+    case MKTAG('t', 'r', 'k', 'n'): key = "track";
         parse = mov_metadata_track_or_disc_number; break;
-    case MKTAG( 't','v','e','n'): key = "episode_id"; break;
-    case MKTAG( 't','v','e','s'): key = "episode_sort";
+    case MKTAG('t', 'v', 'e', 'n'): key = "episode_id"; break;
+    case MKTAG('t', 'v', 'e', 's'): key = "episode_sort";
         parse = mov_metadata_int8_bypass_padding; break;
-    case MKTAG( 't','v','n','n'): key = "network";   break;
-    case MKTAG( 't','v','s','h'): key = "show";      break;
-    case MKTAG( 't','v','s','n'): key = "season_number";
+    case MKTAG('t', 'v', 'n', 'n'): key = "network";   break;
+    case MKTAG('t', 'v', 's', 'h'): key = "show";      break;
+    case MKTAG('t', 'v', 's', 'n'): key = "season_number";
         parse = mov_metadata_int8_bypass_padding; break;
-    case MKTAG(0xa9,'A','R','T'): key = "artist";    break;
-    case MKTAG(0xa9,'P','R','D'): key = "producer";  break;
-    case MKTAG(0xa9,'a','l','b'): key = "album";     break;
-    case MKTAG(0xa9,'a','u','t'): key = "artist";    break;
-    case MKTAG(0xa9,'c','h','p'): key = "chapter";   break;
-    case MKTAG(0xa9,'c','m','t'): key = "comment";   break;
-    case MKTAG(0xa9,'c','o','m'): key = "composer";  break;
-    case MKTAG(0xa9,'c','p','y'): key = "copyright"; break;
-    case MKTAG(0xa9,'d','a','y'): key = "date";      break;
-    case MKTAG(0xa9,'d','i','r'): key = "director";  break;
-    case MKTAG(0xa9,'d','i','s'): key = "disclaimer"; break;
-    case MKTAG(0xa9,'e','d','1'): key = "edit_date"; break;
-    case MKTAG(0xa9,'e','n','c'): key = "encoder";   break;
-    case MKTAG(0xa9,'f','m','t'): key = "original_format"; break;
-    case MKTAG(0xa9,'g','e','n'): key = "genre";     break;
-    case MKTAG(0xa9,'g','r','p'): key = "grouping";  break;
-    case MKTAG(0xa9,'h','s','t'): key = "host_computer"; break;
-    case MKTAG(0xa9,'i','n','f'): key = "comment";   break;
-    case MKTAG(0xa9,'l','y','r'): key = "lyrics";    break;
-    case MKTAG(0xa9,'m','a','k'): key = "make";      break;
-    case MKTAG(0xa9,'m','o','d'): key = "model";     break;
-    case MKTAG(0xa9,'n','a','m'): key = "title";     break;
-    case MKTAG(0xa9,'o','p','e'): key = "original_artist"; break;
-    case MKTAG(0xa9,'p','r','d'): key = "producer";  break;
-    case MKTAG(0xa9,'p','r','f'): key = "performers"; break;
-    case MKTAG(0xa9,'r','e','q'): key = "playback_requirements"; break;
-    case MKTAG(0xa9,'s','r','c'): key = "original_source"; break;
-    case MKTAG(0xa9,'s','t','3'): key = "subtitle";  break;
-    case MKTAG(0xa9,'s','w','r'): key = "encoder";   break;
-    case MKTAG(0xa9,'t','o','o'): key = "encoder";   break;
-    case MKTAG(0xa9,'t','r','k'): key = "track";     break;
-    case MKTAG(0xa9,'u','r','l'): key = "URL";       break;
-    case MKTAG(0xa9,'w','r','n'): key = "warning";   break;
-    case MKTAG(0xa9,'w','r','t'): key = "composer";  break;
-    case MKTAG(0xa9,'x','y','z'): key = "location";  break;
+    case MKTAG(0xa9, 'A', 'R', 'T'): key = "artist";    break;
+    case MKTAG(0xa9, 'P', 'R', 'D'): key = "producer";  break;
+    case MKTAG(0xa9, 'a', 'l', 'b'): key = "album";     break;
+    case MKTAG(0xa9, 'a', 'u', 't'): key = "artist";    break;
+    case MKTAG(0xa9, 'c', 'h', 'p'): key = "chapter";   break;
+    case MKTAG(0xa9, 'c', 'm', 't'): key = "comment";   break;
+    case MKTAG(0xa9, 'c', 'o', 'm'): key = "composer";  break;
+    case MKTAG(0xa9, 'c', 'p', 'y'): key = "copyright"; break;
+    case MKTAG(0xa9, 'd', 'a', 'y'): key = "date";      break;
+    case MKTAG(0xa9, 'd', 'i', 'r'): key = "director";  break;
+    case MKTAG(0xa9, 'd', 'i', 's'): key = "disclaimer"; break;
+    case MKTAG(0xa9, 'e', 'd', '1'): key = "edit_date"; break;
+    case MKTAG(0xa9, 'e', 'n', 'c'): key = "encoder";   break;
+    case MKTAG(0xa9, 'f', 'm', 't'): key = "original_format"; break;
+    case MKTAG(0xa9, 'g', 'e', 'n'): key = "genre";     break;
+    case MKTAG(0xa9, 'g', 'r', 'p'): key = "grouping";  break;
+    case MKTAG(0xa9, 'h', 's', 't'): key = "host_computer"; break;
+    case MKTAG(0xa9, 'i', 'n', 'f'): key = "comment";   break;
+    case MKTAG(0xa9, 'l', 'y', 'r'): key = "lyrics";    break;
+    case MKTAG(0xa9, 'm', 'a', 'k'): key = "make";      break;
+    case MKTAG(0xa9, 'm', 'o', 'd'): key = "model";     break;
+    case MKTAG(0xa9, 'n', 'a', 'm'): key = "title";     break;
+    case MKTAG(0xa9, 'o', 'p', 'e'): key = "original_artist"; break;
+    case MKTAG(0xa9, 'p', 'r', 'd'): key = "producer";  break;
+    case MKTAG(0xa9, 'p', 'r', 'f'): key = "performers"; break;
+    case MKTAG(0xa9, 'r', 'e', 'q'): key = "playback_requirements"; break;
+    case MKTAG(0xa9, 's', 'r', 'c'): key = "original_source"; break;
+    case MKTAG(0xa9, 's', 't', '3'): key = "subtitle";  break;
+    case MKTAG(0xa9, 's', 'w', 'r'): key = "encoder";   break;
+    case MKTAG(0xa9, 't', 'o', 'o'): key = "encoder";   break;
+    case MKTAG(0xa9, 't', 'r', 'k'): key = "track";     break;
+    case MKTAG(0xa9, 'u', 'r', 'l'): key = "URL";       break;
+    case MKTAG(0xa9, 'w', 'r', 'n'): key = "warning";   break;
+    case MKTAG(0xa9, 'w', 'r', 't'): key = "composer";  break;
+    case MKTAG(0xa9, 'x', 'y', 'z'): key = "location";  break;
     }
 retry:
     if (c->itunes_metadata && atom.size > 8) {
         int data_size = avio_rb32(pb);
         int tag = avio_rl32(pb);
-        if (tag == MKTAG('d','a','t','a') && data_size <= atom.size && data_size >= 16) {
+        if (tag == MKTAG('d', 'a', 't', 'a') && data_size <= atom.size && data_size >= 16) {
             data_type = avio_rb32(pb); // type
             avio_rb32(pb); // unknown
             str_size = data_size - 16;
@@ -467,10 +466,11 @@ retry:
                 uint32_t index = av_bswap32(atom.type); // BE number has been read as LE
                 if (index < c->meta_keys_count && index > 0) {
                     key = c->meta_keys[index];
-                } else if (atom.type != MKTAG('c', 'o', 'v', 'r')) {
+                }
+                else if (atom.type != MKTAG('c', 'o', 'v', 'r')) {
                     av_log(c->fc, AV_LOG_WARNING,
-                           "The index of 'data' is out of range: %"PRId32" < 1 or >= %d.\n",
-                           index, c->meta_keys_count);
+                        "The index of 'data' is out of range: %"PRId32" < 1 or >= %d.\n",
+                        index, c->meta_keys_count);
                 }
             }
             if (atom.type == MKTAG('c', 'o', 'v', 'r') ||
@@ -485,8 +485,10 @@ retry:
                     goto retry;
                 return ret;
             }
-        } else return 0;
-    } else if (atom.size > 4 && (key || c->export_all) && !c->itunes_metadata && !raw) {
+        }
+        else return 0;
+    }
+    else if (atom.size > 4 && (key || c->export_all) && !c->itunes_metadata && !raw) {
         str_size = avio_rb16(pb); // string length
         if (str_size > atom.size) {
             raw = 1;
@@ -497,7 +499,8 @@ retry:
         langcode = avio_rb16(pb);
         ff_mov_lang_to_iso639(langcode, language);
         atom.size -= 4;
-    } else
+    }
+    else
         str_size = atom.size;
 
     if (c->export_all && !key) {
@@ -506,7 +509,7 @@ retry:
 
     if (!key)
         return 0;
-    if (atom.size < 0 || str_size >= INT_MAX/2)
+    if (atom.size < 0 || str_size >= INT_MAX / 2)
         return AVERROR_INVALIDDATA;
 
     // Allocates enough space if data_type is a int32 or float32 number, otherwise
@@ -522,23 +525,25 @@ retry:
     else {
         if (!raw && (data_type == 3 || (data_type == 0 && (langcode < 0x400 || langcode == 0x7fff)))) { // MAC Encoded
             mov_read_mac_string(c, pb, str_size, str, str_size_alloc);
-        } else if (data_type == 21) { // BE signed integer, variable size
+        }
+        else if (data_type == 21) { // BE signed integer, variable size
             int val = 0;
             if (str_size == 1)
                 val = (int8_t)avio_r8(pb);
             else if (str_size == 2)
                 val = (int16_t)avio_rb16(pb);
             else if (str_size == 3)
-                val = ((int32_t)(avio_rb24(pb)<<8))>>8;
+                val = ((int32_t)(avio_rb24(pb) << 8)) >> 8;
             else if (str_size == 4)
                 val = (int32_t)avio_rb32(pb);
             if (snprintf(str, str_size_alloc, "%d", val) >= str_size_alloc) {
                 av_log(c->fc, AV_LOG_ERROR,
-                       "Failed to store the number (%d) in string.\n", val);
+                    "Failed to store the number (%d) in string.\n", val);
                 av_free(str);
                 return AVERROR_INVALIDDATA;
             }
-        } else if (data_type == 22) { // BE unsigned integer, variable size
+        }
+        else if (data_type == 22) { // BE unsigned integer, variable size
             unsigned int val = 0;
             if (str_size == 1)
                 val = avio_r8(pb);
@@ -550,19 +555,21 @@ retry:
                 val = avio_rb32(pb);
             if (snprintf(str, str_size_alloc, "%u", val) >= str_size_alloc) {
                 av_log(c->fc, AV_LOG_ERROR,
-                       "Failed to store the number (%u) in string.\n", val);
+                    "Failed to store the number (%u) in string.\n", val);
                 av_free(str);
                 return AVERROR_INVALIDDATA;
             }
-        } else if (data_type == 23 && str_size >= 4) {  // BE float32
+        }
+        else if (data_type == 23 && str_size >= 4) {  // BE float32
             float val = av_int2float(avio_rb32(pb));
             if (snprintf(str, str_size_alloc, "%f", val) >= str_size_alloc) {
                 av_log(c->fc, AV_LOG_ERROR,
-                       "Failed to store the float32 number (%f) in string.\n", val);
+                    "Failed to store the float32 number (%f) in string.\n", val);
                 av_free(str);
                 return AVERROR_INVALIDDATA;
             }
-        } else if (data_type > 1 && data_type != 4) {
+        }
+        else if (data_type > 1 && data_type != 4) {
             // data_type can be 0 if not set at all above. data_type 1 means
             // UTF8 and 4 means "UTF8 sort". For any other type (UTF16 or e.g.
             // a picture), don't return it blindly in a string that is supposed
@@ -570,7 +577,8 @@ retry:
             av_log(c->fc, AV_LOG_WARNING, "Skipping unhandled metadata %s of type %d\n", key, data_type);
             av_free(str);
             return 0;
-        } else {
+        }
+        else {
             int ret = ffio_read_size(pb, str, str_size);
             if (ret < 0) {
                 av_free(str);
@@ -587,7 +595,7 @@ retry:
         if (!strcmp(key, "encoder")) {
             int major, minor, micro;
             if (sscanf(str, "HandBrake %d.%d.%d", &major, &minor, &micro) == 3) {
-                c->handbrake_version = 1000000*major + 1000*minor + micro;
+                c->handbrake_version = 1000000 * major + 1000 * minor + micro;
             }
         }
     }
@@ -596,11 +604,11 @@ retry:
     return 0;
 }
 
-static int mov_read_chpl(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_chpl(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
     int64_t start;
     int i, nb_chapters, str_len, version;
-    char str[256+1];
+    char str[256 + 1];
     int ret;
 
     if (c->ignore_chapters)
@@ -622,39 +630,39 @@ static int mov_read_chpl(MOVContext *c, AVIOContext *pb, MOVAtom atom)
         start = avio_rb64(pb);
         str_len = avio_r8(pb);
 
-        if ((atom.size -= 9+str_len) < 0)
+        if ((atom.size -= 9 + str_len) < 0)
             return 0;
 
         ret = ffio_read_size(pb, str, str_len);
         if (ret < 0)
             return ret;
         str[str_len] = 0;
-        avpriv_new_chapter(c->fc, i, (AVRational){1,10000000}, start, AV_NOPTS_VALUE, str);
+        avpriv_new_chapter(c->fc, i, (AVRational) { 1, 10000000 }, start, AV_NOPTS_VALUE, str);
     }
     return 0;
 }
 
 #define MIN_DATA_ENTRY_BOX_SIZE 12
-static int mov_read_dref(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_dref(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    AVStream *st;
-    MOVStreamContext *sc;
+    AVStream* st;
+    MOVStreamContext* sc;
     int entries, i, j;
 
     if (c->fc->nb_streams < 1)
         return 0;
-    st = c->fc->streams[c->fc->nb_streams-1];
+    st = c->fc->streams[c->fc->nb_streams - 1];
     sc = st->priv_data;
 
     avio_rb32(pb); // version + flags
     entries = avio_rb32(pb);
     if (!entries ||
-        entries >  (atom.size - 1) / MIN_DATA_ENTRY_BOX_SIZE + 1 ||
+        entries > (atom.size - 1) / MIN_DATA_ENTRY_BOX_SIZE + 1 ||
         entries >= UINT_MAX / sizeof(*sc->drefs))
         return AVERROR_INVALIDDATA;
 
     for (i = 0; i < sc->drefs_count; i++) {
-        MOVDref *dref = &sc->drefs[i];
+        MOVDref* dref = &sc->drefs[i];
         av_freep(&dref->path);
         av_freep(&dref->dir);
     }
@@ -666,7 +674,7 @@ static int mov_read_dref(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     sc->drefs_count = entries;
 
     for (i = 0; i < entries; i++) {
-        MOVDref *dref = &sc->drefs[i];
+        MOVDref* dref = &sc->drefs[i];
         uint32_t size = avio_rb32(pb);
         int64_t next = avio_tell(pb);
 
@@ -678,7 +686,7 @@ static int mov_read_dref(MOVContext *c, AVIOContext *pb, MOVAtom atom)
         dref->type = avio_rl32(pb);
         avio_rb32(pb); // version + flags
 
-        if (dref->type == MKTAG('a','l','i','s') && size > 150) {
+        if (dref->type == MKTAG('a', 'l', 'i', 's') && size > 150) {
             /* macintosh alias record */
             uint16_t volume_len, len;
             int16_t type;
@@ -708,9 +716,9 @@ static int mov_read_dref(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 
             /* read next level up_from_alias/down_to_target */
             dref->nlvl_from = avio_rb16(pb);
-            dref->nlvl_to   = avio_rb16(pb);
+            dref->nlvl_to = avio_rb16(pb);
             av_log(c->fc, AV_LOG_DEBUG, "nlvl from %d, nlvl to %d\n",
-                   dref->nlvl_from, dref->nlvl_to);
+                dref->nlvl_from, dref->nlvl_to);
 
             avio_skip(pb, 16);
 
@@ -720,11 +728,11 @@ static int mov_read_dref(MOVContext *c, AVIOContext *pb, MOVAtom atom)
                 type = avio_rb16(pb);
                 len = avio_rb16(pb);
                 av_log(c->fc, AV_LOG_DEBUG, "type %d, len %d\n", type, len);
-                if (len&1)
+                if (len & 1)
                     len += 1;
                 if (type == 2) { // absolute path
                     av_free(dref->path);
-                    dref->path = av_mallocz(len+1);
+                    dref->path = av_mallocz(len + 1);
                     if (!dref->path)
                         return AVERROR(ENOMEM);
 
@@ -735,7 +743,7 @@ static int mov_read_dref(MOVContext *c, AVIOContext *pb, MOVAtom atom)
                     }
                     if (len > volume_len && !strncmp(dref->path, dref->volume, volume_len)) {
                         len -= volume_len;
-                        memmove(dref->path, dref->path+volume_len, len);
+                        memmove(dref->path, dref->path + volume_len, len);
                         dref->path[len] = 0;
                     }
                     // trim string of any ending zeros
@@ -749,9 +757,10 @@ static int mov_read_dref(MOVContext *c, AVIOContext *pb, MOVAtom atom)
                         if (dref->path[j] == ':' || dref->path[j] == 0)
                             dref->path[j] = '/';
                     av_log(c->fc, AV_LOG_DEBUG, "path %s\n", dref->path);
-                } else if (type == 0) { // directory name
+                }
+                else if (type == 0) { // directory name
                     av_free(dref->dir);
-                    dref->dir = av_malloc(len+1);
+                    dref->dir = av_malloc(len + 1);
                     if (!dref->dir)
                         return AVERROR(ENOMEM);
 
@@ -765,12 +774,14 @@ static int mov_read_dref(MOVContext *c, AVIOContext *pb, MOVAtom atom)
                         if (dref->dir[j] == ':')
                             dref->dir[j] = '/';
                     av_log(c->fc, AV_LOG_DEBUG, "dir %s\n", dref->dir);
-                } else
+                }
+                else
                     avio_skip(pb, len);
             }
-        } else {
+        }
+        else {
             av_log(c->fc, AV_LOG_DEBUG, "Unknown dref type 0x%08"PRIx32" size %"PRIu32"\n",
-                   dref->type, size);
+                dref->type, size);
             entries--;
             i--;
         }
@@ -779,13 +790,13 @@ static int mov_read_dref(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return 0;
 }
 
-static int mov_read_hdlr(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_hdlr(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    AVStream *st;
+    AVStream* st;
     uint32_t type;
     uint32_t ctype;
     int64_t title_size;
-    char *title_str;
+    char* title_str;
     int ret;
 
     avio_r8(pb); /* version */
@@ -799,21 +810,21 @@ static int mov_read_hdlr(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     av_log(c->fc, AV_LOG_TRACE, "stype=%s\n", av_fourcc2str(type));
 
     if (c->trak_index < 0) {  // meta not inside a trak
-        if (type == MKTAG('m','d','t','a')) {
+        if (type == MKTAG('m', 'd', 't', 'a')) {
             c->found_hdlr_mdta = 1;
         }
         return 0;
     }
 
-    st = c->fc->streams[c->fc->nb_streams-1];
+    st = c->fc->streams[c->fc->nb_streams - 1];
 
-    if     (type == MKTAG('v','i','d','e'))
+    if (type == MKTAG('v', 'i', 'd', 'e'))
         st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
-    else if (type == MKTAG('s','o','u','n'))
+    else if (type == MKTAG('s', 'o', 'u', 'n'))
         st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
-    else if (type == MKTAG('m','1','a',' '))
+    else if (type == MKTAG('m', '1', 'a', ' '))
         st->codecpar->codec_id = AV_CODEC_ID_MP2;
-    else if ((type == MKTAG('s','u','b','p')) || (type == MKTAG('c','l','c','p')))
+    else if ((type == MKTAG('s', 'u', 'b', 'p')) || (type == MKTAG('c', 'l', 'c', 'p')))
         st->codecpar->codec_type = AVMEDIA_TYPE_SUBTITLE;
 
     avio_rb32(pb); /* component  manufacture */
@@ -822,7 +833,7 @@ static int mov_read_hdlr(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 
     title_size = atom.size - 24;
     if (title_size > 0) {
-        if (title_size > FFMIN(INT_MAX, SIZE_MAX-1))
+        if (title_size > FFMIN(INT_MAX, SIZE_MAX - 1))
             return AVERROR_INVALIDDATA;
         title_str = av_malloc(title_size + 1); /* Add null terminator */
         if (!title_str)
@@ -845,27 +856,27 @@ static int mov_read_hdlr(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return 0;
 }
 
-static int mov_read_esds(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_esds(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
     return ff_mov_read_esds(c->fc, pb);
 }
 
-static int mov_read_dac3(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_dac3(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    AVStream *st;
-    AVPacketSideData *sd;
-    enum AVAudioServiceType *ast;
+    AVStream* st;
+    AVPacketSideData* sd;
+    enum AVAudioServiceType* ast;
     int ac3info, acmod, lfeon, bsmod;
     uint64_t mask;
 
     if (c->fc->nb_streams < 1)
         return 0;
-    st = c->fc->streams[c->fc->nb_streams-1];
+    st = c->fc->streams[c->fc->nb_streams - 1];
 
     sd = av_packet_side_data_new(&st->codecpar->coded_side_data,
-                                 &st->codecpar->nb_coded_side_data,
-                                 AV_PKT_DATA_AUDIO_SERVICE_TYPE,
-                                 sizeof(*ast), 0);
+        &st->codecpar->nb_coded_side_data,
+        AV_PKT_DATA_AUDIO_SERVICE_TYPE,
+        sizeof(*ast), 0);
     if (!sd)
         return AVERROR(ENOMEM);
 
@@ -889,14 +900,14 @@ static int mov_read_dac3(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 }
 
 #if CONFIG_IAMFDEC
-static int mov_read_iacb(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_iacb(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    AVStream *st;
-    MOVStreamContext *sc;
+    AVStream* st;
+    MOVStreamContext* sc;
     FFIOContext b;
-    AVIOContext *descriptor_pb;
-    AVDictionary *metadata;
-    IAMFContext *iamf;
+    AVIOContext* descriptor_pb;
+    AVDictionary* metadata;
+    IAMFContext* iamf;
     int64_t start_time, duration;
     unsigned descriptors_size;
     int nb_frames, disposition;
@@ -911,7 +922,7 @@ static int mov_read_iacb(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     version = avio_r8(pb);
     if (version != 1) {
         av_log(c->fc, AV_LOG_ERROR, "%s configurationVersion %d",
-               version < 1 ? "invalid" : "unsupported", version);
+            version < 1 ? "invalid" : "unsupported", version);
         return AVERROR_INVALIDDATA;
     }
 
@@ -956,9 +967,9 @@ static int mov_read_iacb(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     disposition = st->disposition;
 
     for (int i = 0; i < iamf->nb_audio_elements; i++) {
-        IAMFAudioElement *audio_element = iamf->audio_elements[i];
-        const AVIAMFAudioElement *element;
-        AVStreamGroup *stg =
+        IAMFAudioElement* audio_element = iamf->audio_elements[i];
+        const AVIAMFAudioElement* element;
+        AVStreamGroup* stg =
             avformat_stream_group_create(c->fc, AV_STREAM_GROUP_PARAMS_IAMF_AUDIO_ELEMENT, NULL);
 
         if (!stg) {
@@ -973,14 +984,15 @@ static int mov_read_iacb(MOVContext *c, AVIOContext *pb, MOVAtom atom)
         audio_element->element = NULL;
 
         for (int j = 0; j < audio_element->nb_substreams; j++) {
-            IAMFSubStream *substream = &audio_element->substreams[j];
-            AVStream *stream;
+            IAMFSubStream* substream = &audio_element->substreams[j];
+            AVStream* stream;
 
             if (!i && !j) {
                 if (audio_element->layers[0].substream_count != 1)
                     disposition &= ~AV_DISPOSITION_DEFAULT;
                 stream = st;
-            } else
+            }
+            else
                 stream = avformat_new_stream(c->fc, NULL);
             if (!stream) {
                 ret = AVERROR(ENOMEM);
@@ -1023,9 +1035,9 @@ static int mov_read_iacb(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     }
 
     for (int i = 0; i < iamf->nb_mix_presentations; i++) {
-        IAMFMixPresentation *mix_presentation = iamf->mix_presentations[i];
-        const AVIAMFMixPresentation *mix = mix_presentation->cmix;
-        AVStreamGroup *stg =
+        IAMFMixPresentation* mix_presentation = iamf->mix_presentations[i];
+        const AVIAMFMixPresentation* mix = mix_presentation->cmix;
+        AVStreamGroup* stg =
             avformat_stream_group_create(c->fc, AV_STREAM_GROUP_PARAMS_IAMF_MIX_PRESENTATION, NULL);
 
         if (!stg) {
@@ -1040,15 +1052,15 @@ static int mov_read_iacb(MOVContext *c, AVIOContext *pb, MOVAtom atom)
         mix_presentation->mix = NULL;
 
         for (int j = 0; j < mix->nb_submixes; j++) {
-            const AVIAMFSubmix *submix = mix->submixes[j];
+            const AVIAMFSubmix* submix = mix->submixes[j];
 
             for (int k = 0; k < submix->nb_elements; k++) {
-                const AVIAMFSubmixElement *submix_element = submix->elements[k];
-                const AVStreamGroup *audio_element = NULL;
+                const AVIAMFSubmixElement* submix_element = submix->elements[k];
+                const AVStreamGroup* audio_element = NULL;
 
                 for (int l = 0; l < c->fc->nb_stream_groups; l++)
                     if (c->fc->stream_groups[l]->type == AV_STREAM_GROUP_PARAMS_IAMF_AUDIO_ELEMENT &&
-                        c->fc->stream_groups[l]->id   == submix_element->audio_element_id) {
+                        c->fc->stream_groups[l]->id == submix_element->audio_element_id) {
                         audio_element = c->fc->stream_groups[l];
                         break;
                     }
@@ -1075,56 +1087,22 @@ fail:
 }
 #endif
 
-static int mov_read_srat(MOVContext *c, AVIOContext *pb, MOVAtom atom)
-{
-    AVStream *st;
-    int32_t sample_rate;
-
-    if (atom.size < 8 || c->fc->nb_streams < 1)
-        return 0;
-
-    st = c->fc->streams[c->fc->nb_streams-1];
-    if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO) {
-        av_log(c->fc, AV_LOG_WARNING, "'srat' within non-audio sample entry, skip\n");
-        return 0;
-    }
-
-    if (!c->isom) {
-        av_log(c->fc, AV_LOG_WARNING, "'srat' within non-isom, skip\n");
-        return 0;
-    }
-
-    avio_skip(pb, 4); // version+flags
-    sample_rate = avio_rb32(pb);
-    if (sample_rate > 0) {
-        av_log(c->fc, AV_LOG_DEBUG,
-               "overwrite sample rate from %d to %d by 'srat'\n",
-               st->codecpar->sample_rate, sample_rate);
-        st->codecpar->sample_rate = sample_rate;
-    } else {
-        av_log(c->fc, AV_LOG_WARNING,
-               "ignore invalid sample rate %d in 'srat'\n", sample_rate);
-    }
-
-    return 0;
-}
-
-static int mov_read_dec3(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_dec3(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    AVStream *st;
-    AVPacketSideData *sd;
-    enum AVAudioServiceType *ast;
+    AVStream* st;
+    AVPacketSideData* sd;
+    enum AVAudioServiceType* ast;
     int eac3info, acmod, lfeon, bsmod;
     uint64_t mask;
 
     if (c->fc->nb_streams < 1)
         return 0;
-    st = c->fc->streams[c->fc->nb_streams-1];
+    st = c->fc->streams[c->fc->nb_streams - 1];
 
     sd = av_packet_side_data_new(&st->codecpar->coded_side_data,
-                                 &st->codecpar->nb_coded_side_data,
-                                 AV_PKT_DATA_AUDIO_SERVICE_TYPE,
-                                 sizeof(*ast), 0);
+        &st->codecpar->nb_coded_side_data,
+        AV_PKT_DATA_AUDIO_SERVICE_TYPE,
+        sizeof(*ast), 0);
     if (!sd)
         return AVERROR(ENOMEM);
 
@@ -1136,8 +1114,8 @@ static int mov_read_dec3(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     avio_rb16(pb); /* data_rate and num_ind_sub */
     eac3info = avio_rb24(pb);
     bsmod = (eac3info >> 12) & 0x1f;
-    acmod = (eac3info >>  9) & 0x7;
-    lfeon = (eac3info >>  8) & 0x1;
+    acmod = (eac3info >> 9) & 0x7;
+    lfeon = (eac3info >> 8) & 0x1;
 
     mask = ff_ac3_channel_layout_tab[acmod];
     if (lfeon)
@@ -1152,11 +1130,11 @@ static int mov_read_dec3(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return 0;
 }
 
-static int mov_read_ddts(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_ddts(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
 #define DDTS_SIZE 20
     uint8_t buf[DDTS_SIZE + AV_INPUT_BUFFER_PADDING_SIZE];
-    AVStream *st = NULL;
+    AVStream* st = NULL;
     uint32_t frame_duration_code = 0;
     uint32_t channel_layout_code = 0;
     GetBitContext gb;
@@ -1170,7 +1148,7 @@ static int mov_read_ddts(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     if (c->fc->nb_streams < 1) {
         return 0;
     }
-    st = c->fc->streams[c->fc->nb_streams-1];
+    st = c->fc->streams[c->fc->nb_streams - 1];
 
     st->codecpar->sample_rate = get_bits_long(&gb, 32);
     if (st->codecpar->sample_rate <= 0) {
@@ -1185,33 +1163,33 @@ static int mov_read_ddts(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     channel_layout_code = get_bits(&gb, 16);
 
     st->codecpar->frame_size =
-            (frame_duration_code == 0) ? 512 :
-            (frame_duration_code == 1) ? 1024 :
-            (frame_duration_code == 2) ? 2048 :
-            (frame_duration_code == 3) ? 4096 : 0;
+        (frame_duration_code == 0) ? 512 :
+        (frame_duration_code == 1) ? 1024 :
+        (frame_duration_code == 2) ? 2048 :
+        (frame_duration_code == 3) ? 4096 : 0;
 
     if (channel_layout_code > 0xff) {
         av_log(c->fc, AV_LOG_WARNING, "Unsupported DTS audio channel layout\n");
     }
     av_channel_layout_uninit(&st->codecpar->ch_layout);
     av_channel_layout_from_mask(&st->codecpar->ch_layout,
-            ((channel_layout_code & 0x1) ? AV_CH_FRONT_CENTER : 0) |
-            ((channel_layout_code & 0x2) ? AV_CH_FRONT_LEFT : 0) |
-            ((channel_layout_code & 0x2) ? AV_CH_FRONT_RIGHT : 0) |
-            ((channel_layout_code & 0x4) ? AV_CH_SIDE_LEFT : 0) |
-            ((channel_layout_code & 0x4) ? AV_CH_SIDE_RIGHT : 0) |
-            ((channel_layout_code & 0x8) ? AV_CH_LOW_FREQUENCY : 0));
+        ((channel_layout_code & 0x1) ? AV_CH_FRONT_CENTER : 0) |
+        ((channel_layout_code & 0x2) ? AV_CH_FRONT_LEFT : 0) |
+        ((channel_layout_code & 0x2) ? AV_CH_FRONT_RIGHT : 0) |
+        ((channel_layout_code & 0x4) ? AV_CH_SIDE_LEFT : 0) |
+        ((channel_layout_code & 0x4) ? AV_CH_SIDE_RIGHT : 0) |
+        ((channel_layout_code & 0x8) ? AV_CH_LOW_FREQUENCY : 0));
 
     return 0;
 }
 
-static int mov_read_chan(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_chan(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    AVStream *st;
+    AVStream* st;
 
     if (c->fc->nb_streams < 1)
         return 0;
-    st = c->fc->streams[c->fc->nb_streams-1];
+    st = c->fc->streams[c->fc->nb_streams - 1];
 
     if (atom.size < 16)
         return 0;
@@ -1224,23 +1202,23 @@ static int mov_read_chan(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return 0;
 }
 
-static int mov_read_chnl(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_chnl(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
     int64_t end = av_sat_add64(avio_tell(pb), atom.size);
     int version, flags;
     int ret;
-    AVStream *st;
+    AVStream* st;
 
     if (c->fc->nb_streams < 1)
         return 0;
-    st = c->fc->streams[c->fc->nb_streams-1];
+    st = c->fc->streams[c->fc->nb_streams - 1];
 
     version = avio_r8(pb);
-    flags   = avio_rb24(pb);
+    flags = avio_rb24(pb);
     if (version != 0 || flags != 0) {
         av_log(c->fc, AV_LOG_ERROR,
-               "Unsupported 'chnl' box with version %d, flags: %#x",
-               version, flags);
+            "Unsupported 'chnl' box with version %d, flags: %#x",
+            version, flags);
         return AVERROR_INVALIDDATA;
     }
 
@@ -1250,20 +1228,20 @@ static int mov_read_chnl(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 
     if (avio_tell(pb) != end) {
         av_log(c->fc, AV_LOG_WARNING, "skip %" PRId64 " bytes of unknown data inside chnl\n",
-                end - avio_tell(pb));
+            end - avio_tell(pb));
         avio_seek(pb, end, SEEK_SET);
     }
     return ret;
 }
 
-static int mov_read_wfex(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_wfex(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    AVStream *st;
+    AVStream* st;
     int ret;
 
     if (c->fc->nb_streams < 1)
         return 0;
-    st = c->fc->streams[c->fc->nb_streams-1];
+    st = c->fc->streams[c->fc->nb_streams - 1];
 
     if ((ret = ff_get_wav_header(c->fc, pb, st->codecpar, atom.size, 0)) < 0)
         av_log(c->fc, AV_LOG_WARNING, "get_wav_header failed\n");
@@ -1271,25 +1249,25 @@ static int mov_read_wfex(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return ret;
 }
 
-static int mov_read_clap(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_clap(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    AVStream *st;
-    HEIFItem *item;
-    AVPacketSideData *sd;
+    AVStream* st;
+    HEIFItem* item;
+    AVPacketSideData* sd;
     int width, height, err = 0;
     AVRational aperture_width, aperture_height, horiz_off, vert_off;
     AVRational pc_x, pc_y;
     uint64_t top, bottom, left, right;
 
-    item = get_heif_item(c, c->cur_item_id);
+    item = heif_cur_item(c);
     st = get_curr_st(c);
     if (!st)
         return 0;
 
-    width  = st->codecpar->width;
+    width = st->codecpar->width;
     height = st->codecpar->height;
     if ((!width || !height) && item) {
-        width  = item->width;
+        width = item->width;
         height = item->height;
     }
     if (!width || !height) {
@@ -1297,55 +1275,55 @@ static int mov_read_clap(MOVContext *c, AVIOContext *pb, MOVAtom atom)
         goto fail;
     }
 
-    aperture_width.num  = avio_rb32(pb);
-    aperture_width.den  = avio_rb32(pb);
+    aperture_width.num = avio_rb32(pb);
+    aperture_width.den = avio_rb32(pb);
     aperture_height.num = avio_rb32(pb);
     aperture_height.den = avio_rb32(pb);
 
     horiz_off.num = avio_rb32(pb);
     horiz_off.den = avio_rb32(pb);
-    vert_off.num  = avio_rb32(pb);
-    vert_off.den  = avio_rb32(pb);
+    vert_off.num = avio_rb32(pb);
+    vert_off.den = avio_rb32(pb);
 
-    if (aperture_width.num  < 0 || aperture_width.den  < 0 ||
+    if (aperture_width.num < 0 || aperture_width.den < 0 ||
         aperture_height.num < 0 || aperture_height.den < 0 ||
-        horiz_off.den       < 0 || vert_off.den        < 0) {
+        horiz_off.den < 0 || vert_off.den < 0) {
         err = AVERROR_INVALIDDATA;
         goto fail;
     }
-    if ((av_cmp_q((AVRational) { width,  1 }, aperture_width)  < 0) ||
+    if ((av_cmp_q((AVRational) { width, 1 }, aperture_width) < 0) ||
         (av_cmp_q((AVRational) { height, 1 }, aperture_height) < 0)) {
         err = AVERROR_INVALIDDATA;
         goto fail;
     }
     av_log(c->fc, AV_LOG_TRACE, "clap: apertureWidth %d/%d, apertureHeight %d/%d "
-                                "horizOff %d/%d vertOff %d/%d\n",
-           aperture_width.num, aperture_width.den, aperture_height.num, aperture_height.den,
-           horiz_off.num, horiz_off.den, vert_off.num, vert_off.den);
+        "horizOff %d/%d vertOff %d/%d\n",
+        aperture_width.num, aperture_width.den, aperture_height.num, aperture_height.den,
+        horiz_off.num, horiz_off.den, vert_off.num, vert_off.den);
 
-    pc_x   = av_mul_q((AVRational) { width  - 1, 1 }, (AVRational) { 1, 2 });
-    pc_x   = av_add_q(pc_x, horiz_off);
-    pc_y   = av_mul_q((AVRational) { height - 1, 1 }, (AVRational) { 1, 2 });
-    pc_y   = av_add_q(pc_y, vert_off);
+    pc_x = av_mul_q((AVRational) { width - 1, 1 }, (AVRational) { 1, 2 });
+    pc_x = av_add_q(pc_x, horiz_off);
+    pc_y = av_mul_q((AVRational) { height - 1, 1 }, (AVRational) { 1, 2 });
+    pc_y = av_add_q(pc_y, vert_off);
 
-    aperture_width  = av_sub_q(aperture_width,  (AVRational) { 1, 1 });
-    aperture_width  = av_mul_q(aperture_width,  (AVRational) { 1, 2 });
+    aperture_width = av_sub_q(aperture_width, (AVRational) { 1, 1 });
+    aperture_width = av_mul_q(aperture_width, (AVRational) { 1, 2 });
     aperture_height = av_sub_q(aperture_height, (AVRational) { 1, 1 });
     aperture_height = av_mul_q(aperture_height, (AVRational) { 1, 2 });
 
-    left   = av_q2d(av_sub_q(pc_x, aperture_width));
-    right  = av_q2d(av_add_q(pc_x, aperture_width));
-    top    = av_q2d(av_sub_q(pc_y, aperture_height));
+    left = av_q2d(av_sub_q(pc_x, aperture_width));
+    right = av_q2d(av_add_q(pc_x, aperture_width));
+    top = av_q2d(av_sub_q(pc_y, aperture_height));
     bottom = av_q2d(av_add_q(pc_y, aperture_height));
 
     if (bottom > (height - 1) ||
-        right  > (width  - 1)) {
+        right > (width - 1)) {
         err = AVERROR_INVALIDDATA;
         goto fail;
     }
 
     bottom = height - 1 - bottom;
-    right  = width  - 1 - right;
+    right = width - 1 - right;
 
     if (!(left | right | top | bottom))
         return 0;
@@ -1357,15 +1335,15 @@ static int mov_read_clap(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     }
 
     sd = av_packet_side_data_new(&st->codecpar->coded_side_data,
-                                 &st->codecpar->nb_coded_side_data,
-                                 AV_PKT_DATA_FRAME_CROPPING,
-                                 sizeof(uint32_t) * 4, 0);
+        &st->codecpar->nb_coded_side_data,
+        AV_PKT_DATA_FRAME_CROPPING,
+        sizeof(uint32_t) * 4, 0);
     if (!sd)
         return AVERROR(ENOMEM);
 
-    AV_WL32A(sd->data,      top);
-    AV_WL32A(sd->data + 4,  bottom);
-    AV_WL32A(sd->data + 8,  left);
+    AV_WL32A(sd->data, top);
+    AV_WL32A(sd->data + 4, bottom);
+    AV_WL32A(sd->data + 8, left);
     AV_WL32A(sd->data + 12, right);
 
 fail:
@@ -1380,16 +1358,16 @@ fail:
 }
 
 /* This atom overrides any previously set aspect ratio */
-static int mov_read_pasp(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_pasp(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
     const int num = avio_rb32(pb);
     const int den = avio_rb32(pb);
-    AVStream *st;
-    MOVStreamContext *sc;
+    AVStream* st;
+    MOVStreamContext* sc;
 
     if (c->fc->nb_streams < 1)
         return 0;
-    st = c->fc->streams[c->fc->nb_streams-1];
+    st = c->fc->streams[c->fc->nb_streams - 1];
     sc = st->priv_data;
 
     av_log(c->fc, AV_LOG_TRACE, "pasp: hSpacing %d, vSpacing %d\n", num, den);
@@ -1402,17 +1380,17 @@ static int mov_read_pasp(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 }
 
 /* this atom contains actual media data */
-static int mov_read_mdat(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_mdat(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
     if (atom.size == 0) /* wrong one (MP4) */
         return 0;
-    c->found_mdat=1;
+    c->found_mdat = 1;
     return 0; /* now go for moov */
 }
 
 #define DRM_BLOB_SIZE 56
 
-static int mov_read_adrm(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_adrm(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
     uint8_t intermediate_key[20];
     uint8_t intermediate_iv[20];
@@ -1421,11 +1399,11 @@ static int mov_read_adrm(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     uint8_t file_checksum[20];
     uint8_t calculated_checksum[20];
     char checksum_string[2 * sizeof(file_checksum) + 1];
-    struct AVSHA *sha;
+    struct AVSHA* sha;
     int i;
     int ret = 0;
-    uint8_t *activation_bytes = c->activation_bytes;
-    uint8_t *fixed_key = c->audible_fixed_key;
+    uint8_t* activation_bytes = c->activation_bytes;
+    uint8_t* fixed_key = c->audible_fixed_key;
 
     c->aax_mode = 1;
 
@@ -1513,7 +1491,7 @@ fail:
     return ret;
 }
 
-static int mov_aaxc_crypto(MOVContext *c)
+static int mov_aaxc_crypto(MOVContext* c)
 {
     if (c->audible_key_size != 16) {
         av_log(c->fc, AV_LOG_FATAL, "[aaxc] audible_key value needs to be 16 bytes!\n");
@@ -1538,7 +1516,7 @@ static int mov_aaxc_crypto(MOVContext *c)
 }
 
 // Audible AAX (and AAX+) bytestream decryption
-static int aax_filter(uint8_t *input, int size, MOVContext *c)
+static int aax_filter(uint8_t* input, int size, MOVContext* c)
 {
     int blocks = 0;
     unsigned char iv[16];
@@ -1552,12 +1530,12 @@ static int aax_filter(uint8_t *input, int size, MOVContext *c)
 }
 
 /* read major brand, minor version and compatible brands and store them as metadata */
-static int mov_read_ftyp(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_ftyp(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
     uint32_t minor_ver;
     int comp_brand_size;
     char* comp_brands_str;
-    uint8_t type[5] = {0};
+    uint8_t type[5] = { 0 };
     int ret = ffio_read_size(pb, type, 4);
     if (ret < 0)
         return ret;
@@ -1570,7 +1548,7 @@ static int mov_read_ftyp(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 
     if (strcmp(type, "qt  "))
         c->isom = 1;
-    av_log(c->fc, AV_LOG_DEBUG, "ISO: File Type Major Brand: %.4s\n",(char *)&type);
+    av_log(c->fc, AV_LOG_DEBUG, "ISO: File Type Major Brand: %.4s\n", (char*)&type);
     av_dict_set(&c->fc->metadata, "major_brand", type, 0);
     minor_ver = avio_rb32(pb); /* minor version */
     av_dict_set_int(&c->fc->metadata, "minor_version", minor_ver, 0);
@@ -1589,7 +1567,7 @@ static int mov_read_ftyp(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     }
     comp_brands_str[comp_brand_size] = 0;
     av_dict_set(&c->fc->metadata, "compatible_brands",
-                comp_brands_str, AV_DICT_DONT_STRDUP_VAL);
+        comp_brands_str, AV_DICT_DONT_STRDUP_VAL);
 
     // Logic for handling Audible's .aaxc files
     if (!strcmp(type, "aaxc")) {
@@ -1600,7 +1578,7 @@ static int mov_read_ftyp(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 }
 
 /* this atom should contain all header atoms */
-static int mov_read_moov(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_moov(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
     int ret;
 
@@ -1614,17 +1592,17 @@ static int mov_read_moov(MOVContext *c, AVIOContext *pb, MOVAtom atom)
         return ret;
     /* we parsed the 'moov' atom, we can terminate the parsing as soon as we find the 'mdat' */
     /* so we don't parse the whole file if over a network */
-    c->found_moov=1;
+    c->found_moov = 1;
     return 0; /* now go for mdat */
 }
 
-static MOVFragmentStreamInfo * get_frag_stream_info(
-    MOVFragmentIndex *frag_index,
+static MOVFragmentStreamInfo* get_frag_stream_info(
+    MOVFragmentIndex* frag_index,
     int index,
     int id)
 {
     int i;
-    MOVFragmentIndexItem * item;
+    MOVFragmentIndexItem* item;
 
     if (index < 0 || index >= frag_index->nb_items)
         return NULL;
@@ -1637,10 +1615,10 @@ static MOVFragmentStreamInfo * get_frag_stream_info(
     return NULL;
 }
 
-static void set_frag_stream(MOVFragmentIndex *frag_index, int id)
+static void set_frag_stream(MOVFragmentIndex* frag_index, int id)
 {
     int i;
-    MOVFragmentIndexItem * item;
+    MOVFragmentIndexItem* item;
 
     if (frag_index->current < 0 ||
         frag_index->current >= frag_index->nb_items)
@@ -1657,10 +1635,10 @@ static void set_frag_stream(MOVFragmentIndex *frag_index, int id)
     item->current = -1;
 }
 
-static MOVFragmentStreamInfo * get_current_frag_stream_info(
-    MOVFragmentIndex *frag_index)
+static MOVFragmentStreamInfo* get_current_frag_stream_info(
+    MOVFragmentIndex* frag_index)
 {
-    MOVFragmentIndexItem *item;
+    MOVFragmentIndexItem* item;
     if (frag_index->current < 0 ||
         frag_index->current >= frag_index->nb_items)
         return NULL;
@@ -1673,7 +1651,7 @@ static MOVFragmentStreamInfo * get_current_frag_stream_info(
     return NULL;
 }
 
-static int search_frag_moof_offset(MOVFragmentIndex *frag_index, int64_t offset)
+static int search_frag_moof_offset(MOVFragmentIndex* frag_index, int64_t offset)
 {
     int a, b, m;
     int64_t moof_offset;
@@ -1697,7 +1675,7 @@ static int search_frag_moof_offset(MOVFragmentIndex *frag_index, int64_t offset)
     return b;
 }
 
-static int64_t get_stream_info_time(MOVFragmentStreamInfo * frag_stream_info)
+static int64_t get_stream_info_time(MOVFragmentStreamInfo* frag_stream_info)
 {
     av_assert0(frag_stream_info);
     if (frag_stream_info->sidx_pts != AV_NOPTS_VALUE)
@@ -1707,11 +1685,11 @@ static int64_t get_stream_info_time(MOVFragmentStreamInfo * frag_stream_info)
     return frag_stream_info->tfdt_dts;
 }
 
-static int64_t get_frag_time(AVFormatContext *s, AVStream *dst_st,
-                             MOVFragmentIndex *frag_index, int index)
+static int64_t get_frag_time(AVFormatContext* s, AVStream* dst_st,
+    MOVFragmentIndex* frag_index, int index)
 {
-    MOVFragmentStreamInfo * frag_stream_info;
-    MOVStreamContext *sc = dst_st->priv_data;
+    MOVFragmentStreamInfo* frag_stream_info;
+    MOVStreamContext* sc = dst_st->priv_data;
     int64_t timestamp;
     int i, j;
 
@@ -1729,10 +1707,10 @@ static int64_t get_frag_time(AVFormatContext *s, AVStream *dst_st,
     }
 
     for (i = 0; i < frag_index->item[index].nb_stream_info; i++) {
-        AVStream *frag_stream = NULL;
+        AVStream* frag_stream = NULL;
         frag_stream_info = &frag_index->item[index].stream_info[i];
         for (j = 0; j < s->nb_streams; j++) {
-            MOVStreamContext *sc2 = s->streams[j]->priv_data;
+            MOVStreamContext* sc2 = s->streams[j]->priv_data;
             if (sc2->id == frag_stream_info->id)
                 frag_stream = s->streams[j];
         }
@@ -1747,8 +1725,8 @@ static int64_t get_frag_time(AVFormatContext *s, AVStream *dst_st,
     return AV_NOPTS_VALUE;
 }
 
-static int search_frag_timestamp(AVFormatContext *s, MOVFragmentIndex *frag_index,
-                                 AVStream *st, int64_t timestamp)
+static int search_frag_timestamp(AVFormatContext* s, MOVFragmentIndex* frag_index,
+    AVStream* st, int64_t timestamp)
 {
     int a, b, m, m0;
     int64_t frag_time;
@@ -1760,7 +1738,7 @@ static int search_frag_timestamp(AVFormatContext *s, MOVFragmentIndex *frag_inde
         m0 = m = (a + b) >> 1;
 
         while (m < b &&
-               (frag_time = get_frag_time(s, st, frag_index, m)) == AV_NOPTS_VALUE)
+            (frag_time = get_frag_time(s, st, frag_index, m)) == AV_NOPTS_VALUE)
             m++;
 
         if (m < b && frag_time <= timestamp)
@@ -1772,11 +1750,11 @@ static int search_frag_timestamp(AVFormatContext *s, MOVFragmentIndex *frag_inde
     return a;
 }
 
-static int update_frag_index(MOVContext *c, int64_t offset)
+static int update_frag_index(MOVContext* c, int64_t offset)
 {
     int index, i;
-    MOVFragmentIndexItem * item;
-    MOVFragmentStreamInfo * frag_stream_info;
+    MOVFragmentIndexItem* item;
+    MOVFragmentStreamInfo* frag_stream_info;
 
     // If moof_offset already exists in frag_index, return index to it
     index = search_frag_moof_offset(&c->frag_index, offset);
@@ -1787,21 +1765,21 @@ static int update_frag_index(MOVContext *c, int64_t offset)
     // offset is not yet in frag index.
     // Insert new item at index (sorted by moof offset)
     item = av_fast_realloc(c->frag_index.item,
-                           &c->frag_index.allocated_size,
-                           (c->frag_index.nb_items + 1) *
-                           sizeof(*c->frag_index.item));
+        &c->frag_index.allocated_size,
+        (c->frag_index.nb_items + 1) *
+        sizeof(*c->frag_index.item));
     if (!item)
         return -1;
     c->frag_index.item = item;
 
     frag_stream_info = av_realloc_array(NULL, c->fc->nb_streams,
-                                        sizeof(*item->stream_info));
+        sizeof(*item->stream_info));
     if (!frag_stream_info)
         return -1;
 
     for (i = 0; i < c->fc->nb_streams; i++) {
         // Avoid building frag index if streams lack track id.
-        MOVStreamContext *sc = c->fc->streams[i]->priv_data;
+        MOVStreamContext* sc = c->fc->streams[i]->priv_data;
         if (sc->id < 0) {
             av_free(frag_stream_info);
             return AVERROR_INVALIDDATA;
@@ -1820,7 +1798,7 @@ static int update_frag_index(MOVContext *c, int64_t offset)
 
     if (index < c->frag_index.nb_items)
         memmove(c->frag_index.item + index + 1, c->frag_index.item + index,
-                (c->frag_index.nb_items - index) * sizeof(*c->frag_index.item));
+            (c->frag_index.nb_items - index) * sizeof(*c->frag_index.item));
 
     item = &c->frag_index.item[index];
     item->headers_read = 0;
@@ -1833,11 +1811,11 @@ static int update_frag_index(MOVContext *c, int64_t offset)
     return index;
 }
 
-static void fix_frag_index_entries(MOVFragmentIndex *frag_index, int index,
-                                   int id, int entries)
+static void fix_frag_index_entries(MOVFragmentIndex* frag_index, int index,
+    int id, int entries)
 {
     int i;
-    MOVFragmentStreamInfo * frag_stream_info;
+    MOVFragmentStreamInfo* frag_stream_info;
 
     if (index < 0)
         return;
@@ -1848,7 +1826,7 @@ static void fix_frag_index_entries(MOVFragmentIndex *frag_index, int index,
     }
 }
 
-static int mov_read_moof(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_moof(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
     // Set by mov_read_tfhd(). mov_read_trun() will reject files missing tfhd.
     c->fragment.found_tfhd = 0;
@@ -1858,14 +1836,15 @@ static int mov_read_moof(MOVContext *c, AVIOContext *pb, MOVAtom atom)
         if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
             int ret;
             av_log(c->fc, AV_LOG_VERBOSE, "stream has moof boxes, will look "
-                    "for a mfra\n");
+                "for a mfra\n");
             if ((ret = mov_read_mfra(c, pb)) < 0) {
                 av_log(c->fc, AV_LOG_VERBOSE, "found a moof box but failed to "
-                        "read the mfra (may be a live ismv)\n");
+                    "read the mfra (may be a live ismv)\n");
             }
-        } else {
+        }
+        else {
             av_log(c->fc, AV_LOG_VERBOSE, "found a moof box but stream is not "
-                    "seekable, can not look for mfra\n");
+                "seekable, can not look for mfra\n");
         }
     }
     c->fragment.moof_offset = c->fragment.implicit_offset = avio_tell(pb) - 8;
@@ -1874,7 +1853,7 @@ static int mov_read_moof(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return mov_read_default(c, pb, atom);
 }
 
-static void mov_metadata_creation_time(MOVContext *c, AVIOContext *pb, AVDictionary **metadata, int version)
+static void mov_metadata_creation_time(MOVContext* c, AVIOContext* pb, AVDictionary** metadata, int version)
 {
     int64_t time;
     if (version == 1) {
@@ -1884,7 +1863,8 @@ static void mov_metadata_creation_time(MOVContext *c, AVIOContext *pb, AVDiction
             av_log(c->fc, AV_LOG_DEBUG, "creation_time is negative\n");
             return;
         }
-    } else {
+    }
+    else {
         time = avio_rb32(pb);
         avio_rb32(pb); /* modification time */
         if (time > 0 && time < 2082844800) {
@@ -1904,17 +1884,17 @@ static void mov_metadata_creation_time(MOVContext *c, AVIOContext *pb, AVDiction
     }
 }
 
-static int mov_read_mdhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_mdhd(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    AVStream *st;
-    MOVStreamContext *sc;
+    AVStream* st;
+    MOVStreamContext* sc;
     int version;
-    char language[4] = {0};
+    char language[4] = { 0 };
     unsigned lang;
 
     if (c->fc->nb_streams < 1)
         return 0;
-    st = c->fc->streams[c->fc->nb_streams-1];
+    st = c->fc->streams[c->fc->nb_streams - 1];
     sc = st->priv_data;
 
     if (sc->time_scale) {
@@ -1950,7 +1930,7 @@ static int mov_read_mdhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return 0;
 }
 
-static int mov_read_mvhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_mvhd(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
     int i;
     int version = avio_r8(pb); /* version */
@@ -1989,13 +1969,13 @@ static int mov_read_mvhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return 0;
 }
 
-static void set_last_stream_little_endian(AVFormatContext *fc)
+static void set_last_stream_little_endian(AVFormatContext* fc)
 {
-    AVStream *st;
+    AVStream* st;
 
     if (fc->nb_streams < 1)
         return;
-    st = fc->streams[fc->nb_streams-1];
+    st = fc->streams[fc->nb_streams - 1];
 
     switch (st->codecpar->codec_id) {
     case AV_CODEC_ID_PCM_S16BE:
@@ -2018,7 +1998,7 @@ static void set_last_stream_little_endian(AVFormatContext *fc)
     }
 }
 
-static int mov_read_enda(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_enda(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
     int little_endian = avio_rb16(pb) & 0xFF;
     av_log(c->fc, AV_LOG_TRACE, "enda %d\n", little_endian);
@@ -2027,14 +2007,14 @@ static int mov_read_enda(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return 0;
 }
 
-static int mov_read_pcmc(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_pcmc(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
     int format_flags;
     int version, flags;
     int pcm_sample_size;
-    AVFormatContext *fc = c->fc;
-    AVStream *st;
-    MOVStreamContext *sc;
+    AVFormatContext* fc = c->fc;
+    AVStream* st;
+    MOVStreamContext* sc;
 
     if (atom.size < 6) {
         av_log(c->fc, AV_LOG_ERROR, "Empty pcmC box\n");
@@ -2042,12 +2022,12 @@ static int mov_read_pcmc(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     }
 
     version = avio_r8(pb);
-    flags   = avio_rb24(pb);
+    flags = avio_rb24(pb);
 
     if (version != 0 || flags != 0) {
         av_log(c->fc, AV_LOG_ERROR,
-               "Unsupported 'pcmC' box with version %d, flags: %x",
-               version, flags);
+            "Unsupported 'pcmC' box with version %d, flags: %x",
+            version, flags);
         return AVERROR_INVALIDDATA;
     }
 
@@ -2070,11 +2050,12 @@ static int mov_read_pcmc(MOVContext *c, AVIOContext *pb, MOVAtom atom)
             break;
         default:
             av_log(fc, AV_LOG_ERROR, "invalid pcm_sample_size %d for %s\n",
-                                     pcm_sample_size,
-                                     av_fourcc2str(sc->format));
+                pcm_sample_size,
+                av_fourcc2str(sc->format));
             return AVERROR_INVALIDDATA;
         }
-    } else if (sc->format == MOV_MP4_IPCM_TAG) {
+    }
+    else if (sc->format == MOV_MP4_IPCM_TAG) {
         switch (pcm_sample_size) {
         case 16:
             st->codecpar->codec_id = AV_CODEC_ID_PCM_S16BE;
@@ -2087,13 +2068,14 @@ static int mov_read_pcmc(MOVContext *c, AVIOContext *pb, MOVAtom atom)
             break;
         default:
             av_log(fc, AV_LOG_ERROR, "invalid pcm_sample_size %d for %s\n",
-                                     pcm_sample_size,
-                                     av_fourcc2str(sc->format));
+                pcm_sample_size,
+                av_fourcc2str(sc->format));
             return AVERROR_INVALIDDATA;
         }
-    } else {
+    }
+    else {
         av_log(fc, AV_LOG_ERROR, "'pcmC' with invalid sample entry '%s'\n",
-                av_fourcc2str(sc->format));
+            av_fourcc2str(sc->format));
         return AVERROR_INVALIDDATA;
     }
 
@@ -2104,17 +2086,17 @@ static int mov_read_pcmc(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return 0;
 }
 
-static int mov_read_colr(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_colr(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    AVStream *st;
-    HEIFItem *item = NULL;
+    AVStream* st;
+    HEIFItem* item = NULL;
     char color_parameter_type[5] = { 0 };
     uint16_t color_primaries, color_trc, color_matrix;
     int ret;
 
     st = get_curr_st(c);
     if (!st) {
-        item = get_heif_item(c, c->cur_item_id);
+        item = heif_cur_item(c);
         if (!item)
             return 0;
     }
@@ -2126,22 +2108,23 @@ static int mov_read_colr(MOVContext *c, AVIOContext *pb, MOVAtom atom)
         strncmp(color_parameter_type, "nclc", 4) &&
         strncmp(color_parameter_type, "prof", 4)) {
         av_log(c->fc, AV_LOG_WARNING, "unsupported color_parameter_type %s\n",
-               color_parameter_type);
+            color_parameter_type);
         return 0;
     }
 
     if (!strncmp(color_parameter_type, "prof", 4)) {
-        AVPacketSideData *sd;
-        uint8_t *icc_profile;
+        AVPacketSideData* sd;
+        uint8_t* icc_profile;
         if (st) {
             sd = av_packet_side_data_new(&st->codecpar->coded_side_data,
-                                         &st->codecpar->nb_coded_side_data,
-                                         AV_PKT_DATA_ICC_PROFILE,
-                                         atom.size - 4, 0);
+                &st->codecpar->nb_coded_side_data,
+                AV_PKT_DATA_ICC_PROFILE,
+                atom.size - 4, 0);
             if (!sd)
                 return AVERROR(ENOMEM);
             icc_profile = sd->data;
-        } else {
+        }
+        else {
             av_freep(&item->icc_profile);
             icc_profile = item->icc_profile = av_malloc(atom.size - 4);
             if (!icc_profile) {
@@ -2153,14 +2136,15 @@ static int mov_read_colr(MOVContext *c, AVIOContext *pb, MOVAtom atom)
         ret = ffio_read_size(pb, icc_profile, atom.size - 4);
         if (ret < 0)
             return ret;
-    } else if (st) {
+    }
+    else if (st) {
         color_primaries = avio_rb16(pb);
         color_trc = avio_rb16(pb);
         color_matrix = avio_rb16(pb);
 
         av_log(c->fc, AV_LOG_TRACE,
-               "%s: pri %d trc %d matrix %d",
-               color_parameter_type, color_primaries, color_trc, color_matrix);
+            "%s: pri %d trc %d matrix %d",
+            color_parameter_type, color_primaries, color_trc, color_matrix);
 
         if (!strncmp(color_parameter_type, "nclx", 4)) {
             uint8_t color_range = avio_r8(pb) >> 7;
@@ -2179,22 +2163,22 @@ static int mov_read_colr(MOVContext *c, AVIOContext *pb, MOVAtom atom)
             color_matrix = AVCOL_SPC_UNSPECIFIED;
 
         st->codecpar->color_primaries = color_primaries;
-        st->codecpar->color_trc       = color_trc;
-        st->codecpar->color_space     = color_matrix;
+        st->codecpar->color_trc = color_trc;
+        st->codecpar->color_space = color_matrix;
         av_log(c->fc, AV_LOG_TRACE, "\n");
     }
     return 0;
 }
 
-static int mov_read_fiel(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_fiel(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    AVStream *st;
+    AVStream* st;
     unsigned mov_field_order;
     enum AVFieldOrder decoded_field_order = AV_FIELD_UNKNOWN;
 
     if (c->fc->nb_streams < 1) // will happen with jp2 files
         return 0;
-    st = c->fc->streams[c->fc->nb_streams-1];
+    st = c->fc->streams[c->fc->nb_streams - 1];
     if (atom.size < 2)
         return AVERROR_INVALIDDATA;
     mov_field_order = avio_rb16(pb);
@@ -2203,13 +2187,13 @@ static int mov_read_fiel(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     else if ((mov_field_order & 0xFF00) == 0x0200) {
         switch (mov_field_order & 0xFF) {
         case 0x01: decoded_field_order = AV_FIELD_TT;
-                   break;
+            break;
         case 0x06: decoded_field_order = AV_FIELD_BB;
-                   break;
+            break;
         case 0x09: decoded_field_order = AV_FIELD_TB;
-                   break;
+            break;
         case 0x0E: decoded_field_order = AV_FIELD_BT;
-                   break;
+            break;
         }
     }
     if (decoded_field_order == AV_FIELD_UNKNOWN && mov_field_order) {
@@ -2220,7 +2204,7 @@ static int mov_read_fiel(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return 0;
 }
 
-static int mov_realloc_extradata(AVCodecParameters *par, MOVAtom atom)
+static int mov_realloc_extradata(AVCodecParameters* par, MOVAtom atom)
 {
     int err = 0;
     uint64_t size = (uint64_t)par->extradata_size + atom.size + 8 + AV_INPUT_BUFFER_PADDING_SIZE;
@@ -2235,19 +2219,20 @@ static int mov_realloc_extradata(AVCodecParameters *par, MOVAtom atom)
 }
 
 /* Read a whole atom into the extradata return the size of the atom read, possibly truncated if != atom.size */
-static int64_t mov_read_atom_into_extradata(MOVContext *c, AVIOContext *pb, MOVAtom atom,
-                                        AVCodecParameters *par, uint8_t *buf)
+static int64_t mov_read_atom_into_extradata(MOVContext* c, AVIOContext* pb, MOVAtom atom,
+    AVCodecParameters* par, uint8_t* buf)
 {
     int64_t result = atom.size;
     int err;
 
-    AV_WB32(buf    , atom.size + 8);
+    AV_WB32(buf, atom.size + 8);
     AV_WL32(buf + 4, atom.type);
     err = ffio_read_size(pb, buf + 8, atom.size);
     if (err < 0) {
         par->extradata_size -= atom.size;
         return err;
-    } else if (err < atom.size) {
+    }
+    else if (err < atom.size) {
         av_log(c->fc, AV_LOG_WARNING, "truncated extradata\n");
         par->extradata_size -= atom.size - err;
         result = err;
@@ -2257,16 +2242,16 @@ static int64_t mov_read_atom_into_extradata(MOVContext *c, AVIOContext *pb, MOVA
 }
 
 /* FIXME modify QDM2/SVQ3/H.264 decoders to take full atom as extradata */
-static int mov_read_extradata(MOVContext *c, AVIOContext *pb, MOVAtom atom,
-                              enum AVCodecID codec_id)
+static int mov_read_extradata(MOVContext* c, AVIOContext* pb, MOVAtom atom,
+    enum AVCodecID codec_id)
 {
-    AVStream *st;
+    AVStream* st;
     uint64_t original_size;
     int err;
 
     if (c->fc->nb_streams < 1) // will happen with jp2 files
         return 0;
-    st = c->fc->streams[c->fc->nb_streams-1];
+    st = c->fc->streams[c->fc->nb_streams - 1];
 
     if (st->codecpar->codec_id != codec_id)
         return 0; /* unexpected codec_id - don't mess with extradata */
@@ -2276,34 +2261,34 @@ static int mov_read_extradata(MOVContext *c, AVIOContext *pb, MOVAtom atom,
     if (err)
         return err;
 
-    err =  mov_read_atom_into_extradata(c, pb, atom, st->codecpar,  st->codecpar->extradata + original_size);
+    err = mov_read_atom_into_extradata(c, pb, atom, st->codecpar, st->codecpar->extradata + original_size);
     if (err < 0)
         return err;
     return 0; // Note: this is the original behavior to ignore truncation.
 }
 
 /* wrapper functions for reading ALAC/AVS/MJPEG/MJPEG2000 extradata atoms only for those codecs */
-static int mov_read_alac(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_alac(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
     return mov_read_extradata(c, pb, atom, AV_CODEC_ID_ALAC);
 }
 
-static int mov_read_avss(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_avss(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
     return mov_read_extradata(c, pb, atom, AV_CODEC_ID_CAVS);
 }
 
-static int mov_read_jp2h(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_jp2h(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
     return mov_read_extradata(c, pb, atom, AV_CODEC_ID_JPEG2000);
 }
 
-static int mov_read_dpxe(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_dpxe(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
     return mov_read_extradata(c, pb, atom, AV_CODEC_ID_R10K);
 }
 
-static int mov_read_avid(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_avid(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
     int ret = mov_read_extradata(c, pb, atom, AV_CODEC_ID_AVUI);
     if (!ret)
@@ -2311,26 +2296,26 @@ static int mov_read_avid(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return ret;
 }
 
-static int mov_read_targa_y216(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_targa_y216(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
     int ret = mov_read_extradata(c, pb, atom, AV_CODEC_ID_TARGA_Y216);
 
     if (!ret && c->fc->nb_streams >= 1) {
-        AVCodecParameters *par = c->fc->streams[c->fc->nb_streams-1]->codecpar;
+        AVCodecParameters* par = c->fc->streams[c->fc->nb_streams - 1]->codecpar;
         if (par->extradata_size >= 40) {
             par->height = AV_RB16(&par->extradata[36]);
-            par->width  = AV_RB16(&par->extradata[38]);
+            par->width = AV_RB16(&par->extradata[38]);
         }
     }
     return ret;
 }
 
-static int mov_read_ares(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_ares(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
     if (c->fc->nb_streams >= 1) {
-        AVStream *const  st = c->fc->streams[c->fc->nb_streams - 1];
-        FFStream *const sti = ffstream(st);
-        AVCodecParameters *par = st->codecpar;
+        AVStream* const  st = c->fc->streams[c->fc->nb_streams - 1];
+        FFStream* const sti = ffstream(st);
+        AVCodecParameters* par = st->codecpar;
 
         if (par->codec_tag == MKTAG('A', 'V', 'i', 'n') &&
             par->codec_id == AV_CODEC_ID_H264 &&
@@ -2342,10 +2327,11 @@ static int mov_read_ares(MOVContext *c, AVIOContext *pb, MOVAtom atom)
             if (cid == 0xd4d || cid == 0xd4e)
                 par->width = 1440;
             return 0;
-        } else if ((par->codec_tag == MKTAG('A', 'V', 'd', '1') ||
-                    par->codec_tag == MKTAG('A', 'V', 'j', '2') ||
-                    par->codec_tag == MKTAG('A', 'V', 'd', 'n')) &&
-                   atom.size >= 24) {
+        }
+        else if ((par->codec_tag == MKTAG('A', 'V', 'd', '1') ||
+            par->codec_tag == MKTAG('A', 'V', 'j', '2') ||
+            par->codec_tag == MKTAG('A', 'V', 'd', 'n')) &&
+            atom.size >= 24) {
             int num, den;
             avio_skip(pb, 12);
             num = avio_rb32(pb);
@@ -2368,20 +2354,20 @@ static int mov_read_ares(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return mov_read_avid(c, pb, atom);
 }
 
-static int mov_read_aclr(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_aclr(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
     int ret = 0;
     int length = 0;
     uint64_t original_size;
     if (c->fc->nb_streams >= 1) {
-        AVCodecParameters *par = c->fc->streams[c->fc->nb_streams-1]->codecpar;
+        AVCodecParameters* par = c->fc->streams[c->fc->nb_streams - 1]->codecpar;
         if (par->codec_id == AV_CODEC_ID_H264)
             return 0;
         if (atom.size == 16) {
             original_size = par->extradata_size;
             ret = mov_realloc_extradata(par, atom);
             if (!ret) {
-                length =  mov_read_atom_into_extradata(c, pb, atom, par, par->extradata + original_size);
+                length = mov_read_atom_into_extradata(c, pb, atom, par, par->extradata + original_size);
                 if (length == atom.size) {
                     const uint8_t range_value = par->extradata[original_size + 19];
                     switch (range_value) {
@@ -2396,14 +2382,17 @@ static int mov_read_aclr(MOVContext *c, AVIOContext *pb, MOVAtom atom)
                         break;
                     }
                     ff_dlog(c->fc, "color_range: %d\n", par->color_range);
-                } else {
-                  /* For some reason the whole atom was not added to the extradata */
-                  av_log(c->fc, AV_LOG_ERROR, "aclr not decoded - incomplete atom\n");
                 }
-            } else {
+                else {
+                    /* For some reason the whole atom was not added to the extradata */
+                    av_log(c->fc, AV_LOG_ERROR, "aclr not decoded - incomplete atom\n");
+                }
+            }
+            else {
                 av_log(c->fc, AV_LOG_ERROR, "aclr not decoded - unable to add atom to extradata\n");
             }
-        } else {
+        }
+        else {
             av_log(c->fc, AV_LOG_WARNING, "aclr not decoded - unexpected size %"PRId64"\n", atom.size);
         }
     }
@@ -2411,21 +2400,21 @@ static int mov_read_aclr(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return ret;
 }
 
-static int mov_read_svq3(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_svq3(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
     return mov_read_extradata(c, pb, atom, AV_CODEC_ID_SVQ3);
 }
 
-static int mov_read_wave(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_wave(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    AVStream *st;
+    AVStream* st;
     int ret;
 
     if (c->fc->nb_streams < 1)
         return 0;
-    st = c->fc->streams[c->fc->nb_streams-1];
+    st = c->fc->streams[c->fc->nb_streams - 1];
 
-    if ((uint64_t)atom.size > (1<<30))
+    if ((uint64_t)atom.size > (1 << 30))
         return AVERROR_INVALIDDATA;
 
     if (st->codecpar->codec_id == AV_CODEC_ID_QDM2 ||
@@ -2435,7 +2424,8 @@ static int mov_read_wave(MOVContext *c, AVIOContext *pb, MOVAtom atom)
         ret = ff_get_extradata(c->fc, st->codecpar, pb, atom.size);
         if (ret < 0)
             return ret;
-    } else if (atom.size > 8) { /* to read frma, esds atoms */
+    }
+    else if (atom.size > 8) { /* to read frma, esds atoms */
         if (st->codecpar->codec_id == AV_CODEC_ID_ALAC && atom.size >= 24) {
             uint64_t buffer;
             ret = ffio_ensure_seekback(pb, 8);
@@ -2443,19 +2433,20 @@ static int mov_read_wave(MOVContext *c, AVIOContext *pb, MOVAtom atom)
                 return ret;
             buffer = avio_rb64(pb);
             atom.size -= 8;
-            if (  (buffer & 0xFFFFFFFF) == MKBETAG('f','r','m','a')
+            if ((buffer & 0xFFFFFFFF) == MKBETAG('f', 'r', 'm', 'a')
                 && buffer >> 32 <= atom.size
                 && buffer >> 32 >= 8) {
                 avio_skip(pb, -8);
                 atom.size += 8;
-            } else if (!st->codecpar->extradata_size) {
+            }
+            else if (!st->codecpar->extradata_size) {
 #define ALAC_EXTRADATA_SIZE 36
                 st->codecpar->extradata = av_mallocz(ALAC_EXTRADATA_SIZE + AV_INPUT_BUFFER_PADDING_SIZE);
                 if (!st->codecpar->extradata)
                     return AVERROR(ENOMEM);
                 st->codecpar->extradata_size = ALAC_EXTRADATA_SIZE;
-                AV_WB32(st->codecpar->extradata    , ALAC_EXTRADATA_SIZE);
-                AV_WB32(st->codecpar->extradata + 4, MKTAG('a','l','a','c'));
+                AV_WB32(st->codecpar->extradata, ALAC_EXTRADATA_SIZE);
+                AV_WB32(st->codecpar->extradata + 4, MKTAG('a', 'l', 'a', 'c'));
                 AV_WB64(st->codecpar->extradata + 12, buffer);
                 avio_read(pb, st->codecpar->extradata + 20, 16);
                 avio_skip(pb, atom.size - 24);
@@ -2464,7 +2455,8 @@ static int mov_read_wave(MOVContext *c, AVIOContext *pb, MOVAtom atom)
         }
         if ((ret = mov_read_default(c, pb, atom)) < 0)
             return ret;
-    } else
+    }
+    else
         avio_skip(pb, atom.size);
     return 0;
 }
@@ -2473,19 +2465,19 @@ static int mov_read_wave(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  * This function reads atom content and puts data in extradata without tag
  * nor size unlike mov_read_extradata.
  */
-static int mov_read_glbl(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_glbl(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    AVStream *st;
+    AVStream* st;
     int ret;
 
     st = get_curr_st(c);
     if (!st)
         return 0;
 
-    if ((uint64_t)atom.size > (1<<30))
+    if ((uint64_t)atom.size > (1 << 30))
         return AVERROR_INVALIDDATA;
 
-    if (atom.type == MKTAG('v','v','c','C')) {
+    if (atom.type == MKTAG('v', 'v', 'c', 'C')) {
         avio_skip(pb, 4);
         atom.size -= 4;
     }
@@ -2498,7 +2490,7 @@ static int mov_read_glbl(MOVContext *c, AVIOContext *pb, MOVAtom atom)
         if (avio_feof(pb))
             return AVERROR_INVALIDDATA;
         avio_seek(pb, -8, SEEK_CUR);
-        if (type == MKTAG('f','i','e','l') && size == atom.size)
+        if (type == MKTAG('f', 'i', 'e', 'l') && size == atom.size)
             return mov_read_default(c, pb, atom);
     }
     if (st->codecpar->extradata_size > 1 && st->codecpar->extradata) {
@@ -2508,7 +2500,7 @@ static int mov_read_glbl(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     ret = ff_get_extradata(c->fc, st->codecpar, pb, atom.size);
     if (ret < 0)
         return ret;
-    if (atom.type == MKTAG('h','v','c','C') && st->codecpar->codec_tag == MKTAG('d','v','h','1'))
+    if (atom.type == MKTAG('h', 'v', 'c', 'C') && st->codecpar->codec_tag == MKTAG('d', 'v', 'h', '1'))
         /* HEVC-based Dolby Vision derived from hvc1.
            Happens to match with an identifier
            previously utilized for DV. Thus, if we have
@@ -2519,17 +2511,17 @@ static int mov_read_glbl(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return 0;
 }
 
-static int mov_read_dvc1(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_dvc1(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    AVStream *st;
+    AVStream* st;
     uint8_t profile_level;
     int ret;
 
     if (c->fc->nb_streams < 1)
         return 0;
-    st = c->fc->streams[c->fc->nb_streams-1];
+    st = c->fc->streams[c->fc->nb_streams - 1];
 
-    if (atom.size >= (1<<28) || atom.size < 7)
+    if (atom.size >= (1 << 28) || atom.size < 7)
         return AVERROR_INVALIDDATA;
 
     profile_level = avio_r8(pb);
@@ -2573,18 +2565,18 @@ static int mov_read_sbas(MOVContext* c, AVIOContext* pb, MOVAtom atom)
  * but can have extradata appended at the end after the 40 bytes belonging
  * to the struct.
  */
-static int mov_read_strf(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_strf(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    AVStream *st;
+    AVStream* st;
     int ret;
 
     if (c->fc->nb_streams < 1)
         return 0;
     if (atom.size <= 40)
         return 0;
-    st = c->fc->streams[c->fc->nb_streams-1];
+    st = c->fc->streams[c->fc->nb_streams - 1];
 
-    if ((uint64_t)atom.size > (1<<30))
+    if ((uint64_t)atom.size > (1 << 30))
         return AVERROR_INVALIDDATA;
 
     avio_skip(pb, 40);
@@ -2595,10 +2587,10 @@ static int mov_read_strf(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return 0;
 }
 
-static int mov_read_stco(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_stco(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    AVStream *st;
-    MOVStreamContext *sc;
+    AVStream* st;
+    MOVStreamContext* sc;
     unsigned int i, entries;
 
     if (c->trak_index < 0) {
@@ -2607,7 +2599,7 @@ static int mov_read_stco(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     }
     if (c->fc->nb_streams < 1)
         return 0;
-    st = c->fc->streams[c->fc->nb_streams-1];
+    st = c->fc->streams[c->fc->nb_streams - 1];
     sc = st->priv_data;
 
     avio_r8(pb); /* version */
@@ -2618,8 +2610,8 @@ static int mov_read_stco(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     entries = avio_rb32(pb);
     entries =
         FFMIN(entries,
-              FFMAX(0, (atom.size - 8) /
-                           (atom.type == MKTAG('s', 't', 'c', 'o') ? 4 : 8)));
+            FFMAX(0, (atom.size - 8) /
+                (atom.type == MKTAG('s', 't', 'c', 'o') ? 4 : 8)));
 
     if (!entries)
         return 0;
@@ -2636,10 +2628,10 @@ static int mov_read_stco(MOVContext *c, AVIOContext *pb, MOVAtom atom)
         return AVERROR(ENOMEM);
     sc->chunk_count = entries;
 
-    if      (atom.type == MKTAG('s','t','c','o'))
+    if (atom.type == MKTAG('s', 't', 'c', 'o'))
         for (i = 0; i < entries && !pb->eof_reached; i++)
             sc->chunk_offsets[i] = avio_rb32(pb);
-    else if (atom.type == MKTAG('c','o','6','4'))
+    else if (atom.type == MKTAG('c', 'o', '6', '4'))
         for (i = 0; i < entries && !pb->eof_reached; i++) {
             sc->chunk_offsets[i] = avio_rb64(pb);
             if (sc->chunk_offsets[i] < 0) {
@@ -2660,32 +2652,33 @@ static int mov_read_stco(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return 0;
 }
 
-static int mov_codec_id(AVStream *st, uint32_t format)
+static int mov_codec_id(AVStream* st, uint32_t format)
 {
     int id = ff_codec_get_id(ff_codec_movaudio_tags, format);
 
     if (id <= 0 &&
         ((format & 0xFFFF) == 'm' + ('s' << 8) ||
-         (format & 0xFFFF) == 'T' + ('S' << 8)))
+            (format & 0xFFFF) == 'T' + ('S' << 8)))
         id = ff_codec_get_id(ff_codec_wav_tags, av_bswap32(format) & 0xFFFF);
 
     if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO && id > 0) {
         st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
-    } else if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO &&
-               /* skip old ASF MPEG-4 tag */
-               format && format != MKTAG('m','p','4','s')) {
+    }
+    else if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO &&
+        /* skip old ASF MPEG-4 tag */
+        format && format != MKTAG('m', 'p', '4', 's')) {
         id = ff_codec_get_id(ff_codec_movvideo_tags, format);
         if (id <= 0)
             id = ff_codec_get_id(ff_codec_bmp_tags, format);
         if (id > 0)
             st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
         else if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA ||
-                    (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE &&
-                    st->codecpar->codec_id == AV_CODEC_ID_NONE)) {
+            (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE &&
+                st->codecpar->codec_id == AV_CODEC_ID_NONE)) {
             id = ff_codec_get_id(ff_codec_movsubtitle_tags, format);
             if (id <= 0) {
                 id = (format == MOV_MP4_TTML_TAG || format == MOV_ISMV_TTML_TAG) ?
-                     AV_CODEC_ID_TTML : id;
+                    AV_CODEC_ID_TTML : id;
             }
 
             if (id > 0)
@@ -2700,8 +2693,8 @@ static int mov_codec_id(AVStream *st, uint32_t format)
     return id;
 }
 
-static void mov_parse_stsd_video(MOVContext *c, AVIOContext *pb,
-                                 AVStream *st, MOVStreamContext *sc)
+static void mov_parse_stsd_video(MOVContext* c, AVIOContext* pb,
+    AVStream* st, MOVStreamContext* sc)
 {
     uint8_t codec_name[32] = { 0 };
     int64_t stsd_start;
@@ -2712,20 +2705,14 @@ static void mov_parse_stsd_video(MOVContext *c, AVIOContext *pb,
      * read in ff_mov_read_stsd_entries() */
     stsd_start = avio_tell(pb) - 16;
 
-    if (c->isom) {
-        avio_skip(pb, 2);  /* pre_defined */
-        avio_skip(pb, 2);  /* reserved */
-        avio_skip(pb, 12); /* pre_defined */
-    } else {
-        avio_rb16(pb); /* version */
-        avio_rb16(pb); /* revision level */
-        id = avio_rl32(pb); /* vendor */
-        av_dict_set(&st->metadata, "vendor_id", av_fourcc2str(id), 0);
-        avio_rb32(pb); /* temporal quality */
-        avio_rb32(pb); /* spatial quality */
-    }
+    avio_rb16(pb); /* version */
+    avio_rb16(pb); /* revision level */
+    id = avio_rl32(pb); /* vendor */
+    av_dict_set(&st->metadata, "vendor_id", av_fourcc2str(id), 0);
+    avio_rb32(pb); /* temporal quality */
+    avio_rb32(pb); /* spatial quality */
 
-    st->codecpar->width  = avio_rb16(pb); /* width */
+    st->codecpar->width = avio_rb16(pb); /* width */
     st->codecpar->height = avio_rb16(pb); /* height */
 
     avio_rb32(pb); /* horiz resolution */
@@ -2750,7 +2737,7 @@ static void mov_parse_stsd_video(MOVContext *c, AVIOContext *pb,
         st->codecpar->height &= ~1;
     }
     /* Flash Media Server uses tag H.263 with Sorenson Spark */
-    if (st->codecpar->codec_tag == MKTAG('H','2','6','3') &&
+    if (st->codecpar->codec_tag == MKTAG('H', '2', '6', '3') &&
         !strncmp(codec_name, "Sorenson H263", 13))
         st->codecpar->codec_id = AV_CODEC_ID_FLV1;
 
@@ -2764,22 +2751,18 @@ static void mov_parse_stsd_video(MOVContext *c, AVIOContext *pb,
     }
 }
 
-static void mov_parse_stsd_audio(MOVContext *c, AVIOContext *pb,
-                                 AVStream *st, MOVStreamContext *sc)
+static void mov_parse_stsd_audio(MOVContext* c, AVIOContext* pb,
+    AVStream* st, MOVStreamContext* sc)
 {
     int bits_per_sample, flags;
     uint16_t version = avio_rb16(pb);
     uint32_t id = 0;
-    AVDictionaryEntry *compatible_brands = av_dict_get(c->fc->metadata, "compatible_brands", NULL, AV_DICT_MATCH_CASE);
+    AVDictionaryEntry* compatible_brands = av_dict_get(c->fc->metadata, "compatible_brands", NULL, AV_DICT_MATCH_CASE);
     int channel_count;
 
-    if (c->isom)
-        avio_skip(pb, 6); /* reserved */
-    else {
-        avio_rb16(pb); /* revision level */
-        id = avio_rl32(pb); /* vendor */
-        av_dict_set(&st->metadata, "vendor_id", av_fourcc2str(id), 0);
-    }
+    avio_rb16(pb); /* revision level */
+    id = avio_rl32(pb); /* vendor */
+    av_dict_set(&st->metadata, "vendor_id", av_fourcc2str(id), 0);
 
     channel_count = avio_rb16(pb);
 
@@ -2803,7 +2786,8 @@ static void mov_parse_stsd_audio(MOVContext *c, AVIOContext *pb,
             avio_rb32(pb); /* bytes per packet */
             sc->bytes_per_frame = avio_rb32(pb);
             avio_rb32(pb); /* bytes per sample */
-        } else if (version == 2) {
+        }
+        else if (version == 2) {
             avio_rb32(pb); /* sizeof struct only */
             st->codecpar->sample_rate = av_int2double(avio_rb64(pb));
             channel_count = avio_rb32(pb);
@@ -2813,12 +2797,12 @@ static void mov_parse_stsd_audio(MOVContext *c, AVIOContext *pb,
             st->codecpar->bits_per_coded_sample = avio_rb32(pb);
 
             flags = avio_rb32(pb); /* lpcm format specific flag */
-            sc->bytes_per_frame   = avio_rb32(pb);
+            sc->bytes_per_frame = avio_rb32(pb);
             sc->samples_per_frame = avio_rb32(pb);
-            if (st->codecpar->codec_tag == MKTAG('l','p','c','m'))
+            if (st->codecpar->codec_tag == MKTAG('l', 'p', 'c', 'm'))
                 st->codecpar->codec_id =
-                    ff_mov_get_lpcm_codec_id(st->codecpar->bits_per_coded_sample,
-                                             flags);
+                ff_mov_get_lpcm_codec_id(st->codecpar->bits_per_coded_sample,
+                    flags);
         }
         if (version == 0 || (version == 1 && sc->audio_cid != -2)) {
             /* can't correctly handle variable sized packet as audio unit */
@@ -2833,9 +2817,9 @@ static void mov_parse_stsd_audio(MOVContext *c, AVIOContext *pb,
 
     if (sc->format == 0) {
         if (st->codecpar->bits_per_coded_sample == 8)
-            st->codecpar->codec_id = mov_codec_id(st, MKTAG('r','a','w',' '));
+            st->codecpar->codec_id = mov_codec_id(st, MKTAG('r', 'a', 'w', ' '));
         else if (st->codecpar->bits_per_coded_sample == 16)
-            st->codecpar->codec_id = mov_codec_id(st, MKTAG('t','w','o','s'));
+            st->codecpar->codec_id = mov_codec_id(st, MKTAG('t', 'w', 'o', 's'));
     }
 
     switch (st->codecpar->codec_id) {
@@ -2850,29 +2834,29 @@ static void mov_parse_stsd_audio(MOVContext *c, AVIOContext *pb,
             st->codecpar->codec_id = AV_CODEC_ID_PCM_S8;
         else if (st->codecpar->bits_per_coded_sample == 24)
             st->codecpar->codec_id =
-                st->codecpar->codec_id == AV_CODEC_ID_PCM_S16BE ?
-                AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
+            st->codecpar->codec_id == AV_CODEC_ID_PCM_S16BE ?
+            AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
         else if (st->codecpar->bits_per_coded_sample == 32)
-             st->codecpar->codec_id =
-                st->codecpar->codec_id == AV_CODEC_ID_PCM_S16BE ?
-                AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
+            st->codecpar->codec_id =
+            st->codecpar->codec_id == AV_CODEC_ID_PCM_S16BE ?
+            AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
         break;
-    /* set values for old format before stsd version 1 appeared */
+        /* set values for old format before stsd version 1 appeared */
     case AV_CODEC_ID_MACE3:
         sc->samples_per_frame = 6;
-        sc->bytes_per_frame   = 2 * st->codecpar->ch_layout.nb_channels;
+        sc->bytes_per_frame = 2 * st->codecpar->ch_layout.nb_channels;
         break;
     case AV_CODEC_ID_MACE6:
         sc->samples_per_frame = 6;
-        sc->bytes_per_frame   = 1 * st->codecpar->ch_layout.nb_channels;
+        sc->bytes_per_frame = 1 * st->codecpar->ch_layout.nb_channels;
         break;
     case AV_CODEC_ID_ADPCM_IMA_QT:
         sc->samples_per_frame = 64;
-        sc->bytes_per_frame   = 34 * st->codecpar->ch_layout.nb_channels;
+        sc->bytes_per_frame = 34 * st->codecpar->ch_layout.nb_channels;
         break;
     case AV_CODEC_ID_GSM:
         sc->samples_per_frame = 160;
-        sc->bytes_per_frame   = 33;
+        sc->bytes_per_frame = 33;
         break;
     default:
         break;
@@ -2885,9 +2869,9 @@ static void mov_parse_stsd_audio(MOVContext *c, AVIOContext *pb,
     }
 }
 
-static void mov_parse_stsd_subtitle(MOVContext *c, AVIOContext *pb,
-                                    AVStream *st, MOVStreamContext *sc,
-                                    int64_t size)
+static void mov_parse_stsd_subtitle(MOVContext* c, AVIOContext* pb,
+    AVStream* st, MOVStreamContext* sc,
+    int64_t size)
 {
     // ttxt stsd contains display flags, justification, background
     // color, fonts, and default styles, so fake an atom to read it
@@ -2897,17 +2881,17 @@ static void mov_parse_stsd_subtitle(MOVContext *c, AVIOContext *pb,
     if (st->codecpar->codec_tag != AV_RL32("mp4s") &&
         st->codecpar->codec_tag != MOV_ISMV_TTML_TAG)
         mov_read_glbl(c, pb, fake_atom);
-    st->codecpar->width  = sc->width;
+    st->codecpar->width = sc->width;
     st->codecpar->height = sc->height;
 }
 
-static int mov_parse_stsd_data(MOVContext *c, AVIOContext *pb,
-                                AVStream *st, MOVStreamContext *sc,
-                                int64_t size)
+static int mov_parse_stsd_data(MOVContext* c, AVIOContext* pb,
+    AVStream* st, MOVStreamContext* sc,
+    int64_t size)
 {
     int ret;
 
-    if (st->codecpar->codec_tag == MKTAG('t','m','c','d')) {
+    if (st->codecpar->codec_tag == MKTAG('t', 'm', 'c', 'd')) {
         if ((int)size != size)
             return AVERROR(ENOMEM);
 
@@ -2915,7 +2899,7 @@ static int mov_parse_stsd_data(MOVContext *c, AVIOContext *pb,
         if (ret < 0)
             return ret;
         if (size > 16) {
-            MOVStreamContext *tmcd_ctx = st->priv_data;
+            MOVStreamContext* tmcd_ctx = st->priv_data;
             int val;
             val = AV_RB32(st->codecpar->extradata + 4);
             tmcd_ctx->tmcd_flags = val;
@@ -2929,28 +2913,29 @@ static int mov_parse_stsd_data(MOVContext *c, AVIOContext *pb,
                     uint16_t str_size = AV_RB16(st->codecpar->extradata + 26); /* string length */
                     if (str_size > 0 && size >= (int)str_size + 30 &&
                         st->codecpar->extradata[30] /* Don't add empty string */) {
-                        char *reel_name = av_malloc(str_size + 1);
+                        char* reel_name = av_malloc(str_size + 1);
                         if (!reel_name)
                             return AVERROR(ENOMEM);
                         memcpy(reel_name, st->codecpar->extradata + 30, str_size);
                         reel_name[str_size] = 0; /* Add null terminator */
                         av_dict_set(&st->metadata, "reel_name", reel_name,
-                                    AV_DICT_DONT_STRDUP_VAL);
+                            AV_DICT_DONT_STRDUP_VAL);
                     }
                 }
             }
         }
-    } else {
+    }
+    else {
         /* other codec type, just skip (rtp, mp4s ...) */
         avio_skip(pb, size);
     }
     return 0;
 }
 
-static int mov_finalize_stsd_codec(MOVContext *c, AVIOContext *pb,
-                                   AVStream *st, MOVStreamContext *sc)
+static int mov_finalize_stsd_codec(MOVContext* c, AVIOContext* pb,
+    AVStream* st, MOVStreamContext* sc)
 {
-    FFStream *const sti = ffstream(st);
+    FFStream* const sti = ffstream(st);
 
     if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
         !st->codecpar->sample_rate && sc->time_scale > 1)
@@ -2976,15 +2961,15 @@ static int mov_finalize_stsd_codec(MOVContext *c, AVIOContext *pb,
             return AVERROR(ENOMEM);
         }
         sc->dv_audio_container = 1;
-        st->codecpar->codec_id    = AV_CODEC_ID_PCM_S16LE;
+        st->codecpar->codec_id = AV_CODEC_ID_PCM_S16LE;
         break;
 #endif
-    /* no ifdef since parameters are always those */
+        /* no ifdef since parameters are always those */
     case AV_CODEC_ID_QCELP:
         av_channel_layout_uninit(&st->codecpar->ch_layout);
         st->codecpar->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_MONO;
         // force sample rate for qcelp when not stored in mov
-        if (st->codecpar->codec_tag != MKTAG('Q','c','l','p'))
+        if (st->codecpar->codec_tag != MKTAG('Q', 'c', 'l', 'p'))
             st->codecpar->sample_rate = 8000;
         // FIXME: Why is the following needed for some files?
         sc->samples_per_frame = 160;
@@ -3036,7 +3021,6 @@ static int mov_finalize_stsd_codec(MOVContext *c, AVIOContext *pb,
         sti->need_parsing = AVSTREAM_PARSE_FULL;
         break;
     case AV_CODEC_ID_PRORES_RAW:
-    case AV_CODEC_ID_PRORES:
     case AV_CODEC_ID_APV:
     case AV_CODEC_ID_EVC:
     case AV_CODEC_ID_AV1:
@@ -3050,20 +3034,20 @@ static int mov_finalize_stsd_codec(MOVContext *c, AVIOContext *pb,
     return 0;
 }
 
-static int mov_skip_multiple_stsd(MOVContext *c, AVIOContext *pb,
-                                  int codec_tag, int format,
-                                  int64_t size)
+static int mov_skip_multiple_stsd(MOVContext* c, AVIOContext* pb,
+    int codec_tag, int format,
+    int64_t size)
 {
     if (codec_tag &&
-         (codec_tag != format &&
-          // AVID 1:1 samples with differing data format and codec tag exist
-          (codec_tag != AV_RL32("AV1x") || format != AV_RL32("AVup")) &&
-          // prores is allowed to have differing data format and codec tag
-          codec_tag != AV_RL32("apcn") && codec_tag != AV_RL32("apch") &&
-          // so is dv (sigh)
-          codec_tag != AV_RL32("dvpp") && codec_tag != AV_RL32("dvcp") &&
-          (c->fc->video_codec_id ? ff_codec_get_id(ff_codec_movvideo_tags, format) != c->fc->video_codec_id
-                                 : codec_tag != MKTAG('j','p','e','g')))) {
+        (codec_tag != format &&
+            // AVID 1:1 samples with differing data format and codec tag exist
+            (codec_tag != AV_RL32("AV1x") || format != AV_RL32("AVup")) &&
+            // prores is allowed to have differing data format and codec tag
+            codec_tag != AV_RL32("apcn") && codec_tag != AV_RL32("apch") &&
+            // so is dv (sigh)
+            codec_tag != AV_RL32("dvpp") && codec_tag != AV_RL32("dvcp") &&
+            (c->fc->video_codec_id ? ff_codec_get_id(ff_codec_movvideo_tags, format) != c->fc->video_codec_id
+                : codec_tag != MKTAG('j', 'p', 'e', 'g')))) {
         /* Multiple fourcc, we skip JPEG. This is not correct, we should
          * export it as a separate AVStream but this needs a few changes
          * in the MOV demuxer, patch welcome. */
@@ -3076,7 +3060,7 @@ static int mov_skip_multiple_stsd(MOVContext *c, AVIOContext *pb,
     return 0;
 }
 
-static int mov_finalize_stsd_entry(MOVContext *c, AVStream *st)
+static int mov_finalize_stsd_entry(MOVContext* c, AVStream* st)
 {
     int ret;
 
@@ -3087,7 +3071,7 @@ static int mov_finalize_stsd_entry(MOVContext *c, AVStream *st)
         if (!st->codecpar->extradata_size && TAG_IS_AVCI(st->codecpar->codec_tag)) {
             ret = ff_generate_avci_extradata(st);
             if (ret < 0)
-               return ret;
+                return ret;
         }
         break;
     default:
@@ -3097,57 +3081,59 @@ static int mov_finalize_stsd_entry(MOVContext *c, AVStream *st)
     return 0;
 }
 
-int ff_mov_read_stsd_entries(MOVContext *c, AVIOContext *pb, int entries)
+int ff_mov_read_stsd_entries(MOVContext* c, AVIOContext* pb, int entries)
 {
-    AVStream *st;
-    MOVStreamContext *sc;
+    AVStream* st;
+    MOVStreamContext* sc;
     int pseudo_stream_id;
 
-    av_assert0 (c->fc->nb_streams >= 1);
-    st = c->fc->streams[c->fc->nb_streams-1];
+    av_assert0(c->fc->nb_streams >= 1);
+    st = c->fc->streams[c->fc->nb_streams - 1];
     sc = st->priv_data;
 
     for (pseudo_stream_id = 0;
-         pseudo_stream_id < entries && !pb->eof_reached;
-         pseudo_stream_id++) {
+        pseudo_stream_id < entries && !pb->eof_reached;
+        pseudo_stream_id++) {
         //Parsing Sample description table
         enum AVCodecID id;
         int ret, dref_id = 1;
         MOVAtom a = { AV_RL32("stsd") };
         int64_t start_pos = avio_tell(pb);
-        int64_t size    = avio_rb32(pb); /* size */
+        int64_t size = avio_rb32(pb); /* size */
         uint32_t format = avio_rl32(pb); /* data format */
 
         if (size >= 16) {
             avio_rb32(pb); /* reserved */
             avio_rb16(pb); /* reserved */
             dref_id = avio_rb16(pb);
-        } else if (size <= 7) {
+        }
+        else if (size <= 7) {
             av_log(c->fc, AV_LOG_ERROR,
-                   "invalid size %"PRId64" in stsd\n", size);
+                "invalid size %"PRId64" in stsd\n", size);
             return AVERROR_INVALIDDATA;
         }
 
         if (mov_skip_multiple_stsd(c, pb, st->codecpar->codec_tag, format,
-                                   size - (avio_tell(pb) - start_pos))) {
+            size - (avio_tell(pb) - start_pos))) {
             sc->stsd_count++;
             continue;
         }
 
         sc->pseudo_stream_id = st->codecpar->codec_tag ? -1 : pseudo_stream_id;
-        sc->dref_id= dref_id;
+        sc->dref_id = dref_id;
         sc->format = format;
 
         id = mov_codec_id(st, format);
 
         av_log(c->fc, AV_LOG_TRACE,
-               "size=%"PRId64" 4CC=%s codec_type=%d\n", size,
-               av_fourcc2str(format), st->codecpar->codec_type);
+            "size=%"PRId64" 4CC=%s codec_type=%d\n", size,
+            av_fourcc2str(format), st->codecpar->codec_type);
 
         st->codecpar->codec_id = id;
-        if (st->codecpar->codec_type==AVMEDIA_TYPE_VIDEO) {
+        if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
             mov_parse_stsd_video(c, pb, st, sc);
-        } else if (st->codecpar->codec_type==AVMEDIA_TYPE_AUDIO) {
+        }
+        else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
             mov_parse_stsd_audio(c, pb, st, sc);
             if (st->codecpar->sample_rate < 0) {
                 av_log(c->fc, AV_LOG_ERROR, "Invalid sample rate %d\n", st->codecpar->sample_rate);
@@ -3157,12 +3143,14 @@ int ff_mov_read_stsd_entries(MOVContext *c, AVIOContext *pb, int entries)
                 av_log(c->fc, AV_LOG_ERROR, "Invalid channels %d\n", st->codecpar->ch_layout.nb_channels);
                 return AVERROR_INVALIDDATA;
             }
-        } else if (st->codecpar->codec_type==AVMEDIA_TYPE_SUBTITLE){
+        }
+        else if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
             mov_parse_stsd_subtitle(c, pb, st, sc,
-                                    size - (avio_tell(pb) - start_pos));
-        } else {
+                size - (avio_tell(pb) - start_pos));
+        }
+        else {
             ret = mov_parse_stsd_data(c, pb, st, sc,
-                                      size - (avio_tell(pb) - start_pos));
+                size - (avio_tell(pb) - start_pos));
             if (ret < 0)
                 return ret;
         }
@@ -3171,7 +3159,8 @@ int ff_mov_read_stsd_entries(MOVContext *c, AVIOContext *pb, int entries)
         if (a.size > 8) {
             if ((ret = mov_read_default(c, pb, a)) < 0)
                 return ret;
-        } else if (a.size > 0)
+        }
+        else if (a.size > 0)
             avio_skip(pb, a.size);
 
         ret = mov_finalize_stsd_entry(c, st);
@@ -3184,7 +3173,7 @@ int ff_mov_read_stsd_entries(MOVContext *c, AVIOContext *pb, int entries)
             /* Move the current stream extradata to the stream context one. */
             sc->extradata_size[pseudo_stream_id] = extra_size;
             sc->extradata[pseudo_stream_id] = st->codecpar->extradata;
-            st->codecpar->extradata      = NULL;
+            st->codecpar->extradata = NULL;
             st->codecpar->extradata_size = 0;
         }
         sc->stsd_count++;
@@ -3198,10 +3187,10 @@ int ff_mov_read_stsd_entries(MOVContext *c, AVIOContext *pb, int entries)
     return 0;
 }
 
-static int mov_read_stsd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_stsd(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    AVStream *st;
-    MOVStreamContext *sc;
+    AVStream* st;
+    MOVStreamContext* sc;
     int ret, entries;
 
     if (c->fc->nb_streams < 1)
@@ -3221,7 +3210,7 @@ static int mov_read_stsd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 
     if (sc->extradata) {
         av_log(c->fc, AV_LOG_ERROR,
-               "Duplicate stsd found in this track.\n");
+            "Duplicate stsd found in this track.\n");
         return AVERROR_INVALIDDATA;
     }
 
@@ -3263,10 +3252,10 @@ fail:
     return ret;
 }
 
-static int mov_read_stsc(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_stsc(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    AVStream *st;
-    MOVStreamContext *sc;
+    AVStream* st;
+    MOVStreamContext* sc;
     unsigned int i, entries;
 
     if (c->trak_index < 0) {
@@ -3276,7 +3265,7 @@ static int mov_read_stsc(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 
     if (c->fc->nb_streams < 1)
         return 0;
-    st = c->fc->streams[c->fc->nb_streams-1];
+    st = c->fc->streams[c->fc->nb_streams - 1];
     sc = st->priv_data;
 
     avio_r8(pb); /* version */
@@ -3309,29 +3298,29 @@ static int mov_read_stsc(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     sc->stsc_count = i;
     for (i = sc->stsc_count - 1; i < UINT_MAX; i--) {
         int64_t first_min = i + 1;
-        if ((i+1 < sc->stsc_count && sc->stsc_data[i].first >= sc->stsc_data[i+1].first) ||
-            (i > 0 && sc->stsc_data[i].first <= sc->stsc_data[i-1].first) ||
+        if ((i + 1 < sc->stsc_count && sc->stsc_data[i].first >= sc->stsc_data[i + 1].first) ||
+            (i > 0 && sc->stsc_data[i].first <= sc->stsc_data[i - 1].first) ||
             sc->stsc_data[i].first < first_min ||
             sc->stsc_data[i].count < 1 ||
             sc->stsc_data[i].id < 1) {
             av_log(c->fc, AV_LOG_WARNING, "STSC entry %d is invalid (first=%d count=%d id=%d)\n", i, sc->stsc_data[i].first, sc->stsc_data[i].count, sc->stsc_data[i].id);
-            if (i+1 >= sc->stsc_count) {
+            if (i + 1 >= sc->stsc_count) {
                 if (sc->stsc_data[i].count == 0 && i > 0) {
-                    sc->stsc_count --;
+                    sc->stsc_count--;
                     continue;
                 }
                 sc->stsc_data[i].first = FFMAX(sc->stsc_data[i].first, first_min);
-                if (i > 0 && sc->stsc_data[i].first <= sc->stsc_data[i-1].first)
-                    sc->stsc_data[i].first = FFMIN(sc->stsc_data[i-1].first + 1LL, INT_MAX);
+                if (i > 0 && sc->stsc_data[i].first <= sc->stsc_data[i - 1].first)
+                    sc->stsc_data[i].first = FFMIN(sc->stsc_data[i - 1].first + 1LL, INT_MAX);
                 sc->stsc_data[i].count = FFMAX(sc->stsc_data[i].count, 1);
-                sc->stsc_data[i].id    = FFMAX(sc->stsc_data[i].id, 1);
+                sc->stsc_data[i].id = FFMAX(sc->stsc_data[i].id, 1);
                 continue;
             }
-            av_assert0(sc->stsc_data[i+1].first >= 2);
+            av_assert0(sc->stsc_data[i + 1].first >= 2);
             // We replace this entry by the next valid
-            sc->stsc_data[i].first = sc->stsc_data[i+1].first - 1;
-            sc->stsc_data[i].count = sc->stsc_data[i+1].count;
-            sc->stsc_data[i].id    = sc->stsc_data[i+1].id;
+            sc->stsc_data[i].first = sc->stsc_data[i + 1].first - 1;
+            sc->stsc_data[i].count = sc->stsc_data[i + 1].count;
+            sc->stsc_data[i].id = sc->stsc_data[i + 1].id;
         }
     }
 
@@ -3349,7 +3338,7 @@ static inline int mov_stsc_index_valid(unsigned int index, unsigned int count)
 }
 
 /* Compute the samples value for the stsc entry at the given index. */
-static inline int64_t mov_get_stsc_samples(MOVStreamContext *sc, unsigned int index)
+static inline int64_t mov_get_stsc_samples(MOVStreamContext* sc, unsigned int index)
 {
     int chunk_count;
 
@@ -3364,10 +3353,10 @@ static inline int64_t mov_get_stsc_samples(MOVStreamContext *sc, unsigned int in
     return sc->stsc_data[index].count * (int64_t)chunk_count;
 }
 
-static int mov_read_stps(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_stps(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    AVStream *st;
-    MOVStreamContext *sc;
+    AVStream* st;
+    MOVStreamContext* sc;
     unsigned i, entries;
 
     if (c->trak_index < 0) {
@@ -3377,7 +3366,7 @@ static int mov_read_stps(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 
     if (c->fc->nb_streams < 1)
         return 0;
-    st = c->fc->streams[c->fc->nb_streams-1];
+    st = c->fc->streams[c->fc->nb_streams - 1];
     sc = st->priv_data;
 
     avio_rb32(pb); // version + flags
@@ -3405,11 +3394,11 @@ static int mov_read_stps(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return 0;
 }
 
-static int mov_read_stss(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_stss(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    AVStream *st;
-    FFStream *sti;
-    MOVStreamContext *sc;
+    AVStream* st;
+    FFStream* sti;
+    MOVStreamContext* sc;
     unsigned int i, entries;
 
     if (c->trak_index < 0) {
@@ -3419,7 +3408,7 @@ static int mov_read_stss(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 
     if (c->fc->nb_streams < 1)
         return 0;
-    st = c->fc->streams[c->fc->nb_streams-1];
+    st = c->fc->streams[c->fc->nb_streams - 1];
     sti = ffstream(st);
     sc = st->priv_data;
 
@@ -3460,10 +3449,10 @@ static int mov_read_stss(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return 0;
 }
 
-static int mov_read_stsz(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_stsz(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    AVStream *st;
-    MOVStreamContext *sc;
+    AVStream* st;
+    MOVStreamContext* sc;
     unsigned int i, entries, sample_size, field_size, num_bytes;
     GetBitContext gb;
     unsigned char* buf;
@@ -3476,19 +3465,20 @@ static int mov_read_stsz(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 
     if (c->fc->nb_streams < 1)
         return 0;
-    st = c->fc->streams[c->fc->nb_streams-1];
+    st = c->fc->streams[c->fc->nb_streams - 1];
     sc = st->priv_data;
 
     avio_r8(pb); /* version */
     avio_rb24(pb); /* flags */
 
-    if (atom.type == MKTAG('s','t','s','z')) {
+    if (atom.type == MKTAG('s', 't', 's', 'z')) {
         sample_size = avio_rb32(pb);
         if (!sc->sample_size) /* do not overwrite value computed in stsd */
             sc->sample_size = sample_size;
         sc->stsz_sample_size = sample_size;
         field_size = 32;
-    } else {
+    }
+    else {
         sample_size = 0;
         avio_rb24(pb); /* reserved */
         field_size = avio_r8(pb);
@@ -3518,9 +3508,9 @@ static int mov_read_stsz(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     if (!sc->sample_sizes)
         return AVERROR(ENOMEM);
 
-    num_bytes = (entries*field_size+4)>>3;
+    num_bytes = (entries * field_size + 4) >> 3;
 
-    buf = av_malloc(num_bytes+AV_INPUT_BUFFER_PADDING_SIZE);
+    buf = av_malloc(num_bytes + AV_INPUT_BUFFER_PADDING_SIZE);
     if (!buf) {
         av_freep(&sc->sample_sizes);
         return AVERROR(ENOMEM);
@@ -3534,7 +3524,7 @@ static int mov_read_stsz(MOVContext *c, AVIOContext *pb, MOVAtom atom)
         return 0;
     }
 
-    init_get_bits(&gb, buf, 8*num_bytes);
+    init_get_bits(&gb, buf, 8 * num_bytes);
 
     for (i = 0; i < entries; i++) {
         sc->sample_sizes[i] = get_bits_long(&gb, field_size);
@@ -3553,10 +3543,10 @@ static int mov_read_stsz(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return 0;
 }
 
-static int mov_read_stts(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_stts(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    AVStream *st;
-    MOVStreamContext *sc;
+    AVStream* st;
+    MOVStreamContext* sc;
     unsigned int i, entries;
     int64_t duration = 0;
     int64_t total_sample_count = 0;
@@ -3570,7 +3560,7 @@ static int mov_read_stts(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 
     if (c->fc->nb_streams < 1)
         return 0;
-    st = c->fc->streams[c->fc->nb_streams-1];
+    st = c->fc->streams[c->fc->nb_streams - 1];
     sc = st->priv_data;
 
     avio_r8(pb); /* version */
@@ -3578,7 +3568,7 @@ static int mov_read_stts(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     entries = avio_rb32(pb);
 
     av_log(c->fc, AV_LOG_TRACE, "track[%u].stts.entries = %u\n",
-            c->fc->nb_streams-1, entries);
+        c->fc->nb_streams - 1, entries);
 
     if (sc->stts_data)
         av_log(c->fc, AV_LOG_WARNING, "Duplicated STTS atom\n");
@@ -3591,8 +3581,8 @@ static int mov_read_stts(MOVContext *c, AVIOContext *pb, MOVAtom atom)
         unsigned int sample_duration;
         unsigned int sample_count;
         unsigned int min_entries = FFMIN(FFMAX(i + 1, 1024 * 1024), entries);
-        MOVStts *stts_data = av_fast_realloc(sc->stts_data, &sc->stts_allocated_size,
-                                             min_entries * sizeof(*sc->stts_data));
+        MOVStts* stts_data = av_fast_realloc(sc->stts_data, &sc->stts_allocated_size,
+            min_entries * sizeof(*sc->stts_data));
         if (!stts_data) {
             av_freep(&sc->stts_data);
             sc->stts_count = 0;
@@ -3601,14 +3591,14 @@ static int mov_read_stts(MOVContext *c, AVIOContext *pb, MOVAtom atom)
         sc->stts_count = min_entries;
         sc->stts_data = stts_data;
 
-        sample_count    = avio_rb32(pb);
+        sample_count = avio_rb32(pb);
         sample_duration = avio_rb32(pb);
 
-        sc->stts_data[i].count= sample_count;
-        sc->stts_data[i].duration= sample_duration;
+        sc->stts_data[i].count = sample_count;
+        sc->stts_data[i].duration = sample_duration;
 
         av_log(c->fc, AV_LOG_TRACE, "sample_count=%u, sample_duration=%u\n",
-                sample_count, sample_duration);
+            sample_count, sample_duration);
 
         /* STTS sample offsets are uint32 but some files store it as int32
          * with negative values used to correct DTS delays.
@@ -3617,10 +3607,11 @@ static int mov_read_stts(MOVContext *c, AVIOContext *pb, MOVAtom atom)
             // assume high delta is a correction if negative when cast as int32
             int32_t delta_magnitude = (int32_t)sample_duration;
             av_log(c->fc, AV_LOG_WARNING, "Too large sample offset %u in stts entry %u with count %u in st:%d. Clipping to 1.\n",
-                   sample_duration, i, sample_count, st->index);
+                sample_duration, i, sample_count, st->index);
             sc->stts_data[i].duration = 1;
             corrected_dts = av_sat_add64(corrected_dts, (delta_magnitude < 0 ? (int64_t)delta_magnitude : 1) * sample_count);
-        } else {
+        }
+        else {
             corrected_dts += sample_duration * (uint64_t)sample_count;
         }
 
@@ -3633,8 +3624,8 @@ static int mov_read_stts(MOVContext *c, AVIOContext *pb, MOVAtom atom)
             sc->stts_data[i].duration -= correction;
         }
 
-        duration+=(int64_t)sc->stts_data[i].duration*(uint64_t)sc->stts_data[i].count;
-        total_sample_count+=sc->stts_data[i].count;
+        duration += (int64_t)sc->stts_data[i].duration * (uint64_t)sc->stts_data[i].count;
+        total_sample_count += sc->stts_data[i].count;
     }
 
     sc->stts_count = i;
@@ -3642,7 +3633,7 @@ static int mov_read_stts(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     if (duration > 0 &&
         duration <= INT64_MAX - sc->duration_for_fps &&
         total_sample_count <= INT_MAX - sc->nb_frames_for_fps) {
-        sc->duration_for_fps  += duration;
+        sc->duration_for_fps += duration;
         sc->nb_frames_for_fps += total_sample_count;
     }
 
@@ -3651,9 +3642,9 @@ static int mov_read_stts(MOVContext *c, AVIOContext *pb, MOVAtom atom)
         return AVERROR_EOF;
     }
 
-    st->nb_frames= total_sample_count;
+    st->nb_frames = total_sample_count;
     if (duration)
-        st->duration= FFMIN(st->duration, duration);
+        st->duration = FFMIN(st->duration, duration);
 
     // All samples have zero duration. They have higher chance be chose by
     // mov_find_next_sample, which leads to seek again and again.
@@ -3661,22 +3652,22 @@ static int mov_read_stts(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     // It's AVERROR_INVALIDDATA actually, but such files exist in the wild.
     // So only mark data stream as discarded for safety.
     if (!duration && sc->stts_count &&
-            st->codecpar->codec_type == AVMEDIA_TYPE_DATA) {
+        st->codecpar->codec_type == AVMEDIA_TYPE_DATA) {
         av_log(c->fc, AV_LOG_WARNING,
-               "All samples in data stream index:id [%d:%d] have zero "
-               "duration, stream set to be discarded by default. Override "
-               "using AVStream->discard or -discard for ffmpeg command.\n",
-               st->index, sc->id);
+            "All samples in data stream index:id [%d:%d] have zero "
+            "duration, stream set to be discarded by default. Override "
+            "using AVStream->discard or -discard for ffmpeg command.\n",
+            st->index, sc->id);
         st->discard = AVDISCARD_ALL;
     }
     sc->track_end = duration;
     return 0;
 }
 
-static int mov_read_sdtp(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_sdtp(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    AVStream *st;
-    MOVStreamContext *sc;
+    AVStream* st;
+    MOVStreamContext* sc;
     int64_t i, entries;
 
     if (c->fc->nb_streams < 1)
@@ -3689,7 +3680,7 @@ static int mov_read_sdtp(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     entries = atom.size - 4;
 
     av_log(c->fc, AV_LOG_TRACE, "track[%u].sdtp.entries = %" PRId64 "\n",
-           c->fc->nb_streams - 1, entries);
+        c->fc->nb_streams - 1, entries);
 
     if (sc->sdtp_data)
         av_log(c->fc, AV_LOG_WARNING, "Duplicated SDTP atom\n");
@@ -3707,7 +3698,7 @@ static int mov_read_sdtp(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return 0;
 }
 
-static void mov_update_dts_shift(MOVStreamContext *sc, int duration, void *logctx)
+static void mov_update_dts_shift(MOVStreamContext* sc, int duration, void* logctx)
 {
     if (duration < 0) {
         if (duration == INT_MIN) {
@@ -3718,10 +3709,10 @@ static void mov_update_dts_shift(MOVStreamContext *sc, int duration, void *logct
     }
 }
 
-static int mov_read_ctts(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_ctts(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    AVStream *st;
-    MOVStreamContext *sc;
+    AVStream* st;
+    MOVStreamContext* sc;
     unsigned int i, entries, ctts_count = 0;
 
     if (c->trak_index < 0) {
@@ -3731,7 +3722,7 @@ static int mov_read_ctts(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 
     if (c->fc->nb_streams < 1)
         return 0;
-    st = c->fc->streams[c->fc->nb_streams-1];
+    st = c->fc->streams[c->fc->nb_streams - 1];
     sc = st->priv_data;
 
     avio_r8(pb); /* version */
@@ -3750,19 +3741,19 @@ static int mov_read_ctts(MOVContext *c, AVIOContext *pb, MOVAtom atom)
         return AVERROR(ENOMEM);
 
     for (i = 0; i < entries && !pb->eof_reached; i++) {
-        MOVCtts *ctts_data;
+        MOVCtts* ctts_data;
         const size_t min_size_needed = (ctts_count + 1) * sizeof(MOVCtts);
         const size_t requested_size =
             min_size_needed > sc->ctts_allocated_size ?
             FFMAX(min_size_needed, 2 * sc->ctts_allocated_size) :
             min_size_needed;
-        int count    = avio_rb32(pb);
+        int count = avio_rb32(pb);
         int duration = avio_rb32(pb);
 
         if (count <= 0) {
             av_log(c->fc, AV_LOG_TRACE,
-                   "ignoring CTTS entry with count=%d duration=%d\n",
-                   count, duration);
+                "ignoring CTTS entry with count=%d duration=%d\n",
+                count, duration);
             continue;
         }
 
@@ -3781,9 +3772,9 @@ static int mov_read_ctts(MOVContext *c, AVIOContext *pb, MOVAtom atom)
         ctts_count++;
 
         av_log(c->fc, AV_LOG_TRACE, "count=%d, duration=%d\n",
-                count, duration);
+            count, duration);
 
-        if (i+2<entries)
+        if (i + 2 < entries)
             mov_update_dts_shift(sc, duration, c->fc);
     }
 
@@ -3799,10 +3790,10 @@ static int mov_read_ctts(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return 0;
 }
 
-static int mov_read_sgpd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_sgpd(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    AVStream *st;
-    MOVStreamContext *sc;
+    AVStream* st;
+    MOVStreamContext* sc;
     uint8_t version;
     uint32_t grouping_type;
     uint32_t default_length;
@@ -3822,7 +3813,7 @@ static int mov_read_sgpd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
      * This function only supports "sync" boxes, but the code is able to parse
      * other boxes (such as "tscl", "tsas" and "stsa")
      */
-    if (grouping_type != MKTAG('s','y','n','c'))
+    if (grouping_type != MKTAG('s', 'y', 'n', 'c'))
         return 0;
 
     default_length = version >= 1 ? avio_rb32(pb) : 0;
@@ -3839,7 +3830,7 @@ static int mov_read_sgpd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
         uint32_t description_length = default_length;
         if (version >= 1 && default_length == 0)
             description_length = avio_rb32(pb);
-        if (grouping_type == MKTAG('s','y','n','c')) {
+        if (grouping_type == MKTAG('s', 'y', 'n', 'c')) {
             const uint8_t nal_unit_type = avio_r8(pb) & 0x3f;
             sc->sgpd_sync[i] = nal_unit_type;
             description_length -= 1;
@@ -3855,32 +3846,34 @@ static int mov_read_sgpd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return 0;
 }
 
-static int mov_read_sbgp(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_sbgp(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    AVStream *st;
-    MOVStreamContext *sc;
+    AVStream* st;
+    MOVStreamContext* sc;
     unsigned int i, entries;
     uint8_t version;
     uint32_t grouping_type;
-    MOVSbgp *table, **tablep;
-    int *table_count;
+    MOVSbgp* table, ** tablep;
+    int* table_count;
 
     if (c->fc->nb_streams < 1)
         return 0;
-    st = c->fc->streams[c->fc->nb_streams-1];
+    st = c->fc->streams[c->fc->nb_streams - 1];
     sc = st->priv_data;
 
     version = avio_r8(pb); /* version */
     avio_rb24(pb); /* flags */
     grouping_type = avio_rl32(pb);
 
-    if (grouping_type == MKTAG('r','a','p',' ')) {
+    if (grouping_type == MKTAG('r', 'a', 'p', ' ')) {
         tablep = &sc->rap_group;
         table_count = &sc->rap_group_count;
-    } else if (grouping_type == MKTAG('s','y','n','c')) {
+    }
+    else if (grouping_type == MKTAG('s', 'y', 'n', 'c')) {
         tablep = &sc->sync_group;
         table_count = &sc->sync_group_count;
-    } else {
+    }
+    else {
         return 0;
     }
 
@@ -3916,12 +3909,12 @@ static int mov_read_sbgp(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 /**
  * Get ith edit list entry (media time, duration).
  */
-static int get_edit_list_entry(MOVContext *mov,
-                               const MOVStreamContext *msc,
-                               unsigned int edit_list_index,
-                               int64_t *edit_list_media_time,
-                               int64_t *edit_list_duration,
-                               int64_t global_timescale)
+static int get_edit_list_entry(MOVContext* mov,
+    const MOVStreamContext* msc,
+    unsigned int edit_list_index,
+    int64_t* edit_list_media_time,
+    int64_t* edit_list_duration,
+    int64_t global_timescale)
 {
     if (edit_list_index == msc->elst_count) {
         return 0;
@@ -3931,11 +3924,11 @@ static int get_edit_list_entry(MOVContext *mov,
 
     /* duration is in global timescale units;convert to msc timescale */
     if (global_timescale == 0) {
-      avpriv_request_sample(mov->fc, "Support for mvhd.timescale = 0 with editlists");
-      return 0;
+        avpriv_request_sample(mov->fc, "Support for mvhd.timescale = 0 with editlists");
+        return 0;
     }
     *edit_list_duration = av_rescale(*edit_list_duration, msc->time_scale,
-                                     global_timescale);
+        global_timescale);
 
     if (*edit_list_duration + (uint64_t)*edit_list_media_time > INT64_MAX)
         *edit_list_duration = 0;
@@ -3962,20 +3955,20 @@ static int get_edit_list_entry(MOVContext *mov,
  *
  * Places the found ctts_index and ctts_sample in corresponding output args.
  */
-static int find_prev_closest_index(AVStream *st,
-                                   AVIndexEntry *e_old,
-                                   int nb_old,
-                                   MOVTimeToSample *tts_data,
-                                   int64_t tts_count,
-                                   int64_t timestamp_pts,
-                                   int flag,
-                                   int64_t* index,
-                                   int64_t* tts_index,
-                                   int64_t* tts_sample)
-{
-    MOVStreamContext *msc = st->priv_data;
-    FFStream *const sti = ffstream(st);
-    AVIndexEntry *e_keep = sti->index_entries;
+static int find_prev_closest_index(AVStream* st,
+    AVIndexEntry* e_old,
+    int nb_old,
+    MOVTimeToSample* tts_data,
+    int64_t tts_count,
+    int64_t timestamp_pts,
+    int flag,
+    int64_t* index,
+    int64_t* tts_index,
+    int64_t* tts_sample)
+{
+    MOVStreamContext* msc = st->priv_data;
+    FFStream* const sti = ffstream(st);
+    AVIndexEntry* e_keep = sti->index_entries;
     int nb_keep = sti->nb_index_entries;
     int64_t i = 0;
 
@@ -3988,14 +3981,14 @@ static int find_prev_closest_index(AVStream *st,
         timestamp_pts -= msc->dts_shift;
     }
 
-    sti->index_entries    = e_old;
+    sti->index_entries = e_old;
     sti->nb_index_entries = nb_old;
     *index = av_index_search_timestamp(st, timestamp_pts, flag | AVSEEK_FLAG_BACKWARD);
 
     // Keep going backwards in the index entries until the timestamp is the same.
     if (*index >= 0) {
         for (i = *index; i > 0 && e_old[i].timestamp == e_old[i - 1].timestamp;
-             i--) {
+            i--) {
             if ((flag & AVSEEK_FLAG_ANY) ||
                 (e_old[i - 1].flags & AVINDEX_KEYFRAME)) {
                 *index = i - 1;
@@ -4034,15 +4027,16 @@ static int find_prev_closest_index(AVStream *st,
             if (*tts_sample == 0) {
                 (*tts_index)--;
                 if (*tts_index >= 0)
-                  *tts_sample = tts_data[*tts_index].count - 1;
-            } else {
+                    *tts_sample = tts_data[*tts_index].count - 1;
+            }
+            else {
                 (*tts_sample)--;
             }
         }
     }
 
     /* restore AVStream state*/
-    sti->index_entries    = e_keep;
+    sti->index_entries = e_keep;
     sti->nb_index_entries = nb_keep;
     return *index >= 0 ? 0 : -1;
 }
@@ -4058,11 +4052,11 @@ static int find_prev_closest_index(AVStream *st,
  * This is needed because the mov_fix_index calls this func with the same
  * unincremented timestamp for successive discarded frames.
  */
-static int64_t add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
-                               int size, int distance, int flags)
+static int64_t add_index_entry(AVStream* st, int64_t pos, int64_t timestamp,
+    int size, int distance, int flags)
 {
-    FFStream *const sti = ffstream(st);
-    AVIndexEntry *entries, *ie;
+    FFStream* const sti = ffstream(st);
+    AVIndexEntry* entries, * ie;
     int64_t index = -1;
     const size_t min_size_needed = (sti->nb_index_entries + 1) * sizeof(AVIndexEntry);
 
@@ -4077,20 +4071,20 @@ static int64_t add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
         return -1;
 
     entries = av_fast_realloc(sti->index_entries,
-                              &sti->index_entries_allocated_size,
-                              requested_size);
+        &sti->index_entries_allocated_size,
+        requested_size);
     if (!entries)
         return -1;
 
     sti->index_entries = entries;
 
     index = sti->nb_index_entries++;
-    ie= &entries[index];
+    ie = &entries[index];
 
     ie->pos = pos;
     ie->timestamp = timestamp;
-    ie->min_distance= distance;
-    ie->size= size;
+    ie->min_distance = distance;
+    ie->size = size;
     ie->flags = flags;
     return index;
 }
@@ -4100,9 +4094,9 @@ static int64_t add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
  * by subtracting end_ts successively by the amounts given in frame_duration_buffer.
  */
 static void fix_index_entry_timestamps(AVStream* st, int end_index, int64_t end_ts,
-                                       int64_t* frame_duration_buffer,
-                                       int frame_duration_buffer_size) {
-    FFStream *const sti = ffstream(st);
+    int64_t* frame_duration_buffer,
+    int frame_duration_buffer_size) {
+    FFStream* const sti = ffstream(st);
     int i = 0;
     av_assert0(end_index >= 0 && end_index <= sti->nb_index_entries);
     for (i = 0; i < frame_duration_buffer_size; i++) {
@@ -4111,10 +4105,10 @@ static void fix_index_entry_timestamps(AVStream* st, int end_index, int64_t end_
     }
 }
 
-static int add_tts_entry(MOVTimeToSample **tts_data, unsigned int *tts_count, unsigned int *allocated_size,
-                         int count, int offset, unsigned int duration)
+static int add_tts_entry(MOVTimeToSample** tts_data, unsigned int* tts_count, unsigned int* allocated_size,
+    int count, int offset, unsigned int duration)
 {
-    MOVTimeToSample *tts_buf_new;
+    MOVTimeToSample* tts_buf_new;
     const size_t min_size_needed = (*tts_count + 1) * sizeof(MOVTimeToSample);
     const size_t requested_size =
         min_size_needed > *allocated_size ?
@@ -4140,10 +4134,10 @@ static int add_tts_entry(MOVTimeToSample **tts_data, unsigned int *tts_count, un
 }
 
 #define MAX_REORDER_DELAY 16
-static void mov_estimate_video_delay(MOVContext *c, AVStream* st)
+static void mov_estimate_video_delay(MOVContext* c, AVStream* st)
 {
-    MOVStreamContext *msc = st->priv_data;
-    FFStream *const sti = ffstream(st);
+    MOVStreamContext* msc = st->priv_data;
+    FFStream* const sti = ffstream(st);
     int ctts_ind = 0;
     int ctts_sample = 0;
     int64_t pts_buf[MAX_REORDER_DELAY + 1]; // Circular buffer to sort pts.
@@ -4178,7 +4172,8 @@ static void mov_estimate_video_delay(MOVContext *c, AVStream* st)
                 if (pts_buf[j] < pts_buf[r]) {
                     FFSWAP(int64_t, pts_buf[j], pts_buf[r]);
                     ++num_swaps;
-                } else {
+                }
+                else {
                     break;
                 }
                 j = r;
@@ -4192,11 +4187,11 @@ static void mov_estimate_video_delay(MOVContext *c, AVStream* st)
             }
         }
         av_log(c->fc, AV_LOG_DEBUG, "Setting codecpar->delay to %d for stream st: %d\n",
-               st->codecpar->video_delay, st->index);
+            st->codecpar->video_delay, st->index);
     }
 }
 
-static void mov_current_sample_inc(MOVStreamContext *sc)
+static void mov_current_sample_inc(MOVStreamContext* sc)
 {
     sc->current_sample++;
     sc->current_index++;
@@ -4208,7 +4203,7 @@ static void mov_current_sample_inc(MOVStreamContext *sc)
     }
 }
 
-static void mov_current_sample_dec(MOVStreamContext *sc)
+static void mov_current_sample_dec(MOVStreamContext* sc)
 {
     sc->current_sample--;
     sc->current_index--;
@@ -4220,7 +4215,7 @@ static void mov_current_sample_dec(MOVStreamContext *sc)
     }
 }
 
-static void mov_current_sample_set(MOVStreamContext *sc, int current_sample)
+static void mov_current_sample_set(MOVStreamContext* sc, int current_sample)
 {
     int64_t range_size;
 
@@ -4248,15 +4243,15 @@ static void mov_current_sample_set(MOVStreamContext *sc, int current_sample)
  * Also fixes the timestamps of the index entries to match the timeline
  * specified the edit lists.
  */
-static void mov_fix_index(MOVContext *mov, AVStream *st)
+static void mov_fix_index(MOVContext* mov, AVStream* st)
 {
-    MOVStreamContext *msc = st->priv_data;
-    FFStream *const sti = ffstream(st);
-    AVIndexEntry *e_old = sti->index_entries;
+    MOVStreamContext* msc = st->priv_data;
+    FFStream* const sti = ffstream(st);
+    AVIndexEntry* e_old = sti->index_entries;
     int nb_old = sti->nb_index_entries;
-    const AVIndexEntry *e_old_end = e_old + nb_old;
-    const AVIndexEntry *current = NULL;
-    MOVTimeToSample *tts_data_old = msc->tts_data;
+    const AVIndexEntry* e_old_end = e_old + nb_old;
+    const AVIndexEntry* current = NULL;
+    MOVTimeToSample* tts_data_old = msc->tts_data;
     int64_t tts_index_old = 0;
     int64_t tts_sample_old = 0;
     int64_t tts_count_old = msc->tts_count;
@@ -4279,7 +4274,7 @@ static void mov_fix_index(MOVContext *mov, AVStream *st)
     int num_discarded_begin = 0;
     int first_non_zero_audio_edit = -1;
     int packet_skip_samples = 0;
-    MOVIndexRange *current_index_range = NULL;
+    MOVIndexRange* current_index_range = NULL;
     int found_keyframe_after_edit = 0;
     int found_non_empty_edit = 0;
 
@@ -4289,7 +4284,7 @@ static void mov_fix_index(MOVContext *mov, AVStream *st)
 
     // allocate the index ranges array
     msc->index_ranges = av_malloc_array(msc->elst_count + 1,
-                                        sizeof(msc->index_ranges[0]));
+        sizeof(msc->index_ranges[0]));
     if (!msc->index_ranges) {
         av_log(mov->fc, AV_LOG_ERROR, "Cannot allocate index ranges buffer\n");
         return;
@@ -4321,9 +4316,9 @@ static void mov_fix_index(MOVContext *mov, AVStream *st)
     start_dts = edit_list_dts_entry_end;
 
     while (get_edit_list_entry(mov, msc, edit_list_index, &edit_list_media_time,
-                               &edit_list_duration, mov->time_scale)) {
+        &edit_list_duration, mov->time_scale)) {
         av_log(mov->fc, AV_LOG_DEBUG, "Processing st: %d, edit list %"PRId64" - media time: %"PRId64", duration: %"PRId64"\n",
-               st->index, edit_list_index, edit_list_media_time, edit_list_duration);
+            st->index, edit_list_index, edit_list_media_time, edit_list_duration);
         edit_list_index++;
         edit_list_dts_counter = edit_list_dts_entry_end;
         edit_list_dts_entry_end += edit_list_duration;
@@ -4339,7 +4334,8 @@ static void mov_fix_index(MOVContext *mov, AVStream *st)
         if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
             if (first_non_zero_audio_edit < 0) {
                 first_non_zero_audio_edit = 1;
-            } else {
+            }
+            else {
                 first_non_zero_audio_edit = 0;
             }
 
@@ -4360,15 +4356,15 @@ static void mov_fix_index(MOVContext *mov, AVStream *st)
         }
 
         if (find_prev_closest_index(st, e_old, nb_old, tts_data_old, tts_count_old, search_timestamp, 0,
-                                    &index, &tts_index_old, &tts_sample_old) < 0) {
+            &index, &tts_index_old, &tts_sample_old) < 0) {
             av_log(mov->fc, AV_LOG_WARNING,
-                   "st: %d edit list: %"PRId64" Missing key frame while searching for timestamp: %"PRId64"\n",
-                   st->index, edit_list_index, search_timestamp);
+                "st: %d edit list: %"PRId64" Missing key frame while searching for timestamp: %"PRId64"\n",
+                st->index, edit_list_index, search_timestamp);
             if (find_prev_closest_index(st, e_old, nb_old, tts_data_old, tts_count_old, search_timestamp, AVSEEK_FLAG_ANY,
-                                        &index, &tts_index_old, &tts_sample_old) < 0) {
+                &index, &tts_index_old, &tts_sample_old) < 0) {
                 av_log(mov->fc, AV_LOG_WARNING,
-                       "st: %d edit list %"PRId64" Cannot find an index entry before timestamp: %"PRId64".\n",
-                       st->index, edit_list_index, search_timestamp);
+                    "st: %d edit list %"PRId64" Cannot find an index entry before timestamp: %"PRId64".\n",
+                    st->index, edit_list_index, search_timestamp);
                 index = 0;
                 tts_index_old = 0;
                 tts_sample_old = 0;
@@ -4382,8 +4378,8 @@ static void mov_fix_index(MOVContext *mov, AVStream *st)
         found_keyframe_after_edit = 0;
         for (; current < e_old_end; current++, index++) {
             // check  if frame outside edit list mark it for discard
-            frame_duration = (current + 1 <  e_old_end) ?
-                             ((current + 1)->timestamp - current->timestamp) : edit_list_duration;
+            frame_duration = (current + 1 < e_old_end) ?
+                ((current + 1)->timestamp - current->timestamp) : edit_list_duration;
 
             flags = current->flags;
 
@@ -4394,18 +4390,18 @@ static void mov_fix_index(MOVContext *mov, AVStream *st)
             if (tts_data_old && tts_index_old < tts_count_old) {
                 curr_ctts = tts_data_old[tts_index_old].offset;
                 av_log(mov->fc, AV_LOG_TRACE, "stts: %"PRId64" ctts: %"PRId64", tts_index: %"PRId64", tts_count: %"PRId64"\n",
-                       curr_cts, curr_ctts, tts_index_old, tts_count_old);
+                    curr_cts, curr_ctts, tts_index_old, tts_count_old);
                 curr_cts += curr_ctts;
                 tts_sample_old++;
                 if (tts_sample_old == tts_data_old[tts_index_old].count) {
                     if (add_tts_entry(&msc->tts_data, &msc->tts_count,
-                                       &msc->tts_allocated_size,
-                                       tts_data_old[tts_index_old].count - edit_list_start_tts_sample,
-                                       tts_data_old[tts_index_old].offset, tts_data_old[tts_index_old].duration) == -1) {
+                        &msc->tts_allocated_size,
+                        tts_data_old[tts_index_old].count - edit_list_start_tts_sample,
+                        tts_data_old[tts_index_old].offset, tts_data_old[tts_index_old].duration) == -1) {
                         av_log(mov->fc, AV_LOG_ERROR, "Cannot add Time To Sample entry %"PRId64" - {%"PRId64", %d}\n",
-                               tts_index_old,
-                               tts_data_old[tts_index_old].count - edit_list_start_tts_sample,
-                               tts_data_old[tts_index_old].offset);
+                            tts_index_old,
+                            tts_data_old[tts_index_old].count - edit_list_start_tts_sample,
+                            tts_data_old[tts_index_old].offset);
                         break;
                     }
                     tts_index_old++;
@@ -4423,26 +4419,27 @@ static void mov_fix_index(MOVContext *mov, AVStream *st)
 
                     // Shift the index entry timestamp by packet_skip_samples to be correct.
                     edit_list_dts_counter -= packet_skip_samples;
-                    if (edit_list_start_encountered == 0)  {
+                    if (edit_list_start_encountered == 0) {
                         edit_list_start_encountered = 1;
                         // Make timestamps strictly monotonically increasing for audio, by rewriting timestamps for
                         // discarded packets.
                         if (frame_duration_buffer) {
                             fix_index_entry_timestamps(st, sti->nb_index_entries, edit_list_dts_counter,
-                                                       frame_duration_buffer, num_discarded_begin);
+                                frame_duration_buffer, num_discarded_begin);
                             av_freep(&frame_duration_buffer);
                         }
                     }
 
                     av_log(mov->fc, AV_LOG_DEBUG, "skip %d audio samples from curr_cts: %"PRId64"\n", packet_skip_samples, curr_cts);
-                } else {
+                }
+                else {
                     flags |= AVINDEX_DISCARD_FRAME;
                     av_log(mov->fc, AV_LOG_DEBUG, "drop a frame at curr_cts: %"PRId64" @ %"PRId64"\n", curr_cts, index);
 
                     if (edit_list_start_encountered == 0) {
                         num_discarded_begin++;
                         frame_duration_buffer = av_realloc(frame_duration_buffer,
-                                                           num_discarded_begin * sizeof(int64_t));
+                            num_discarded_begin * sizeof(int64_t));
                         if (!frame_duration_buffer) {
                             av_log(mov->fc, AV_LOG_ERROR, "Cannot reallocate frame duration buffer\n");
                             break;
@@ -4456,10 +4453,12 @@ static void mov_fix_index(MOVContext *mov, AVStream *st)
                         }
                     }
                 }
-            } else {
+            }
+            else {
                 if (msc->min_corrected_pts < 0) {
                     msc->min_corrected_pts = edit_list_dts_counter + curr_ctts + msc->dts_shift;
-                } else {
+                }
+                else {
                     msc->min_corrected_pts = FFMIN(msc->min_corrected_pts, edit_list_dts_counter + curr_ctts + msc->dts_shift);
                 }
                 if (edit_list_start_encountered == 0) {
@@ -4468,14 +4467,14 @@ static void mov_fix_index(MOVContext *mov, AVStream *st)
                     // discarded packets.
                     if (frame_duration_buffer) {
                         fix_index_entry_timestamps(st, sti->nb_index_entries, edit_list_dts_counter,
-                                                   frame_duration_buffer, num_discarded_begin);
+                            frame_duration_buffer, num_discarded_begin);
                         av_freep(&frame_duration_buffer);
                     }
                 }
             }
 
             if (add_index_entry(st, current->pos, edit_list_dts_counter, current->size,
-                                current->min_distance, flags) == -1) {
+                current->min_distance, flags) == -1) {
                 av_log(mov->fc, AV_LOG_ERROR, "Cannot add index entry\n");
                 break;
             }
@@ -4483,7 +4482,7 @@ static void mov_fix_index(MOVContext *mov, AVStream *st)
             // Update the index ranges array
             if (!current_index_range || index != current_index_range->end) {
                 current_index_range = current_index_range ? current_index_range + 1
-                                                          : msc->index_ranges;
+                    : msc->index_ranges;
                 current_index_range->start = index;
             }
             current_index_range->end = index + 1;
@@ -4506,12 +4505,12 @@ static void mov_fix_index(MOVContext *mov, AVStream *st)
                     }
                     if (tts_sample_old != 0) {
                         if (add_tts_entry(&msc->tts_data, &msc->tts_count,
-                                           &msc->tts_allocated_size,
-                                           tts_sample_old - edit_list_start_tts_sample,
-                                           tts_data_old[tts_index_old].offset, tts_data_old[tts_index_old].duration) == -1) {
+                            &msc->tts_allocated_size,
+                            tts_sample_old - edit_list_start_tts_sample,
+                            tts_data_old[tts_index_old].offset, tts_data_old[tts_index_old].duration) == -1) {
                             av_log(mov->fc, AV_LOG_ERROR, "Cannot add Time To Sample entry %"PRId64" - {%"PRId64", %d}\n",
-                                   tts_index_old, tts_sample_old - edit_list_start_tts_sample,
-                                   tts_data_old[tts_index_old].offset);
+                                tts_index_old, tts_sample_old - edit_list_start_tts_sample,
+                                tts_data_old[tts_index_old].offset);
                             break;
                         }
                     }
@@ -4547,13 +4546,13 @@ static void mov_fix_index(MOVContext *mov, AVStream *st)
 
     // Null terminate the index ranges array
     current_index_range = current_index_range ? current_index_range + 1
-                                              : msc->index_ranges;
+        : msc->index_ranges;
     current_index_range->start = 0;
     current_index_range->end = 0;
     msc->current_index = msc->index_ranges[0].start;
 }
 
-static uint32_t get_sgpd_sync_index(const MOVStreamContext *sc, int nal_unit_type)
+static uint32_t get_sgpd_sync_index(const MOVStreamContext* sc, int nal_unit_type)
 {
     for (uint32_t i = 0; i < sc->sgpd_sync_count; i++)
         if (sc->sgpd_sync[i] == nal_unit_type)
@@ -4561,12 +4560,12 @@ static uint32_t get_sgpd_sync_index(const MOVStreamContext *sc, int nal_unit_typ
     return 0;
 }
 
-static int build_open_gop_key_points(AVStream *st)
+static int build_open_gop_key_points(AVStream* st)
 {
     int k;
     int sample_id = 0;
     uint32_t cra_index;
-    MOVStreamContext *sc = st->priv_data;
+    MOVStreamContext* sc = st->priv_data;
 
     if (st->codecpar->codec_id != AV_CODEC_ID_HEVC || !sc->sync_group_count)
         return 0;
@@ -4585,7 +4584,7 @@ static int build_open_gop_key_points(AVStream *st)
     k = 0;
     for (uint32_t i = 0; i < sc->ctts_count; i++)
         for (int j = 0; j < sc->ctts_data[i].count; j++)
-             sc->sample_offsets[k++] = sc->ctts_data[i].offset;
+            sc->sample_offsets[k++] = sc->ctts_data[i].offset;
 
     /* The following HEVC NAL type reveal the use of open GOP sync points
      * (TODO: BLA types may also be concerned) */
@@ -4607,7 +4606,7 @@ static int build_open_gop_key_points(AVStream *st)
         return AVERROR(ENOMEM);
     k = 0;
     for (uint32_t i = 0; i < sc->sync_group_count; i++) {
-        const MOVSbgp *sg = &sc->sync_group[i];
+        const MOVSbgp* sg = &sc->sync_group[i];
         if (sg->index == cra_index)
             for (uint32_t j = 0; j < sg->count; j++)
                 sc->open_key_samples[k++] = sample_id;
@@ -4631,9 +4630,9 @@ static int build_open_gop_key_points(AVStream *st)
  * stts_count and ctts_count may be left untouched as they will be
  * used to check for the presence of either of them.
  */
-static int mov_merge_tts_data(MOVContext *mov, AVStream *st, int flags)
+static int mov_merge_tts_data(MOVContext* mov, AVStream* st, int flags)
 {
-    MOVStreamContext *sc = st->priv_data;
+    MOVStreamContext* sc = st->priv_data;
     int ctts = sc->ctts_data && (flags & MOV_MERGE_CTTS);
     int stts = sc->stts_data && (flags & MOV_MERGE_STTS);
     int idx = 0;
@@ -4646,30 +4645,31 @@ static int mov_merge_tts_data(MOVContext *mov, AVStream *st, int flags)
 
     if (ctts) {
         sc->tts_data = av_fast_realloc(NULL, &sc->tts_allocated_size,
-                                       sc->sample_count * sizeof(*sc->tts_data));
+            sc->sample_count * sizeof(*sc->tts_data));
         if (!sc->tts_data)
             return -1;
 
         memset(sc->tts_data, 0, sc->tts_allocated_size);
 
         for (int i = 0; i < sc->ctts_count &&
-                    idx < sc->sample_count; i++)
+            idx < sc->sample_count; i++)
             for (int j = 0; j < sc->ctts_data[i].count &&
-                        idx < sc->sample_count; j++) {
+                idx < sc->sample_count; j++) {
                 sc->tts_data[idx].offset = sc->ctts_data[i].offset;
                 sc->tts_data[idx++].count = 1;
             }
 
         sc->tts_count = idx;
-    } else
+    }
+    else
         sc->ctts_count = 0;
     av_freep(&sc->ctts_data);
     sc->ctts_allocated_size = 0;
 
     idx = 0;
     if (stts) {
-        MOVTimeToSample *tts_data = av_fast_realloc(sc->tts_data, &sc->tts_allocated_size,
-                                                    sc->sample_count * sizeof(*sc->tts_data));
+        MOVTimeToSample* tts_data = av_fast_realloc(sc->tts_data, &sc->tts_allocated_size,
+            sc->sample_count * sizeof(*sc->tts_data));
         if (!tts_data)
             return -1;
 
@@ -4678,15 +4678,16 @@ static int mov_merge_tts_data(MOVContext *mov, AVStream *st, int flags)
         sc->tts_data = tts_data;
 
         for (int i = 0; i < sc->stts_count &&
-                    idx < sc->sample_count; i++)
+            idx < sc->sample_count; i++)
             for (int j = 0; j < sc->stts_data[i].count &&
-                        idx < sc->sample_count; j++) {
+                idx < sc->sample_count; j++) {
                 sc->tts_data[idx].duration = sc->stts_data[i].duration;
                 sc->tts_data[idx++].count = 1;
             }
 
         sc->tts_count = FFMAX(sc->tts_count, idx);
-    } else
+    }
+    else
         sc->stts_count = 0;
     av_freep(&sc->stts_data);
     sc->stts_allocated_size = 0;
@@ -4694,10 +4695,10 @@ static int mov_merge_tts_data(MOVContext *mov, AVStream *st, int flags)
     return 0;
 }
 
-static void mov_build_index(MOVContext *mov, AVStream *st)
+static void mov_build_index(MOVContext* mov, AVStream* st)
 {
-    MOVStreamContext *sc = st->priv_data;
-    FFStream *const sti = ffstream(st);
+    MOVStreamContext* sc = st->priv_data;
+    FFStream* const sti = ffstream(st);
     int64_t current_offset;
     int64_t current_dts = 0;
     unsigned int stts_index = 0;
@@ -4717,15 +4718,17 @@ static void mov_build_index(MOVContext *mov, AVStream *st)
         int64_t start_time = 0; // start time of the media
 
         for (i = 0; i < sc->elst_count; i++) {
-            const MOVElst *e = &sc->elst_data[i];
+            const MOVElst* e = &sc->elst_data[i];
             if (i == 0 && e->time == -1) {
                 /* if empty, the first entry is the start time of the stream
                  * relative to the presentation itself */
                 empty_duration = e->duration;
                 edit_start_index = 1;
-            } else if (i == edit_start_index && e->time >= 0) {
+            }
+            else if (i == edit_start_index && e->time >= 0) {
                 start_time = e->time;
-            } else {
+            }
+            else {
                 multiple_edits = 1;
             }
         }
@@ -4733,11 +4736,11 @@ static void mov_build_index(MOVContext *mov, AVStream *st)
         if (multiple_edits && !mov->advanced_editlist) {
             if (mov->advanced_editlist_autodisabled)
                 av_log(mov->fc, AV_LOG_WARNING, "multiple edit list entries, "
-                       "not supported in fragmented MP4 files\n");
+                    "not supported in fragmented MP4 files\n");
             else
                 av_log(mov->fc, AV_LOG_WARNING, "multiple edit list entries, "
-                       "Use -advanced_editlist to correctly decode otherwise "
-                       "a/v desync might occur\n");
+                    "Use -advanced_editlist to correctly decode otherwise "
+                    "a/v desync might occur\n");
         }
 
         /* adjust first dts according to edit list */
@@ -4748,7 +4751,7 @@ static void mov_build_index(MOVContext *mov, AVStream *st)
             if (av_sat_sub64(start_time, empty_duration) != start_time - (uint64_t)empty_duration)
                 av_log(mov->fc, AV_LOG_WARNING, "start_time - empty_duration is not representable\n");
 
-            sc->time_offset = start_time -  (uint64_t)empty_duration;
+            sc->time_offset = start_time - (uint64_t)empty_duration;
             sc->min_corrected_pts = start_time;
             if (!mov->advanced_editlist)
                 current_dts = -sc->time_offset;
@@ -4761,7 +4764,7 @@ static void mov_build_index(MOVContext *mov, AVStream *st)
 
     /* only use old uncompressed audio chunk demuxing when stts specifies it */
     if (!(st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
-          sc->stts_count == 1 && sc->stts_data && sc->stts_data[0].duration == 1)) {
+        sc->stts_count == 1 && sc->stts_data && sc->stts_data[0].duration == 1)) {
         unsigned int current_sample = 0;
         unsigned int stts_sample = 0;
         unsigned int sample_size;
@@ -4778,8 +4781,8 @@ static void mov_build_index(MOVContext *mov, AVStream *st)
         if (sc->sample_count >= UINT_MAX / sizeof(*sti->index_entries) - sti->nb_index_entries)
             return;
         if (av_reallocp_array(&sti->index_entries,
-                              sti->nb_index_entries + sc->sample_count,
-                              sizeof(*sti->index_entries)) < 0) {
+            sti->nb_index_entries + sc->sample_count,
+            sizeof(*sti->index_entries)) < 0) {
             sti->nb_index_entries = 0;
             return;
         }
@@ -4790,18 +4793,18 @@ static void mov_build_index(MOVContext *mov, AVStream *st)
             return;
 
         for (i = 0; i < sc->chunk_count; i++) {
-            int64_t next_offset = i+1 < sc->chunk_count ? sc->chunk_offsets[i+1] : INT64_MAX;
+            int64_t next_offset = i + 1 < sc->chunk_count ? sc->chunk_offsets[i + 1] : INT64_MAX;
             current_offset = sc->chunk_offsets[i];
             while (mov_stsc_index_valid(stsc_index, sc->stsc_count) &&
                 i + 1 == sc->stsc_data[stsc_index + 1].first)
                 stsc_index++;
 
-            if (next_offset > current_offset && sc->sample_size>0 && sc->sample_size < sc->stsz_sample_size &&
+            if (next_offset > current_offset && sc->sample_size > 0 && sc->sample_size < sc->stsz_sample_size &&
                 sc->stsc_data[stsc_index].count * (int64_t)sc->stsz_sample_size > next_offset - current_offset) {
                 av_log(mov->fc, AV_LOG_WARNING, "STSZ sample size %d invalid (too large), ignoring\n", sc->stsz_sample_size);
                 sc->stsz_sample_size = sc->sample_size;
             }
-            if (sc->stsz_sample_size>0 && sc->stsz_sample_size < sc->sample_size) {
+            if (sc->stsz_sample_size > 0 && sc->stsz_sample_size < sc->sample_size) {
                 av_log(mov->fc, AV_LOG_WARNING, "STSZ sample size %d invalid (too small), ignoring\n", sc->stsz_sample_size);
                 sc->stsz_sample_size = sc->sample_size;
             }
@@ -4813,11 +4816,12 @@ static void mov_build_index(MOVContext *mov, AVStream *st)
                     return;
                 }
 
-                if (!sc->keyframe_absent && (!sc->keyframe_count || current_sample+key_off == sc->keyframes[stss_index])) {
+                if (!sc->keyframe_absent && (!sc->keyframe_count || current_sample + key_off == sc->keyframes[stss_index])) {
                     keyframe = 1;
                     if (stss_index + 1 < sc->keyframe_count)
                         stss_index++;
-                } else if (sc->stps_count && current_sample+key_off == sc->stps_data[stps_index]) {
+                }
+                else if (sc->stps_count && current_sample + key_off == sc->stps_data[stps_index]) {
                     keyframe = 1;
                     if (stps_index + 1 < sc->stps_count)
                         stps_index++;
@@ -4833,21 +4837,21 @@ static void mov_build_index(MOVContext *mov, AVStream *st)
                 if (sc->keyframe_absent
                     && !sc->stps_count
                     && !rap_group_present
-                    && (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO || (i==0 && j==0)))
-                     keyframe = 1;
+                    && (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO || (i == 0 && j == 0)))
+                    keyframe = 1;
                 if (keyframe)
                     distance = 0;
                 sample_size = sc->stsz_sample_size > 0 ? sc->stsz_sample_size : sc->sample_sizes[current_sample];
                 if (current_offset > INT64_MAX - sample_size) {
                     av_log(mov->fc, AV_LOG_ERROR, "Current offset %"PRId64" or sample size %u is too large\n",
-                           current_offset,
-                           sample_size);
+                        current_offset,
+                        sample_size);
                     return;
                 }
 
                 if (sc->pseudo_stream_id == -1 ||
-                   sc->stsc_data[stsc_index].id - 1 == sc->pseudo_stream_id) {
-                    AVIndexEntry *e;
+                    sc->stsc_data[stsc_index].id - 1 == sc->pseudo_stream_id) {
+                    AVIndexEntry* e;
                     if (sample_size > 0x3FFFFFFF) {
                         av_log(mov->fc, AV_LOG_ERROR, "Sample size %u is too large\n", sample_size);
                         return;
@@ -4859,8 +4863,8 @@ static void mov_build_index(MOVContext *mov, AVStream *st)
                     e->min_distance = distance;
                     e->flags = keyframe ? AVINDEX_KEYFRAME : 0;
                     av_log(mov->fc, AV_LOG_TRACE, "AVIndex stream %d, sample %u, offset %"PRIx64", dts %"PRId64", "
-                            "size %u, distance %u, keyframe %d\n", st->index, current_sample,
-                            current_offset, current_dts, sample_size, distance, keyframe);
+                        "size %u, distance %u, keyframe %d\n", st->index, current_sample,
+                        current_offset, current_dts, sample_size, distance, keyframe);
                     if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && sti->nb_index_entries < 100)
                         ff_rfps_add_frame(mov->fc, st, current_dts);
                 }
@@ -4880,13 +4884,18 @@ static void mov_build_index(MOVContext *mov, AVStream *st)
             }
         }
         if (st->duration > 0)
-            st->codecpar->bit_rate = stream_size*8*sc->time_scale/st->duration;
-    } else {
+            st->codecpar->bit_rate = stream_size * 8 * sc->time_scale / st->duration;
+    }
+    else {
         unsigned chunk_samples, total = 0;
 
         if (!sc->chunk_count || sc->tts_count)
             return;
 
+        ret = mov_merge_tts_data(mov, st, MOV_MERGE_CTTS);
+        if (ret < 0)
+            return;
+
         // compute total chunk count
         for (i = 0; i < sc->stsc_count; i++) {
             unsigned count, chunk_count;
@@ -4900,15 +4909,17 @@ static void mov_build_index(MOVContext *mov, AVStream *st)
 
             if (sc->samples_per_frame >= 160) { // gsm
                 count = chunk_samples / sc->samples_per_frame;
-            } else if (sc->samples_per_frame > 1) {
-                unsigned samples = (1024/sc->samples_per_frame)*sc->samples_per_frame;
-                count = (chunk_samples+samples-1) / samples;
-            } else {
-                count = (chunk_samples+1023) / 1024;
+            }
+            else if (sc->samples_per_frame > 1) {
+                unsigned samples = (1024 / sc->samples_per_frame) * sc->samples_per_frame;
+                count = (chunk_samples + samples - 1) / samples;
+            }
+            else {
+                count = (chunk_samples + 1023) / 1024;
             }
 
             if (mov_stsc_index_valid(i, sc->stsc_count))
-                chunk_count = sc->stsc_data[i+1].first - sc->stsc_data[i].first;
+                chunk_count = sc->stsc_data[i + 1].first - sc->stsc_data[i].first;
             else
                 chunk_count = sc->chunk_count - (sc->stsc_data[i].first - 1);
             total += chunk_count * count;
@@ -4918,8 +4929,8 @@ static void mov_build_index(MOVContext *mov, AVStream *st)
         if (total >= UINT_MAX / sizeof(*sti->index_entries) - sti->nb_index_entries)
             return;
         if (av_reallocp_array(&sti->index_entries,
-                              sti->nb_index_entries + total,
-                              sizeof(*sti->index_entries)) < 0) {
+            sti->nb_index_entries + total,
+            sizeof(*sti->index_entries)) < 0) {
             sti->nb_index_entries = 0;
             return;
         }
@@ -4934,25 +4945,27 @@ static void mov_build_index(MOVContext *mov, AVStream *st)
             chunk_samples = sc->stsc_data[stsc_index].count;
 
             while (chunk_samples > 0) {
-                AVIndexEntry *e;
+                AVIndexEntry* e;
                 unsigned size, samples;
 
                 if (sc->samples_per_frame > 1 && !sc->bytes_per_frame) {
                     avpriv_request_sample(mov->fc,
-                           "Zero bytes per frame, but %d samples per frame",
-                           sc->samples_per_frame);
+                        "Zero bytes per frame, but %d samples per frame",
+                        sc->samples_per_frame);
                     return;
                 }
 
                 if (sc->samples_per_frame >= 160) { // gsm
                     samples = sc->samples_per_frame;
                     size = sc->bytes_per_frame;
-                } else {
+                }
+                else {
                     if (sc->samples_per_frame > 1) {
-                        samples = FFMIN((1024 / sc->samples_per_frame)*
-                                        sc->samples_per_frame, chunk_samples);
+                        samples = FFMIN((1024 / sc->samples_per_frame) *
+                            sc->samples_per_frame, chunk_samples);
                         size = (samples / sc->samples_per_frame) * sc->bytes_per_frame;
-                    } else {
+                    }
+                    else {
                         samples = FFMIN(1024, chunk_samples);
                         size = samples * sc->sample_size;
                     }
@@ -4973,18 +4986,14 @@ static void mov_build_index(MOVContext *mov, AVStream *st)
                 e->min_distance = 0;
                 e->flags = AVINDEX_KEYFRAME;
                 av_log(mov->fc, AV_LOG_TRACE, "AVIndex stream %d, chunk %u, offset %"PRIx64", dts %"PRId64", "
-                       "size %u, duration %u\n", st->index, i, current_offset, current_dts,
-                       size, samples);
+                    "size %u, duration %u\n", st->index, i, current_offset, current_dts,
+                    size, samples);
 
                 current_offset += size;
                 current_dts += samples;
                 chunk_samples -= samples;
             }
         }
-
-        ret = mov_merge_tts_data(mov, st, MOV_MERGE_CTTS);
-        if (ret < 0)
-            return;
     }
 
     if (!mov->ignore_editlist && mov->advanced_editlist) {
@@ -5003,42 +5012,45 @@ static void mov_build_index(MOVContext *mov, AVStream *st)
     mov_estimate_video_delay(mov, st);
 }
 
-static int test_same_origin(const char *src, const char *ref) {
+static int test_same_origin(const char* src, const char* ref) {
     char src_proto[64];
     char ref_proto[64];
     char src_auth[256];
     char ref_auth[256];
     char src_host[256];
     char ref_host[256];
-    int src_port=-1;
-    int ref_port=-1;
+    int src_port = -1;
+    int ref_port = -1;
 
     av_url_split(src_proto, sizeof(src_proto), src_auth, sizeof(src_auth), src_host, sizeof(src_host), &src_port, NULL, 0, src);
     av_url_split(ref_proto, sizeof(ref_proto), ref_auth, sizeof(ref_auth), ref_host, sizeof(ref_host), &ref_port, NULL, 0, ref);
 
     if (strlen(src) == 0) {
         return -1;
-    } else if (strlen(src_auth) + 1 >= sizeof(src_auth) ||
+    }
+    else if (strlen(src_auth) + 1 >= sizeof(src_auth) ||
         strlen(ref_auth) + 1 >= sizeof(ref_auth) ||
         strlen(src_host) + 1 >= sizeof(src_host) ||
         strlen(ref_host) + 1 >= sizeof(ref_host)) {
         return 0;
-    } else if (strcmp(src_proto, ref_proto) ||
-               strcmp(src_auth, ref_auth) ||
-               strcmp(src_host, ref_host) ||
-               src_port != ref_port) {
+    }
+    else if (strcmp(src_proto, ref_proto) ||
+        strcmp(src_auth, ref_auth) ||
+        strcmp(src_host, ref_host) ||
+        src_port != ref_port) {
         return 0;
-    } else
+    }
+    else
         return 1;
 }
 
-static int mov_open_dref(MOVContext *c, AVIOContext **pb, const char *src, MOVDref *ref)
+static int mov_open_dref(MOVContext* c, AVIOContext** pb, const char* src, MOVDref* ref)
 {
     /* try relative path, we do not try the absolute because it can leak information about our
        system to an attacker */
     if (ref->nlvl_to > 0 && ref->nlvl_from > 0) {
         char filename[1025];
-        const char *src_path;
+        const char* src_path;
         int i, l;
 
         /* find a source dir */
@@ -5058,7 +5070,7 @@ static int mov_open_dref(MOVContext *c, AVIOContext **pb, const char *src, MOVDr
             }
 
         /* compose filename if next level down to target was found */
-        if (i == ref->nlvl_to - 1 && src_path - src  < sizeof(filename)) {
+        if (i == ref->nlvl_to - 1 && src_path - src < sizeof(filename)) {
             memcpy(filename, src, src_path - src);
             filename[src_path - src] = 0;
 
@@ -5089,22 +5101,24 @@ static int mov_open_dref(MOVContext *c, AVIOContext **pb, const char *src, MOVDr
             if (!c->fc->io_open(c->fc, pb, filename, AVIO_FLAG_READ, NULL))
                 return 0;
         }
-    } else if (c->use_absolute_path) {
+    }
+    else if (c->use_absolute_path) {
         av_log(c->fc, AV_LOG_WARNING, "Using absolute path on user request, "
-               "this is a possible security issue\n");
+            "this is a possible security issue\n");
         if (!c->fc->io_open(c->fc, pb, ref->path, AVIO_FLAG_READ, NULL))
             return 0;
-    } else {
+    }
+    else {
         av_log(c->fc, AV_LOG_ERROR,
-               "Absolute path %s not tried for security reasons, "
-               "set demuxer option use_absolute_path to allow absolute paths\n",
-               ref->path);
+            "Absolute path %s not tried for security reasons, "
+            "set demuxer option use_absolute_path to allow absolute paths\n",
+            ref->path);
     }
 
     return AVERROR(ENOENT);
 }
 
-static void fix_timescale(MOVContext *c, MOVStreamContext *sc)
+static void fix_timescale(MOVContext* c, MOVStreamContext* sc)
 {
     if (sc->time_scale <= 0) {
         av_log(c->fc, AV_LOG_WARNING, "stream %d, timescale not set\n", sc->ffindex);
@@ -5115,13 +5129,13 @@ static void fix_timescale(MOVContext *c, MOVStreamContext *sc)
 }
 
 #if CONFIG_IAMFDEC
-static int mov_update_iamf_streams(MOVContext *c, const AVStream *st)
+static int mov_update_iamf_streams(MOVContext* c, const AVStream* st)
 {
-    const MOVStreamContext *sc = st->priv_data;
-    const IAMFContext *iamf = &sc->iamf->iamf;
+    const MOVStreamContext* sc = st->priv_data;
+    const IAMFContext* iamf = &sc->iamf->iamf;
 
     for (int i = 0; i < iamf->nb_audio_elements; i++) {
-        const AVStreamGroup *stg = NULL;
+        const AVStreamGroup* stg = NULL;
 
         for (int j = 0; j < c->fc->nb_stream_groups; j++)
             if (c->fc->stream_groups[j]->id == iamf->audio_elements[i]->audio_element_id)
@@ -5129,20 +5143,20 @@ static int mov_update_iamf_streams(MOVContext *c, const AVStream *st)
         av_assert0(stg);
 
         for (int j = 0; j < stg->nb_streams; j++) {
-            const FFStream *sti = cffstream(st);
-            AVStream *out = stg->streams[j];
-            FFStream *out_sti = ffstream(stg->streams[j]);
+            const FFStream* sti = cffstream(st);
+            AVStream* out = stg->streams[j];
+            FFStream* out_sti = ffstream(stg->streams[j]);
 
             out->codecpar->bit_rate = 0;
 
             if (out == st)
                 continue;
 
-            out->time_base           = st->time_base;
-            out->start_time          = st->start_time;
-            out->duration            = st->duration;
-            out->nb_frames           = st->nb_frames;
-            out->discard             = st->discard;
+            out->time_base = st->time_base;
+            out->start_time = st->start_time;
+            out->duration = st->duration;
+            out->nb_frames = st->nb_frames;
+            out->discard = st->discard;
 
             av_assert0(!out_sti->index_entries);
             out_sti->index_entries = av_malloc(sti->index_entries_allocated_size);
@@ -5160,29 +5174,28 @@ static int mov_update_iamf_streams(MOVContext *c, const AVStream *st)
 }
 #endif
 
-static int sanity_checks(void *log_obj, MOVStreamContext *sc, int index)
+static int sanity_checks(void* log_obj, MOVStreamContext* sc, int index)
 {
     if ((sc->chunk_count && (!sc->stts_count || !sc->stsc_count ||
-                            (!sc->sample_size && !sc->sample_count))) ||
-        (sc->sample_count && (!sc->chunk_count ||
-                             (!sc->sample_size && !sc->sample_sizes)))) {
+        (!sc->sample_size && !sc->sample_count))) ||
+        (!sc->chunk_count && sc->sample_count)) {
         av_log(log_obj, AV_LOG_ERROR, "stream %d, missing mandatory atoms, broken header\n",
-               index);
+            index);
         return 1;
     }
 
-    if (sc->stsc_count && sc->stsc_data[ sc->stsc_count - 1 ].first > sc->chunk_count) {
+    if (sc->stsc_count && sc->stsc_data[sc->stsc_count - 1].first > sc->chunk_count) {
         av_log(log_obj, AV_LOG_ERROR, "stream %d, contradictionary STSC and STCO\n",
-               index);
+            index);
         return 2;
     }
     return 0;
 }
 
-static int mov_read_trak(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_trak(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    AVStream *st;
-    MOVStreamContext *sc;
+    AVStream* st;
+    MOVStreamContext* sc;
     int ret;
 
     st = avformat_new_stream(c->fc, NULL);
@@ -5227,13 +5240,20 @@ static int mov_read_trak(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     if (!sc->stts_count && c->advanced_editlist) {
 
         av_log(c->fc, AV_LOG_VERBOSE, "advanced_editlist does not work with fragmented "
-                                      "MP4. disabling.\n");
+            "MP4. disabling.\n");
         c->advanced_editlist = 0;
         c->advanced_editlist_autodisabled = 1;
     }
 
     mov_build_index(c, st);
+    if (sc->fragment_duration_sum > 0 &&
+        st->codecpar->bit_rate == 0) {
 
+        st->codecpar->bit_rate =
+            av_rescale(sc->fragment_size_sum * 8,
+                sc->time_scale,
+                sc->fragment_duration_sum);
+    }
 #if CONFIG_IAMFDEC
     if (sc->iamf) {
         ret = mov_update_iamf_streams(c, st);
@@ -5242,25 +5262,27 @@ static int mov_read_trak(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     }
 #endif
 
-    if (sc->dref_id-1 < sc->drefs_count && sc->drefs[sc->dref_id-1].path) {
-        MOVDref *dref = &sc->drefs[sc->dref_id - 1];
+    if (sc->dref_id - 1 < sc->drefs_count && sc->drefs[sc->dref_id - 1].path) {
+        MOVDref* dref = &sc->drefs[sc->dref_id - 1];
         if (c->enable_drefs) {
             if (mov_open_dref(c, &sc->pb, c->fc->url, dref) < 0)
                 av_log(c->fc, AV_LOG_ERROR,
-                       "stream %d, error opening alias: path='%s', dir='%s', "
-                       "filename='%s', volume='%s', nlvl_from=%d, nlvl_to=%d\n",
-                       st->index, dref->path, dref->dir, dref->filename,
-                       dref->volume, dref->nlvl_from, dref->nlvl_to);
-        } else {
+                    "stream %d, error opening alias: path='%s', dir='%s', "
+                    "filename='%s', volume='%s', nlvl_from=%d, nlvl_to=%d\n",
+                    st->index, dref->path, dref->dir, dref->filename,
+                    dref->volume, dref->nlvl_from, dref->nlvl_to);
+        }
+        else {
             av_log(c->fc, AV_LOG_WARNING,
-                   "Skipped opening external track: "
-                   "stream %d, alias: path='%s', dir='%s', "
-                   "filename='%s', volume='%s', nlvl_from=%d, nlvl_to=%d."
-                   "Set enable_drefs to allow this.\n",
-                   st->index, dref->path, dref->dir, dref->filename,
-                   dref->volume, dref->nlvl_from, dref->nlvl_to);
-        }
-    } else {
+                "Skipped opening external track: "
+                "stream %d, alias: path='%s', dir='%s', "
+                "filename='%s', volume='%s', nlvl_from=%d, nlvl_to=%d."
+                "Set enable_drefs to allow this.\n",
+                st->index, dref->path, dref->dir, dref->filename,
+                dref->volume, dref->nlvl_from, dref->nlvl_to);
+        }
+    }
+    else {
         sc->pb = c->fc->pb;
         sc->pb_is_copied = 1;
     }
@@ -5269,13 +5291,13 @@ static int mov_read_trak(MOVContext *c, AVIOContext *pb, MOVAtom atom)
         int stts_constant = sc->stts_count && sc->tts_count;
         if (sc->h_spacing && sc->v_spacing)
             av_reduce(&st->sample_aspect_ratio.num, &st->sample_aspect_ratio.den,
-                      sc->h_spacing, sc->v_spacing, INT_MAX);
+                sc->h_spacing, sc->v_spacing, INT_MAX);
         if (!st->sample_aspect_ratio.num && st->codecpar->width && st->codecpar->height &&
             sc->height && sc->width &&
             (st->codecpar->width != sc->width || st->codecpar->height != sc->height)) {
             av_reduce(&st->sample_aspect_ratio.num, &st->sample_aspect_ratio.den,
-                      (int64_t)st->codecpar->height * sc->width,
-                      (int64_t)st->codecpar->width  * sc->height, INT_MAX);
+                (int64_t)st->codecpar->height * sc->width,
+                (int64_t)st->codecpar->width * sc->height, INT_MAX);
         }
 
 #if FF_API_R_FRAME_RATE
@@ -5286,26 +5308,20 @@ static int mov_read_trak(MOVContext *c, AVIOContext *pb, MOVAtom atom)
         }
         if (stts_constant)
             av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den,
-                      sc->time_scale, sc->tts_data[0].duration, INT_MAX);
+                sc->time_scale, sc->tts_data[0].duration, INT_MAX);
 #endif
     }
 
-#if CONFIG_H261_DECODER || CONFIG_H263_DECODER || CONFIG_MPEG4_DECODER
     switch (st->codecpar->codec_id) {
-#if CONFIG_H261_DECODER
     case AV_CODEC_ID_H261:
-#endif
-#if CONFIG_H263_DECODER
     case AV_CODEC_ID_H263:
-#endif
-#if CONFIG_MPEG4_DECODER
     case AV_CODEC_ID_MPEG4:
-#endif
         st->codecpar->width = 0; /* let decoder init width/height */
-        st->codecpar->height= 0;
+        st->codecpar->height = 0;
+        break;
+    default:
         break;
     }
-#endif
 
     // If the duration of the mp3 packets is not constant, then they could need a parser
     if (st->codecpar->codec_id == AV_CODEC_ID_MP3
@@ -5332,7 +5348,7 @@ static int mov_read_trak(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return 0;
 }
 
-static int mov_read_ilst(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_ilst(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
     int ret;
     c->itunes_metadata = 1;
@@ -5341,7 +5357,7 @@ static int mov_read_ilst(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return ret;
 }
 
-static int mov_read_keys(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_keys(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
     uint32_t count;
     uint32_t i;
@@ -5354,7 +5370,7 @@ static int mov_read_keys(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     atom.size -= 8;
     if (count >= UINT_MAX / sizeof(*c->meta_keys)) {
         av_log(c->fc, AV_LOG_ERROR,
-               "The 'keys' atom with the invalid key count: %"PRIu32"\n", count);
+            "The 'keys' atom with the invalid key count: %"PRIu32"\n", count);
         return AVERROR_INVALIDDATA;
     }
 
@@ -5368,13 +5384,13 @@ static int mov_read_keys(MOVContext *c, AVIOContext *pb, MOVAtom atom)
         uint32_t type = avio_rl32(pb);
         if (key_size < 8 || key_size > atom.size) {
             av_log(c->fc, AV_LOG_ERROR,
-                   "The key# %"PRIu32" in meta has invalid size:"
-                   "%"PRIu32"\n", i, key_size);
+                "The key# %"PRIu32" in meta has invalid size:"
+                "%"PRIu32"\n", i, key_size);
             return AVERROR_INVALIDDATA;
         }
         atom.size -= key_size;
         key_size -= 8;
-        if (type != MKTAG('m','d','t','a')) {
+        if (type != MKTAG('m', 'd', 't', 'a')) {
             avio_skip(pb, key_size);
             continue;
         }
@@ -5387,22 +5403,22 @@ static int mov_read_keys(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return 0;
 }
 
-static int mov_read_custom(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_custom(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
     int64_t end = av_sat_add64(avio_tell(pb), atom.size);
-    uint8_t *key = NULL, *val = NULL, *mean = NULL;
+    uint8_t* key = NULL, * val = NULL, * mean = NULL;
     int i;
     int ret = 0;
-    AVStream *st;
-    MOVStreamContext *sc;
+    AVStream* st;
+    MOVStreamContext* sc;
 
     if (c->fc->nb_streams < 1)
         return 0;
-    st = c->fc->streams[c->fc->nb_streams-1];
+    st = c->fc->streams[c->fc->nb_streams - 1];
     sc = st->priv_data;
 
     for (i = 0; i < 3; i++) {
-        uint8_t **p;
+        uint8_t** p;
         uint32_t len, tag;
 
         if (end - avio_tell(pb) <= 12)
@@ -5424,7 +5440,8 @@ static int mov_read_custom(MOVContext *c, AVIOContext *pb, MOVAtom atom)
             avio_skip(pb, 4);
             len -= 4;
             p = &val;
-        } else
+        }
+        else
             break;
 
         if (*p)
@@ -5446,19 +5463,20 @@ static int mov_read_custom(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     if (mean && key && val) {
         if (strcmp(key, "iTunSMPB") == 0) {
             int priming, remainder, samples;
-            if(sscanf(val, "%*X %X %X %X", &priming, &remainder, &samples) == 3){
-                if(priming>0 && priming<16384)
+            if (sscanf(val, "%*X %X %X %X", &priming, &remainder, &samples) == 3) {
+                if (priming > 0 && priming < 16384)
                     sc->start_pad = priming;
             }
         }
         if (strcmp(key, "cdec") != 0) {
             av_dict_set(&c->fc->metadata, key, val,
-                        AV_DICT_DONT_STRDUP_KEY | AV_DICT_DONT_STRDUP_VAL);
+                AV_DICT_DONT_STRDUP_KEY | AV_DICT_DONT_STRDUP_VAL);
             key = val = NULL;
         }
-    } else {
+    }
+    else {
         av_log(c->fc, AV_LOG_VERBOSE,
-               "Unhandled or malformed custom metadata of size %"PRId64"\n", atom.size);
+            "Unhandled or malformed custom metadata of size %"PRId64"\n", atom.size);
     }
 
     avio_seek(pb, end, SEEK_SET);
@@ -5468,10 +5486,10 @@ static int mov_read_custom(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return ret;
 }
 
-static int heif_add_stream(MOVContext *c, HEIFItem *item)
+static int heif_add_stream(MOVContext* c, HEIFItem* item)
 {
-    MOVStreamContext *sc;
-    AVStream *st;
+    MOVStreamContext* sc;
+    AVStream* st;
 
     st = avformat_new_stream(c->fc, NULL);
     if (!st)
@@ -5527,7 +5545,7 @@ fail:
     return AVERROR(ENOMEM);
 }
 
-static int mov_read_meta(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_meta(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
     while (atom.size > 8) {
         uint32_t tag;
@@ -5535,7 +5553,7 @@ static int mov_read_meta(MOVContext *c, AVIOContext *pb, MOVAtom atom)
             return AVERROR_EOF;
         tag = avio_rl32(pb);
         atom.size -= 4;
-        if (tag == MKTAG('h','d','l','r')) {
+        if (tag == MKTAG('h', 'd', 'l', 'r')) {
             avio_seek(pb, -8, SEEK_CUR);
             atom.size += 8;
             return mov_read_default(c, pb, atom);
@@ -5553,21 +5571,21 @@ static int mov_read_meta(MOVContext *c, AVIOContext *pb, MOVAtom atom)
      !(matrix)[1][0] && !(matrix)[1][2] && \
      !(matrix)[2][0] && !(matrix)[2][1])
 
-static int mov_read_tkhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_tkhd(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
     int i, j, e;
     int width;
     int height;
     int display_matrix[3][3];
     int res_display_matrix[3][3] = { { 0 } };
-    AVStream *st;
-    MOVStreamContext *sc;
+    AVStream* st;
+    MOVStreamContext* sc;
     int version;
     int flags;
 
     if (c->fc->nb_streams < 1)
         return 0;
-    st = c->fc->streams[c->fc->nb_streams-1];
+    st = c->fc->streams[c->fc->nb_streams - 1];
     sc = st->priv_data;
 
     // Each stream (trak) should have exactly 1 tkhd. This catches bad files and
@@ -5582,7 +5600,8 @@ static int mov_read_tkhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     if (version == 1) {
         avio_rb64(pb);
         avio_rb64(pb);
-    } else {
+    }
+    else {
         avio_rb32(pb); /* creation time */
         avio_rb32(pb); /* modification time */
     }
@@ -5621,8 +5640,8 @@ static int mov_read_tkhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
         for (j = 0; j < 3; j++) {
             for (e = 0; e < 3; e++) {
                 res_display_matrix[i][j] +=
-                    ((int64_t) display_matrix[i][e] *
-                     c->movie_display_matrix[e][j]) >> sh[e];
+                    ((int64_t)display_matrix[i][e] *
+                        c->movie_display_matrix[e][j]) >> sh[e];
             }
         }
     }
@@ -5646,10 +5665,10 @@ static int mov_read_tkhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 
         for (i = 0; i < 2; i++)
             disp_transform[i] = hypot(sc->display_matrix[0 + i],
-                                      sc->display_matrix[3 + i]);
+                sc->display_matrix[3 + i]);
 
-        if (disp_transform[0] > 1       && disp_transform[1] > 1 &&
-            disp_transform[0] < (1<<24) && disp_transform[1] < (1<<24) &&
+        if (disp_transform[0] > 1 && disp_transform[1] > 1 &&
+            disp_transform[0] < (1 << 24) && disp_transform[1] < (1 << 24) &&
             fabs((disp_transform[0] / disp_transform[1]) - 1.0) > 0.01)
             st->sample_aspect_ratio = av_d2q(
                 disp_transform[0] / disp_transform[1],
@@ -5658,12 +5677,12 @@ static int mov_read_tkhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return 0;
 }
 
-static int mov_read_tfhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_tfhd(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    MOVFragment *frag = &c->fragment;
-    MOVTrackExt *trex = NULL;
+    MOVFragment* frag = &c->fragment;
+    MOVTrackExt* trex = NULL;
     int flags, track_id, i;
-    MOVFragmentStreamInfo * frag_stream_info;
+    MOVFragmentStreamInfo* frag_stream_info;
 
     avio_r8(pb); /* version */
     flags = avio_rb24(pb);
@@ -5685,16 +5704,16 @@ static int mov_read_tfhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     set_frag_stream(&c->frag_index, track_id);
 
     frag->base_data_offset = flags & MOV_TFHD_BASE_DATA_OFFSET ?
-                             avio_rb64(pb) : flags & MOV_TFHD_DEFAULT_BASE_IS_MOOF ?
-                             frag->moof_offset : frag->implicit_offset;
-    frag->stsd_id  = flags & MOV_TFHD_STSD_ID ? avio_rb32(pb) : trex->stsd_id;
+        avio_rb64(pb) : flags & MOV_TFHD_DEFAULT_BASE_IS_MOOF ?
+        frag->moof_offset : frag->implicit_offset;
+    frag->stsd_id = flags & MOV_TFHD_STSD_ID ? avio_rb32(pb) : trex->stsd_id;
 
     frag->duration = flags & MOV_TFHD_DEFAULT_DURATION ?
-                     avio_rb32(pb) : trex->duration;
-    frag->size     = flags & MOV_TFHD_DEFAULT_SIZE ?
-                     avio_rb32(pb) : trex->size;
-    frag->flags    = flags & MOV_TFHD_DEFAULT_FLAGS ?
-                     avio_rb32(pb) : trex->flags;
+        avio_rb32(pb) : trex->duration;
+    frag->size = flags & MOV_TFHD_DEFAULT_SIZE ?
+        avio_rb32(pb) : trex->size;
+    frag->flags = flags & MOV_TFHD_DEFAULT_FLAGS ?
+        avio_rb32(pb) : trex->flags;
     av_log(c->fc, AV_LOG_TRACE, "frag flags 0x%x\n", frag->flags);
 
     frag_stream_info = get_current_frag_stream_info(&c->frag_index);
@@ -5705,10 +5724,10 @@ static int mov_read_tfhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return 0;
 }
 
-static int mov_read_chap(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_chap(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
     unsigned i, num;
-    void *new_tracks;
+    void* new_tracks;
 
     num = atom.size / 4;
     if (!(new_tracks = av_malloc_array(num, sizeof(int))))
@@ -5726,15 +5745,15 @@ static int mov_read_chap(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return 0;
 }
 
-static int mov_read_trex(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_trex(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    MOVTrackExt *trex;
+    MOVTrackExt* trex;
     int err;
 
-    if ((uint64_t)c->trex_count+1 >= UINT_MAX / sizeof(*c->trex_data))
+    if ((uint64_t)c->trex_count + 1 >= UINT_MAX / sizeof(*c->trex_data))
         return AVERROR_INVALIDDATA;
     if ((err = av_reallocp_array(&c->trex_data, c->trex_count + 1,
-                                 sizeof(*c->trex_data))) < 0) {
+        sizeof(*c->trex_data))) < 0) {
         c->trex_count = 0;
         return err;
     }
@@ -5745,20 +5764,20 @@ static int mov_read_trex(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     avio_r8(pb); /* version */
     avio_rb24(pb); /* flags */
     trex->track_id = avio_rb32(pb);
-    trex->stsd_id  = avio_rb32(pb);
+    trex->stsd_id = avio_rb32(pb);
     trex->duration = avio_rb32(pb);
-    trex->size     = avio_rb32(pb);
-    trex->flags    = avio_rb32(pb);
+    trex->size = avio_rb32(pb);
+    trex->flags = avio_rb32(pb);
     return 0;
 }
 
-static int mov_read_tfdt(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_tfdt(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    MOVFragment *frag = &c->fragment;
-    AVStream *st = NULL;
-    MOVStreamContext *sc;
+    MOVFragment* frag = &c->fragment;
+    AVStream* st = NULL;
+    MOVStreamContext* sc;
     int version, i;
-    MOVFragmentStreamInfo * frag_stream_info;
+    MOVFragmentStreamInfo* frag_stream_info;
     int64_t base_media_decode_time;
 
     for (i = 0; i < c->fc->nb_streams; i++) {
@@ -5779,7 +5798,8 @@ static int mov_read_tfdt(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     avio_rb24(pb); /* flags */
     if (version) {
         base_media_decode_time = avio_rb64(pb);
-    } else {
+    }
+    else {
         base_media_decode_time = avio_rb32(pb);
     }
 
@@ -5791,13 +5811,13 @@ static int mov_read_tfdt(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return 0;
 }
 
-static int mov_read_trun(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_trun(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    MOVFragment *frag = &c->fragment;
-    AVStream *st = NULL;
-    FFStream *sti = NULL;
-    MOVStreamContext *sc;
-    MOVTimeToSample *tts_data;
+    MOVFragment* frag = &c->fragment;
+    AVStream* st = NULL;
+    FFStream* sti = NULL;
+    MOVStreamContext* sc;
+    MOVTimeToSample* tts_data;
     uint64_t offset;
     int64_t dts, pts = AV_NOPTS_VALUE;
     int data_offset = 0;
@@ -5807,8 +5827,8 @@ static int mov_read_trun(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     int next_frag_index = -1, index_entry_pos;
     size_t requested_size;
     size_t old_allocated_size;
-    AVIndexEntry *new_entries;
-    MOVFragmentStreamInfo * frag_stream_info;
+    AVIndexEntry* new_entries;
+    MOVFragmentStreamInfo* frag_stream_info;
 
     if (!frag->found_tfhd) {
         av_log(c->fc, AV_LOG_ERROR, "trun track id unknown, no tfhd was found\n");
@@ -5828,7 +5848,7 @@ static int mov_read_trun(MOVContext *c, AVIOContext *pb, MOVAtom atom)
         return 0;
     }
     sc = st->priv_data;
-    if (sc->pseudo_stream_id+1 != frag->stsd_id && sc->pseudo_stream_id != -1)
+    if (sc->pseudo_stream_id + 1 != frag->stsd_id && sc->pseudo_stream_id != -1)
         return 0;
 
     // Find the next frag_index index that has a valid index_entry for
@@ -5853,30 +5873,33 @@ static int mov_read_trun(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     entries = avio_rb32(pb);
     av_log(c->fc, AV_LOG_TRACE, "flags 0x%x entries %u\n", flags, entries);
 
-    if ((uint64_t)entries+sc->tts_count >= UINT_MAX/sizeof(*sc->tts_data))
+    if ((uint64_t)entries + sc->tts_count >= UINT_MAX / sizeof(*sc->tts_data))
         return AVERROR_INVALIDDATA;
-    if (flags & MOV_TRUN_DATA_OFFSET)        data_offset        = avio_rb32(pb);
+    if (flags & MOV_TRUN_DATA_OFFSET)        data_offset = avio_rb32(pb);
     if (flags & MOV_TRUN_FIRST_SAMPLE_FLAGS) first_sample_flags = avio_rb32(pb);
 
     frag_stream_info = get_current_frag_stream_info(&c->frag_index);
     if (frag_stream_info) {
         if (frag_stream_info->next_trun_dts != AV_NOPTS_VALUE) {
             dts = frag_stream_info->next_trun_dts - sc->time_offset;
-        } else if (frag_stream_info->first_tfra_pts != AV_NOPTS_VALUE &&
+        }
+        else if (frag_stream_info->first_tfra_pts != AV_NOPTS_VALUE &&
             c->use_mfra_for == FF_MOV_FLAG_MFRA_PTS) {
             pts = frag_stream_info->first_tfra_pts;
             av_log(c->fc, AV_LOG_DEBUG, "found mfra time %"PRId64
-                    ", using it for pts\n", pts);
-        } else if (frag_stream_info->first_tfra_pts != AV_NOPTS_VALUE &&
+                ", using it for pts\n", pts);
+        }
+        else if (frag_stream_info->first_tfra_pts != AV_NOPTS_VALUE &&
             c->use_mfra_for == FF_MOV_FLAG_MFRA_DTS) {
             dts = frag_stream_info->first_tfra_pts;
             av_log(c->fc, AV_LOG_DEBUG, "found mfra time %"PRId64
-                    ", using it for dts\n", pts);
-        } else {
+                ", using it for dts\n", pts);
+        }
+        else {
             int has_tfdt = frag_stream_info->tfdt_dts != AV_NOPTS_VALUE;
             int has_sidx = frag_stream_info->sidx_pts != AV_NOPTS_VALUE;
             int fallback_tfdt = !c->use_tfdt && !has_sidx && has_tfdt;
-            int fallback_sidx =  c->use_tfdt && !has_tfdt && has_sidx;
+            int fallback_sidx = c->use_tfdt && !has_tfdt && has_sidx;
 
             if (fallback_sidx) {
                 av_log(c->fc, AV_LOG_DEBUG, "use_tfdt set but no tfdt found, using sidx instead\n");
@@ -5888,25 +5911,28 @@ static int mov_read_trun(MOVContext *c, AVIOContext *pb, MOVAtom atom)
             if (has_tfdt && c->use_tfdt || fallback_tfdt) {
                 dts = frag_stream_info->tfdt_dts - sc->time_offset;
                 av_log(c->fc, AV_LOG_DEBUG, "found tfdt time %"PRId64
-                        ", using it for dts\n", dts);
-            } else if (has_sidx && !c->use_tfdt || fallback_sidx) {
+                    ", using it for dts\n", dts);
+            }
+            else if (has_sidx && !c->use_tfdt || fallback_sidx) {
                 // FIXME: sidx earliest_presentation_time is *PTS*, s.b.
                 // pts = frag_stream_info->sidx_pts;
-                dts = frag_stream_info->sidx_pts;
+                dts = frag_stream_info->sidx_pts - sc->time_offset;
                 av_log(c->fc, AV_LOG_DEBUG, "found sidx time %"PRId64
-                        ", using it for dts\n", frag_stream_info->sidx_pts);
-            } else {
+                    ", using it for dts\n", frag_stream_info->sidx_pts);
+            }
+            else {
                 dts = sc->track_end - sc->time_offset;
                 av_log(c->fc, AV_LOG_DEBUG, "found track end time %"PRId64
-                        ", using it for dts\n", dts);
+                    ", using it for dts\n", dts);
             }
         }
-    } else {
+    }
+    else {
         dts = sc->track_end - sc->time_offset;
         av_log(c->fc, AV_LOG_DEBUG, "found track end time %"PRId64
-                ", using it for dts\n", dts);
+            ", using it for dts\n", dts);
     }
-    offset   = frag->base_data_offset + data_offset;
+    offset = frag->base_data_offset + data_offset;
     distance = 0;
     av_log(c->fc, AV_LOG_TRACE, "first sample flags 0x%x\n", first_sample_flags);
 
@@ -5920,16 +5946,16 @@ static int mov_read_trun(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 
     requested_size = (sti->nb_index_entries + entries) * sizeof(AVIndexEntry);
     new_entries = av_fast_realloc(sti->index_entries,
-                                  &sti->index_entries_allocated_size,
-                                  requested_size);
+        &sti->index_entries_allocated_size,
+        requested_size);
     if (!new_entries)
         return AVERROR(ENOMEM);
-    sti->index_entries= new_entries;
+    sti->index_entries = new_entries;
 
     requested_size = (sti->nb_index_entries + entries) * sizeof(*sc->tts_data);
     old_allocated_size = sc->tts_allocated_size;
     tts_data = av_fast_realloc(sc->tts_data, &sc->tts_allocated_size,
-                                requested_size);
+        requested_size);
     if (!tts_data)
         return AVERROR(ENOMEM);
     sc->tts_data = tts_data;
@@ -5938,17 +5964,17 @@ static int mov_read_trun(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     // zero valued entries. This ensures clips which mix boxes with and
     // without time to sample entries don't pickup uninitialized data.
     memset((uint8_t*)(sc->tts_data) + old_allocated_size, 0,
-           sc->tts_allocated_size - old_allocated_size);
+        sc->tts_allocated_size - old_allocated_size);
 
     if (index_entry_pos < sti->nb_index_entries) {
         // Make hole in index_entries and tts_data for new samples
         memmove(sti->index_entries + index_entry_pos + entries,
-                sti->index_entries + index_entry_pos,
-                sizeof(*sti->index_entries) *
-                (sti->nb_index_entries - index_entry_pos));
+            sti->index_entries + index_entry_pos,
+            sizeof(*sti->index_entries) *
+            (sti->nb_index_entries - index_entry_pos));
         memmove(sc->tts_data + index_entry_pos + entries,
-                sc->tts_data + index_entry_pos,
-                sizeof(*sc->tts_data) * (sc->tts_count - index_entry_pos));
+            sc->tts_data + index_entry_pos,
+            sizeof(*sc->tts_data) * (sc->tts_count - index_entry_pos));
         if (index_entry_pos < sc->current_sample) {
             sc->current_sample += entries;
         }
@@ -5968,7 +5994,7 @@ static int mov_read_trun(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     }
 
     if (index_entry_pos > 0)
-        prev_dts = sti->index_entries[index_entry_pos-1].timestamp;
+        prev_dts = sti->index_entries[index_entry_pos - 1].timestamp;
 
     for (i = 0; i < entries && !pb->eof_reached; i++) {
         unsigned sample_size = frag->size;
@@ -5979,32 +6005,33 @@ static int mov_read_trun(MOVContext *c, AVIOContext *pb, MOVAtom atom)
         int index_entry_flags = 0;
 
         if (flags & MOV_TRUN_SAMPLE_DURATION) sample_duration = avio_rb32(pb);
-        if (flags & MOV_TRUN_SAMPLE_SIZE)     sample_size     = avio_rb32(pb);
-        if (flags & MOV_TRUN_SAMPLE_FLAGS)    sample_flags    = avio_rb32(pb);
-        if (flags & MOV_TRUN_SAMPLE_CTS)      ctts_duration   = avio_rb32(pb);
+        if (flags & MOV_TRUN_SAMPLE_SIZE)     sample_size = avio_rb32(pb);
+        if (flags & MOV_TRUN_SAMPLE_FLAGS)    sample_flags = avio_rb32(pb);
+        if (flags & MOV_TRUN_SAMPLE_CTS)      ctts_duration = avio_rb32(pb);
 
         mov_update_dts_shift(sc, ctts_duration, c->fc);
         if (pts != AV_NOPTS_VALUE) {
             dts = pts - sc->dts_shift;
             if (flags & MOV_TRUN_SAMPLE_CTS) {
                 dts -= ctts_duration;
-            } else {
+            }
+            else {
                 dts -= sc->time_offset;
             }
             av_log(c->fc, AV_LOG_DEBUG,
-                   "pts %"PRId64" calculated dts %"PRId64
-                   " sc->dts_shift %d ctts.duration %d"
-                   " sc->time_offset %"PRId64
-                   " flags & MOV_TRUN_SAMPLE_CTS %d\n",
-                   pts, dts,
-                   sc->dts_shift, ctts_duration,
-                   sc->time_offset, flags & MOV_TRUN_SAMPLE_CTS);
+                "pts %"PRId64" calculated dts %"PRId64
+                " sc->dts_shift %d ctts.duration %d"
+                " sc->time_offset %"PRId64
+                " flags & MOV_TRUN_SAMPLE_CTS %d\n",
+                pts, dts,
+                sc->dts_shift, ctts_duration,
+                sc->time_offset, flags & MOV_TRUN_SAMPLE_CTS);
             pts = AV_NOPTS_VALUE;
         }
 
         keyframe =
-                !(sample_flags & (MOV_FRAG_SAMPLE_FLAG_IS_NON_SYNC |
-                                  MOV_FRAG_SAMPLE_FLAG_DEPENDS_YES));
+            !(sample_flags & (MOV_FRAG_SAMPLE_FLAG_IS_NON_SYNC |
+                MOV_FRAG_SAMPLE_FLAG_DEPENDS_YES));
         if (keyframe) {
             distance = 0;
             index_entry_flags |= AVINDEX_KEYFRAME;
@@ -6014,9 +6041,9 @@ static int mov_read_trun(MOVContext *c, AVIOContext *pb, MOVAtom atom)
         if (prev_dts >= dts)
             index_entry_flags |= AVINDEX_DISCARD_FRAME;
 
-        sti->index_entries[index_entry_pos].pos   = offset;
+        sti->index_entries[index_entry_pos].pos = offset;
         sti->index_entries[index_entry_pos].timestamp = dts;
-        sti->index_entries[index_entry_pos].size  = sample_size;
+        sti->index_entries[index_entry_pos].size = sample_size;
         sti->index_entries[index_entry_pos].min_distance = distance;
         sti->index_entries[index_entry_pos].flags = index_entry_flags;
 
@@ -6026,8 +6053,8 @@ static int mov_read_trun(MOVContext *c, AVIOContext *pb, MOVAtom atom)
         index_entry_pos++;
 
         av_log(c->fc, AV_LOG_TRACE, "AVIndex stream %d, sample %d, offset %"PRIx64", dts %"PRId64", "
-                "size %u, distance %d, keyframe %d\n", st->index,
-                index_entry_pos, offset, dts, sample_size, distance, keyframe);
+            "size %u, distance %d, keyframe %d\n", st->index,
+            index_entry_pos, offset, dts, sample_size, distance, keyframe);
         distance++;
         if (av_sat_add64(dts, sample_duration) != dts + (uint64_t)sample_duration)
             return AVERROR_INVALIDDATA;
@@ -6036,12 +6063,14 @@ static int mov_read_trun(MOVContext *c, AVIOContext *pb, MOVAtom atom)
         dts += sample_duration;
         offset += sample_size;
         sc->data_size += sample_size;
-
+        sc->total_data_size += sample_size;
+        sc->fragment_duration_sum += sample_duration;
+        sc->fragment_size_sum += sample_size;
         if (sample_duration <= INT64_MAX - sc->duration_for_fps &&
             1 <= INT_MAX - sc->nb_frames_for_fps
-        ) {
+            ) {
             sc->duration_for_fps += sample_duration;
-            sc->nb_frames_for_fps ++;
+            sc->nb_frames_for_fps++;
         }
     }
     if (frag_stream_info)
@@ -6051,13 +6080,13 @@ static int mov_read_trun(MOVContext *c, AVIOContext *pb, MOVAtom atom)
         // leave in index_entries and tts_data
         int gap = entries - i;
         memmove(sti->index_entries + index_entry_pos,
-                sti->index_entries + index_entry_pos + gap,
-                sizeof(*sti->index_entries) *
-                (sti->nb_index_entries - (index_entry_pos + gap)));
+            sti->index_entries + index_entry_pos + gap,
+            sizeof(*sti->index_entries) *
+            (sti->nb_index_entries - (index_entry_pos + gap)));
         memmove(sc->tts_data + index_entry_pos,
-                sc->tts_data + index_entry_pos + gap,
-                sizeof(*sc->tts_data) *
-                (sc->tts_count - (index_entry_pos + gap)));
+            sc->tts_data + index_entry_pos + gap,
+            sizeof(*sc->tts_data) *
+            (sc->tts_count - (index_entry_pos + gap)));
 
         sti->nb_index_entries -= gap;
         sc->tts_count -= gap;
@@ -6072,7 +6101,7 @@ static int mov_read_trun(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     // fragment that overlap with AVINDEX_DISCARD_FRAME
     prev_dts = AV_NOPTS_VALUE;
     if (index_entry_pos > 0)
-        prev_dts = sti->index_entries[index_entry_pos-1].timestamp;
+        prev_dts = sti->index_entries[index_entry_pos - 1].timestamp;
     for (int i = index_entry_pos; i < sti->nb_index_entries; i++) {
         if (prev_dts < sti->index_entries[i].timestamp)
             break;
@@ -6083,7 +6112,7 @@ static int mov_read_trun(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     // the index_entry recorded for all subsequent moof must
     // be incremented by the number of entries inserted.
     fix_frag_index_entries(&c->frag_index, next_frag_index,
-                           frag->track_id, entries);
+        frag->track_id, entries);
 
     if (pb->eof_reached) {
         av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted TRUN atom\n");
@@ -6099,16 +6128,16 @@ static int mov_read_trun(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return 0;
 }
 
-static int mov_read_sidx(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_sidx(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
     int64_t stream_size = avio_size(pb);
     int64_t offset = av_sat_add64(avio_tell(pb), atom.size), pts, timestamp;
     uint8_t version, is_complete;
     int64_t offadd;
     unsigned i, j, track_id, item_count;
-    AVStream *st = NULL;
-    AVStream *ref_st = NULL;
-    MOVStreamContext *sc, *ref_sc = NULL;
+    AVStream* st = NULL;
+    AVStream* ref_st = NULL;
+    MOVStreamContext* sc, * ref_sc = NULL;
     AVRational timescale;
 
     version = avio_r8(pb);
@@ -6143,10 +6172,11 @@ static int mov_read_sidx(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 
     if (version == 0) {
         pts = avio_rb32(pb);
-        offadd= avio_rb32(pb);
-    } else {
+        offadd = avio_rb32(pb);
+    }
+    else {
         pts = avio_rb64(pb);
-        offadd= avio_rb64(pb);
+        offadd = avio_rb64(pb);
     }
     if (av_sat_add64(offset, offadd) != offset + (uint64_t)offadd)
         return AVERROR_INVALIDDATA;
@@ -6161,7 +6191,7 @@ static int mov_read_sidx(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 
     for (i = 0; i < item_count; i++) {
         int index;
-        MOVFragmentStreamInfo * frag_stream_info;
+        MOVFragmentStreamInfo* frag_stream_info;
         uint32_t size = avio_rb32(pb);
         uint32_t duration = avio_rb32(pb);
         if (size & 0x80000000) {
@@ -6178,19 +6208,23 @@ static int mov_read_sidx(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 
         if (av_sat_add64(offset, size) != offset + (uint64_t)size ||
             av_sat_add64(pts, duration) != pts + (uint64_t)duration
-        )
+            )
             return AVERROR_INVALIDDATA;
         offset += size;
         pts += duration;
     }
 
     st->duration = sc->track_end = pts;
+    if (sc->total_data_size > 0 && st->duration > 0) {
+        int64_t bitrate = sc->total_data_size * 8 * sc->time_scale / st->duration;
+        av_log(c->fc, AV_LOG_INFO, "Calculated full stream bit_rate=%"PRId64"\n", bitrate);
+    }
 
     sc->has_sidx = 1;
 
     // See if the remaining bytes are just an mfra which we can ignore.
     is_complete = offset == stream_size;
-    if (!is_complete && (pb->seekable & AVIO_SEEKABLE_NORMAL) && stream_size > 0 ) {
+    if (!is_complete && (pb->seekable & AVIO_SEEKABLE_NORMAL) && stream_size > 0) {
         int64_t ret;
         int64_t original_pos = avio_tell(pb);
         if (!c->have_read_mfra_size) {
@@ -6209,9 +6243,9 @@ static int mov_read_sidx(MOVContext *c, AVIOContext *pb, MOVAtom atom)
         // Find first entry in fragment index that came from an sidx.
         // This will pretty much always be the first entry.
         for (i = 0; i < c->frag_index.nb_items; i++) {
-            MOVFragmentIndexItem * item = &c->frag_index.item[i];
+            MOVFragmentIndexItem* item = &c->frag_index.item[i];
             for (j = 0; ref_st == NULL && j < item->nb_stream_info; j++) {
-                MOVFragmentStreamInfo * si;
+                MOVFragmentStreamInfo* si;
                 si = &item->stream_info[j];
                 if (si->sidx_pts != AV_NOPTS_VALUE) {
                     ref_st = c->fc->streams[j];
@@ -6228,8 +6262,7 @@ static int mov_read_sidx(MOVContext *c, AVIOContext *pb, MOVAtom atom)
             }
         }
 
-        if (offadd == 0)
-            c->frag_index.complete = 1;
+        c->frag_index.complete = 1;
     }
 
     return 0;
@@ -6238,7 +6271,7 @@ static int mov_read_sidx(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 /* this atom should be null (from specs), but some buggy files put the 'moov' atom inside it... */
 /* like the files created with Adobe Premiere 5.0, for samples see */
 /* http://graphics.tudelft.nl/~wouter/publications/soundtests/ */
-static int mov_read_wide(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_wide(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
     int err;
 
@@ -6250,7 +6283,7 @@ static int mov_read_wide(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     }
     atom.type = avio_rl32(pb);
     atom.size -= 8;
-    if (atom.type != MKTAG('m','d','a','t')) {
+    if (atom.type != MKTAG('m', 'd', 'a', 't')) {
         avio_skip(pb, atom.size);
         return 0;
     }
@@ -6258,24 +6291,24 @@ static int mov_read_wide(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return err;
 }
 
-static int mov_read_cmov(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_cmov(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
 #if CONFIG_ZLIB
     FFIOContext ctx;
-    uint8_t *cmov_data;
-    uint8_t *moov_data; /* uncompressed data */
+    uint8_t* cmov_data;
+    uint8_t* moov_data; /* uncompressed data */
     long cmov_len, moov_len;
     int ret = -1;
 
     avio_rb32(pb); /* dcom atom */
-    if (avio_rl32(pb) != MKTAG('d','c','o','m'))
+    if (avio_rl32(pb) != MKTAG('d', 'c', 'o', 'm'))
         return AVERROR_INVALIDDATA;
-    if (avio_rl32(pb) != MKTAG('z','l','i','b')) {
+    if (avio_rl32(pb) != MKTAG('z', 'l', 'i', 'b')) {
         av_log(c->fc, AV_LOG_ERROR, "unknown compression for cmov atom !\n");
         return AVERROR_INVALIDDATA;
     }
     avio_rb32(pb); /* cmvd atom */
-    if (avio_rl32(pb) != MKTAG('c','m','v','d'))
+    if (avio_rl32(pb) != MKTAG('c', 'm', 'v', 'd'))
         return AVERROR_INVALIDDATA;
     moov_len = avio_rb32(pb); /* uncompressed size */
     cmov_len = atom.size - 6 * 4;
@@ -6293,11 +6326,11 @@ static int mov_read_cmov(MOVContext *c, AVIOContext *pb, MOVAtom atom)
         goto free_and_return;
 
     ret = AVERROR_INVALIDDATA;
-    if (uncompress (moov_data, (uLongf *) &moov_len, (const Bytef *)cmov_data, cmov_len) != Z_OK)
+    if (uncompress(moov_data, (uLongf*)&moov_len, (const Bytef*)cmov_data, cmov_len) != Z_OK)
         goto free_and_return;
     ffio_init_read_context(&ctx, moov_data, moov_len);
     ctx.pub.seekable = AVIO_SEEKABLE_NORMAL;
-    atom.type = MKTAG('m','o','o','v');
+    atom.type = MKTAG('m', 'o', 'o', 'v');
     atom.size = moov_len;
     ret = mov_read_default(c, &ctx.pub, atom);
 free_and_return:
@@ -6311,15 +6344,15 @@ free_and_return:
 }
 
 /* edit list atom */
-static int mov_read_elst(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_elst(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    MOVStreamContext *sc;
+    MOVStreamContext* sc;
     int i, edit_count, version;
     int64_t elst_entry_size;
 
     if (c->fc->nb_streams < 1 || c->ignore_editlist)
         return 0;
-    sc = c->fc->streams[c->fc->nb_streams-1]->priv_data;
+    sc = c->fc->streams[c->fc->nb_streams - 1]->priv_data;
 
     version = avio_r8(pb); /* version */
     avio_rb24(pb); /* flags */
@@ -6330,9 +6363,10 @@ static int mov_read_elst(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     if (atom.size != edit_count * elst_entry_size) {
         if (c->fc->strict_std_compliance >= FF_COMPLIANCE_STRICT) {
             av_log(c->fc, AV_LOG_ERROR, "Invalid edit list entry_count: %d for elst atom of size: %"PRId64" bytes.\n",
-                   edit_count, atom.size + 8);
+                edit_count, atom.size + 8);
             return AVERROR_INVALIDDATA;
-        } else {
+        }
+        else {
             edit_count = atom.size / elst_entry_size;
             if (edit_count * elst_entry_size != atom.size) {
                 av_log(c->fc, AV_LOG_WARNING, "ELST atom of %"PRId64" bytes, bigger than %d entries.\n", atom.size, edit_count);
@@ -6352,31 +6386,32 @@ static int mov_read_elst(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 
     av_log(c->fc, AV_LOG_TRACE, "track[%u].edit_count = %i\n", c->fc->nb_streams - 1, edit_count);
     for (i = 0; i < edit_count && atom.size > 0 && !pb->eof_reached; i++) {
-        MOVElst *e = &sc->elst_data[i];
+        MOVElst* e = &sc->elst_data[i];
 
         if (version == 1) {
             e->duration = avio_rb64(pb);
-            e->time     = avio_rb64(pb);
+            e->time = avio_rb64(pb);
             atom.size -= 16;
-        } else {
+        }
+        else {
             e->duration = avio_rb32(pb); /* segment duration */
-            e->time     = (int32_t)avio_rb32(pb); /* media time */
+            e->time = (int32_t)avio_rb32(pb); /* media time */
             atom.size -= 8;
         }
         e->rate = avio_rb32(pb) / 65536.0;
         atom.size -= 4;
         av_log(c->fc, AV_LOG_TRACE, "duration=%"PRId64" time=%"PRId64" rate=%f\n",
-               e->duration, e->time, e->rate);
+            e->duration, e->time, e->rate);
 
         if (e->time < 0 && e->time != -1 &&
             c->fc->strict_std_compliance >= FF_COMPLIANCE_STRICT) {
             av_log(c->fc, AV_LOG_ERROR, "Track %d, edit %d: Invalid edit list media time=%"PRId64"\n",
-                   c->fc->nb_streams-1, i, e->time);
+                c->fc->nb_streams - 1, i, e->time);
             return AVERROR_INVALIDDATA;
         }
         if (e->duration < 0) {
             av_log(c->fc, AV_LOG_ERROR, "Track %d, edit %d: Invalid edit list duration=%"PRId64"\n",
-                   c->fc->nb_streams-1, i, e->duration);
+                c->fc->nb_streams - 1, i, e->duration);
             return AVERROR_INVALIDDATA;
         }
     }
@@ -6385,9 +6420,9 @@ static int mov_read_elst(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return 0;
 }
 
-static int mov_read_tmcd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_tmcd(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    MOVStreamContext *sc;
+    MOVStreamContext* sc;
 
     if (c->fc->nb_streams < 1)
         return AVERROR_INVALIDDATA;
@@ -6396,9 +6431,9 @@ static int mov_read_tmcd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return 0;
 }
 
-static int mov_read_vpcc(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_vpcc(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    AVStream *st;
+    AVStream* st;
     int version, color_range, color_primaries, color_trc, color_space;
 
     if (c->fc->nb_streams < 1)
@@ -6418,10 +6453,10 @@ static int mov_read_vpcc(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     avio_skip(pb, 3); /* flags */
 
     avio_skip(pb, 2); /* profile + level */
-    color_range     = avio_r8(pb); /* bitDepth, chromaSubsampling, videoFullRangeFlag */
+    color_range = avio_r8(pb); /* bitDepth, chromaSubsampling, videoFullRangeFlag */
     color_primaries = avio_r8(pb);
-    color_trc       = avio_r8(pb);
-    color_space     = avio_r8(pb);
+    color_trc = avio_r8(pb);
+    color_space = avio_r8(pb);
     if (avio_rb16(pb)) /* codecIntializationDataSize */
         return AVERROR_INVALIDDATA;
 
@@ -6432,17 +6467,17 @@ static int mov_read_vpcc(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     if (!av_color_space_name(color_space))
         color_space = AVCOL_SPC_UNSPECIFIED;
 
-    st->codecpar->color_range     = (color_range & 1) ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;
+    st->codecpar->color_range = (color_range & 1) ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;
     st->codecpar->color_primaries = color_primaries;
-    st->codecpar->color_trc       = color_trc;
-    st->codecpar->color_space     = color_space;
+    st->codecpar->color_trc = color_trc;
+    st->codecpar->color_space = color_space;
 
     return 0;
 }
 
-static int mov_read_smdm(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_smdm(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    MOVStreamContext *sc;
+    MOVStreamContext* sc;
     int i, version;
 
     if (c->fc->nb_streams < 1)
@@ -6487,10 +6522,10 @@ static int mov_read_smdm(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return 0;
 }
 
-static int mov_read_mdcv(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_mdcv(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    MOVStreamContext *sc;
-    const int mapping[3] = {1, 2, 0};
+    MOVStreamContext* sc;
+    const int mapping[3] = { 1, 2, 0 };
     const int chroma_den = 50000;
     const int luma_den = 10000;
     int i;
@@ -6531,9 +6566,9 @@ static int mov_read_mdcv(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return 0;
 }
 
-static int mov_read_coll(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_coll(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    MOVStreamContext *sc;
+    MOVStreamContext* sc;
     int version;
 
     if (c->fc->nb_streams < 1)
@@ -6553,7 +6588,7 @@ static int mov_read_coll(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     }
     avio_skip(pb, 3); /* flags */
 
-    if (sc->coll){
+    if (sc->coll) {
         av_log(c->fc, AV_LOG_WARNING, "Ignoring duplicate COLL\n");
         return 0;
     }
@@ -6562,15 +6597,15 @@ static int mov_read_coll(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     if (!sc->coll)
         return AVERROR(ENOMEM);
 
-    sc->coll->MaxCLL  = avio_rb16(pb);
+    sc->coll->MaxCLL = avio_rb16(pb);
     sc->coll->MaxFALL = avio_rb16(pb);
 
     return 0;
 }
 
-static int mov_read_clli(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_clli(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    MOVStreamContext *sc;
+    MOVStreamContext* sc;
 
     if (c->fc->nb_streams < 1)
         return AVERROR_INVALIDDATA;
@@ -6582,7 +6617,7 @@ static int mov_read_clli(MOVContext *c, AVIOContext *pb, MOVAtom atom)
         return AVERROR_INVALIDDATA;
     }
 
-    if (sc->coll){
+    if (sc->coll) {
         av_log(c->fc, AV_LOG_WARNING, "Ignoring duplicate CLLI/COLL\n");
         return 0;
     }
@@ -6591,15 +6626,15 @@ static int mov_read_clli(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     if (!sc->coll)
         return AVERROR(ENOMEM);
 
-    sc->coll->MaxCLL  = avio_rb16(pb);
+    sc->coll->MaxCLL = avio_rb16(pb);
     sc->coll->MaxFALL = avio_rb16(pb);
 
     return 0;
 }
 
-static int mov_read_amve(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_amve(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    MOVStreamContext *sc;
+    MOVStreamContext* sc;
     const int illuminance_den = 10000;
     const int ambient_den = 50000;
     if (c->fc->nb_streams < 1)
@@ -6609,23 +6644,23 @@ static int mov_read_amve(MOVContext *c, AVIOContext *pb, MOVAtom atom)
         av_log(c->fc, AV_LOG_ERROR, "Empty Ambient Viewing Environment Info box\n");
         return AVERROR_INVALIDDATA;
     }
-    if (sc->ambient){
+    if (sc->ambient) {
         av_log(c->fc, AV_LOG_WARNING, "Ignoring duplicate AMVE\n");
         return 0;
     }
     sc->ambient = av_ambient_viewing_environment_alloc(&sc->ambient_size);
     if (!sc->ambient)
         return AVERROR(ENOMEM);
-    sc->ambient->ambient_illuminance  = av_make_q(avio_rb32(pb), illuminance_den);
+    sc->ambient->ambient_illuminance = av_make_q(avio_rb32(pb), illuminance_den);
     sc->ambient->ambient_light_x = av_make_q(avio_rb16(pb), ambient_den);
     sc->ambient->ambient_light_y = av_make_q(avio_rb16(pb), ambient_den);
     return 0;
 }
 
-static int mov_read_st3d(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_st3d(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    AVStream *st;
-    MOVStreamContext *sc;
+    AVStream* st;
+    MOVStreamContext* sc;
     enum AVStereo3DType type;
     int mode;
 
@@ -6669,10 +6704,10 @@ static int mov_read_st3d(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return 0;
 }
 
-static int mov_read_pack(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_pack(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    AVStream *st;
-    MOVStreamContext *sc;
+    AVStream* st;
+    MOVStreamContext* sc;
     int size = 0;
     int64_t remaining;
     uint32_t tag = 0;
@@ -6687,14 +6722,14 @@ static int mov_read_pack(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     remaining = atom.size;
     while (remaining > 0) {
         size = avio_rb32(pb);
-        if (size < 8 || size > remaining ) {
+        if (size < 8 || size > remaining) {
             av_log(c->fc, AV_LOG_ERROR, "Invalid child size in pack box\n");
             return AVERROR_INVALIDDATA;
         }
 
         tag = avio_rl32(pb);
         switch (tag) {
-        case MKTAG('p','k','i','n'): {
+        case MKTAG('p', 'k', 'i', 'n'): {
             if (size != 16) {
                 av_log(c->fc, AV_LOG_ERROR, "Invalid size of pkin box: %d\n", size);
                 return AVERROR_INVALIDDATA;
@@ -6704,18 +6739,17 @@ static int mov_read_pack(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 
             tag = avio_rl32(pb);
             switch (tag) {
-            case MKTAG('s','i','d','e'):
+            case MKTAG('s', 'i', 'd', 'e'):
                 type = AV_STEREO3D_SIDEBYSIDE;
                 break;
-            case MKTAG('o','v','e','r'):
+            case MKTAG('o', 'v', 'e', 'r'):
                 type = AV_STEREO3D_TOPBOTTOM;
                 break;
             case 0:
                 // This means value will be set in another layer
                 break;
             default:
-                av_log(c->fc, AV_LOG_WARNING, "Unknown tag in pkin: %s\n",
-                       av_fourcc2str(tag));
+                av_log(c->fc, AV_LOG_WARNING, "Unknown tag in pkin: 0x%08X\n", tag);
                 avio_skip(pb, size - 8);
                 break;
             }
@@ -6723,8 +6757,7 @@ static int mov_read_pack(MOVContext *c, AVIOContext *pb, MOVAtom atom)
             break;
         }
         default:
-            av_log(c->fc, AV_LOG_WARNING, "Unknown tag in pack: %s\n",
-                   av_fourcc2str(tag));
+            av_log(c->fc, AV_LOG_WARNING, "Unknown tag in pack: 0x%08X\n", tag);
             avio_skip(pb, size - 8);
             break;
         }
@@ -6750,10 +6783,10 @@ static int mov_read_pack(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return 0;
 }
 
-static int mov_read_sv3d(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_sv3d(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    AVStream *st;
-    MOVStreamContext *sc;
+    AVStream* st;
+    MOVStreamContext* sc;
     int size, version, layout;
     int32_t yaw, pitch, roll;
     uint32_t l = 0, t = 0, r = 0, b = 0;
@@ -6776,14 +6809,14 @@ static int mov_read_sv3d(MOVContext *c, AVIOContext *pb, MOVAtom atom)
         return AVERROR_INVALIDDATA;
 
     tag = avio_rl32(pb);
-    if (tag != MKTAG('s','v','h','d')) {
+    if (tag != MKTAG('s', 'v', 'h', 'd')) {
         av_log(c->fc, AV_LOG_ERROR, "Missing spherical video header\n");
         return 0;
     }
     version = avio_r8(pb);
     if (version != 0) {
         av_log(c->fc, AV_LOG_WARNING, "Unknown spherical version %d\n",
-               version);
+            version);
         return 0;
     }
     avio_skip(pb, 3); /* flags */
@@ -6794,7 +6827,7 @@ static int mov_read_sv3d(MOVContext *c, AVIOContext *pb, MOVAtom atom)
         return AVERROR_INVALIDDATA;
 
     tag = avio_rl32(pb);
-    if (tag != MKTAG('p','r','o','j')) {
+    if (tag != MKTAG('p', 'r', 'o', 'j')) {
         av_log(c->fc, AV_LOG_ERROR, "Missing projection box\n");
         return 0;
     }
@@ -6804,22 +6837,22 @@ static int mov_read_sv3d(MOVContext *c, AVIOContext *pb, MOVAtom atom)
         return AVERROR_INVALIDDATA;
 
     tag = avio_rl32(pb);
-    if (tag != MKTAG('p','r','h','d')) {
+    if (tag != MKTAG('p', 'r', 'h', 'd')) {
         av_log(c->fc, AV_LOG_ERROR, "Missing projection header box\n");
         return 0;
     }
     version = avio_r8(pb);
     if (version != 0) {
         av_log(c->fc, AV_LOG_WARNING, "Unknown spherical version %d\n",
-               version);
+            version);
         return 0;
     }
     avio_skip(pb, 3); /* flags */
 
     /* 16.16 fixed point */
-    yaw   = avio_rb32(pb);
+    yaw = avio_rb32(pb);
     pitch = avio_rb32(pb);
-    roll  = avio_rb32(pb);
+    roll = avio_rb32(pb);
 
     size = avio_rb32(pb);
     if (size > atom.size)
@@ -6829,22 +6862,22 @@ static int mov_read_sv3d(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     version = avio_r8(pb);
     if (version != 0) {
         av_log(c->fc, AV_LOG_WARNING, "Unknown spherical version %d\n",
-               version);
+            version);
         return 0;
     }
     avio_skip(pb, 3); /* flags */
     switch (tag) {
-    case MKTAG('c','b','m','p'):
+    case MKTAG('c', 'b', 'm', 'p'):
         layout = avio_rb32(pb);
         if (layout) {
             av_log(c->fc, AV_LOG_WARNING,
-                   "Unsupported cubemap layout %d\n", layout);
+                "Unsupported cubemap layout %d\n", layout);
             return 0;
         }
         projection = AV_SPHERICAL_CUBEMAP;
         padding = avio_rb32(pb);
         break;
-    case MKTAG('e','q','u','i'):
+    case MKTAG('e', 'q', 'u', 'i'):
         t = avio_rb32(pb);
         b = avio_rb32(pb);
         l = avio_rb32(pb);
@@ -6852,8 +6885,8 @@ static int mov_read_sv3d(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 
         if (b >= UINT_MAX - t || r >= UINT_MAX - l) {
             av_log(c->fc, AV_LOG_ERROR,
-                   "Invalid bounding rectangle coordinates "
-                   "%"PRIu32",%"PRIu32",%"PRIu32",%"PRIu32"\n", l, t, r, b);
+                "Invalid bounding rectangle coordinates "
+                "%"PRIu32",%"PRIu32",%"PRIu32",%"PRIu32"\n", l, t, r, b);
             return AVERROR_INVALIDDATA;
         }
 
@@ -6873,24 +6906,24 @@ static int mov_read_sv3d(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 
     sc->spherical->projection = projection;
 
-    sc->spherical->yaw   = yaw;
+    sc->spherical->yaw = yaw;
     sc->spherical->pitch = pitch;
-    sc->spherical->roll  = roll;
+    sc->spherical->roll = roll;
 
     sc->spherical->padding = padding;
 
-    sc->spherical->bound_left   = l;
-    sc->spherical->bound_top    = t;
-    sc->spherical->bound_right  = r;
+    sc->spherical->bound_left = l;
+    sc->spherical->bound_top = t;
+    sc->spherical->bound_right = r;
     sc->spherical->bound_bottom = b;
 
     return 0;
 }
 
-static int mov_read_vexu_proj(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_vexu_proj(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    AVStream *st;
-    MOVStreamContext *sc;
+    AVStream* st;
+    MOVStreamContext* sc;
     int size;
     uint32_t tag;
     enum AVSphericalProjection projection;
@@ -6901,53 +6934,45 @@ static int mov_read_vexu_proj(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     st = c->fc->streams[c->fc->nb_streams - 1];
     sc = st->priv_data;
 
-    if (atom.size < 16) {
+    if (atom.size != 16) {
         av_log(c->fc, AV_LOG_ERROR, "Invalid size for proj box: %"PRIu64"\n", atom.size);
         return AVERROR_INVALIDDATA;
     }
 
     size = avio_rb32(pb);
-    if (size < 16) {
+    if (size != 16) {
         av_log(c->fc, AV_LOG_ERROR, "Invalid size for prji box: %d\n", size);
         return AVERROR_INVALIDDATA;
-    } else if (size > 16) {
-        av_log(c->fc, AV_LOG_WARNING, "Box has more bytes (%d) than prji box required (16) \n", size);
     }
 
     tag = avio_rl32(pb);
-    if (tag != MKTAG('p','r','j','i')) {
-        av_log(c->fc, AV_LOG_ERROR, "Invalid child box of proj box: %s\n",
-               av_fourcc2str(tag));
+    if (tag != MKTAG('p', 'r', 'j', 'i')) {
+        av_log(c->fc, AV_LOG_ERROR, "Invalid child box of proj box: 0x%08X\n", tag);
         return AVERROR_INVALIDDATA;
     }
 
-     // version and flags, only support (0, 0)
-    unsigned n = avio_rl32(pb);
-    if (n != 0) {
-        av_log(c->fc, AV_LOG_ERROR, "prji version %u, flag %u are not supported\n",
-               n & 0xFF, n >> 8);
-        return AVERROR_PATCHWELCOME;
-    }
+    avio_skip(pb, 1); // version
+    avio_skip(pb, 3); // flags
 
     tag = avio_rl32(pb);
     switch (tag) {
-    case MKTAG('r','e','c','t'):
+    case MKTAG('r', 'e', 'c', 't'):
         projection = AV_SPHERICAL_RECTILINEAR;
         break;
-    case MKTAG('e','q','u','i'):
+    case MKTAG('e', 'q', 'u', 'i'):
         projection = AV_SPHERICAL_EQUIRECTANGULAR;
         break;
-    case MKTAG('h','e','q','u'):
+    case MKTAG('h', 'e', 'q', 'u'):
         projection = AV_SPHERICAL_HALF_EQUIRECTANGULAR;
         break;
-    case MKTAG('f','i','s','h'):
+    case MKTAG('f', 'i', 's', 'h'):
         projection = AV_SPHERICAL_FISHEYE;
         break;
-    case MKTAG('p','r','i','m'):
+    case MKTAG('p', 'r', 'i', 'm'):
         projection = AV_SPHERICAL_PARAMETRIC_IMMERSIVE;
         break;
     default:
-        av_log(c->fc, AV_LOG_ERROR, "Invalid projection type in prji box: %s\n", av_fourcc2str(tag));
+        av_log(c->fc, AV_LOG_ERROR, "Invalid projection type in prji box: 0x%08X\n", tag);
         return AVERROR_INVALIDDATA;
     }
 
@@ -6960,10 +6985,10 @@ static int mov_read_vexu_proj(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return 0;
 }
 
-static int mov_read_eyes(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_eyes(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    AVStream *st;
-    MOVStreamContext *sc;
+    AVStream* st;
+    MOVStreamContext* sc;
     int size, flags = 0;
     int64_t remaining;
     uint32_t tag, baseline = 0;
@@ -6981,14 +7006,14 @@ static int mov_read_eyes(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     remaining = atom.size;
     while (remaining > 0) {
         size = avio_rb32(pb);
-        if (size < 8 || size > remaining ) {
+        if (size < 8 || size > remaining) {
             av_log(c->fc, AV_LOG_ERROR, "Invalid child size in eyes box\n");
             return AVERROR_INVALIDDATA;
         }
 
         tag = avio_rl32(pb);
         switch (tag) {
-        case MKTAG('s','t','r','i'): {
+        case MKTAG('s', 't', 'r', 'i'): {
             int has_right, has_left;
             uint8_t tmp;
             if (size != 13) {
@@ -7023,7 +7048,7 @@ static int mov_read_eyes(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 
             break;
         }
-        case MKTAG('h','e','r','o'): {
+        case MKTAG('h', 'e', 'r', 'o'): {
             int tmp;
             if (size != 13) {
                 av_log(c->fc, AV_LOG_ERROR, "Invalid size of hero box: %d\n", size);
@@ -7044,7 +7069,7 @@ static int mov_read_eyes(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 
             break;
         }
-        case MKTAG('c','a','m','s'): {
+        case MKTAG('c', 'a', 'm', 's'): {
             uint32_t subtag;
             int subsize;
             if (size != 24) {
@@ -7059,9 +7084,8 @@ static int mov_read_eyes(MOVContext *c, AVIOContext *pb, MOVAtom atom)
             }
 
             subtag = avio_rl32(pb);
-            if (subtag != MKTAG('b','l','i','n')) {
-                av_log(c->fc, AV_LOG_ERROR, "Expected blin box, got %s\n",
-                       av_fourcc2str(subtag));
+            if (subtag != MKTAG('b', 'l', 'i', 'n')) {
+                av_log(c->fc, AV_LOG_ERROR, "Expected blin box, got 0x%08X\n", subtag);
                 return AVERROR_INVALIDDATA;
             }
 
@@ -7072,7 +7096,7 @@ static int mov_read_eyes(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 
             break;
         }
-        case MKTAG('c','m','f','y'): {
+        case MKTAG('c', 'm', 'f', 'y'): {
             uint32_t subtag;
             int subsize;
             int32_t adjustment;
@@ -7088,25 +7112,23 @@ static int mov_read_eyes(MOVContext *c, AVIOContext *pb, MOVAtom atom)
             }
 
             subtag = avio_rl32(pb);
-            if (subtag != MKTAG('d','a','d','j')) {
-                av_log(c->fc, AV_LOG_ERROR, "Expected dadj box, got %s\n",
-                       av_fourcc2str(subtag));
+            if (subtag != MKTAG('d', 'a', 'd', 'j')) {
+                av_log(c->fc, AV_LOG_ERROR, "Expected dadj box, got 0x%08X\n", subtag);
                 return AVERROR_INVALIDDATA;
             }
 
             avio_skip(pb, 1); // version
             avio_skip(pb, 3); // flags
 
-            adjustment = (int32_t) avio_rb32(pb);
+            adjustment = (int32_t)avio_rb32(pb);
 
-            horizontal_disparity_adjustment.num = (int) adjustment;
+            horizontal_disparity_adjustment.num = (int)adjustment;
             horizontal_disparity_adjustment.den = 10000;
 
             break;
         }
         default:
-            av_log(c->fc, AV_LOG_WARNING, "Unknown tag in eyes: %s\n",
-                   av_fourcc2str(tag));
+            av_log(c->fc, AV_LOG_WARNING, "Unknown tag in eyes: 0x%08X\n", tag);
             avio_skip(pb, size - 8);
             break;
         }
@@ -7127,17 +7149,17 @@ static int mov_read_eyes(MOVContext *c, AVIOContext *pb, MOVAtom atom)
             return AVERROR(ENOMEM);
     }
 
-    sc->stereo3d->flags                           = flags;
-    sc->stereo3d->type                            = type;
-    sc->stereo3d->view                            = view;
-    sc->stereo3d->primary_eye                     = primary_eye;
-    sc->stereo3d->baseline                        = baseline;
+    sc->stereo3d->flags = flags;
+    sc->stereo3d->type = type;
+    sc->stereo3d->view = view;
+    sc->stereo3d->primary_eye = primary_eye;
+    sc->stereo3d->baseline = baseline;
     sc->stereo3d->horizontal_disparity_adjustment = horizontal_disparity_adjustment;
 
     return 0;
 }
 
-static int mov_read_vexu(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_vexu(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
     int size;
     int64_t remaining;
@@ -7154,28 +7176,28 @@ static int mov_read_vexu(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     remaining = atom.size;
     while (remaining > 0) {
         size = avio_rb32(pb);
-        if (size < 8 || size > remaining ) {
+        if (size < 8 || size > remaining) {
             av_log(c->fc, AV_LOG_ERROR, "Invalid child size in vexu box\n");
             return AVERROR_INVALIDDATA;
         }
 
         tag = avio_rl32(pb);
         switch (tag) {
-        case MKTAG('p','r','o','j'): {
+        case MKTAG('p', 'r', 'o', 'j'): {
             MOVAtom proj = { tag, size - 8 };
             int ret = mov_read_vexu_proj(c, pb, proj);
             if (ret < 0)
                 return ret;
             break;
         }
-        case MKTAG('e','y','e','s'): {
+        case MKTAG('e', 'y', 'e', 's'): {
             MOVAtom eyes = { tag, size - 8 };
             int ret = mov_read_eyes(c, pb, eyes);
             if (ret < 0)
                 return ret;
             break;
         }
-        case MKTAG('p','a','c','k'): {
+        case MKTAG('p', 'a', 'c', 'k'): {
             MOVAtom pack = { tag, size - 8 };
             int ret = mov_read_pack(c, pb, pack);
             if (ret < 0)
@@ -7183,8 +7205,7 @@ static int mov_read_vexu(MOVContext *c, AVIOContext *pb, MOVAtom atom)
             break;
         }
         default:
-            av_log(c->fc, AV_LOG_WARNING, "Unknown tag in vexu: %s\n",
-                   av_fourcc2str(tag));
+            av_log(c->fc, AV_LOG_WARNING, "Unknown tag in vexu: 0x%08X\n", tag);
             avio_skip(pb, size - 8);
             break;
         }
@@ -7199,10 +7220,10 @@ static int mov_read_vexu(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return 0;
 }
 
-static int mov_read_hfov(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_hfov(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    AVStream *st;
-    MOVStreamContext *sc;
+    AVStream* st;
+    MOVStreamContext* sc;
 
     if (c->fc->nb_streams < 1)
         return 0;
@@ -7211,8 +7232,8 @@ static int mov_read_hfov(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     sc = st->priv_data;
 
     if (atom.size != 4) {
-         av_log(c->fc, AV_LOG_ERROR, "Invalid size of hfov box: %"PRIu64"\n", atom.size);
-         return AVERROR_INVALIDDATA;
+        av_log(c->fc, AV_LOG_ERROR, "Invalid size of hfov box: %"PRIu64"\n", atom.size);
+        return AVERROR_INVALIDDATA;
     }
 
 
@@ -7228,11 +7249,11 @@ static int mov_read_hfov(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return 0;
 }
 
-static int mov_parse_uuid_spherical(MOVStreamContext *sc, AVIOContext *pb, size_t len)
+static int mov_parse_uuid_spherical(MOVStreamContext* sc, AVIOContext* pb, size_t len)
 {
     int ret = 0;
-    uint8_t *buffer = av_malloc(len + 1);
-    const char *val;
+    uint8_t* buffer = av_malloc(len + 1);
+    const char* val;
 
     if (!buffer)
         return AVERROR(ENOMEM);
@@ -7291,10 +7312,10 @@ out:
     return ret;
 }
 
-static int mov_read_uuid(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_uuid(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    AVStream *st;
-    MOVStreamContext *sc;
+    AVStream* st;
+    MOVStreamContext* sc;
     int64_t ret;
     AVUUID uuid;
     static const AVUUID uuid_isml_manifest = {
@@ -7322,8 +7343,8 @@ static int mov_read_uuid(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     if (ret < 0)
         return ret;
     if (av_uuid_equal(uuid, uuid_isml_manifest)) {
-        uint8_t *buffer, *ptr;
-        char *endptr;
+        uint8_t* buffer, * ptr;
+        char* endptr;
         size_t len = atom.size - AV_UUID_LEN;
 
         if (len < 4) {
@@ -7356,14 +7377,16 @@ static int mov_read_uuid(MOVContext *c, AVIOContext *pb, MOVAtom atom)
             ret = strtol(ptr, &endptr, 10);
             if (ret < 0 || errno || *endptr != '"') {
                 c->bitrates[c->bitrates_count - 1] = 0;
-            } else {
+            }
+            else {
                 c->bitrates[c->bitrates_count - 1] = ret;
             }
         }
 
         av_free(buffer);
-    } else if (av_uuid_equal(uuid, uuid_xmp)) {
-        uint8_t *buffer;
+    }
+    else if (av_uuid_equal(uuid, uuid_xmp)) {
+        uint8_t* buffer;
         size_t len = atom.size - AV_UUID_LEN;
         if (c->export_xmp) {
             buffer = av_mallocz(len + 1);
@@ -7377,14 +7400,16 @@ static int mov_read_uuid(MOVContext *c, AVIOContext *pb, MOVAtom atom)
             }
             buffer[len] = '\0';
             av_dict_set(&c->fc->metadata, "xmp",
-                        buffer, AV_DICT_DONT_STRDUP_VAL);
-        } else {
+                buffer, AV_DICT_DONT_STRDUP_VAL);
+        }
+        else {
             // skip all uuid atom, which makes it fast for long uuid-xmp file
             ret = avio_skip(pb, len);
             if (ret < 0)
                 return ret;
         }
-    } else if (av_uuid_equal(uuid, uuid_spherical)) {
+    }
+    else if (av_uuid_equal(uuid, uuid_spherical)) {
         size_t len = atom.size - AV_UUID_LEN;
         ret = mov_parse_uuid_spherical(sc, pb, len);
         if (ret < 0)
@@ -7396,7 +7421,7 @@ static int mov_read_uuid(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return 0;
 }
 
-static int mov_read_free(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_free(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
     int ret;
     uint8_t content[16];
@@ -7408,7 +7433,7 @@ static int mov_read_free(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     if (ret < 0)
         return ret;
 
-    if (   !c->found_moov
+    if (!c->found_moov
         && !c->found_mdat
         && !memcmp(content, "Anevia\x1A\x1A", 8)
         && c->use_mfra_for == FF_MOV_FLAG_MFRA_AUTO) {
@@ -7418,12 +7443,12 @@ static int mov_read_free(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return 0;
 }
 
-static int mov_read_frma(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_frma(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
     uint32_t format = avio_rl32(pb);
-    MOVStreamContext *sc;
+    MOVStreamContext* sc;
     enum AVCodecID id;
-    AVStream *st;
+    AVStream* st;
 
     if (c->fc->nb_streams < 1)
         return 0;
@@ -7432,14 +7457,14 @@ static int mov_read_frma(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 
     switch (sc->format)
     {
-    case MKTAG('e','n','c','v'):        // encrypted video
-    case MKTAG('e','n','c','a'):        // encrypted audio
+    case MKTAG('e', 'n', 'c', 'v'):        // encrypted video
+    case MKTAG('e', 'n', 'c', 'a'):        // encrypted audio
         id = mov_codec_id(st, format);
         if (st->codecpar->codec_id != AV_CODEC_ID_NONE &&
             st->codecpar->codec_id != id) {
             av_log(c->fc, AV_LOG_WARNING,
-                   "ignoring 'frma' atom of '%.4s', stream has codec id %d\n",
-                   (char*)&format, st->codecpar->codec_id);
+                "ignoring 'frma' atom of '%.4s', stream has codec id %d\n",
+                (char*)&format, st->codecpar->codec_id);
             break;
         }
 
@@ -7450,8 +7475,8 @@ static int mov_read_frma(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     default:
         if (format != sc->format) {
             av_log(c->fc, AV_LOG_WARNING,
-                   "ignoring 'frma' atom of '%.4s', stream format is '%.4s'\n",
-                   (char*)&format, (char*)&sc->format);
+                "ignoring 'frma' atom of '%.4s', stream format is '%.4s'\n",
+                (char*)&format, (char*)&sc->format);
         }
         break;
     }
@@ -7465,10 +7490,10 @@ static int mov_read_frma(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  * info for this fragment; otherwise this will return the global encryption
  * info for the current stream.
  */
-static int get_current_encryption_info(MOVContext *c, MOVEncryptionIndex **encryption_index, MOVStreamContext **sc)
+static int get_current_encryption_info(MOVContext* c, MOVEncryptionIndex** encryption_index, MOVStreamContext** sc)
 {
-    MOVFragmentStreamInfo *frag_stream_info;
-    AVStream *st;
+    MOVFragmentStreamInfo* frag_stream_info;
+    AVStream* st;
     int i;
 
     frag_stream_info = get_current_frag_stream_info(&c->frag_index);
@@ -7476,8 +7501,8 @@ static int get_current_encryption_info(MOVContext *c, MOVEncryptionIndex **encry
         for (i = 0; i < c->fc->nb_streams; i++) {
             *sc = c->fc->streams[i]->priv_data;
             if ((*sc)->id == frag_stream_info->id) {
-              st = c->fc->streams[i];
-              break;
+                st = c->fc->streams[i];
+                break;
             }
         }
         if (i == c->fc->nb_streams)
@@ -7494,7 +7519,8 @@ static int get_current_encryption_info(MOVContext *c, MOVEncryptionIndex **encry
         }
         *encryption_index = frag_stream_info->encryption_index;
         return 1;
-    } else {
+    }
+    else {
         // No current track fragment, using stream level encryption info.
 
         if (c->fc->nb_streams < 1)
@@ -7516,11 +7542,11 @@ static int get_current_encryption_info(MOVContext *c, MOVEncryptionIndex **encry
     }
 }
 
-static int mov_read_sample_encryption_info(MOVContext *c, AVIOContext *pb, MOVStreamContext *sc, AVEncryptionInfo **sample, int use_subsamples)
+static int mov_read_sample_encryption_info(MOVContext* c, AVIOContext* pb, MOVStreamContext* sc, AVEncryptionInfo** sample, int use_subsamples)
 {
     int i, ret;
     unsigned int subsample_count;
-    AVSubsampleEncryptionInfo *subsamples;
+    AVSubsampleEncryptionInfo* subsamples;
 
     if (!sc->cenc.default_encrypted_sample) {
         av_log(c->fc, AV_LOG_ERROR, "Missing schm or tenc\n");
@@ -7531,7 +7557,8 @@ static int mov_read_sample_encryption_info(MOVContext *c, AVIOContext *pb, MOVSt
         *sample = av_encryption_info_clone(sc->cenc.default_encrypted_sample);
         if (!*sample)
             return AVERROR(ENOMEM);
-    } else
+    }
+    else
         *sample = NULL;
 
     if (sc->cenc.per_sample_iv_size != 0) {
@@ -7570,11 +7597,11 @@ static int mov_read_sample_encryption_info(MOVContext *c, AVIOContext *pb, MOVSt
     return 0;
 }
 
-static int mov_read_senc(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_senc(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    AVEncryptionInfo **encrypted_samples;
-    MOVEncryptionIndex *encryption_index;
-    MOVStreamContext *sc;
+    AVEncryptionInfo** encrypted_samples;
+    MOVEncryptionIndex* encryption_index;
+    MOVStreamContext* sc;
     int use_subsamples, ret;
     unsigned int sample_count, i, alloc_size = 0;
 
@@ -7598,13 +7625,14 @@ static int mov_read_senc(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     for (i = 0; i < sample_count; i++) {
         unsigned int min_samples = FFMIN(FFMAX(i + 1, 1024 * 1024), sample_count);
         encrypted_samples = av_fast_realloc(encryption_index->encrypted_samples, &alloc_size,
-                                            min_samples * sizeof(*encrypted_samples));
+            min_samples * sizeof(*encrypted_samples));
         if (encrypted_samples) {
             encryption_index->encrypted_samples = encrypted_samples;
 
             ret = mov_read_sample_encryption_info(
                 c, pb, sc, &encryption_index->encrypted_samples[i], use_subsamples);
-        } else {
+        }
+        else {
             ret = AVERROR(ENOMEM);
         }
         if (pb->eof_reached) {
@@ -7626,9 +7654,9 @@ static int mov_read_senc(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return 0;
 }
 
-static int mov_parse_auxiliary_info(MOVContext *c, MOVStreamContext *sc, AVIOContext *pb, MOVEncryptionIndex *encryption_index)
+static int mov_parse_auxiliary_info(MOVContext* c, MOVStreamContext* sc, AVIOContext* pb, MOVEncryptionIndex* encryption_index)
 {
-    AVEncryptionInfo **sample, **encrypted_samples;
+    AVEncryptionInfo** sample, ** encrypted_samples;
     int64_t prev_pos;
     size_t sample_count, sample_info_size, i;
     int ret = 0;
@@ -7654,7 +7682,7 @@ static int mov_parse_auxiliary_info(MOVContext *c, MOVStreamContext *sc, AVIOCon
     for (i = 0; i < sample_count && !pb->eof_reached; i++) {
         unsigned int min_samples = FFMIN(FFMAX(i + 1, 1024 * 1024), sample_count);
         encrypted_samples = av_fast_realloc(encryption_index->encrypted_samples, &alloc_size,
-                                            min_samples * sizeof(*encrypted_samples));
+            min_samples * sizeof(*encrypted_samples));
         if (!encrypted_samples) {
             ret = AVERROR(ENOMEM);
             goto finish;
@@ -7663,8 +7691,8 @@ static int mov_parse_auxiliary_info(MOVContext *c, MOVStreamContext *sc, AVIOCon
 
         sample = &encryption_index->encrypted_samples[i];
         sample_info_size = encryption_index->auxiliary_info_default_size
-                               ? encryption_index->auxiliary_info_default_size
-                               : encryption_index->auxiliary_info_sizes[i];
+            ? encryption_index->auxiliary_info_default_size
+            : encryption_index->auxiliary_info_sizes[i];
 
         ret = mov_read_sample_encryption_info(c, pb, sc, sample, sample_info_size > sc->cenc.per_sample_iv_size);
         if (ret < 0)
@@ -7673,7 +7701,8 @@ static int mov_parse_auxiliary_info(MOVContext *c, MOVStreamContext *sc, AVIOCon
     if (pb->eof_reached) {
         av_log(c->fc, AV_LOG_ERROR, "Hit EOF while reading auxiliary info\n");
         ret = AVERROR_INVALIDDATA;
-    } else {
+    }
+    else {
         encryption_index->nb_encrypted_samples = sample_count;
     }
 
@@ -7688,10 +7717,10 @@ finish:
     return ret;
 }
 
-static int mov_read_saiz(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_saiz(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    MOVEncryptionIndex *encryption_index;
-    MOVStreamContext *sc;
+    MOVEncryptionIndex* encryption_index;
+    MOVStreamContext* sc;
     int ret;
     unsigned int sample_count, aux_info_type, aux_info_param;
 
@@ -7723,20 +7752,23 @@ static int mov_read_saiz(MOVContext *c, AVIOContext *pb, MOVAtom atom)
                 av_log(c->fc, AV_LOG_DEBUG, "Ignoring saiz box with non-zero aux_info_type_parameter\n");
                 return 0;
             }
-        } else {
+        }
+        else {
             // Didn't see 'schm' or 'tenc', so this isn't encrypted.
-            if ((aux_info_type == MKBETAG('c','e','n','c') ||
-                 aux_info_type == MKBETAG('c','e','n','s') ||
-                 aux_info_type == MKBETAG('c','b','c','1') ||
-                 aux_info_type == MKBETAG('c','b','c','s')) &&
+            if ((aux_info_type == MKBETAG('c', 'e', 'n', 'c') ||
+                aux_info_type == MKBETAG('c', 'e', 'n', 's') ||
+                aux_info_type == MKBETAG('c', 'b', 'c', '1') ||
+                aux_info_type == MKBETAG('c', 'b', 'c', 's')) &&
                 aux_info_param == 0) {
                 av_log(c->fc, AV_LOG_ERROR, "Saw encrypted saiz without schm/tenc\n");
                 return AVERROR_INVALIDDATA;
-            } else {
+            }
+            else {
                 return 0;
             }
         }
-    } else if (!sc->cenc.default_encrypted_sample) {
+    }
+    else if (!sc->cenc.default_encrypted_sample) {
         // Didn't see 'schm' or 'tenc', so this isn't encrypted.
         return 0;
     }
@@ -7759,7 +7791,7 @@ static int mov_read_saiz(MOVContext *c, AVIOContext *pb, MOVAtom atom)
             if (ret >= 0)
                 ret = AVERROR_INVALIDDATA;
             av_log(c->fc, AV_LOG_ERROR, "Failed to read the auxiliary info, %s\n",
-                   av_err2str(ret));
+                av_err2str(ret));
             return ret;
         }
     }
@@ -7772,11 +7804,11 @@ static int mov_read_saiz(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return 0;
 }
 
-static int mov_read_saio(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_saio(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    uint64_t *auxiliary_offsets;
-    MOVEncryptionIndex *encryption_index;
-    MOVStreamContext *sc;
+    uint64_t* auxiliary_offsets;
+    MOVEncryptionIndex* encryption_index;
+    MOVStreamContext* sc;
     int i, ret;
     unsigned int version, entry_count, aux_info_type, aux_info_param;
     unsigned int alloc_size = 0;
@@ -7809,20 +7841,23 @@ static int mov_read_saio(MOVContext *c, AVIOContext *pb, MOVAtom atom)
                 av_log(c->fc, AV_LOG_DEBUG, "Ignoring saio box with non-zero aux_info_type_parameter\n");
                 return 0;
             }
-        } else {
+        }
+        else {
             // Didn't see 'schm' or 'tenc', so this isn't encrypted.
-            if ((aux_info_type == MKBETAG('c','e','n','c') ||
-                 aux_info_type == MKBETAG('c','e','n','s') ||
-                 aux_info_type == MKBETAG('c','b','c','1') ||
-                 aux_info_type == MKBETAG('c','b','c','s')) &&
+            if ((aux_info_type == MKBETAG('c', 'e', 'n', 'c') ||
+                aux_info_type == MKBETAG('c', 'e', 'n', 's') ||
+                aux_info_type == MKBETAG('c', 'b', 'c', '1') ||
+                aux_info_type == MKBETAG('c', 'b', 'c', 's')) &&
                 aux_info_param == 0) {
                 av_log(c->fc, AV_LOG_ERROR, "Saw encrypted saio without schm/tenc\n");
                 return AVERROR_INVALIDDATA;
-            } else {
+            }
+            else {
                 return 0;
             }
         }
-    } else if (!sc->cenc.default_encrypted_sample) {
+    }
+    else if (!sc->cenc.default_encrypted_sample) {
         // Didn't see 'schm' or 'tenc', so this isn't encrypted.
         return 0;
     }
@@ -7844,7 +7879,8 @@ static int mov_read_saio(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 
         if (version == 0) {
             encryption_index->auxiliary_offsets[i] = avio_rb32(pb);
-        } else {
+        }
+        else {
             encryption_index->auxiliary_offsets[i] = avio_rb64(pb);
         }
         if (c->frag_index.current >= 0) {
@@ -7867,26 +7903,26 @@ static int mov_read_saio(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return 0;
 }
 
-static int mov_read_pssh(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_pssh(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    AVEncryptionInitInfo *info, *old_init_info;
-    uint8_t **key_ids;
-    AVStream *st;
-    const AVPacketSideData *old_side_data;
-    uint8_t *side_data, *extra_data;
+    AVEncryptionInitInfo* info, * old_init_info;
+    uint8_t** key_ids;
+    AVStream* st;
+    const AVPacketSideData* old_side_data;
+    uint8_t* side_data, * extra_data;
     size_t side_data_size;
     int ret = 0;
     unsigned int version, kid_count, extra_data_size, alloc_size = 0;
 
     if (c->fc->nb_streams < 1)
         return 0;
-    st = c->fc->streams[c->fc->nb_streams-1];
+    st = c->fc->streams[c->fc->nb_streams - 1];
 
     version = avio_r8(pb); /* version */
     avio_rb24(pb);  /* flags */
 
     info = av_encryption_init_info_alloc(/* system_id_size */ 16, /* num_key_ids */ 0,
-                                         /* key_id_size */ 16, /* data_size */ 0);
+        /* key_id_size */ 16, /* data_size */ 0);
     if (!info)
         return AVERROR(ENOMEM);
 
@@ -7905,7 +7941,7 @@ static int mov_read_pssh(MOVContext *c, AVIOContext *pb, MOVAtom atom)
         for (unsigned int i = 0; i < kid_count && !pb->eof_reached; i++) {
             unsigned int min_kid_count = FFMIN(FFMAX(i + 1, 1024), kid_count);
             key_ids = av_fast_realloc(info->key_ids, &alloc_size,
-                                      min_kid_count * sizeof(*key_ids));
+                min_kid_count * sizeof(*key_ids));
             if (!key_ids) {
                 ret = AVERROR(ENOMEM);
                 goto finish;
@@ -7953,19 +7989,20 @@ static int mov_read_pssh(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 
     // If there is existing initialization data, append to the list.
     old_side_data = av_packet_side_data_get(st->codecpar->coded_side_data, st->codecpar->nb_coded_side_data,
-                                            AV_PKT_DATA_ENCRYPTION_INIT_INFO);
+        AV_PKT_DATA_ENCRYPTION_INIT_INFO);
     if (old_side_data) {
         old_init_info = av_encryption_init_info_get_side_data(old_side_data->data, old_side_data->size);
         if (old_init_info) {
             // Append to the end of the list.
-            for (AVEncryptionInitInfo *cur = old_init_info;; cur = cur->next) {
+            for (AVEncryptionInitInfo* cur = old_init_info;; cur = cur->next) {
                 if (!cur->next) {
                     cur->next = info;
                     break;
                 }
             }
             info = old_init_info;
-        } else {
+        }
+        else {
             // Assume existing side-data will be valid, so the only error we could get is OOM.
             ret = AVERROR(ENOMEM);
             goto finish;
@@ -7978,9 +8015,9 @@ static int mov_read_pssh(MOVContext *c, AVIOContext *pb, MOVAtom atom)
         goto finish;
     }
     if (!av_packet_side_data_add(&st->codecpar->coded_side_data,
-                                 &st->codecpar->nb_coded_side_data,
-                                 AV_PKT_DATA_ENCRYPTION_INIT_INFO,
-                                 side_data, side_data_size, 0))
+        &st->codecpar->nb_coded_side_data,
+        AV_PKT_DATA_ENCRYPTION_INIT_INFO,
+        side_data, side_data_size, 0))
         av_free(side_data);
 
 finish:
@@ -7988,14 +8025,14 @@ finish:
     return ret;
 }
 
-static int mov_read_schm(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_schm(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    AVStream *st;
-    MOVStreamContext *sc;
+    AVStream* st;
+    MOVStreamContext* sc;
 
     if (c->fc->nb_streams < 1)
         return 0;
-    st = c->fc->streams[c->fc->nb_streams-1];
+    st = c->fc->streams[c->fc->nb_streams - 1];
     sc = st->priv_data;
 
     if (sc->pseudo_stream_id != 0) {
@@ -8019,15 +8056,15 @@ static int mov_read_schm(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return 0;
 }
 
-static int mov_read_tenc(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_tenc(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    AVStream *st;
-    MOVStreamContext *sc;
+    AVStream* st;
+    MOVStreamContext* sc;
     unsigned int version, pattern, is_protected, iv_size;
 
     if (c->fc->nb_streams < 1)
         return 0;
-    st = c->fc->streams[c->fc->nb_streams-1];
+    st = c->fc->streams[c->fc->nb_streams - 1];
     sc = st->priv_data;
 
     if (sc->pseudo_stream_id != 0) {
@@ -8090,17 +8127,17 @@ static int mov_read_tenc(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return 0;
 }
 
-static int mov_read_dfla(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_dfla(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    AVStream *st;
+    AVStream* st;
     int last, type, size, ret;
     uint8_t buf[4];
 
     if (c->fc->nb_streams < 1)
         return 0;
-    st = c->fc->streams[c->fc->nb_streams-1];
+    st = c->fc->streams[c->fc->nb_streams - 1];
 
-    if ((uint64_t)atom.size > (1<<30) || atom.size < 42)
+    if ((uint64_t)atom.size > (1 << 30) || atom.size < 42)
         return AVERROR_INVALIDDATA;
 
     /* Check FlacSpecificBox version. */
@@ -8130,7 +8167,7 @@ static int mov_read_dfla(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return 0;
 }
 
-static int cenc_scheme_decrypt(MOVContext *c, MOVStreamContext *sc, AVEncryptionInfo *sample, uint8_t *input, int size)
+static int cenc_scheme_decrypt(MOVContext* c, MOVStreamContext* sc, AVEncryptionInfo* sample, uint8_t* input, int size)
 {
     int i, ret;
     int bytes_of_protected_data;
@@ -8183,7 +8220,7 @@ static int cenc_scheme_decrypt(MOVContext *c, MOVStreamContext *sc, AVEncryption
     return 0;
 }
 
-static int cbc1_scheme_decrypt(MOVContext *c, MOVStreamContext *sc, AVEncryptionInfo *sample, uint8_t *input, int size)
+static int cbc1_scheme_decrypt(MOVContext* c, MOVStreamContext* sc, AVEncryptionInfo* sample, uint8_t* input, int size)
 {
     int i, ret;
     int num_of_encrypted_blocks;
@@ -8207,7 +8244,7 @@ static int cbc1_scheme_decrypt(MOVContext *c, MOVStreamContext *sc, AVEncryption
     /* whole-block full sample encryption */
     if (!sample->subsample_count) {
         /* decrypt the whole packet */
-        av_aes_crypt(sc->cenc.aes_ctx, input, input, size/16, iv, 1);
+        av_aes_crypt(sc->cenc.aes_ctx, input, input, size / 16, iv, 1);
         return 0;
     }
 
@@ -8227,7 +8264,7 @@ static int cbc1_scheme_decrypt(MOVContext *c, MOVStreamContext *sc, AVEncryption
         size -= sample->subsamples[i].bytes_of_clear_data;
 
         /* decrypt the encrypted bytes */
-        num_of_encrypted_blocks = sample->subsamples[i].bytes_of_protected_data/16;
+        num_of_encrypted_blocks = sample->subsamples[i].bytes_of_protected_data / 16;
         if (num_of_encrypted_blocks > 0) {
             av_aes_crypt(sc->cenc.aes_ctx, input, input, num_of_encrypted_blocks, iv, 1);
         }
@@ -8243,10 +8280,10 @@ static int cbc1_scheme_decrypt(MOVContext *c, MOVStreamContext *sc, AVEncryption
     return 0;
 }
 
-static int cens_scheme_decrypt(MOVContext *c, MOVStreamContext *sc, AVEncryptionInfo *sample, uint8_t *input, int size)
+static int cens_scheme_decrypt(MOVContext* c, MOVStreamContext* sc, AVEncryptionInfo* sample, uint8_t* input, int size)
 {
     int i, ret, rem_bytes;
-    uint8_t *data;
+    uint8_t* data;
 
     if (!sc->cenc.aes_ctr) {
         /* initialize the cipher */
@@ -8268,7 +8305,8 @@ static int cens_scheme_decrypt(MOVContext *c, MOVStreamContext *sc, AVEncryption
         /* decrypt the whole packet */
         av_aes_ctr_crypt(sc->cenc.aes_ctr, input, input, size);
         return 0;
-    } else if (!sample->crypt_byte_block && !sample->skip_byte_block) {
+    }
+    else if (!sample->crypt_byte_block && !sample->skip_byte_block) {
         av_log(c->fc, AV_LOG_ERROR, "pattern encryption is not present in 'cens' scheme\n");
         return AVERROR_INVALIDDATA;
     }
@@ -8287,14 +8325,14 @@ static int cens_scheme_decrypt(MOVContext *c, MOVStreamContext *sc, AVEncryption
         data = input;
         rem_bytes = sample->subsamples[i].bytes_of_protected_data;
         while (rem_bytes > 0) {
-            if (rem_bytes < 16*sample->crypt_byte_block) {
+            if (rem_bytes < 16 * sample->crypt_byte_block) {
                 break;
             }
-            av_aes_ctr_crypt(sc->cenc.aes_ctr, data, data, 16*sample->crypt_byte_block);
-            data += 16*sample->crypt_byte_block;
-            rem_bytes -= 16*sample->crypt_byte_block;
-            data += FFMIN(16*sample->skip_byte_block, rem_bytes);
-            rem_bytes -= FFMIN(16*sample->skip_byte_block, rem_bytes);
+            av_aes_ctr_crypt(sc->cenc.aes_ctr, data, data, 16 * sample->crypt_byte_block);
+            data += 16 * sample->crypt_byte_block;
+            rem_bytes -= 16 * sample->crypt_byte_block;
+            data += FFMIN(16 * sample->skip_byte_block, rem_bytes);
+            rem_bytes -= FFMIN(16 * sample->skip_byte_block, rem_bytes);
         }
         input += sample->subsamples[i].bytes_of_protected_data;
         size -= sample->subsamples[i].bytes_of_protected_data;
@@ -8308,11 +8346,11 @@ static int cens_scheme_decrypt(MOVContext *c, MOVStreamContext *sc, AVEncryption
     return 0;
 }
 
-static int cbcs_scheme_decrypt(MOVContext *c, MOVStreamContext *sc, AVEncryptionInfo *sample, uint8_t *input, int size)
+static int cbcs_scheme_decrypt(MOVContext* c, MOVStreamContext* sc, AVEncryptionInfo* sample, uint8_t* input, int size)
 {
     int i, ret, rem_bytes;
     uint8_t iv[16];
-    uint8_t *data;
+    uint8_t* data;
 
     if (!sc->cenc.aes_ctx) {
         /* initialize the cipher */
@@ -8331,9 +8369,10 @@ static int cbcs_scheme_decrypt(MOVContext *c, MOVStreamContext *sc, AVEncryption
     if (!sample->subsample_count) {
         /* decrypt the whole packet */
         memcpy(iv, sample->iv, 16);
-        av_aes_crypt(sc->cenc.aes_ctx, input, input, size/16, iv, 1);
+        av_aes_crypt(sc->cenc.aes_ctx, input, input, size / 16, iv, 1);
         return 0;
-    } else if (!sample->crypt_byte_block && !sample->skip_byte_block) {
+    }
+    else if (!sample->crypt_byte_block && !sample->skip_byte_block) {
         av_log(c->fc, AV_LOG_ERROR, "pattern encryption is not present in 'cbcs' scheme\n");
         return AVERROR_INVALIDDATA;
     }
@@ -8353,14 +8392,14 @@ static int cbcs_scheme_decrypt(MOVContext *c, MOVStreamContext *sc, AVEncryption
         data = input;
         rem_bytes = sample->subsamples[i].bytes_of_protected_data;
         while (rem_bytes > 0) {
-            if (rem_bytes < 16*sample->crypt_byte_block) {
+            if (rem_bytes < 16 * sample->crypt_byte_block) {
                 break;
             }
             av_aes_crypt(sc->cenc.aes_ctx, data, data, sample->crypt_byte_block, iv, 1);
-            data += 16*sample->crypt_byte_block;
-            rem_bytes -= 16*sample->crypt_byte_block;
-            data += FFMIN(16*sample->skip_byte_block, rem_bytes);
-            rem_bytes -= FFMIN(16*sample->skip_byte_block, rem_bytes);
+            data += 16 * sample->crypt_byte_block;
+            rem_bytes -= 16 * sample->crypt_byte_block;
+            data += FFMIN(16 * sample->skip_byte_block, rem_bytes);
+            rem_bytes -= FFMIN(16 * sample->skip_byte_block, rem_bytes);
         }
         input += sample->subsamples[i].bytes_of_protected_data;
         size -= sample->subsamples[i].bytes_of_protected_data;
@@ -8374,23 +8413,27 @@ static int cbcs_scheme_decrypt(MOVContext *c, MOVStreamContext *sc, AVEncryption
     return 0;
 }
 
-static int cenc_decrypt(MOVContext *c, MOVStreamContext *sc, AVEncryptionInfo *sample, uint8_t *input, int size)
+static int cenc_decrypt(MOVContext* c, MOVStreamContext* sc, AVEncryptionInfo* sample, uint8_t* input, int size)
 {
-    if (sample->scheme == MKBETAG('c','e','n','c') && !sample->crypt_byte_block && !sample->skip_byte_block) {
+    if (sample->scheme == MKBETAG('c', 'e', 'n', 'c') && !sample->crypt_byte_block && !sample->skip_byte_block) {
         return cenc_scheme_decrypt(c, sc, sample, input, size);
-    } else if (sample->scheme == MKBETAG('c','b','c','1') && !sample->crypt_byte_block && !sample->skip_byte_block) {
+    }
+    else if (sample->scheme == MKBETAG('c', 'b', 'c', '1') && !sample->crypt_byte_block && !sample->skip_byte_block) {
         return cbc1_scheme_decrypt(c, sc, sample, input, size);
-    } else if (sample->scheme == MKBETAG('c','e','n','s')) {
+    }
+    else if (sample->scheme == MKBETAG('c', 'e', 'n', 's')) {
         return cens_scheme_decrypt(c, sc, sample, input, size);
-    } else if (sample->scheme == MKBETAG('c','b','c','s')) {
+    }
+    else if (sample->scheme == MKBETAG('c', 'b', 'c', 's')) {
         return cbcs_scheme_decrypt(c, sc, sample, input, size);
-    } else {
+    }
+    else {
         av_log(c->fc, AV_LOG_ERROR, "invalid encryption scheme\n");
         return AVERROR_INVALIDDATA;
     }
 }
 
-static MOVFragmentStreamInfo *get_frag_stream_info_from_pkt(MOVFragmentIndex *frag_index, AVPacket *pkt, int id)
+static MOVFragmentStreamInfo* get_frag_stream_info_from_pkt(MOVFragmentIndex* frag_index, AVPacket* pkt, int id)
 {
     int current = frag_index->current;
 
@@ -8401,7 +8444,7 @@ static MOVFragmentStreamInfo *get_frag_stream_info_from_pkt(MOVFragmentIndex *fr
     if (current >= 0 && current < frag_index->nb_items) {
         if (frag_index->item[current].moof_offset < pkt->pos &&
             (current + 1 == frag_index->nb_items ||
-             frag_index->item[current + 1].moof_offset > pkt->pos))
+                frag_index->item[current + 1].moof_offset > pkt->pos))
             return get_frag_stream_info(frag_index, current, id);
     }
 
@@ -8415,11 +8458,11 @@ static MOVFragmentStreamInfo *get_frag_stream_info_from_pkt(MOVFragmentIndex *fr
     return get_frag_stream_info(frag_index, current, id);
 }
 
-static int cenc_filter(MOVContext *mov, AVStream* st, MOVStreamContext *sc, AVPacket *pkt, int current_index)
+static int cenc_filter(MOVContext* mov, AVStream* st, MOVStreamContext* sc, AVPacket* pkt, int current_index)
 {
-    MOVFragmentStreamInfo *frag_stream_info;
-    MOVEncryptionIndex *encryption_index;
-    AVEncryptionInfo *encrypted_sample;
+    MOVFragmentStreamInfo* frag_stream_info;
+    MOVEncryptionIndex* encryption_index;
+    AVEncryptionInfo* encrypted_sample;
     int encrypted_index, ret;
 
     frag_stream_info = get_frag_stream_info_from_pkt(&mov->frag_index, pkt, sc->id);
@@ -8431,11 +8474,13 @@ static int cenc_filter(MOVContext *mov, AVStream* st, MOVStreamContext *sc, AVPa
             if (frag_stream_info->encryption_index) {
                 encrypted_index = current_index - frag_stream_info->index_base;
                 encryption_index = frag_stream_info->encryption_index;
-            } else {
+            }
+            else {
                 encryption_index = sc->cenc.encryption_index;
             }
         }
-    } else {
+    }
+    else {
         encryption_index = sc->cenc.encryption_index;
     }
 
@@ -8455,7 +8500,8 @@ static int cenc_filter(MOVContext *mov, AVStream* st, MOVStreamContext *sc, AVPa
         if (!encryption_index->nb_encrypted_samples) {
             // Full-sample encryption with default settings.
             encrypted_sample = sc->cenc.default_encrypted_sample;
-        } else if (encrypted_index >= 0 && encrypted_index < encryption_index->nb_encrypted_samples) {
+        }
+        else if (encrypted_index >= 0 && encrypted_index < encryption_index->nb_encrypted_samples) {
             // Per-sample setting override.
             encrypted_sample = encryption_index->encrypted_samples[encrypted_index];
             if (!encrypted_sample) {
@@ -8470,9 +8516,10 @@ static int cenc_filter(MOVContext *mov, AVStream* st, MOVStreamContext *sc, AVPa
 
         if (mov->decryption_key) {
             return cenc_decrypt(mov, sc, encrypted_sample, pkt->data, pkt->size);
-        } else {
+        }
+        else {
             size_t size;
-            uint8_t *side_data = av_encryption_info_add_side_data(encrypted_sample, &size);
+            uint8_t* side_data = av_encryption_info_add_side_data(encrypted_sample, &size);
             if (!side_data)
                 return AVERROR(ENOMEM);
             ret = av_packet_add_side_data(pkt, AV_PKT_DATA_ENCRYPTION_INFO, side_data, size);
@@ -8485,19 +8532,19 @@ static int cenc_filter(MOVContext *mov, AVStream* st, MOVStreamContext *sc, AVPa
     return 0;
 }
 
-static int mov_read_dops(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_dops(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
     const int OPUS_SEEK_PREROLL_MS = 80;
     int ret;
-    AVStream *st;
+    AVStream* st;
     size_t size;
     uint16_t pre_skip;
 
     if (c->fc->nb_streams < 1)
         return 0;
-    st = c->fc->streams[c->fc->nb_streams-1];
+    st = c->fc->streams[c->fc->nb_streams - 1];
 
-    if ((uint64_t)atom.size > (1<<30) || atom.size < 11)
+    if ((uint64_t)atom.size > (1 << 30) || atom.size < 11)
         return AVERROR_INVALIDDATA;
 
     /* Check OpusSpecificBox version. */
@@ -8512,8 +8559,8 @@ static int mov_read_dops(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     if ((ret = ff_alloc_extradata(st->codecpar, size)) < 0)
         return ret;
 
-    AV_WL32A(st->codecpar->extradata, MKTAG('O','p','u','s'));
-    AV_WL32A(st->codecpar->extradata + 4, MKTAG('H','e','a','d'));
+    AV_WL32A(st->codecpar->extradata, MKTAG('O', 'p', 'u', 's'));
+    AV_WL32A(st->codecpar->extradata + 4, MKTAG('H', 'e', 'a', 'd'));
     AV_WB8(st->codecpar->extradata + 8, 1); /* OpusHead version */
     avio_read(pb, st->codecpar->extradata + 9, size - 9);
 
@@ -8528,15 +8575,19 @@ static int mov_read_dops(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 
     st->codecpar->initial_padding = pre_skip;
     st->codecpar->seek_preroll = av_rescale_q(OPUS_SEEK_PREROLL_MS,
-                                              (AVRational){1, 1000},
-                                              (AVRational){1, 48000});
+        (AVRational) {
+        1, 1000
+    },
+        (AVRational) {
+        1, 48000
+    });
 
     return 0;
 }
 
-static int mov_read_dmlp(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_dmlp(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    AVStream *st;
+    AVStream* st;
     unsigned format_info;
     int channel_assignment, channel_assignment1, channel_assignment2;
     int ratebits;
@@ -8544,14 +8595,14 @@ static int mov_read_dmlp(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 
     if (c->fc->nb_streams < 1)
         return 0;
-    st = c->fc->streams[c->fc->nb_streams-1];
+    st = c->fc->streams[c->fc->nb_streams - 1];
 
     if (atom.size < 10)
         return AVERROR_INVALIDDATA;
 
     format_info = avio_rb32(pb);
 
-    ratebits            = (format_info >> 28) & 0xF;
+    ratebits = (format_info >> 28) & 0xF;
     channel_assignment1 = (format_info >> 15) & 0x1F;
     channel_assignment2 = format_info & 0x1FFF;
     if (channel_assignment2)
@@ -8569,16 +8620,16 @@ static int mov_read_dmlp(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return 0;
 }
 
-static int mov_read_dvcc_dvvc(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_dvcc_dvvc(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    AVStream *st;
+    AVStream* st;
     uint8_t buf[ISOM_DVCC_DVVC_SIZE];
     int ret;
     int64_t read_size = atom.size;
 
     if (c->fc->nb_streams < 1)
         return 0;
-    st = c->fc->streams[c->fc->nb_streams-1];
+    st = c->fc->streams[c->fc->nb_streams - 1];
 
     // At most 24 bytes
     read_size = FFMIN(read_size, ISOM_DVCC_DVVC_SIZE);
@@ -8589,15 +8640,15 @@ static int mov_read_dvcc_dvvc(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return ff_isom_parse_dvcc_dvvc(c->fc, st, buf, read_size);
 }
 
-static int mov_read_lhvc(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_lhvc(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    AVStream *st;
-    uint8_t *buf;
+    AVStream* st;
+    uint8_t* buf;
     int ret, old_size, num_arrays;
 
     if (c->fc->nb_streams < 1)
         return 0;
-    st = c->fc->streams[c->fc->nb_streams-1];
+    st = c->fc->streams[c->fc->nb_streams - 1];
 
     if (!st->codecpar->extradata_size)
         // TODO: handle lhvC when present before hvcC
@@ -8621,7 +8672,7 @@ static int mov_read_lhvc(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     num_arrays = buf[5];
     old_size = st->codecpar->extradata_size;
     atom.size -= 8 /* account for mov_realloc_extradata offsetting */
-               + 6 /* lhvC bytes before the arrays*/;
+        + 6 /* lhvC bytes before the arrays*/;
 
     ret = mov_realloc_extradata(st->codecpar, atom);
     if (ret < 0) {
@@ -8638,10 +8689,10 @@ static int mov_read_lhvc(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return 0;
 }
 
-static int mov_read_kind(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_kind(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    AVFormatContext *ctx = c->fc;
-    AVStream *st = NULL;
+    AVFormatContext* ctx = c->fc;
+    AVStream* st = NULL;
     AVBPrint scheme_buf, value_buf;
     int64_t scheme_str_len = 0, value_str_len = 0;
     int version, flags, ret = AVERROR_BUG;
@@ -8653,24 +8704,24 @@ static int mov_read_kind(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 
     if (c->fc->nb_streams < 1)
         return 0;
-    st = c->fc->streams[c->fc->nb_streams-1];
+    st = c->fc->streams[c->fc->nb_streams - 1];
 
     version = avio_r8(pb);
-    flags   = avio_rb24(pb);
-    size   -= 4;
+    flags = avio_rb24(pb);
+    size -= 4;
 
     if (version != 0 || flags != 0) {
         av_log(ctx, AV_LOG_ERROR,
-               "Unsupported 'kind' box with version %d, flags: %x",
-               version, flags);
+            "Unsupported 'kind' box with version %d, flags: %x",
+            version, flags);
         return AVERROR_INVALIDDATA;
     }
 
     av_bprint_init(&scheme_buf, 0, AV_BPRINT_SIZE_UNLIMITED);
-    av_bprint_init(&value_buf,  0, AV_BPRINT_SIZE_UNLIMITED);
+    av_bprint_init(&value_buf, 0, AV_BPRINT_SIZE_UNLIMITED);
 
     if ((scheme_str_len = ff_read_string_to_bprint_overwrite(pb, &scheme_buf,
-                                                             size)) < 0) {
+        size)) < 0) {
         ret = scheme_str_len;
         goto cleanup;
     }
@@ -8686,7 +8737,7 @@ static int mov_read_kind(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     size -= scheme_str_len + 1;
 
     if ((value_str_len = ff_read_string_to_bprint_overwrite(pb, &value_buf,
-                                                            size)) < 0) {
+        size)) < 0) {
         ret = value_str_len;
         goto cleanup;
     }
@@ -8698,10 +8749,10 @@ static int mov_read_kind(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     }
 
     av_log(ctx, AV_LOG_TRACE,
-           "%s stream %d KindBox(scheme: %s, value: %s)\n",
-           av_get_media_type_string(st->codecpar->codec_type),
-           st->index,
-           scheme_buf.str, value_buf.str);
+        "%s stream %d KindBox(scheme: %s, value: %s)\n",
+        av_get_media_type_string(st->codecpar->codec_type),
+        st->index,
+        scheme_buf.str, value_buf.str);
 
     for (int i = 0; ff_mov_track_kind_table[i].scheme_uri; i++) {
         const struct MP4TrackKindMapping map = ff_mov_track_kind_table[i];
@@ -8722,14 +8773,14 @@ static int mov_read_kind(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 cleanup:
 
     av_bprint_finalize(&scheme_buf, NULL);
-    av_bprint_finalize(&value_buf,  NULL);
+    av_bprint_finalize(&value_buf, NULL);
 
     return ret;
 }
 
-static int mov_read_SA3D(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_SA3D(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    AVStream *st;
+    AVStream* st;
     AVChannelLayout ch_layout = { 0 };
     int ret, i, version, type;
     int ambisonic_order, channel_order, normalization, channel_count;
@@ -8754,7 +8805,7 @@ static int mov_read_SA3D(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     type = avio_r8(pb);
     if (type & 0x7f) {
         av_log(c->fc, AV_LOG_WARNING,
-               "Unsupported ambisonic type %d\n", type & 0x7f);
+            "Unsupported ambisonic type %d\n", type & 0x7f);
         return 0;
     }
     non_diegetic_channels = (type >> 7) * 2; // head_locked_stereo
@@ -8764,24 +8815,24 @@ static int mov_read_SA3D(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     channel_order = avio_r8(pb);
     if (channel_order) {
         av_log(c->fc, AV_LOG_WARNING,
-               "Unsupported channel_order %d\n", channel_order);
+            "Unsupported channel_order %d\n", channel_order);
         return 0;
     }
 
     normalization = avio_r8(pb);
     if (normalization) {
         av_log(c->fc, AV_LOG_WARNING,
-               "Unsupported normalization %d\n", normalization);
+            "Unsupported normalization %d\n", normalization);
         return 0;
     }
 
     channel_count = avio_rb32(pb);
     if (ambisonic_order < 0 || ambisonic_order > 31 ||
         channel_count != ((ambisonic_order + 1LL) * (ambisonic_order + 1LL) +
-                           non_diegetic_channels)) {
+            non_diegetic_channels)) {
         av_log(c->fc, AV_LOG_ERROR,
-               "Invalid number of channels (%d / %d)\n",
-               channel_count, ambisonic_order);
+            "Invalid number of channels (%d / %d)\n",
+            channel_count, ambisonic_order);
         return 0;
     }
     ambi_channels = channel_count - non_diegetic_channels;
@@ -8795,7 +8846,7 @@ static int mov_read_SA3D(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 
         if (channel >= channel_count) {
             av_log(c->fc, AV_LOG_ERROR, "Invalid channel index (%d / %d)\n",
-                   channel, ambisonic_order);
+                channel, ambisonic_order);
             av_channel_layout_uninit(&ch_layout);
             return 0;
         }
@@ -8817,9 +8868,9 @@ static int mov_read_SA3D(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return 0;
 }
 
-static int mov_read_SAND(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_SAND(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    AVStream *st;
+    AVStream* st;
     int version;
 
     if (c->fc->nb_streams < 1)
@@ -8843,7 +8894,7 @@ static int mov_read_SAND(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return 0;
 }
 
-static int rb_size(AVIOContext *pb, int64_t *value, int size)
+static int rb_size(AVIOContext* pb, int64_t* value, int size)
 {
     if (size == 0)
         *value = 0;
@@ -8857,12 +8908,13 @@ static int rb_size(AVIOContext *pb, int64_t *value, int size)
         *value = avio_rb64(pb);
         if (*value < 0)
             return -1;
-    } else
+    }
+    else
         return -1;
     return size;
 }
 
-static int mov_read_pitm(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_pitm(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
     avio_rb32(pb);  // version & flags.
     c->primary_item_id = avio_rb16(pb);
@@ -8870,15 +8922,15 @@ static int mov_read_pitm(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return atom.size;
 }
 
-static int mov_read_idat(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_idat(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
     c->idat_offset = avio_tell(pb);
     return 0;
 }
 
-static int mov_read_iloc(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_iloc(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    HEIFItem **heif_item;
+    HEIFItem** heif_item;
     int version, offset_size, length_size, base_offset_size, index_size;
     int item_count, extent_count;
     int64_t base_offset, extent_offset, extent_length;
@@ -8910,12 +8962,12 @@ static int mov_read_iloc(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     c->heif_item = heif_item;
     if (item_count > c->nb_heif_item)
         memset(&c->heif_item[c->nb_heif_item], 0,
-               sizeof(*c->heif_item) * (item_count - c->nb_heif_item));
+            sizeof(*c->heif_item) * (item_count - c->nb_heif_item));
     c->nb_heif_item = FFMAX(c->nb_heif_item, item_count);
 
     av_log(c->fc, AV_LOG_TRACE, "iloc: item_count %d\n", item_count);
     for (int i = 0; i < item_count; i++) {
-        HEIFItem *item = NULL;
+        HEIFItem* item = NULL;
         int item_id = (version < 2) ? avio_rb16(pb) : avio_rb32(pb);
         int offset_type = (version > 0) ? avio_rb16(pb) & 0xf : 0;
 
@@ -8959,17 +9011,17 @@ static int mov_read_iloc(MOVContext *c, AVIOContext *pb, MOVAtom atom)
         item->extent_length = extent_length;
         item->extent_offset = base_offset + extent_offset;
         av_log(c->fc, AV_LOG_TRACE, "iloc: item_idx %d, item->item_id %d, offset_type %d, "
-                                    "extent_offset %"PRId64", extent_length %"PRId64"\n",
-               i, item->item_id, offset_type, item->extent_offset, item->extent_length);
+            "extent_offset %"PRId64", extent_length %"PRId64"\n",
+            i, item->item_id, offset_type, item->extent_offset, item->extent_length);
     }
 
     c->found_iloc = 1;
     return atom.size;
 }
 
-static int mov_read_infe(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_infe(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    HEIFItem *item = NULL;
+    HEIFItem* item = NULL;
     AVBPrint item_name;
     int64_t size = atom.size;
     uint32_t item_type;
@@ -9003,7 +9055,7 @@ static int mov_read_infe(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     }
 
     av_log(c->fc, AV_LOG_TRACE, "infe: item_id %d, item_type %s, item_name %s\n",
-           item_id, av_fourcc2str(item_type), item_name.str);
+        item_id, av_fourcc2str(item_type), item_name.str);
 
     size -= ret + 1;
     if (size > 0)
@@ -9025,12 +9077,12 @@ static int mov_read_infe(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     av_freep(&item->name);
     av_bprint_finalize(&item_name, ret ? &item->name : NULL);
     item->item_id = item_id;
-    item->type    = item_type;
+    item->type = item_type;
 
     switch (item_type) {
-    case MKTAG('a','v','0','1'):
-    case MKTAG('j','p','e','g'):
-    case MKTAG('h','v','c','1'):
+    case MKTAG('a', 'v', '0', '1'):
+    case MKTAG('j', 'p', 'e', 'g'):
+    case MKTAG('h', 'v', 'c', '1'):
         ret = heif_add_stream(c, item);
         if (ret < 0)
             return ret;
@@ -9040,9 +9092,9 @@ static int mov_read_infe(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return 0;
 }
 
-static int mov_read_iinf(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_iinf(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    HEIFItem **heif_item;
+    HEIFItem** heif_item;
     int entry_count;
     int version, got_stream = 0, ret, i;
 
@@ -9061,7 +9113,7 @@ static int mov_read_iinf(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     c->heif_item = heif_item;
     if (entry_count > c->nb_heif_item)
         memset(&c->heif_item[c->nb_heif_item], 0,
-               sizeof(*c->heif_item) * (entry_count - c->nb_heif_item));
+            sizeof(*c->heif_item) * (entry_count - c->nb_heif_item));
     c->nb_heif_item = FFMAX(c->nb_heif_item, entry_count);
 
     for (i = 0; i < entry_count; i++) {
@@ -9084,7 +9136,7 @@ static int mov_read_iinf(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return 0;
 fail:
     for (; i >= 0; i--) {
-        HEIFItem *item = c->heif_item[i];
+        HEIFItem* item = c->heif_item[i];
 
         if (!item)
             continue;
@@ -9094,17 +9146,17 @@ fail:
     return ret;
 }
 
-static int mov_read_iref_dimg(MOVContext *c, AVIOContext *pb, int version)
+static int mov_read_iref_dimg(MOVContext* c, AVIOContext* pb, int version)
 {
-    HEIFItem *item = NULL;
-    HEIFGrid *grid;
+    HEIFItem* item = NULL;
+    HEIFGrid* grid;
     int entries, i;
     int from_item_id = version ? avio_rb32(pb) : avio_rb16(pb);
 
     for (int i = 0; i < c->nb_heif_grid; i++) {
         if (c->heif_grid[i].item->item_id == from_item_id) {
             av_log(c->fc, AV_LOG_ERROR, "More than one 'dimg' box "
-                                        "referencing the same Derived Image item\n");
+                "referencing the same Derived Image item\n");
             return AVERROR_INVALIDDATA;
         }
     }
@@ -9114,12 +9166,12 @@ static int mov_read_iref_dimg(MOVContext *c, AVIOContext *pb, int version)
         item = c->heif_item[i];
 
         switch (item->type) {
-        case MKTAG('g','r','i','d'):
-        case MKTAG('i','o','v','l'):
+        case MKTAG('g', 'r', 'i', 'd'):
+        case MKTAG('i', 'o', 'v', 'l'):
             break;
         default:
             avpriv_report_missing_feature(c->fc, "Derived Image item of type %s",
-                                          av_fourcc2str(item->type));
+                av_fourcc2str(item->type));
             return 0;
         }
         break;
@@ -9130,7 +9182,7 @@ static int mov_read_iref_dimg(MOVContext *c, AVIOContext *pb, int version)
     }
 
     grid = av_realloc_array(c->heif_grid, c->nb_heif_grid + 1U,
-                            sizeof(*c->heif_grid));
+        sizeof(*c->heif_grid));
     if (!grid)
         return AVERROR(ENOMEM);
     c->heif_grid = grid;
@@ -9149,46 +9201,42 @@ static int mov_read_iref_dimg(MOVContext *c, AVIOContext *pb, int version)
     grid->item = item;
 
     av_log(c->fc, AV_LOG_TRACE, "dimg: from_item_id %d, entries %d\n",
-           from_item_id, entries);
+        from_item_id, entries);
 
     return 0;
 }
 
-static int mov_read_iref_cdsc(MOVContext *c, AVIOContext *pb, uint32_t type, int version)
+static int mov_read_iref_thmb(MOVContext* c, AVIOContext* pb, int version)
 {
-    HEIFItem *from_item = NULL;
+    int* thmb_item_id;
     int entries;
-    int from_item_id = version ? avio_rb32(pb) : avio_rb16(pb);
-    const HEIFItemRef ref = { type, from_item_id };
-
-    from_item = get_heif_item(c, from_item_id);
-    if (!from_item) {
-        av_log(c->fc, AV_LOG_ERROR, "Missing stream referenced by thmb item\n");
-        return AVERROR_INVALIDDATA;
-    }
+    int to_item_id, from_item_id = version ? avio_rb32(pb) : avio_rb16(pb);
 
     entries = avio_rb16(pb);
+    if (entries > 1) {
+        avpriv_request_sample(c->fc, "thmb in iref referencing several items");
+        return AVERROR_PATCHWELCOME;
+    }
     /* 'to' item ids */
-    for (int i = 0; i < entries; i++) {
-        HEIFItem *item = get_heif_item(c, version ? avio_rb32(pb) : avio_rb16(pb));
-        if (!item) {
-            av_log(c->fc, AV_LOG_WARNING, "Missing stream referenced by %s item\n",
-                   av_fourcc2str(type));
-            continue;
-        }
+    to_item_id = version ? avio_rb32(pb) : avio_rb16(pb);
 
-        if (!av_dynarray2_add((void **)&item->iref_list, &item->nb_iref_list,
-                              sizeof(*item->iref_list), (const uint8_t *)&ref))
-            return AVERROR(ENOMEM);
-    }
+    if (to_item_id != c->primary_item_id)
+        return 0;
+
+    /* Put thumnbail IDs into an array */
+    thmb_item_id = av_dynarray2_add((void**)&c->thmb_item_id, &c->nb_thmb_item,
+        sizeof(*c->thmb_item_id),
+        (const void*)&from_item_id);
+    if (!thmb_item_id)
+        return AVERROR(ENOMEM);
 
-    av_log(c->fc, AV_LOG_TRACE, "%s: from_item_id %d, entries %d\n",
-           av_fourcc2str(type), from_item_id, entries);
+    av_log(c->fc, AV_LOG_TRACE, "thmb: from_item_id %d, entries %d, nb_thmb: %d\n",
+        from_item_id, entries, c->nb_thmb_item);
 
     return 0;
 }
 
-static int mov_read_iref(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_iref(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
     int version = avio_r8(pb);
     avio_rb24(pb); // flags
@@ -9209,16 +9257,15 @@ static int mov_read_iref(MOVContext *c, AVIOContext *pb, MOVAtom atom)
         next += size - 4;
         type = avio_rl32(pb);
         switch (type) {
-        case MKTAG('d','i','m','g'):
+        case MKTAG('d', 'i', 'm', 'g'):
             mov_read_iref_dimg(c, pb, version);
             break;
-        case MKTAG('c','d','s','c'):
-        case MKTAG('t','h','m','b'):
-            mov_read_iref_cdsc(c, pb, type, version);
+        case MKTAG('t', 'h', 'm', 'b'):
+            mov_read_iref_thmb(c, pb, version);
             break;
         default:
             av_log(c->fc, AV_LOG_DEBUG, "Unknown iref type %s size %"PRIu32"\n",
-                   av_fourcc2str(type), size);
+                av_fourcc2str(type), size);
         }
 
         atom.size -= size;
@@ -9227,39 +9274,39 @@ static int mov_read_iref(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return 0;
 }
 
-static int mov_read_ispe(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_ispe(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    HEIFItem *item;
+    HEIFItem* item;
     uint32_t width, height;
 
     avio_r8(pb);  /* version */
     avio_rb24(pb);  /* flags */
-    width  = avio_rb32(pb);
+    width = avio_rb32(pb);
     height = avio_rb32(pb);
 
     av_log(c->fc, AV_LOG_TRACE, "ispe: item_id %d, width %u, height %u\n",
-           c->cur_item_id, width, height);
+        c->cur_item_id, width, height);
 
-    item = get_heif_item(c, c->cur_item_id);
+    item = heif_cur_item(c);
     if (item) {
-        item->width  = width;
+        item->width = width;
         item->height = height;
     }
 
     return 0;
 }
 
-static int mov_read_irot(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_irot(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    HEIFItem *item;
+    HEIFItem* item;
     int angle;
 
     angle = avio_r8(pb) & 0x3;
 
     av_log(c->fc, AV_LOG_TRACE, "irot: item_id %d, angle %u\n",
-           c->cur_item_id, angle);
+        c->cur_item_id, angle);
 
-    item = get_heif_item(c, c->cur_item_id);
+    item = heif_cur_item(c);
     if (item) {
         // angle * 90 specifies the angle (in anti-clockwise direction)
         // in units of degrees.
@@ -9269,34 +9316,34 @@ static int mov_read_irot(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return 0;
 }
 
-static int mov_read_imir(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_imir(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
-    HEIFItem *item;
+    HEIFItem* item;
     int axis;
 
     axis = avio_r8(pb) & 0x1;
 
     av_log(c->fc, AV_LOG_TRACE, "imir: item_id %d, axis %u\n",
-           c->cur_item_id, axis);
+        c->cur_item_id, axis);
 
-    item = get_heif_item(c, c->cur_item_id);
+    item = heif_cur_item(c);
     if (item) {
-        item->hflip =  axis;
+        item->hflip = axis;
         item->vflip = !axis;
     }
 
     return 0;
 }
 
-static int mov_read_iprp(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_iprp(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
     typedef struct MOVAtoms {
         FFIOContext b;
         uint32_t type;
         int64_t  size;
-        uint8_t *data;
+        uint8_t* data;
     } MOVAtoms;
-    MOVAtoms *atoms = NULL;
+    MOVAtoms* atoms = NULL;
     MOVAtom a;
     unsigned count;
     int nb_atoms = 0;
@@ -9306,12 +9353,12 @@ static int mov_read_iprp(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     a.size = avio_rb32(pb);
     a.type = avio_rl32(pb);
 
-    if (a.size < 8 || a.type != MKTAG('i','p','c','o'))
+    if (a.size < 8 || a.type != MKTAG('i', 'p', 'c', 'o'))
         return AVERROR_INVALIDDATA;
 
     a.size -= 8;
     while (a.size >= 8) {
-        MOVAtoms *ref = av_dynarray2_add((void**)&atoms, &nb_atoms, sizeof(MOVAtoms), NULL);
+        MOVAtoms* ref = av_dynarray2_add((void**)&atoms, &nb_atoms, sizeof(MOVAtoms), NULL);
         if (!ref) {
             ret = AVERROR(ENOMEM);
             goto fail;
@@ -9344,14 +9391,14 @@ static int mov_read_iprp(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     a.size = avio_rb32(pb);
     a.type = avio_rl32(pb);
 
-    if (a.size < 8 || a.type != MKTAG('i','p','m','a')) {
+    if (a.size < 8 || a.type != MKTAG('i', 'p', 'm', 'a')) {
         ret = AVERROR_INVALIDDATA;
         goto fail;
     }
 
     version = avio_r8(pb);
-    flags   = avio_rb24(pb);
-    count   = avio_rb32(pb);
+    flags = avio_rb24(pb);
+    count = avio_rb32(pb);
 
     for (int i = 0; i < count; i++) {
         int item_id = version ? avio_rb32(pb) : avio_rb16(pb);
@@ -9363,7 +9410,7 @@ static int mov_read_iprp(MOVContext *c, AVIOContext *pb, MOVAtom atom)
         }
 
         for (int j = 0; j < assoc_count; j++) {
-            MOVAtoms *ref;
+            MOVAtoms* ref;
             int index = avio_r8(pb) & 0x7f;
             if (flags & 1) {
                 index <<= 8;
@@ -9376,13 +9423,15 @@ static int mov_read_iprp(MOVContext *c, AVIOContext *pb, MOVAtom atom)
             ref = &atoms[--index];
 
             av_log(c->fc, AV_LOG_TRACE, "ipma: property_index %d, item_id %d, item_type %s\n",
-                   index + 1, item_id, av_fourcc2str(ref->type));
+                index + 1, item_id, av_fourcc2str(ref->type));
 
             c->cur_item_id = item_id;
 
             ret = mov_read_default(c, &ref->b.pub,
-                                   (MOVAtom) { .size = ref->size,
-                                               .type = MKTAG('i','p','c','o') });
+                (MOVAtom) {
+                .size = ref->size,
+                    .type = MKTAG('i', 'p', 'c', 'o')
+            });
             if (ret < 0)
                 goto fail;
             ffio_init_read_context(&ref->b, ref->data, ref->size);
@@ -9525,11 +9574,10 @@ static const MOVParseTableEntry mov_default_parse_table[] = {
 #if CONFIG_IAMFDEC
 { MKTAG('i','a','c','b'), mov_read_iacb },
 #endif
-{ MKTAG('s','r','a','t'), mov_read_srat },
 { 0, NULL }
 };
 
-static int mov_read_default(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+static int mov_read_default(MOVContext* c, AVIOContext* pb, MOVAtom atom)
 {
     int64_t total_size = 0;
     MOVAtom a;
@@ -9539,7 +9587,7 @@ static int mov_read_default(MOVContext *c, AVIOContext *pb, MOVAtom atom)
         av_log(c->fc, AV_LOG_ERROR, "Atoms too deeply nested\n");
         return AVERROR_INVALIDDATA;
     }
-    c->atom_depth ++;
+    c->atom_depth++;
 
     if (atom.size < 0)
         atom.size = INT64_MAX;
@@ -9549,29 +9597,29 @@ static int mov_read_default(MOVContext *c, AVIOContext *pb, MOVAtom atom)
         a.type = avio_rl32(pb);
         if (avio_feof(pb))
             break;
-        if (((a.type == MKTAG('f','r','e','e') && c->moov_retry) ||
-              a.type == MKTAG('h','o','o','v')) &&
+        if (((a.type == MKTAG('f', 'r', 'e', 'e') && c->moov_retry) ||
+            a.type == MKTAG('h', 'o', 'o', 'v')) &&
             a.size >= 8 &&
             c->fc->strict_std_compliance < FF_COMPLIANCE_STRICT) {
-                uint32_t type;
-                avio_skip(pb, 4);
-                type = avio_rl32(pb);
-                if (avio_feof(pb))
-                    break;
-                avio_seek(pb, -8, SEEK_CUR);
-                if (type == MKTAG('m','v','h','d') ||
-                    type == MKTAG('c','m','o','v')) {
-                    av_log(c->fc, AV_LOG_ERROR, "Detected moov in a free or hoov atom.\n");
-                    a.type = MKTAG('m','o','o','v');
-                }
+            uint32_t type;
+            avio_skip(pb, 4);
+            type = avio_rl32(pb);
+            if (avio_feof(pb))
+                break;
+            avio_seek(pb, -8, SEEK_CUR);
+            if (type == MKTAG('m', 'v', 'h', 'd') ||
+                type == MKTAG('c', 'm', 'o', 'v')) {
+                av_log(c->fc, AV_LOG_ERROR, "Detected moov in a free or hoov atom.\n");
+                a.type = MKTAG('m', 'o', 'o', 'v');
+            }
         }
-        if (atom.type != MKTAG('r','o','o','t') &&
-            atom.type != MKTAG('m','o','o','v')) {
-            if (a.type == MKTAG('t','r','a','k') ||
-                a.type == MKTAG('m','d','a','t')) {
+        if (atom.type != MKTAG('r', 'o', 'o', 't') &&
+            atom.type != MKTAG('m', 'o', 'o', 'v')) {
+            if (a.type == MKTAG('t', 'r', 'a', 'k') ||
+                a.type == MKTAG('m', 'd', 'a', 't')) {
                 av_log(c->fc, AV_LOG_ERROR, "Broken file, trak/mdat not at top-level\n");
                 avio_skip(pb, -8);
-                c->atom_depth --;
+                c->atom_depth--;
                 return 0;
             }
         }
@@ -9581,7 +9629,7 @@ static int mov_read_default(MOVContext *c, AVIOContext *pb, MOVAtom atom)
             total_size += 8;
         }
         av_log(c->fc, AV_LOG_TRACE, "type:'%s' parent:'%s' sz: %"PRId64" %"PRId64" %"PRId64"\n",
-               av_fourcc2str(a.type), av_fourcc2str(atom.type), a.size, total_size, atom.size);
+            av_fourcc2str(a.type), av_fourcc2str(atom.type), a.size, total_size, atom.size);
         if (a.size == 0) {
             a.size = atom.size - total_size + 8;
         }
@@ -9599,35 +9647,36 @@ static int mov_read_default(MOVContext *c, AVIOContext *pb, MOVAtom atom)
             }
 
         // container is user data
-        if (!parse && (atom.type == MKTAG('u','d','t','a') ||
-                       atom.type == MKTAG('i','l','s','t')))
+        if (!parse && (atom.type == MKTAG('u', 'd', 't', 'a') ||
+            atom.type == MKTAG('i', 'l', 's', 't')))
             parse = mov_read_udta_string;
 
         // Supports parsing the QuickTime Metadata Keys.
         // https://developer.apple.com/library/mac/documentation/QuickTime/QTFF/Metadata/Metadata.html
         if (!parse && c->found_hdlr_mdta &&
-            atom.type == MKTAG('m','e','t','a') &&
-            a.type == MKTAG('k','e','y','s') &&
+            atom.type == MKTAG('m', 'e', 't', 'a') &&
+            a.type == MKTAG('k', 'e', 'y', 's') &&
             c->meta_keys_count == 0) {
             parse = mov_read_keys;
         }
 
         if (!parse) { /* skip leaf atoms data */
             avio_skip(pb, a.size);
-        } else {
+        }
+        else {
             int64_t start_pos = avio_tell(pb);
             int64_t left;
             int err = parse(c, pb, a);
             if (err < 0) {
-                c->atom_depth --;
+                c->atom_depth--;
                 return err;
             }
             if (c->found_moov && c->found_mdat && a.size <= INT64_MAX - start_pos &&
                 ((!(pb->seekable & AVIO_SEEKABLE_NORMAL) || c->fc->flags & AVFMT_FLAG_IGNIDX || c->frag_index.complete) ||
-                 start_pos + a.size == avio_size(pb))) {
+                    start_pos + a.size == avio_size(pb))) {
                 if (!(pb->seekable & AVIO_SEEKABLE_NORMAL) || c->fc->flags & AVFMT_FLAG_IGNIDX || c->frag_index.complete)
                     c->next_root_atom = start_pos + a.size;
-                c->atom_depth --;
+                c->atom_depth--;
                 return 0;
             }
             left = a.size - avio_tell(pb) + start_pos;
@@ -9635,8 +9684,8 @@ static int mov_read_default(MOVContext *c, AVIOContext *pb, MOVAtom atom)
                 avio_skip(pb, left);
             else if (left < 0) {
                 av_log(c->fc, AV_LOG_WARNING,
-                       "overread end of atom '%s' by %"PRId64" bytes\n",
-                       av_fourcc2str(a.type), -left);
+                    "overread end of atom '%s' by %"PRId64" bytes\n",
+                    av_fourcc2str(a.type), -left);
                 avio_seek(pb, left, SEEK_CUR);
             }
         }
@@ -9647,11 +9696,11 @@ static int mov_read_default(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     if (total_size < atom.size && atom.size < 0x7ffff)
         avio_skip(pb, atom.size - total_size);
 
-    c->atom_depth --;
+    c->atom_depth--;
     return 0;
 }
 
-static int mov_probe(const AVProbeData *p)
+static int mov_probe(const AVProbeData* p)
 {
     int64_t offset;
     uint32_t tag;
@@ -9668,9 +9717,10 @@ static int mov_probe(const AVProbeData *p)
             break;
         size = AV_RB32(p->buf + offset);
         if (size == 1 && offset + 16 <= (unsigned int)p->buf_size) {
-            size = AV_RB64(p->buf+offset + 8);
+            size = AV_RB64(p->buf + offset + 8);
             minsize = 16;
-        } else if (size == 0) {
+        }
+        else if (size == 0) {
             size = p->buf_size - offset;
         }
         if (size < minsize) {
@@ -9678,40 +9728,41 @@ static int mov_probe(const AVProbeData *p)
             continue;
         }
         tag = AV_RL32(p->buf + offset + 4);
-        switch(tag) {
-        /* check for obvious tags */
-        case MKTAG('m','o','o','v'):
+        switch (tag) {
+            /* check for obvious tags */
+        case MKTAG('m', 'o', 'o', 'v'):
             moov_offset = offset + 4;
-        case MKTAG('m','d','a','t'):
-        case MKTAG('p','n','o','t'): /* detect movs with preview pics like ew.mov and april.mov */
-        case MKTAG('u','d','t','a'): /* Packet Video PVAuthor adds this and a lot of more junk */
-        case MKTAG('f','t','y','p'):
-            if (tag == MKTAG('f','t','y','p') &&
-                       (   AV_RL32(p->buf + offset + 8) == MKTAG('j','p','2',' ')
-                        || AV_RL32(p->buf + offset + 8) == MKTAG('j','p','x',' ')
-                        || AV_RL32(p->buf + offset + 8) == MKTAG('j','x','l',' ')
+        case MKTAG('m', 'd', 'a', 't'):
+        case MKTAG('p', 'n', 'o', 't'): /* detect movs with preview pics like ew.mov and april.mov */
+        case MKTAG('u', 'd', 't', 'a'): /* Packet Video PVAuthor adds this and a lot of more junk */
+        case MKTAG('f', 't', 'y', 'p'):
+            if (tag == MKTAG('f', 't', 'y', 'p') &&
+                (AV_RL32(p->buf + offset + 8) == MKTAG('j', 'p', '2', ' ')
+                    || AV_RL32(p->buf + offset + 8) == MKTAG('j', 'p', 'x', ' ')
+                    || AV_RL32(p->buf + offset + 8) == MKTAG('j', 'x', 'l', ' ')
                     )) {
                 score = FFMAX(score, 5);
-            } else {
+            }
+            else {
                 score = AVPROBE_SCORE_MAX;
             }
             break;
-        /* those are more common words, so rate then a bit less */
-        case MKTAG('e','d','i','w'): /* xdcam files have reverted first tags */
-        case MKTAG('w','i','d','e'):
-        case MKTAG('f','r','e','e'):
-        case MKTAG('j','u','n','k'):
-        case MKTAG('p','i','c','t'):
-            score  = FFMAX(score, AVPROBE_SCORE_MAX - 5);
+            /* those are more common words, so rate then a bit less */
+        case MKTAG('e', 'd', 'i', 'w'): /* xdcam files have reverted first tags */
+        case MKTAG('w', 'i', 'd', 'e'):
+        case MKTAG('f', 'r', 'e', 'e'):
+        case MKTAG('j', 'u', 'n', 'k'):
+        case MKTAG('p', 'i', 'c', 't'):
+            score = FFMAX(score, AVPROBE_SCORE_MAX - 5);
             break;
-        case MKTAG(0x82,0x82,0x7f,0x7d):
-            score  = FFMAX(score, AVPROBE_SCORE_EXTENSION - 5);
+        case MKTAG(0x82, 0x82, 0x7f, 0x7d):
+            score = FFMAX(score, AVPROBE_SCORE_EXTENSION - 5);
             break;
-        case MKTAG('s','k','i','p'):
-        case MKTAG('u','u','i','d'):
-        case MKTAG('p','r','f','l'):
+        case MKTAG('s', 'k', 'i', 'p'):
+        case MKTAG('u', 'u', 'i', 'd'):
+        case MKTAG('p', 'r', 'f', 'l'):
             /* if we only find those cause probedata is too small at least rate them */
-            score  = FFMAX(score, AVPROBE_SCORE_EXTENSION);
+            score = FFMAX(score, AVPROBE_SCORE_EXTENSION);
             break;
         }
         if (size > INT64_MAX - offset)
@@ -9724,17 +9775,18 @@ static int mov_probe(const AVProbeData *p)
         offset = moov_offset;
 
         while (offset < (p->buf_size - 16)) { /* Sufficient space */
-               /* We found an actual hdlr atom */
-            if (AV_RL32(p->buf + offset     ) == MKTAG('h','d','l','r') &&
-                AV_RL32(p->buf + offset +  8) == MKTAG('m','h','l','r') &&
-                AV_RL32(p->buf + offset + 12) == MKTAG('M','P','E','G')) {
+            /* We found an actual hdlr atom */
+            if (AV_RL32(p->buf + offset) == MKTAG('h', 'd', 'l', 'r') &&
+                AV_RL32(p->buf + offset + 8) == MKTAG('m', 'h', 'l', 'r') &&
+                AV_RL32(p->buf + offset + 12) == MKTAG('M', 'P', 'E', 'G')) {
                 av_log(NULL, AV_LOG_WARNING, "Found media data tag MPEG indicating this is a MOV-packed MPEG-PS.\n");
                 /* We found a media handler reference atom describing an
                  * MPEG-PS-in-MOV, return a
                  * low score to force expanding the probe window until
                  * mpegps_probe finds what it needs */
                 return 5;
-            } else {
+            }
+            else {
                 /* Keep looking */
                 offset += 2;
             }
@@ -9745,17 +9797,17 @@ static int mov_probe(const AVProbeData *p)
 }
 
 // must be done after parsing all trak because there's no order requirement
-static void mov_read_chapters(AVFormatContext *s)
+static void mov_read_chapters(AVFormatContext* s)
 {
-    MOVContext *mov = s->priv_data;
-    MOVStreamContext *sc;
+    MOVContext* mov = s->priv_data;
+    MOVStreamContext* sc;
     int64_t cur_pos;
     int i, j;
     int chapter_track;
 
     for (j = 0; j < mov->nb_chapter_tracks; j++) {
-        AVStream *st = NULL;
-        FFStream *sti = NULL;
+        AVStream* st = NULL;
+        FFStream* sti = NULL;
         chapter_track = mov->chapter_tracks[j];
         for (i = 0; i < s->nb_streams; i++) {
             sc = mov->fc->streams[i]->priv_data;
@@ -9777,7 +9829,7 @@ static void mov_read_chapters(AVFormatContext *s)
             st->disposition |= AV_DISPOSITION_ATTACHED_PIC | AV_DISPOSITION_TIMED_THUMBNAILS;
             if (!st->attached_pic.data && sti->nb_index_entries) {
                 // Retrieve the first frame, if possible
-                AVIndexEntry *sample = &sti->index_entries[0];
+                AVIndexEntry* sample = &sti->index_entries[0];
                 if (avio_seek(sc->pb, sample->pos, SEEK_SET) != sample->pos) {
                     av_log(s, AV_LOG_ERROR, "Failed to retrieve first frame\n");
                     goto finish;
@@ -9786,14 +9838,15 @@ static void mov_read_chapters(AVFormatContext *s)
                 if (ff_add_attached_pic(s, st, sc->pb, NULL, sample->size) < 0)
                     goto finish;
             }
-        } else {
+        }
+        else {
             st->codecpar->codec_type = AVMEDIA_TYPE_DATA;
             st->codecpar->codec_id = AV_CODEC_ID_BIN_DATA;
             st->discard = AVDISCARD_ALL;
             for (int i = 0; i < sti->nb_index_entries; i++) {
-                AVIndexEntry *sample = &sti->index_entries[i];
-                int64_t end = i+1 < sti->nb_index_entries ? sti->index_entries[i+1].timestamp : st->duration;
-                uint8_t *title;
+                AVIndexEntry* sample = &sti->index_entries[i];
+                int64_t end = i + 1 < sti->nb_index_entries ? sti->index_entries[i + 1].timestamp : st->duration;
+                uint8_t* title;
                 uint16_t ch;
                 int len, title_len;
 
@@ -9809,9 +9862,9 @@ static void mov_read_chapters(AVFormatContext *s)
 
                 // the first two bytes are the length of the title
                 len = avio_rb16(sc->pb);
-                if (len > sample->size-2)
+                if (len > sample->size - 2)
                     continue;
-                title_len = 2*len + 1;
+                title_len = 2 * len + 1;
                 if (!(title = av_mallocz(title_len)))
                     goto finish;
 
@@ -9820,7 +9873,8 @@ static void mov_read_chapters(AVFormatContext *s)
                 // instead by the presence of a BOM
                 if (!len) {
                     title[0] = 0;
-                } else {
+                }
+                else {
                     ch = avio_rb16(sc->pb);
                     if (ch == 0xfeff)
                         avio_get_str16be(sc->pb, len, title, title_len);
@@ -9839,13 +9893,13 @@ static void mov_read_chapters(AVFormatContext *s)
                 av_freep(&title);
             }
         }
-finish:
+    finish:
         avio_seek(sc->pb, cur_pos, SEEK_SET);
     }
 }
 
-static int parse_timecode_in_framenum_format(AVFormatContext *s, AVStream *st,
-                                             int64_t value, int flags)
+static int parse_timecode_in_framenum_format(AVFormatContext* s, AVStream* st,
+    int64_t value, int flags)
 {
     AVTimecode tc;
     char buf[AV_TIMECODE_STR_SIZE];
@@ -9854,14 +9908,14 @@ static int parse_timecode_in_framenum_format(AVFormatContext *s, AVStream *st,
     if (ret < 0)
         return ret;
     av_dict_set(&st->metadata, "timecode",
-                av_timecode_make_string(&tc, buf, value), 0);
+        av_timecode_make_string(&tc, buf, value), 0);
     return 0;
 }
 
-static int mov_read_rtmd_track(AVFormatContext *s, AVStream *st)
+static int mov_read_rtmd_track(AVFormatContext* s, AVStream* st)
 {
-    MOVStreamContext *sc = st->priv_data;
-    FFStream *const sti = ffstream(st);
+    MOVStreamContext* sc = st->priv_data;
+    FFStream* const sti = ffstream(st);
     char buf[AV_TIMECODE_STR_SIZE];
     int64_t cur_pos = avio_tell(sc->pb);
     int hh, mm, ss, ff, drop;
@@ -9877,17 +9931,17 @@ static int mov_read_rtmd_track(AVFormatContext *s, AVStream *st)
     drop = avio_r8(s->pb);
     ff = avio_r8(s->pb);
     snprintf(buf, AV_TIMECODE_STR_SIZE, "%02d:%02d:%02d%c%02d",
-             hh, mm, ss, drop ? ';' : ':', ff);
+        hh, mm, ss, drop ? ';' : ':', ff);
     av_dict_set(&st->metadata, "timecode", buf, 0);
 
     avio_seek(sc->pb, cur_pos, SEEK_SET);
     return 0;
 }
 
-static int mov_read_timecode_track(AVFormatContext *s, AVStream *st)
+static int mov_read_timecode_track(AVFormatContext* s, AVStream* st)
 {
-    MOVStreamContext *sc = st->priv_data;
-    FFStream *const sti = ffstream(st);
+    MOVStreamContext* sc = st->priv_data;
+    FFStream* const sti = ffstream(st);
     int flags = 0;
     int64_t cur_pos = avio_tell(sc->pb);
     int64_t value;
@@ -9914,9 +9968,9 @@ static int mov_read_timecode_track(AVFormatContext *s, AVStream *st)
      * despite what the tmcd track "suggests" (Counter flag set to 0 means QT
      * format). */
 
-    /* 60 fps content have tmcd_nb_frames set to 30 but tc_rate set to 60, so
-     * we multiply the frame number with the quotient.
-     * See tickets #9492, #9710. */
+     /* 60 fps content have tmcd_nb_frames set to 30 but tc_rate set to 60, so
+      * we multiply the frame number with the quotient.
+      * See tickets #9492, #9710. */
     rounded_tc_rate = (tc_rate.num + tc_rate.den / 2LL) / tc_rate.den;
     /* Work around files where tmcd_nb_frames is rounded down from frame rate
      * instead of up. See ticket #5978. */
@@ -9931,7 +9985,7 @@ static int mov_read_timecode_track(AVFormatContext *s, AVStream *st)
     return 0;
 }
 
-static void mov_free_encryption_index(MOVEncryptionIndex **index) {
+static void mov_free_encryption_index(MOVEncryptionIndex** index) {
     int i;
     if (!index || !*index) return;
     for (i = 0; i < (*index)->nb_encrypted_samples; i++) {
@@ -9943,9 +9997,9 @@ static void mov_free_encryption_index(MOVEncryptionIndex **index) {
     av_freep(index);
 }
 
-static void mov_free_stream_context(AVFormatContext *s, AVStream *st)
+static void mov_free_stream_context(AVFormatContext* s, AVStream* st)
 {
-    MOVStreamContext *sc = st->priv_data;
+    MOVStreamContext* sc = st->priv_data;
 
     if (!sc || --sc->refcount) {
         st->priv_data = NULL;
@@ -10005,13 +10059,13 @@ static void mov_free_stream_context(AVFormatContext *s, AVStream *st)
     av_freep(&sc->iamf);
 }
 
-static int mov_read_close(AVFormatContext *s)
+static int mov_read_close(AVFormatContext* s)
 {
-    MOVContext *mov = s->priv_data;
+    MOVContext* mov = s->priv_data;
     int i, j;
 
     for (i = 0; i < s->nb_streams; i++) {
-        AVStream *st = s->streams[i];
+        AVStream* st = s->streams[i];
 
         mov_free_stream_context(s, st);
     }
@@ -10031,7 +10085,7 @@ static int mov_read_close(AVFormatContext *s)
     av_freep(&mov->bitrates);
 
     for (i = 0; i < mov->frag_index.nb_items; i++) {
-        MOVFragmentStreamInfo *frag = mov->frag_index.item[i].stream_info;
+        MOVFragmentStreamInfo* frag = mov->frag_index.item[i].stream_info;
         for (j = 0; j < mov->frag_index.item[i].nb_stream_info; j++) {
             mov_free_encryption_index(&frag[j].encryption_index);
         }
@@ -10045,7 +10099,6 @@ static int mov_read_close(AVFormatContext *s)
         if (!mov->heif_item[i])
             continue;
         av_freep(&mov->heif_item[i]->name);
-        av_freep(&mov->heif_item[i]->iref_list);
         av_freep(&mov->heif_item[i]->icc_profile);
         av_freep(&mov->heif_item[i]);
     }
@@ -10056,17 +10109,18 @@ static int mov_read_close(AVFormatContext *s)
         av_freep(&mov->heif_grid[i].tile_item_list);
     }
     av_freep(&mov->heif_grid);
+    av_freep(&mov->thmb_item_id);
 
     return 0;
 }
 
-static int tmcd_is_referenced(AVFormatContext *s, int tmcd_id)
+static int tmcd_is_referenced(AVFormatContext* s, int tmcd_id)
 {
     int i;
 
     for (i = 0; i < s->nb_streams; i++) {
-        AVStream *st = s->streams[i];
-        MOVStreamContext *sc = st->priv_data;
+        AVStream* st = s->streams[i];
+        MOVStreamContext* sc = st->priv_data;
 
         if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
             sc->timecode_track == tmcd_id)
@@ -10076,16 +10130,16 @@ static int tmcd_is_referenced(AVFormatContext *s, int tmcd_id)
 }
 
 /* look for a tmcd track not referenced by any video track, and export it globally */
-static void export_orphan_timecode(AVFormatContext *s)
+static void export_orphan_timecode(AVFormatContext* s)
 {
     int i;
 
     for (i = 0; i < s->nb_streams; i++) {
-        AVStream *st = s->streams[i];
+        AVStream* st = s->streams[i];
 
-        if (st->codecpar->codec_tag  == MKTAG('t','m','c','d') &&
+        if (st->codecpar->codec_tag == MKTAG('t', 'm', 'c', 'd') &&
             !tmcd_is_referenced(s, i + 1)) {
-            AVDictionaryEntry *tcr = av_dict_get(st->metadata, "timecode", NULL, 0);
+            AVDictionaryEntry* tcr = av_dict_get(st->metadata, "timecode", NULL, 0);
             if (tcr) {
                 av_dict_set(&s->metadata, "timecode", tcr->value, 0);
                 break;
@@ -10094,7 +10148,7 @@ static void export_orphan_timecode(AVFormatContext *s)
     }
 }
 
-static int read_tfra(MOVContext *mov, AVIOContext *f)
+static int read_tfra(MOVContext* mov, AVIOContext* f)
 {
     int version, fieldlength, i, j;
     int64_t pos = avio_tell(f);
@@ -10114,17 +10168,18 @@ static int read_tfra(MOVContext *mov, AVIOContext *f)
     for (i = 0; i < item_count; i++) {
         int64_t time, offset;
         int index;
-        MOVFragmentStreamInfo * frag_stream_info;
+        MOVFragmentStreamInfo* frag_stream_info;
 
         if (avio_feof(f)) {
             return AVERROR_INVALIDDATA;
         }
 
         if (version == 1) {
-            time   = avio_rb64(f);
+            time = avio_rb64(f);
             offset = avio_rb64(f);
-        } else {
-            time   = avio_rb32(f);
+        }
+        else {
+            time = avio_rb32(f);
             offset = avio_rb32(f);
         }
 
@@ -10149,7 +10204,7 @@ static int read_tfra(MOVContext *mov, AVIOContext *f)
     return 0;
 }
 
-static int mov_read_mfra(MOVContext *c, AVIOContext *f)
+static int mov_read_mfra(MOVContext* c, AVIOContext* f)
 {
     int64_t stream_size = avio_size(f);
     int64_t original_pos = avio_tell(f);
@@ -10165,7 +10220,7 @@ static int mov_read_mfra(MOVContext *c, AVIOContext *f)
         av_log(c->fc, AV_LOG_DEBUG, "doesn't look like mfra (unreasonable size)\n");
         goto fail;
     }
-    if ((seek_ret = avio_seek(f, -((int64_t) c->mfra_size), SEEK_CUR)) < 0) {
+    if ((seek_ret = avio_seek(f, -((int64_t)c->mfra_size), SEEK_CUR)) < 0) {
         ret = seek_ret;
         goto fail;
     }
@@ -10189,18 +10244,18 @@ fail:
     seek_ret = avio_seek(f, original_pos, SEEK_SET);
     if (seek_ret < 0) {
         av_log(c->fc, AV_LOG_ERROR,
-               "failed to seek back after looking for mfra\n");
+            "failed to seek back after looking for mfra\n");
         ret = seek_ret;
     }
     return ret;
 }
 
-static int set_icc_profile_from_item(AVPacketSideData **coded_side_data, int *nb_coded_side_data,
-                                     const HEIFItem *item)
+static int set_icc_profile_from_item(AVPacketSideData** coded_side_data, int* nb_coded_side_data,
+    const HEIFItem* item)
 {
-    AVPacketSideData *sd = av_packet_side_data_new(coded_side_data, nb_coded_side_data,
-                                                   AV_PKT_DATA_ICC_PROFILE,
-                                                   item->icc_profile_size, 0);
+    AVPacketSideData* sd = av_packet_side_data_new(coded_side_data, nb_coded_side_data,
+        AV_PKT_DATA_ICC_PROFILE,
+        item->icc_profile_size, 0);
     if (!sd)
         return AVERROR(ENOMEM);
 
@@ -10209,14 +10264,14 @@ static int set_icc_profile_from_item(AVPacketSideData **coded_side_data, int *nb
     return 0;
 }
 
-static int set_display_matrix_from_item(AVPacketSideData **coded_side_data, int *nb_coded_side_data,
-                                        const HEIFItem *item)
+static int set_display_matrix_from_item(AVPacketSideData** coded_side_data, int* nb_coded_side_data,
+    const HEIFItem* item)
 {
-    int32_t *matrix;
-    AVPacketSideData *sd = av_packet_side_data_new(coded_side_data,
-                                                   nb_coded_side_data,
-                                                   AV_PKT_DATA_DISPLAYMATRIX,
-                                                   9 * sizeof(*matrix), 0);
+    int32_t* matrix;
+    AVPacketSideData* sd = av_packet_side_data_new(coded_side_data,
+        nb_coded_side_data,
+        AV_PKT_DATA_DISPLAYMATRIX,
+        9 * sizeof(*matrix), 0);
     if (!sd)
         return AVERROR(ENOMEM);
 
@@ -10230,11 +10285,11 @@ static int set_display_matrix_from_item(AVPacketSideData **coded_side_data, int
     return 0;
 }
 
-static int read_image_grid(AVFormatContext *s, const HEIFGrid *grid,
-                           AVStreamGroupTileGrid *tile_grid)
+static int read_image_grid(AVFormatContext* s, const HEIFGrid* grid,
+    AVStreamGroupTileGrid* tile_grid)
 {
-    MOVContext *c = s->priv_data;
-    const HEIFItem *item = grid->item;
+    MOVContext* c = s->priv_data;
+    const HEIFItem* item = grid->item;
     int64_t offset = 0, pos = avio_tell(s->pb);
     int x = 0, y = 0, i = 0;
     int tile_rows, tile_cols;
@@ -10252,9 +10307,6 @@ static int read_image_grid(AVFormatContext *s, const HEIFGrid *grid,
         offset = c->idat_offset;
     }
 
-    if (offset > INT64_MAX - item->extent_offset)
-        return AVERROR_INVALIDDATA;
-
     avio_seek(s->pb, item->extent_offset + offset, SEEK_SET);
 
     avio_r8(s->pb);    /* version */
@@ -10263,11 +10315,26 @@ static int read_image_grid(AVFormatContext *s, const HEIFGrid *grid,
     tile_rows = avio_r8(s->pb) + 1;
     tile_cols = avio_r8(s->pb) + 1;
     /* actual width and height of output image */
-    tile_grid->width  = (flags & 1) ? avio_rb32(s->pb) : avio_rb16(s->pb);
+    tile_grid->width = (flags & 1) ? avio_rb32(s->pb) : avio_rb16(s->pb);
     tile_grid->height = (flags & 1) ? avio_rb32(s->pb) : avio_rb16(s->pb);
 
+    /* ICC profile */
+    if (item->icc_profile_size) {
+        int ret = set_icc_profile_from_item(&tile_grid->coded_side_data,
+            &tile_grid->nb_coded_side_data, item);
+        if (ret < 0)
+            return ret;
+    }
+    /* rotation */
+    if (item->rotation || item->hflip || item->vflip) {
+        int ret = set_display_matrix_from_item(&tile_grid->coded_side_data,
+            &tile_grid->nb_coded_side_data, item);
+        if (ret < 0)
+            return ret;
+    }
+
     av_log(c->fc, AV_LOG_TRACE, "grid: grid_rows %d grid_cols %d output_width %d output_height %d\n",
-           tile_rows, tile_cols, tile_grid->width, tile_grid->height);
+        tile_rows, tile_cols, tile_grid->width, tile_grid->height);
 
     avio_seek(s->pb, pos, SEEK_SET);
 
@@ -10278,7 +10345,7 @@ static int read_image_grid(AVFormatContext *s, const HEIFGrid *grid,
         return AVERROR_INVALIDDATA;
 
     for (int i = 0; i < tile_cols; i++)
-        tile_grid->coded_width  += grid->tile_item_list[i]->width;
+        tile_grid->coded_width += grid->tile_item_list[i]->width;
     for (int i = 0; i < size; i += tile_cols)
         tile_grid->coded_height += grid->tile_item_list[i]->height;
 
@@ -10293,9 +10360,9 @@ static int read_image_grid(AVFormatContext *s, const HEIFGrid *grid,
             if (i == tile_grid->nb_tiles)
                 return AVERROR_INVALIDDATA;
 
-            tile_grid->offsets[i].idx        = grid->tile_idx_list[i];
+            tile_grid->offsets[i].idx = grid->tile_idx_list[i];
             tile_grid->offsets[i].horizontal = x;
-            tile_grid->offsets[i].vertical   = y;
+            tile_grid->offsets[i].vertical = y;
 
             x += grid->tile_item_list[i++]->width;
         }
@@ -10305,7 +10372,7 @@ static int read_image_grid(AVFormatContext *s, const HEIFGrid *grid,
             return AVERROR_INVALIDDATA;
         }
 
-        x  = 0;
+        x = 0;
         y += grid->tile_item_list[left_col]->height;
     }
 
@@ -10317,11 +10384,11 @@ static int read_image_grid(AVFormatContext *s, const HEIFGrid *grid,
     return 0;
 }
 
-static int read_image_iovl(AVFormatContext *s, const HEIFGrid *grid,
-                           AVStreamGroupTileGrid *tile_grid)
+static int read_image_iovl(AVFormatContext* s, const HEIFGrid* grid,
+    AVStreamGroupTileGrid* tile_grid)
 {
-    MOVContext *c = s->priv_data;
-    const HEIFItem *item = grid->item;
+    MOVContext* c = s->priv_data;
+    const HEIFItem* item = grid->item;
     uint16_t canvas_fill_value[4];
     int64_t offset = 0, pos = avio_tell(s->pb);
     int ret = 0, flags;
@@ -10338,9 +10405,6 @@ static int read_image_iovl(AVFormatContext *s, const HEIFGrid *grid,
         offset = c->idat_offset;
     }
 
-    if (offset > INT64_MAX - item->extent_offset)
-        return AVERROR_INVALIDDATA;
-
     avio_seek(s->pb, item->extent_offset + offset, SEEK_SET);
 
     avio_r8(s->pb);    /* version */
@@ -10349,19 +10413,35 @@ static int read_image_iovl(AVFormatContext *s, const HEIFGrid *grid,
     for (int i = 0; i < 4; i++)
         canvas_fill_value[i] = avio_rb16(s->pb);
     av_log(c->fc, AV_LOG_TRACE, "iovl: canvas_fill_value { %u, %u, %u, %u }\n",
-           canvas_fill_value[0], canvas_fill_value[1],
-           canvas_fill_value[2], canvas_fill_value[3]);
+        canvas_fill_value[0], canvas_fill_value[1],
+        canvas_fill_value[2], canvas_fill_value[3]);
     for (int i = 0; i < 4; i++)
         tile_grid->background[i] = canvas_fill_value[i];
 
     /* actual width and height of output image */
-    tile_grid->width        =
-    tile_grid->coded_width  = (flags & 1) ? avio_rb32(s->pb) : avio_rb16(s->pb);
-    tile_grid->height       =
-    tile_grid->coded_height = (flags & 1) ? avio_rb32(s->pb) : avio_rb16(s->pb);
+    tile_grid->width =
+        tile_grid->coded_width = (flags & 1) ? avio_rb32(s->pb) : avio_rb16(s->pb);
+    tile_grid->height =
+        tile_grid->coded_height = (flags & 1) ? avio_rb32(s->pb) : avio_rb16(s->pb);
+
+    /* rotation */
+    if (item->rotation || item->hflip || item->vflip) {
+        int ret = set_display_matrix_from_item(&tile_grid->coded_side_data,
+            &tile_grid->nb_coded_side_data, item);
+        if (ret < 0)
+            return ret;
+    }
+
+    /* ICC profile */
+    if (item->icc_profile_size) {
+        int ret = set_icc_profile_from_item(&tile_grid->coded_side_data,
+            &tile_grid->nb_coded_side_data, item);
+        if (ret < 0)
+            return ret;
+    }
 
     av_log(c->fc, AV_LOG_TRACE, "iovl: output_width %d, output_height %d\n",
-           tile_grid->width, tile_grid->height);
+        tile_grid->width, tile_grid->height);
 
     tile_grid->nb_tiles = grid->nb_tiles;
     tile_grid->offsets = av_malloc_array(tile_grid->nb_tiles, sizeof(*tile_grid->offsets));
@@ -10371,13 +10451,13 @@ static int read_image_iovl(AVFormatContext *s, const HEIFGrid *grid,
     }
 
     for (int i = 0; i < tile_grid->nb_tiles; i++) {
-        tile_grid->offsets[i].idx        = grid->tile_idx_list[i];
+        tile_grid->offsets[i].idx = grid->tile_idx_list[i];
         tile_grid->offsets[i].horizontal = (flags & 1) ? avio_rb32(s->pb) : avio_rb16(s->pb);
-        tile_grid->offsets[i].vertical   = (flags & 1) ? avio_rb32(s->pb) : avio_rb16(s->pb);
+        tile_grid->offsets[i].vertical = (flags & 1) ? avio_rb32(s->pb) : avio_rb16(s->pb);
         av_log(c->fc, AV_LOG_TRACE, "iovl: stream_idx[%d] %u, "
-                                    "horizontal_offset[%d] %d, vertical_offset[%d] %d\n",
-               i, tile_grid->offsets[i].idx,
-               i, tile_grid->offsets[i].horizontal, i, tile_grid->offsets[i].vertical);
+            "horizontal_offset[%d] %d, vertical_offset[%d] %d\n",
+            i, tile_grid->offsets[i].idx,
+            i, tile_grid->offsets[i].horizontal, i, tile_grid->offsets[i].vertical);
     }
 
 fail:
@@ -10386,98 +10466,14 @@ fail:
     return ret;
 }
 
-static int mov_parse_exif_item(AVFormatContext *s,
-                               AVPacketSideData **coded_side_data, int *nb_coded_side_data,
-                               const HEIFItem *ref)
-{
-    MOVContext *c = s->priv_data;
-    AVPacketSideData *sd;
-    AVExifMetadata ifd = { 0 };
-    AVBufferRef *buf;
-    int64_t offset = 0, pos = avio_tell(s->pb);
-    unsigned orientation_id = av_exif_get_tag_id("Orientation");
-    int err;
-
-    if (!(s->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
-        av_log(c->fc, AV_LOG_WARNING, "Exif metadata with non seekable input\n");
-        return AVERROR_PATCHWELCOME;
-    }
-    if (ref->is_idat_relative) {
-        if (!c->idat_offset) {
-            av_log(c->fc, AV_LOG_ERROR, "missing idat box required by the Exif metadata\n");
-            return AVERROR_INVALIDDATA;
-        }
-        offset = c->idat_offset;
-    }
-
-    buf = av_buffer_alloc(ref->extent_length);
-    if (!buf)
-        return AVERROR(ENOMEM);
-
-    if (offset > INT64_MAX - ref->extent_offset) {
-        err = AVERROR(ENOMEM);
-        goto fail;
-    }
-
-    avio_seek(s->pb, ref->extent_offset + offset, SEEK_SET);
-    err = avio_read(s->pb, buf->data, ref->extent_length);
-    if (err != ref->extent_length) {
-        if (err > 0)
-            err = AVERROR_INVALIDDATA;
-        goto fail;
-    }
-
-    // HEIF spec states that Exif metadata is informative. The irot item property is
-    // the normative source of rotation information. So we remove any Orientation tag
-    // present in the Exif buffer.
-    err = av_exif_parse_buffer(s, buf->data, ref->extent_length, &ifd, AV_EXIF_T_OFF);
-    if (err < 0) {
-        av_log(s, AV_LOG_ERROR, "Unable to parse Exif metadata\n");
-        goto fail;
-    }
-
-    err = av_exif_remove_entry(s, &ifd, orientation_id, 0);
-    if (err < 0)
-        goto fail;
-    else if (!err)
-        goto finish;
-
-    av_buffer_unref(&buf);
-    err = av_exif_write(s, &ifd, &buf, AV_EXIF_T_OFF);
-    if (err < 0)
-        goto fail;
-
-finish:
-    offset = AV_RB32(buf->data) + 4;
-    if (offset >= buf->size) {
-        err = AVERROR_INVALIDDATA;
-        goto fail;
-    }
-    sd = av_packet_side_data_new(coded_side_data, nb_coded_side_data,
-                                 AV_PKT_DATA_EXIF, buf->size - offset, 0);
-    if (!sd) {
-        err = AVERROR(ENOMEM);
-        goto fail;
-    }
-    memcpy(sd->data, buf->data + offset, buf->size - offset);
-
-    err = 0;
-fail:
-    av_buffer_unref(&buf);
-    av_exif_free(&ifd);
-    avio_seek(s->pb, pos, SEEK_SET);
-
-    return err;
-}
-
-static int mov_parse_tiles(AVFormatContext *s)
+static int mov_parse_tiles(AVFormatContext* s)
 {
-    MOVContext *mov = s->priv_data;
+    MOVContext* mov = s->priv_data;
 
     for (int i = 0; i < mov->nb_heif_grid; i++) {
-        AVStreamGroup *stg = avformat_stream_group_create(s, AV_STREAM_GROUP_PARAMS_TILE_GRID, NULL);
-        AVStreamGroupTileGrid *tile_grid;
-        const HEIFGrid *grid = &mov->heif_grid[i];
+        AVStreamGroup* stg = avformat_stream_group_create(s, AV_STREAM_GROUP_PARAMS_TILE_GRID, NULL);
+        AVStreamGroupTileGrid* tile_grid;
+        const HEIFGrid* grid = &mov->heif_grid[i];
         int err, loop = 1;
 
         if (!stg)
@@ -10491,16 +10487,16 @@ static int mov_parse_tiles(AVFormatContext *s)
             int k;
 
             for (k = 0; k < mov->nb_heif_item; k++) {
-                HEIFItem *item = mov->heif_item[k];
-                AVStream *st;
+                HEIFItem* item = mov->heif_item[k];
+                AVStream* st;
 
                 if (!item || item->item_id != tile_id)
                     continue;
                 st = item->st;
                 if (!st) {
                     av_log(s, AV_LOG_WARNING, "HEIF item id %d from grid id %d doesn't "
-                                              "reference a stream\n",
-                           tile_id, grid->item->item_id);
+                        "reference a stream\n",
+                        tile_id, grid->item->item_id);
                     ff_remove_stream_group(s, stg);
                     loop = 0;
                     break;
@@ -10530,8 +10526,8 @@ static int mov_parse_tiles(AVFormatContext *s)
             if (k == mov->nb_heif_item) {
                 av_assert0(loop);
                 av_log(s, AV_LOG_WARNING, "HEIF item id %d referenced by grid id %d doesn't "
-                                          "exist\n",
-                       tile_id, grid->item->item_id);
+                    "exist\n",
+                    tile_id, grid->item->item_id);
                 ff_remove_stream_group(s, stg);
                 loop = 0;
             }
@@ -10543,10 +10539,10 @@ static int mov_parse_tiles(AVFormatContext *s)
             continue;
 
         switch (grid->item->type) {
-        case MKTAG('g','r','i','d'):
+        case MKTAG('g', 'r', 'i', 'd'):
             err = read_image_grid(s, grid, tile_grid);
             break;
-        case MKTAG('i','o','v','l'):
+        case MKTAG('i', 'o', 'v', 'l'):
             err = read_image_iovl(s, grid, tile_grid);
             break;
         default:
@@ -10555,37 +10551,6 @@ static int mov_parse_tiles(AVFormatContext *s)
         if (err < 0)
             return err;
 
-        for (int j = 0; j < grid->item->nb_iref_list; j++) {
-            HEIFItem *ref = get_heif_item(mov, grid->item->iref_list[j].item_id);
-
-            av_assert0(ref);
-            switch(ref->type) {
-            case MKTAG('E','x','i','f'):
-                err = mov_parse_exif_item(s, &tile_grid->coded_side_data,
-                                             &tile_grid->nb_coded_side_data, ref);
-                if (err < 0 && (s->error_recognition & AV_EF_EXPLODE))
-                    return err;
-                break;
-            default:
-                break;
-            }
-        }
-
-        /* rotation */
-        if (grid->item->rotation || grid->item->hflip || grid->item->vflip) {
-            err = set_display_matrix_from_item(&tile_grid->coded_side_data,
-                                               &tile_grid->nb_coded_side_data, grid->item);
-            if (err < 0)
-                return err;
-        }
-
-        /* ICC profile */
-        if (grid->item->icc_profile_size) {
-            err = set_icc_profile_from_item(&tile_grid->coded_side_data,
-                                            &tile_grid->nb_coded_side_data, grid->item);
-            if (err < 0)
-                return err;
-        }
 
         if (grid->item->name)
             av_dict_set(&stg->metadata, "title", grid->item->name, 0);
@@ -10596,20 +10561,27 @@ static int mov_parse_tiles(AVFormatContext *s)
     return 0;
 }
 
-static int mov_parse_heif_items(AVFormatContext *s)
+static int mov_parse_heif_items(AVFormatContext* s)
 {
-    MOVContext *mov = s->priv_data;
+    MOVContext* mov = s->priv_data;
     int err;
 
     for (int i = 0; i < mov->nb_heif_item; i++) {
-        HEIFItem *item = mov->heif_item[i];
-        MOVStreamContext *sc;
-        AVStream *st;
+        HEIFItem* item = mov->heif_item[i];
+        MOVStreamContext* sc;
+        AVStream* st;
         int64_t offset = 0;
 
         if (!item)
             continue;
         if (!item->st) {
+            for (int j = 0; j < mov->nb_thmb_item; j++) {
+                if (item->item_id == mov->thmb_item_id[j]) {
+                    av_log(s, AV_LOG_ERROR, "HEIF thumbnail ID %d doesn't reference a stream\n",
+                        item->item_id);
+                    return AVERROR_INVALIDDATA;
+                }
+            }
             continue;
         }
         if (item->is_idat_relative) {
@@ -10622,43 +10594,24 @@ static int mov_parse_heif_items(AVFormatContext *s)
 
         st = item->st;
         sc = st->priv_data;
-        st->codecpar->width  = item->width;
+        st->codecpar->width = item->width;
         st->codecpar->height = item->height;
 
-        sc->sample_size  = sc->stsz_sample_size = item->extent_length;
+        sc->sample_size = sc->stsz_sample_size = item->extent_length;
         sc->sample_count = 1;
 
-        err = sanity_checks(s, sc, st->index);
+        err = sanity_checks(s, sc, item->item_id);
         if (err)
             return AVERROR_INVALIDDATA;
 
-        if (offset > INT64_MAX - item->extent_offset)
-            return AVERROR_INVALIDDATA;
-
         sc->chunk_offsets[0] = item->extent_offset + offset;
 
         if (item->item_id == mov->primary_item_id)
             st->disposition |= AV_DISPOSITION_DEFAULT;
 
-        for (int j = 0; j < item->nb_iref_list; j++) {
-            HEIFItem *ref = get_heif_item(mov, item->iref_list[j].item_id);
-
-            av_assert0(ref);
-            switch(ref->type) {
-            case MKTAG('E','x','i','f'):
-                err = mov_parse_exif_item(s, &st->codecpar->coded_side_data,
-                                             &st->codecpar->nb_coded_side_data, ref);
-                if (err < 0 && (s->error_recognition & AV_EF_EXPLODE))
-                    return err;
-                break;
-            default:
-                break;
-            }
-        }
-
         if (item->rotation || item->hflip || item->vflip) {
             err = set_display_matrix_from_item(&st->codecpar->coded_side_data,
-                                               &st->codecpar->nb_coded_side_data, item);
+                &st->codecpar->nb_coded_side_data, item);
             if (err < 0)
                 return err;
         }
@@ -10675,10 +10628,10 @@ static int mov_parse_heif_items(AVFormatContext *s)
     return 0;
 }
 
-static AVStream *mov_find_reference_track(AVFormatContext *s, AVStream *st,
-                                          int first_index)
+static AVStream* mov_find_reference_track(AVFormatContext* s, AVStream* st,
+    int first_index)
 {
-    MOVStreamContext *sc = st->priv_data;
+    MOVStreamContext* sc = st->priv_data;
 
     if (sc->tref_id < 0)
         return NULL;
@@ -10690,15 +10643,15 @@ static AVStream *mov_find_reference_track(AVFormatContext *s, AVStream *st,
     return NULL;
 }
 
-static int mov_parse_lcevc_streams(AVFormatContext *s)
+static int mov_parse_lcevc_streams(AVFormatContext* s)
 {
     int err;
 
     for (int i = 0; i < s->nb_streams; i++) {
-        AVStreamGroup *stg;
-        AVStream *st = s->streams[i];
-        AVStream *st_base;
-        MOVStreamContext *sc = st->priv_data;
+        AVStreamGroup* stg;
+        AVStream* st = s->streams[i];
+        AVStream* st_base;
+        MOVStreamContext* sc = st->priv_data;
         int j = 0;
 
         /* Find an enhancement stream. */
@@ -10713,7 +10666,7 @@ static int mov_parse_lcevc_streams(AVFormatContext *s)
             return AVERROR(ENOMEM);
 
         stg->id = st->id;
-        stg->params.lcevc->width  = st->codecpar->width;
+        stg->params.lcevc->width = st->codecpar->width;
         stg->params.lcevc->height = st->codecpar->height;
         st->codecpar->width = 0;
         st->codecpar->height = 0;
@@ -10740,34 +10693,34 @@ static int mov_parse_lcevc_streams(AVFormatContext *s)
     return 0;
 }
 
-static void fix_stream_ids(AVFormatContext *s)
+static void fix_stream_ids(AVFormatContext* s)
 {
     int highest_id = 0;
 
     for (int i = 0; i < s->nb_streams; i++) {
-        const AVStream *st = s->streams[i];
-        const MOVStreamContext *sc = st->priv_data;
+        const AVStream* st = s->streams[i];
+        const MOVStreamContext* sc = st->priv_data;
         if (!sc->iamf)
             highest_id = FFMAX(highest_id, st->id);
     }
     highest_id += !highest_id;
     for (int i = 0; highest_id > 1 && i < s->nb_stream_groups; i++) {
-        AVStreamGroup *stg = s->stream_groups[i];
+        AVStreamGroup* stg = s->stream_groups[i];
         if (stg->type != AV_STREAM_GROUP_PARAMS_IAMF_AUDIO_ELEMENT)
             continue;
         for (int j = 0; j < stg->nb_streams; j++) {
-            AVStream *st = stg->streams[j];
-            MOVStreamContext *sc = st->priv_data;
+            AVStream* st = stg->streams[j];
+            MOVStreamContext* sc = st->priv_data;
             st->id += highest_id;
             sc->iamf_stream_offset = highest_id;
         }
     }
 }
 
-static int mov_read_header(AVFormatContext *s)
+static int mov_read_header(AVFormatContext* s)
 {
-    MOVContext *mov = s->priv_data;
-    AVIOContext *pb = s->pb;
+    MOVContext* mov = s->priv_data;
+    AVIOContext* pb = s->pb;
     int j, err;
     MOVAtom atom = { AV_RL32("root") };
     int i;
@@ -10780,6 +10733,7 @@ static int mov_read_header(AVFormatContext *s)
 
     mov->fc = s;
     mov->trak_index = -1;
+    mov->thmb_item_id = NULL;
     mov->primary_item_id = -1;
     mov->cur_item_id = -1;
     /* .mov and .mp4 aren't streamable anyway (only progressive download if moov is before mdat) */
@@ -10797,7 +10751,7 @@ static int mov_read_header(AVFormatContext *s)
             return err;
         }
     } while ((pb->seekable & AVIO_SEEKABLE_NORMAL) &&
-             !mov->found_moov && (!mov->found_iloc || !mov->found_iinf) && !mov->moov_retry++);
+        !mov->found_moov && (!mov->found_iloc || !mov->found_iinf) && !mov->moov_retry++);
     if (!mov->found_moov && !mov->found_iloc && !mov->found_iinf) {
         av_log(s, AV_LOG_ERROR, "moov atom not found\n");
         return AVERROR_INVALIDDATA;
@@ -10820,21 +10774,22 @@ static int mov_read_header(AVFormatContext *s)
         for (i = 0; i < s->nb_streams; i++)
             if (s->streams[i]->codecpar->codec_tag == AV_RL32("tmcd")) {
                 mov_read_timecode_track(s, s->streams[i]);
-            } else if (s->streams[i]->codecpar->codec_tag == AV_RL32("rtmd")) {
+            }
+            else if (s->streams[i]->codecpar->codec_tag == AV_RL32("rtmd")) {
                 mov_read_rtmd_track(s, s->streams[i]);
             }
     }
 
     /* copy timecode metadata from tmcd tracks to the related video streams */
     for (i = 0; i < s->nb_streams; i++) {
-        AVStream *st = s->streams[i];
-        MOVStreamContext *sc = st->priv_data;
+        AVStream* st = s->streams[i];
+        MOVStreamContext* sc = st->priv_data;
         if (sc->timecode_track > 0) {
-            AVDictionaryEntry *tcr;
+            AVDictionaryEntry* tcr;
             int tmcd_st_id = -1;
 
             for (j = 0; j < s->nb_streams; j++) {
-                MOVStreamContext *sc2 = s->streams[j]->priv_data;
+                MOVStreamContext* sc2 = s->streams[j]->priv_data;
                 if (sc2->id == sc->timecode_track)
                     tmcd_st_id = j;
             }
@@ -10854,10 +10809,10 @@ static int mov_read_header(AVFormatContext *s)
         return err;
 
     for (i = 0; i < s->nb_streams; i++) {
-        AVStream *st = s->streams[i];
-        FFStream *const sti = ffstream(st);
-        MOVStreamContext *sc = st->priv_data;
-        uint32_t dvdsub_clut[FF_DVDCLUT_CLUT_LEN] = {0};
+        AVStream* st = s->streams[i];
+        FFStream* const sti = ffstream(st);
+        MOVStreamContext* sc = st->priv_data;
+        uint32_t dvdsub_clut[FF_DVDCLUT_CLUT_LEN] = { 0 };
         fix_timescale(mov, sc);
 
         /* Set the primary extradata based on the first Sample if it doesn't reference the first stsd entry. */
@@ -10875,15 +10830,15 @@ static int mov_read_header(AVFormatContext *s)
         }
 
         if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
-            st->codecpar->codec_id   == AV_CODEC_ID_AAC) {
+            st->codecpar->codec_id == AV_CODEC_ID_AAC) {
             sti->skip_samples = sc->start_pad;
         }
         if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && sc->nb_frames_for_fps > 0 && sc->duration_for_fps > 0)
             av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
-                      sc->time_scale*(int64_t)sc->nb_frames_for_fps, sc->duration_for_fps, INT_MAX);
+                sc->time_scale * (int64_t)sc->nb_frames_for_fps, sc->duration_for_fps, INT_MAX);
         if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
             if (st->codecpar->width <= 0 || st->codecpar->height <= 0) {
-                st->codecpar->width  = sc->width;
+                st->codecpar->width = sc->width;
                 st->codecpar->height = sc->height;
             }
             if (st->codecpar->codec_id == AV_CODEC_ID_DVD_SUBTITLE &&
@@ -10900,13 +10855,13 @@ static int mov_read_header(AVFormatContext *s)
                 st->codecpar->extradata_size = 0;
 
                 err = ff_dvdclut_palette_extradata_cat(dvdsub_clut, FF_DVDCLUT_CLUT_SIZE,
-                                                       st->codecpar);
+                    st->codecpar);
                 if (err < 0)
                     return err;
             }
         }
         if (mov->handbrake_version &&
-            mov->handbrake_version <= 1000000*0 + 1000*10 + 2 &&  // 0.10.2
+            mov->handbrake_version <= 1000000 * 0 + 1000 * 10 + 2 &&  // 0.10.2
             st->codecpar->codec_id == AV_CODEC_ID_MP3) {
             av_log(s, AV_LOG_VERBOSE, "Forcing full parsing for mp3 stream\n");
             sti->need_parsing = AVSTREAM_PARSE_FULL;
@@ -10915,14 +10870,14 @@ static int mov_read_header(AVFormatContext *s)
 
     if (mov->trex_data || mov->use_mfra_for > 0) {
         for (i = 0; i < s->nb_streams; i++) {
-            AVStream *st = s->streams[i];
-            MOVStreamContext *sc = st->priv_data;
+            AVStream* st = s->streams[i];
+            MOVStreamContext* sc = st->priv_data;
             if (sc->duration_for_fps > 0) {
                 /* Akin to sc->data_size * 8 * sc->time_scale / sc->duration_for_fps but accounting for overflows. */
-                st->codecpar->bit_rate = av_rescale(sc->data_size, ((int64_t) sc->time_scale) * 8, sc->duration_for_fps);
+                st->codecpar->bit_rate = av_rescale(sc->data_size, ((int64_t)sc->time_scale) * 8, sc->duration_for_fps);
                 if (st->codecpar->bit_rate == INT64_MIN) {
                     av_log(s, AV_LOG_WARNING, "Overflow during bit rate calculation %"PRId64" * 8 * %d\n",
-                           sc->data_size, sc->time_scale);
+                        sc->data_size, sc->time_scale);
                     st->codecpar->bit_rate = 0;
                     if (s->error_recognition & AV_EF_EXPLODE)
                         return AVERROR_INVALIDDATA;
@@ -10940,8 +10895,8 @@ static int mov_read_header(AVFormatContext *s)
     ff_rfps_calculate(s);
 
     for (i = 0; i < s->nb_streams; i++) {
-        AVStream *st = s->streams[i];
-        MOVStreamContext *sc = st->priv_data;
+        AVStream* st = s->streams[i];
+        MOVStreamContext* sc = st->priv_data;
 
         switch (st->codecpar->codec_type) {
         case AVMEDIA_TYPE_AUDIO:
@@ -10952,48 +10907,48 @@ static int mov_read_header(AVFormatContext *s)
         case AVMEDIA_TYPE_VIDEO:
             if (sc->display_matrix) {
                 if (!av_packet_side_data_add(&st->codecpar->coded_side_data, &st->codecpar->nb_coded_side_data,
-                                             AV_PKT_DATA_DISPLAYMATRIX,
-                                             (uint8_t*)sc->display_matrix, sizeof(int32_t) * 9, 0))
+                    AV_PKT_DATA_DISPLAYMATRIX,
+                    (uint8_t*)sc->display_matrix, sizeof(int32_t) * 9, 0))
                     return AVERROR(ENOMEM);
 
                 sc->display_matrix = NULL;
             }
             if (sc->stereo3d) {
                 if (!av_packet_side_data_add(&st->codecpar->coded_side_data, &st->codecpar->nb_coded_side_data,
-                                             AV_PKT_DATA_STEREO3D,
-                                             (uint8_t *)sc->stereo3d, sc->stereo3d_size, 0))
+                    AV_PKT_DATA_STEREO3D,
+                    (uint8_t*)sc->stereo3d, sc->stereo3d_size, 0))
                     return AVERROR(ENOMEM);
 
                 sc->stereo3d = NULL;
             }
             if (sc->spherical) {
                 if (!av_packet_side_data_add(&st->codecpar->coded_side_data, &st->codecpar->nb_coded_side_data,
-                                             AV_PKT_DATA_SPHERICAL,
-                                                 (uint8_t *)sc->spherical, sc->spherical_size, 0))
+                    AV_PKT_DATA_SPHERICAL,
+                    (uint8_t*)sc->spherical, sc->spherical_size, 0))
                     return AVERROR(ENOMEM);
 
                 sc->spherical = NULL;
             }
             if (sc->mastering) {
                 if (!av_packet_side_data_add(&st->codecpar->coded_side_data, &st->codecpar->nb_coded_side_data,
-                                             AV_PKT_DATA_MASTERING_DISPLAY_METADATA,
-                                             (uint8_t *)sc->mastering, sc->mastering_size, 0))
+                    AV_PKT_DATA_MASTERING_DISPLAY_METADATA,
+                    (uint8_t*)sc->mastering, sc->mastering_size, 0))
                     return AVERROR(ENOMEM);
 
                 sc->mastering = NULL;
             }
             if (sc->coll) {
                 if (!av_packet_side_data_add(&st->codecpar->coded_side_data, &st->codecpar->nb_coded_side_data,
-                                             AV_PKT_DATA_CONTENT_LIGHT_LEVEL,
-                                             (uint8_t *)sc->coll, sc->coll_size, 0))
+                    AV_PKT_DATA_CONTENT_LIGHT_LEVEL,
+                    (uint8_t*)sc->coll, sc->coll_size, 0))
                     return AVERROR(ENOMEM);
 
                 sc->coll = NULL;
             }
             if (sc->ambient) {
                 if (!av_packet_side_data_add(&st->codecpar->coded_side_data, &st->codecpar->nb_coded_side_data,
-                                             AV_PKT_DATA_AMBIENT_VIEWING_ENVIRONMENT,
-                                             (uint8_t *) sc->ambient, sc->ambient_size, 0))
+                    AV_PKT_DATA_AMBIENT_VIEWING_ENVIRONMENT,
+                    (uint8_t*)sc->ambient, sc->ambient_size, 0))
                     return AVERROR(ENOMEM);
 
                 sc->ambient = NULL;
@@ -11013,27 +10968,27 @@ static int mov_read_header(AVFormatContext *s)
     return 0;
 }
 
-static AVIndexEntry *mov_find_next_sample(AVFormatContext *s, AVStream **st)
+static AVIndexEntry* mov_find_next_sample(AVFormatContext* s, AVStream** st)
 {
-    AVIndexEntry *sample = NULL;
+    AVIndexEntry* sample = NULL;
     int64_t best_dts = INT64_MAX;
     int i;
-    MOVContext *mov = s->priv_data;
+    MOVContext* mov = s->priv_data;
     int no_interleave = !mov->interleaved_read || !(s->pb->seekable & AVIO_SEEKABLE_NORMAL);
     for (i = 0; i < s->nb_streams; i++) {
-        AVStream *avst = s->streams[i];
-        FFStream *const avsti = ffstream(avst);
-        MOVStreamContext *msc = avst->priv_data;
+        AVStream* avst = s->streams[i];
+        FFStream* const avsti = ffstream(avst);
+        MOVStreamContext* msc = avst->priv_data;
         if (msc->pb && msc->current_sample < avsti->nb_index_entries) {
-            AVIndexEntry *current_sample = &avsti->index_entries[msc->current_sample];
+            AVIndexEntry* current_sample = &avsti->index_entries[msc->current_sample];
             int64_t dts = av_rescale(current_sample->timestamp, AV_TIME_BASE, msc->time_scale);
             uint64_t dtsdiff = best_dts > dts ? best_dts - (uint64_t)dts : ((uint64_t)dts - best_dts);
             av_log(s, AV_LOG_TRACE, "stream %d, sample %d, dts %"PRId64"\n", i, msc->current_sample, dts);
             if (!sample || (no_interleave && current_sample->pos < sample->pos) ||
                 ((s->pb->seekable & AVIO_SEEKABLE_NORMAL) &&
-                 ((msc->pb != s->pb && dts < best_dts) || (msc->pb == s->pb && dts != AV_NOPTS_VALUE &&
-                 ((dtsdiff <= AV_TIME_BASE && current_sample->pos < sample->pos) ||
-                  (dtsdiff > AV_TIME_BASE && dts < best_dts && mov->interleaved_read)))))) {
+                    ((msc->pb != s->pb && dts < best_dts) || (msc->pb == s->pb && dts != AV_NOPTS_VALUE &&
+                        ((dtsdiff <= AV_TIME_BASE && current_sample->pos < sample->pos) ||
+                            (dtsdiff > AV_TIME_BASE && dts < best_dts && mov->interleaved_read)))))) {
                 sample = current_sample;
                 best_dts = dts;
                 *st = avst;
@@ -11043,17 +10998,17 @@ static AVIndexEntry *mov_find_next_sample(AVFormatContext *s, AVStream **st)
     return sample;
 }
 
-static int should_retry(AVIOContext *pb, int error_code) {
+static int should_retry(AVIOContext* pb, int error_code) {
     if (error_code == AVERROR_EOF || avio_feof(pb))
         return 0;
 
     return 1;
 }
 
-static int mov_switch_root(AVFormatContext *s, int64_t target, int index)
+static int mov_switch_root(AVFormatContext* s, int64_t target, int index)
 {
     int ret;
-    MOVContext *mov = s->priv_data;
+    MOVContext* mov = s->priv_data;
 
     if (index >= 0 && index < mov->frag_index.nb_items)
         target = mov->frag_index.item[index].moof_offset;
@@ -11076,7 +11031,7 @@ static int mov_switch_root(AVFormatContext *s, int64_t target, int index)
 
     mov->found_mdat = 0;
 
-    ret = mov_read_default(mov, s->pb, (MOVAtom){ AV_RL32("root"), INT64_MAX });
+    ret = mov_read_default(mov, s->pb, (MOVAtom) { AV_RL32("root"), INT64_MAX });
     if (ret < 0)
         return ret;
     if (avio_feof(s->pb))
@@ -11086,10 +11041,10 @@ static int mov_switch_root(AVFormatContext *s, int64_t target, int index)
     return 1;
 }
 
-static int mov_change_extradata(AVStream *st, AVPacket *pkt)
+static int mov_change_extradata(AVStream* st, AVPacket* pkt)
 {
-    MOVStreamContext *sc = st->priv_data;
-    uint8_t *side, *extradata;
+    MOVStreamContext* sc = st->priv_data;
+    uint8_t* side, * extradata;
     int extradata_size;
 
     /* Save the current index. */
@@ -11100,8 +11055,8 @@ static int mov_change_extradata(AVStream *st, AVPacket *pkt)
     extradata = sc->extradata[sc->last_stsd_index];
     if (st->discard != AVDISCARD_ALL && extradata_size > 0 && extradata) {
         side = av_packet_new_side_data(pkt,
-                                       AV_PKT_DATA_NEW_EXTRADATA,
-                                       extradata_size);
+            AV_PKT_DATA_NEW_EXTRADATA,
+            extradata_size);
         if (!side)
             return AVERROR(ENOMEM);
         memcpy(side, extradata, extradata_size);
@@ -11110,7 +11065,7 @@ static int mov_change_extradata(AVStream *st, AVPacket *pkt)
     return 0;
 }
 
-static int get_eia608_packet(AVIOContext *pb, AVPacket *pkt, int src_size)
+static int get_eia608_packet(AVIOContext* pb, AVPacket* pkt, int src_size)
 {
     /* We can't make assumptions about the structure of the payload,
        because it may include multiple cdat and cdt2 samples. */
@@ -11179,10 +11134,10 @@ static int get_eia608_packet(AVIOContext *pb, AVPacket *pkt, int src_size)
     return ret;
 }
 
-static int mov_finalize_packet(AVFormatContext *s, AVStream *st, AVIndexEntry *sample,
-                                int64_t current_index, AVPacket *pkt)
+static int mov_finalize_packet(AVFormatContext* s, AVStream* st, AVIndexEntry* sample,
+    int64_t current_index, AVPacket* pkt)
 {
-    MOVStreamContext *sc = st->priv_data;
+    MOVStreamContext* sc = st->priv_data;
 
     pkt->stream_index = sc->ffindex;
     pkt->dts = sample->timestamp;
@@ -11193,7 +11148,8 @@ static int mov_finalize_packet(AVFormatContext *s, AVStream *st, AVIndexEntry *s
         pkt->duration = sc->tts_data[sc->tts_index].duration;
     if (sc->ctts_count && sc->tts_index < sc->tts_count) {
         pkt->pts = av_sat_add64(pkt->dts, av_sat_add64(sc->dts_shift, sc->tts_data[sc->tts_index].offset));
-    } else {
+    }
+    else {
         if (pkt->duration == 0) {
             int64_t next_dts = (sc->current_sample < ffstream(st)->nb_index_entries) ?
                 ffstream(st)->index_entries[sc->current_sample].timestamp : st->duration;
@@ -11243,23 +11199,23 @@ static int mov_finalize_packet(AVFormatContext *s, AVStream *st, AVIndexEntry *s
     return 0;
 }
 
-static int mov_read_packet(AVFormatContext *s, AVPacket *pkt)
+static int mov_read_packet(AVFormatContext* s, AVPacket* pkt)
 {
-    MOVContext *mov = s->priv_data;
-    MOVStreamContext *sc;
-    AVIndexEntry *sample;
-    AVStream *st = NULL;
-    FFStream *avsti = NULL;
+    MOVContext* mov = s->priv_data;
+    MOVStreamContext* sc;
+    AVIndexEntry* sample;
+    AVStream* st = NULL;
+    FFStream* avsti = NULL;
     int64_t current_index;
     int ret;
     int i;
     mov->fc = s;
- retry:
+retry:
     if (s->pb->pos == 0) {
 
         // Discard current fragment index
         if (mov->frag_index.allocated_size > 0) {
-            for(int i = 0; i < mov->frag_index.nb_items; i++) {
+            for (int i = 0; i < mov->frag_index.nb_items; i++) {
                 av_freep(&mov->frag_index.item[i].stream_info);
             }
             av_freep(&mov->frag_index.item);
@@ -11270,8 +11226,8 @@ static int mov_read_packet(AVFormatContext *s, AVPacket *pkt)
         }
 
         for (i = 0; i < s->nb_streams; i++) {
-            AVStream *avst = s->streams[i];
-            MOVStreamContext *msc = avst->priv_data;
+            AVStream* avst = s->streams[i];
+            MOVStreamContext* msc = avst->priv_data;
 
             // Clear current sample
             mov_current_sample_set(msc, 0);
@@ -11311,10 +11267,11 @@ static int mov_read_packet(AVFormatContext *s, AVPacket *pkt)
         int64_t ret64 = avio_seek(sc->pb, sample->pos, SEEK_SET);
         if (ret64 != sample->pos) {
             av_log(mov->fc, AV_LOG_ERROR, "stream %d, offset 0x%"PRIx64": partial file\n",
-                   sc->ffindex, sample->pos);
+                sc->ffindex, sample->pos);
             if (should_retry(sc->pb, ret64)) {
                 mov_current_sample_dec(sc);
-            } else if (ret64 < 0) {
+            }
+            else if (ret64 < 0) {
                 return (int)ret64;
             }
             return AVERROR_INVALIDDATA;
@@ -11355,7 +11312,8 @@ static int mov_read_packet(AVFormatContext *s, AVPacket *pkt)
         else if (st->codecpar->codec_id == AV_CODEC_ID_APV && sample->size > 4) {
             const uint32_t au_size = avio_rb32(sc->pb);
             ret = av_get_packet(sc->pb, pkt, au_size);
-        } else
+        }
+        else
             ret = av_get_packet(sc->pb, pkt, sample->size);
         if (ret < 0) {
             if (should_retry(sc->pb, ret)) {
@@ -11375,12 +11333,13 @@ static int mov_read_packet(AVFormatContext *s, AVPacket *pkt)
         }
 #endif
         if (sc->has_palette) {
-            uint8_t *pal;
+            uint8_t* pal;
 
             pal = av_packet_new_side_data(pkt, AV_PKT_DATA_PALETTE, AVPALETTE_SIZE);
             if (!pal) {
                 av_log(mov->fc, AV_LOG_ERROR, "Cannot append palette to packet\n");
-            } else {
+            }
+            else {
                 memcpy(pal, sc->palette, AVPALETTE_SIZE);
                 sc->has_palette = 0;
             }
@@ -11409,9 +11368,9 @@ static int mov_read_packet(AVFormatContext *s, AVPacket *pkt)
     return 0;
 }
 
-static int mov_seek_fragment(AVFormatContext *s, AVStream *st, int64_t timestamp)
+static int mov_seek_fragment(AVFormatContext* s, AVStream* st, int64_t timestamp)
 {
-    MOVContext *mov = s->priv_data;
+    MOVContext* mov = s->priv_data;
     int index;
 
     if (!mov->frag_index.complete)
@@ -11428,7 +11387,7 @@ static int mov_seek_fragment(AVFormatContext *s, AVStream *st, int64_t timestamp
     return 0;
 }
 
-static int is_open_key_sample(const MOVStreamContext *sc, int sample)
+static int is_open_key_sample(const MOVStreamContext* sc, int sample)
 {
     // TODO: a bisect search would scale much better
     for (int i = 0; i < sc->open_key_samples_count; i++) {
@@ -11445,10 +11404,10 @@ static int is_open_key_sample(const MOVStreamContext *sc, int sample)
  * Some key sample may be key frames but not IDR frames, so a random access to
  * them may not be allowed.
  */
-static int can_seek_to_key_sample(AVStream *st, int sample, int64_t requested_pts)
+static int can_seek_to_key_sample(AVStream* st, int sample, int64_t requested_pts)
 {
-    MOVStreamContext *sc = st->priv_data;
-    FFStream *const sti = ffstream(st);
+    MOVStreamContext* sc = st->priv_data;
+    FFStream* const sti = ffstream(st);
     int64_t key_sample_dts, key_sample_pts;
 
     if (st->codecpar->codec_id != AV_CODEC_ID_HEVC)
@@ -11471,12 +11430,11 @@ static int can_seek_to_key_sample(AVStream *st, int sample, int64_t requested_pt
     return 1;
 }
 
-static int mov_seek_stream(AVFormatContext *s, AVStream *st, int64_t timestamp, int flags)
+static int mov_seek_stream(AVFormatContext* s, AVStream* st, int64_t timestamp, int flags)
 {
-    MOVStreamContext *sc = st->priv_data;
-    FFStream *const sti = ffstream(st);
-    int sample, time_sample, ret, requested_sample;
-    int64_t next_ts;
+    MOVStreamContext* sc = st->priv_data;
+    FFStream* const sti = ffstream(st);
+    int sample, time_sample, ret, next_ts, requested_sample;
     unsigned int i;
 
     // Here we consider timestamp to be PTS, hence try to offset it so that we
@@ -11544,10 +11502,10 @@ static int mov_seek_stream(AVFormatContext *s, AVStream *st, int64_t timestamp,
     return sample;
 }
 
-static int64_t mov_get_skip_samples(AVStream *st, int sample)
+static int64_t mov_get_skip_samples(AVStream* st, int sample)
 {
-    MOVStreamContext *sc = st->priv_data;
-    FFStream *const sti = ffstream(st);
+    MOVStreamContext* sc = st->priv_data;
+    FFStream* const sti = ffstream(st);
     int64_t first_ts = sti->index_entries[0].timestamp;
     int64_t ts = sti->index_entries[sample].timestamp;
     int64_t off;
@@ -11557,15 +11515,17 @@ static int64_t mov_get_skip_samples(AVStream *st, int sample)
 
     /* compute skip samples according to stream start_pad, seek ts and first ts */
     off = av_rescale_q(ts - first_ts, st->time_base,
-                       (AVRational){1, st->codecpar->sample_rate});
+        (AVRational) {
+        1, st->codecpar->sample_rate
+    });
     return FFMAX(sc->start_pad - off, 0);
 }
 
-static int mov_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
+static int mov_read_seek(AVFormatContext* s, int stream_index, int64_t sample_time, int flags)
 {
-    MOVContext *mc = s->priv_data;
-    AVStream *st;
-    FFStream *sti;
+    MOVContext* mc = s->priv_data;
+    AVStream* st;
+    FFStream* sti;
     int sample;
     int i;
 
@@ -11584,8 +11544,8 @@ static int mov_read_seek(AVFormatContext *s, int stream_index, int64_t sample_ti
         sti->skip_samples = mov_get_skip_samples(st, sample);
 
         for (i = 0; i < s->nb_streams; i++) {
-            AVStream *const st  = s->streams[i];
-            FFStream *const sti = ffstream(st);
+            AVStream* const st = s->streams[i];
+            FFStream* const sti = ffstream(st);
             int64_t timestamp;
 
             if (stream_index == i)
@@ -11596,16 +11556,17 @@ static int mov_read_seek(AVFormatContext *s, int stream_index, int64_t sample_ti
             if (sample >= 0)
                 sti->skip_samples = mov_get_skip_samples(st, sample);
         }
-    } else {
+    }
+    else {
         for (i = 0; i < s->nb_streams; i++) {
-            MOVStreamContext *sc;
+            MOVStreamContext* sc;
             st = s->streams[i];
             sc = st->priv_data;
             mov_current_sample_set(sc, 0);
         }
         while (1) {
-            MOVStreamContext *sc;
-            AVIndexEntry *entry = mov_find_next_sample(s, &st);
+            MOVStreamContext* sc;
+            AVIndexEntry* entry = mov_find_next_sample(s, &st);
             if (!entry)
                 return AVERROR_INVALIDDATA;
             sc = st->priv_data;
@@ -11626,7 +11587,7 @@ static const AVOption mov_options[] = {
         0, 1, FLAGS},
     {"seek_streams_individually",
         "Seek each stream individually to the closest point",
-        OFFSET(seek_individually), AV_OPT_TYPE_BOOL, { .i64 = 1 },
+        OFFSET(seek_individually), AV_OPT_TYPE_BOOL, {.i64 = 1 },
         0, 1, FLAGS},
     {"ignore_editlist", "Ignore the edit list atom.", OFFSET(ignore_editlist), AV_OPT_TYPE_BOOL, {.i64 = 0},
         0, 1, FLAGS},
@@ -11650,9 +11611,9 @@ static const AVOption mov_options[] = {
     {"use_tfdt", "use tfdt for fragment timestamps", OFFSET(use_tfdt), AV_OPT_TYPE_BOOL, {.i64 = 1},
         0, 1, FLAGS},
     { "export_all", "Export unrecognized metadata entries", OFFSET(export_all),
-        AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, .flags = FLAGS },
+        AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, .flags = FLAGS },
     { "export_xmp", "Export full XMP metadata", OFFSET(export_xmp),
-        AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, .flags = FLAGS },
+        AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, .flags = FLAGS },
     { "activation_bytes", "Secret bytes for Audible AAX files", OFFSET(activation_bytes),
         AV_OPT_TYPE_BINARY, .flags = AV_OPT_FLAG_DECODING_PARAM },
     { "audible_key", "AES-128 Key for Audible AAXC files", OFFSET(audible_key),
@@ -11661,12 +11622,12 @@ static const AVOption mov_options[] = {
         AV_OPT_TYPE_BINARY, .flags = AV_OPT_FLAG_DECODING_PARAM },
     { "audible_fixed_key", // extracted from libAAX_SDK.so and AAXSDKWin.dll files!
         "Fixed key used for handling Audible AAX files", OFFSET(audible_fixed_key),
-        AV_OPT_TYPE_BINARY, {.str="77214d4b196a87cd520045fd20a51d67"},
+        AV_OPT_TYPE_BINARY, {.str = "77214d4b196a87cd520045fd20a51d67"},
         .flags = AV_OPT_FLAG_DECODING_PARAM },
     { "decryption_key", "The media decryption key (hex)", OFFSET(decryption_key), AV_OPT_TYPE_BINARY, .flags = AV_OPT_FLAG_DECODING_PARAM },
     { "enable_drefs", "Enable external track support.", OFFSET(enable_drefs), AV_OPT_TYPE_BOOL,
         {.i64 = 0}, 0, 1, FLAGS },
-    { "max_stts_delta", "treat offsets above this value as invalid", OFFSET(max_stts_delta), AV_OPT_TYPE_INT, {.i64 = UINT_MAX-48000*10 }, 0, UINT_MAX, .flags = AV_OPT_FLAG_DECODING_PARAM },
+    { "max_stts_delta", "treat offsets above this value as invalid", OFFSET(max_stts_delta), AV_OPT_TYPE_INT, {.i64 = UINT_MAX - 48000 * 10 }, 0, UINT_MAX, .flags = AV_OPT_FLAG_DECODING_PARAM },
     { "interleaved_read", "Interleave packets from multiple tracks at demuxer level", OFFSET(interleaved_read), AV_OPT_TYPE_BOOL, {.i64 = 1 }, 0, 1, .flags = AV_OPT_FLAG_DECODING_PARAM },
 
     { NULL },
@@ -11674,22 +11635,22 @@ static const AVOption mov_options[] = {
 
 static const AVClass mov_class = {
     .class_name = "mov,mp4,m4a,3gp,3g2,mj2",
-    .item_name  = av_default_item_name,
-    .option     = mov_options,
-    .version    = LIBAVUTIL_VERSION_INT,
+    .item_name = av_default_item_name,
+    .option = mov_options,
+    .version = LIBAVUTIL_VERSION_INT,
 };
 
 const FFInputFormat ff_mov_demuxer = {
-    .p.name         = "mov,mp4,m4a,3gp,3g2,mj2",
-    .p.long_name    = NULL_IF_CONFIG_SMALL("QuickTime / MOV"),
-    .p.priv_class   = &mov_class,
-    .p.extensions   = "mov,mp4,m4a,3gp,3g2,mj2,psp,m4b,ism,ismv,isma,f4v,avif,heic,heif",
-    .p.flags        = AVFMT_NO_BYTE_SEEK | AVFMT_SEEK_TO_PTS | AVFMT_SHOW_IDS,
+    .p.name = "mov,mp4,m4a,3gp,3g2,mj2",
+    .p.long_name = NULL_IF_CONFIG_SMALL("QuickTime / MOV"),
+    .p.priv_class = &mov_class,
+    .p.extensions = "mov,mp4,m4a,3gp,3g2,mj2,psp,m4b,ism,ismv,isma,f4v,avif,heic,heif",
+    .p.flags = AVFMT_NO_BYTE_SEEK | AVFMT_SEEK_TO_PTS | AVFMT_SHOW_IDS,
     .priv_data_size = sizeof(MOVContext),
     .flags_internal = FF_INFMT_FLAG_INIT_CLEANUP,
-    .read_probe     = mov_probe,
-    .read_header    = mov_read_header,
-    .read_packet    = mov_read_packet,
-    .read_close     = mov_read_close,
-    .read_seek      = mov_read_seek,
+    .read_probe = mov_probe,
+    .read_header = mov_read_header,
+    .read_packet = mov_read_packet,
+    .read_close = mov_read_close,
+    .read_seek = mov_read_seek,
 };
-- 
2.51.2.windows.1

