X-Git-Url: http://git.tuebingen.mpg.de/?a=blobdiff_plain;f=mp4.c;h=365dce6550a5a150d1736cd194de8318667f4492;hb=2ca18e6d22391a7eded4a21925a44860a9840ecf;hp=d030d62d3e759c81ddfa440a6b47613e87f4d14e;hpb=eb369edec255c992294a77b83f981e46c5de7906;p=paraslash.git diff --git a/mp4.c b/mp4.c index d030d62d..365dce65 100644 --- a/mp4.c +++ b/mp4.c @@ -14,8 +14,9 @@ #include "mp4.h" struct mp4_track { - uint16_t channelCount; - uint16_t sampleRate; + /* mp4a */ + uint16_t channel_count; + uint16_t sample_rate; /* stsz */ uint32_t stsz_sample_size; @@ -35,7 +36,8 @@ struct mp4_track { uint32_t stco_entry_count; uint32_t *stco_chunk_offset; - uint32_t timeScale; + /* mdhd */ + uint32_t time_scale; uint64_t duration; }; @@ -43,7 +45,6 @@ struct mp4_track { struct mp4 { const struct mp4_callback *cb; - int64_t current_position; uint64_t moov_offset; uint64_t moov_size; @@ -55,8 +56,6 @@ struct mp4 { uint32_t udta_size; uint8_t last_atom; - uint64_t file_size; - /* incremental track index while reading the file */ int32_t total_tracks; /* track data */ @@ -81,7 +80,6 @@ static int read_data(struct mp4 *f, void *data, size_t size) /* regard EAGAIN as an error as reads should be blocking. */ if (ret <= 0) return ret < 0? -1 : 0; - f->current_position += ret; size -= ret; } return 1; @@ -92,7 +90,7 @@ static int read_int64(struct mp4 *f, uint64_t *result) uint8_t data[8]; int ret = read_data(f, data, 8); - if (ret > 0 && result) + if (ret > 0) *result = read_u64_be(data); return ret; } @@ -102,130 +100,64 @@ static int read_int32(struct mp4 *f, uint32_t *result) uint8_t data[4]; int ret = read_data(f, data, 4); - if (ret > 0 && result) + if (ret > 0) *result = read_u32_be(data); return ret; } -static int read_int24(struct mp4 *f, uint32_t *result) -{ - uint8_t data[3]; - int ret = read_data(f, data, 3); - - if (ret > 0 && result) - *result = read_u24_be(data); - return ret; -} - static int read_int16(struct mp4 *f, uint16_t *result) { uint8_t data[2]; int ret = read_data(f, data, 2); - if (ret > 0 && result) + if (ret > 0) *result = read_u16_be(data); return ret; } -static uint8_t read_int8(struct mp4 *f, uint8_t *result) -{ - uint8_t data[1]; - int ret = read_data(f, data, 1); - - if (ret > 0 && result) - *result = data[0]; - return ret; -} - -static bool atom_compare(int8_t a1, int8_t b1, int8_t c1, int8_t d1, - int8_t a2, int8_t b2, int8_t c2, int8_t d2) -{ - return a1 == a2 && b1 == b2 && c1 == c2 && d1 == d2; -} - -enum atoms { - /* atoms with subatoms */ - ATOM_MOOV, - ATOM_TRAK, - ATOM_MDIA, - ATOM_MINF, - ATOM_STBL, - ATOM_UDTA, - ATOM_ILST, /* iTunes Metadata list */ - ATOM_TITLE, - ATOM_ARTIST, - ATOM_ALBUM, - ATOM_DATE, - ATOM_COMMENT, - - SUBATOMIC = 128, - - /* atoms without subatoms */ - ATOM_MDHD, /* track header */ - ATOM_STSD, /* sample description box */ - ATOM_STTS, /* time to sample box */ - ATOM_STSZ, /* sample size box */ - ATOM_STCO, /* chunk offset box */ - ATOM_STSC, /* sample to chunk box */ - ATOM_MP4A, - ATOM_META, /* iTunes Metadata box */ - ATOM_DATA, /* iTunes Metadata data box */ - ATOM_UNKNOWN = 255 -}; - -#define COPYRIGHT_SYMBOL ((int8_t)0xA9) - -static uint8_t atom_name_to_type(int8_t a, int8_t b, int8_t c, int8_t d) -{ - if (a == 'm') { - if (atom_compare(a, b, c, d, 'm', 'o', 'o', 'v')) - return ATOM_MOOV; - else if (atom_compare(a, b, c, d, 'm', 'i', 'n', 'f')) - return ATOM_MINF; - else if (atom_compare(a, b, c, d, 'm', 'd', 'i', 'a')) - return ATOM_MDIA; - else if (atom_compare(a, b, c, d, 'm', 'd', 'h', 'd')) - return ATOM_MDHD; - else if (atom_compare(a, b, c, d, 'm', 'p', '4', 'a')) - return ATOM_MP4A; - else if (atom_compare(a, b, c, d, 'm', 'e', 't', 'a')) - return ATOM_META; - } else if (a == 't') { - if (atom_compare(a, b, c, d, 't', 'r', 'a', 'k')) - return ATOM_TRAK; - } else if (a == 's') { - if (atom_compare(a, b, c, d, 's', 't', 'b', 'l')) - return ATOM_STBL; - else if (atom_compare(a, b, c, d, 's', 't', 's', 'd')) - return ATOM_STSD; - else if (atom_compare(a, b, c, d, 's', 't', 't', 's')) - return ATOM_STTS; - else if (atom_compare(a, b, c, d, 's', 't', 'c', 'o')) - return ATOM_STCO; - else if (atom_compare(a, b, c, d, 's', 't', 's', 'c')) - return ATOM_STSC; - else if (atom_compare(a, b, c, d, 's', 't', 's', 'z')) - return ATOM_STSZ; - } else if (a == COPYRIGHT_SYMBOL) { - if (atom_compare(a, b, c, d, COPYRIGHT_SYMBOL, 'n', 'a', 'm')) - return ATOM_TITLE; - else if (atom_compare(a, b, c, d, COPYRIGHT_SYMBOL, 'A', 'R', 'T')) - return ATOM_ARTIST; - else if (atom_compare(a, b, c, d, COPYRIGHT_SYMBOL, 'a', 'l', 'b')) - return ATOM_ALBUM; - else if (atom_compare(a, b, c, d, COPYRIGHT_SYMBOL, 'd', 'a', 'y')) - return ATOM_DATE; - else if (atom_compare(a, b, c, d, COPYRIGHT_SYMBOL, 'c', 'm', 't')) - return ATOM_COMMENT; - } - if (atom_compare(a, b, c, d, 'u', 'd', 't', 'a')) - return ATOM_UDTA; - else if (atom_compare(a, b, c, d, 'i', 'l', 's', 't')) - return ATOM_ILST; - else if (atom_compare(a, b, c, d, 'd', 'a', 't', 'a')) - return ATOM_DATA; - else - return ATOM_UNKNOWN; +#define ATOM_ITEMS \ + ATOM_ITEM(MOOV, 'm', 'o', 'o', 'v') \ + ATOM_ITEM(TRAK, 't', 'r', 'a', 'k') \ + ATOM_ITEM(MDIA, 'm', 'd', 'i', 'a') \ + ATOM_ITEM(MINF, 'm', 'i', 'n', 'f') \ + ATOM_ITEM(STBL, 's', 't', 'b', 'l') \ + ATOM_ITEM(UDTA, 'u', 'd', 't', 'a') \ + ATOM_ITEM(ILST, 'i', 'l', 's', 't') /* iTunes Metadata list */ \ + ATOM_ITEM(ARTIST, 0xa9, 'A', 'R', 'T') \ + ATOM_ITEM(TITLE, 0xa9, 'n', 'a', 'm') \ + ATOM_ITEM(ALBUM, 0xa9, 'a', 'l', 'b') \ + ATOM_ITEM(DATE, 0xa9, 'd', 'a', 'y') \ + ATOM_ITEM(COMMENT, 0xa9, 'c', 'm', 't') \ + ATOM_ITEM(MDHD, 'm', 'd', 'h', 'd') /* track header */ \ + ATOM_ITEM(STSD, 's', 't', 's', 'd') /* sample description box */ \ + ATOM_ITEM(STTS, 's', 't', 't', 's') /* time to sample box */ \ + ATOM_ITEM(STSZ, 's', 't', 's', 'z') /* sample size box */ \ + ATOM_ITEM(STCO, 's', 't', 'c', 'o') /* chunk offset box */ \ + ATOM_ITEM(STSC, 's', 't', 's', 'c') /* sample to chunk box */ \ + ATOM_ITEM(MP4A, 'm', 'p', '4', 'a') \ + ATOM_ITEM(META, 'm', 'e', 't', 'a') /* iTunes Metadata box */ \ + ATOM_ITEM(DATA, 'd', 'a', 't', 'a') /* iTunes Metadata data box */ \ + +#define ATOM_ITEM(_name, a, b, c, d) ATOM_ ## _name, +enum atom {ATOM_ITEMS}; +#undef ATOM_ITEM + +static uint8_t atom_name_to_type(uint8_t *p) +{ + #define ATOM_VALUE(a, b, c, d) ((a << 24) + (b << 16) + (c << 8) + d) + #define ATOM_ITEM(_name, a, b, c, d) \ + {.name = # _name, .val = ATOM_VALUE(a, b, c, d)}, + static const struct { + const char *name; + uint32_t val; + } atom_table[] = {ATOM_ITEMS}; + #undef ATOM_ITEM + uint32_t val = read_u32_be(p); + + for (uint8_t n = 0; n < ARRAY_SIZE(atom_table); n++) + if (val == atom_table[n].val) + return n; + return 255; } /* read atom header, atom size is returned with header included. */ @@ -234,7 +166,7 @@ static int atom_read_header(struct mp4 *f, uint8_t *atom_type, { uint32_t size; int ret; - int8_t atom_header[8]; + uint8_t atom_header[8]; ret = read_data(f, atom_header, 8); if (ret <= 0) @@ -252,22 +184,23 @@ static int atom_read_header(struct mp4 *f, uint8_t *atom_type, if (atom_size) *atom_size = size; } - *atom_type = atom_name_to_type(atom_header[4], atom_header[5], - atom_header[6], atom_header[7]); + *atom_type = atom_name_to_type(atom_header + 4); return 1; } -static int64_t get_position(const struct mp4 *f) +static off_t get_position(const struct mp4 *f) { - return f->current_position; + return f->cb->seek(f->cb->user_data, 0, SEEK_CUR); } -static int32_t set_position(struct mp4 *f, int64_t position) +static void set_position(struct mp4 *f, off_t position) { - f->cb->seek(f->cb->user_data, position); - f->current_position = position; + f->cb->seek(f->cb->user_data, position, SEEK_SET); +} - return 0; +static void skip_bytes(struct mp4 *f, off_t num_skip) +{ + f->cb->seek(f->cb->user_data, num_skip, SEEK_CUR); } static int read_stsz(struct mp4 *f) @@ -279,12 +212,7 @@ static int read_stsz(struct mp4 *f) if (f->total_tracks == 0) return -1; t = f->track[f->total_tracks - 1]; - ret = read_int8(f, NULL); /* version */ - if (ret <= 0) - return ret; - ret = read_int24(f, NULL); /* flags */ - if (ret <= 0) - return ret; + skip_bytes(f, 4); /* version (1), flags (3) */ ret = read_int32(f, &t->stsz_sample_size); if (ret <= 0) return ret; @@ -313,12 +241,7 @@ static int read_stts(struct mp4 *f) t = f->track[f->total_tracks - 1]; if (t->stts_entry_count) return 0; - ret = read_int8(f, NULL); /* version */ - if (ret <= 0) - return ret; - ret = read_int24(f, NULL); /* flags */ - if (ret <= 0) - return ret; + skip_bytes(f, 4); /* version (1), flags (3) */ ret = read_int32(f, &t->stts_entry_count); if (ret <= 0) return ret; @@ -328,9 +251,7 @@ static int read_stts(struct mp4 *f) ret = read_int32(f, &t->stts_sample_count[i]); if (ret <= 0) return ret; - ret = read_int32(f, NULL); /* sample delta */ - if (ret <= 0) - return ret; + skip_bytes(f, 4); /* sample delta */ } return 1; } @@ -345,12 +266,7 @@ static int read_stsc(struct mp4 *f) return -1; t = f->track[f->total_tracks - 1]; - ret = read_int8(f, NULL); /* version */ - if (ret <= 0) - return ret; - ret = read_int24(f, NULL); /* flags */ - if (ret <= 0) - return ret; + skip_bytes(f, 4); /* version (1), flags (3) */ ret = read_int32(f, &t->stsc_entry_count); if (ret <= 0) return ret; @@ -364,9 +280,7 @@ static int read_stsc(struct mp4 *f) ret = read_int32(f, &t->stsc_samples_per_chunk[i]); if (ret <= 0) return ret; - ret = read_int32(f, NULL); /* sample desc index */ - if (ret <= 0) - return ret; + skip_bytes(f, 4); /* sample desc index */ } return 1; } @@ -381,12 +295,7 @@ static int read_stco(struct mp4 *f) return -1; t = f->track[f->total_tracks - 1]; - ret = read_int8(f, NULL); /* version */ - if (ret <= 0) - return ret; - ret = read_int24(f, NULL); /* flags */ - if (ret <= 0) - return ret; + skip_bytes(f, 4); /* version (1), flags (3) */ ret = read_int32(f, &t->stco_entry_count); if (ret <= 0) return ret; @@ -400,45 +309,6 @@ static int read_stco(struct mp4 *f) return 1; } -static int read_mp4a(struct mp4 *f) -{ - int ret; - int32_t i; - struct mp4_track *t; - - if (f->total_tracks == 0) - return -1; - t = f->track[f->total_tracks - 1]; - - for (i = 0; i < 6; i++) { - ret = read_int8(f, NULL); /* reserved */ - if (ret <= 0) - return ret; - } - ret = read_int16(f, NULL); /* data_reference_index */ - if (ret <= 0) - return ret; - ret = read_int32(f, NULL); /* reserved */ - if (ret <= 0) - return ret; - ret = read_int32(f, NULL); /* reserved */ - if (ret <= 0) - return ret; - ret = read_int16(f, &t->channelCount); - if (ret <= 0) - return ret; - ret = read_int16(f, NULL); - if (ret <= 0) - return ret; - ret = read_int16(f, NULL); - if (ret <= 0) - return ret; - ret = read_int16(f, NULL); - if (ret <= 0) - return ret; - return read_int16(f, &t->sampleRate); -} - static int read_stsd(struct mp4 *f) { int ret; @@ -448,12 +318,7 @@ static int read_stsd(struct mp4 *f) if (f->total_tracks == 0) return -1; t = f->track[f->total_tracks - 1]; - ret = read_int8(f, NULL); /* version */ - if (ret <= 0) - return ret; - ret = read_int24(f, NULL); /* flags */ - if (ret <= 0) - return ret; + skip_bytes(f, 4); /* version (1), flags (3) */ ret = read_int32(f, &entry_count); if (ret <= 0) return ret; @@ -467,7 +332,15 @@ static int read_stsd(struct mp4 *f) skip += size; if (!f->audio_track && atom_type == ATOM_MP4A) { f->audio_track = t; - read_mp4a(f); + /* reserved (6), data reference index (2), reserved (8) */ + skip_bytes(f, 16); + ret = read_int16(f, &t->channel_count); + if (ret <= 0) + return ret; + skip_bytes(f, 6); + ret = read_int16(f, &t->sample_rate); + if (ret <= 0) + return ret; } set_position(f, skip); } @@ -508,15 +381,7 @@ static int parse_tag(struct mp4 *f, uint8_t parent, int32_t size) destpos = get_position(f) + subsize - header_size; if (atom_type != ATOM_DATA) continue; - ret = read_int8(f, NULL); /* version */ - if (ret <= 0) - goto fail; - ret = read_int24(f, NULL); /* flags */ - if (ret <= 0) - goto fail; - ret = read_int32(f, NULL); /* reserved */ - if (ret <= 0) - goto fail; + skip_bytes(f, 8); /* version (1), flags (3), reserved (4) */ ret = -ERRNO_TO_PARA_ERROR(EINVAL); if (subsize < header_size + 8 || subsize > UINT_MAX) goto fail; @@ -557,13 +422,8 @@ static int read_mdhd(struct mp4 *f) if (ret <= 0) return ret; if (version == 1) { - ret = read_int64(f, NULL); /* creation-time */ - if (ret <= 0) - return ret; - ret = read_int64(f, NULL); /* modification-time */ - if (ret <= 0) - return ret; - ret = read_int32(f, &t->timeScale); + skip_bytes(f, 16); /* creation time (8), modification time (8) */ + ret = read_int32(f, &t->time_scale); if (ret <= 0) return ret; ret = read_int64(f, &t->duration); @@ -572,13 +432,8 @@ static int read_mdhd(struct mp4 *f) } else { //version == 0 uint32_t temp; - ret = read_int32(f, NULL); /* creation-time */ - if (ret <= 0) - return ret; - ret = read_int32(f, NULL); /* modification-time */ - if (ret <= 0) - return ret; - ret = read_int32(f, &t->timeScale); + skip_bytes(f, 8); /* creation time (4), modification time (4) */ + ret = read_int32(f, &t->time_scale); if (ret <= 0) return ret; ret = read_int32(f, &temp); @@ -587,12 +442,7 @@ static int read_mdhd(struct mp4 *f) t->duration = (temp == (uint32_t) (-1))? (uint64_t) (-1) : (uint64_t) (temp); } - ret = read_int16(f, NULL); - if (ret <= 0) - return ret; - ret = read_int16(f, NULL); - if (ret <= 0) - return ret; + skip_bytes(f, 4); return 1; } @@ -632,12 +482,7 @@ static int32_t read_meta(struct mp4 *f, uint64_t size) uint8_t atom_type; uint8_t header_size = 0; - ret = read_int8(f, NULL); /* version */ - if (ret <= 0) - return ret; - ret = read_int24(f, NULL); /* flags */ - if (ret <= 0) - return ret; + skip_bytes(f, 4); /* version (1), flags (3) */ while (sumsize < (size - (header_size + 4))) { ret = atom_read_header(f, &atom_type, &header_size, &subsize); if (ret <= 0) @@ -657,29 +502,6 @@ static int32_t read_meta(struct mp4 *f, uint64_t size) return 1; } -static int parse_leaf_atom(struct mp4 *f, uint64_t size, uint8_t header_size, - uint8_t atom_type) -{ - uint64_t dest_position = get_position(f) + size - 8; - int ret = 1; /* return success for atoms we don't care about */ - - switch (atom_type) { - case ATOM_STSZ: ret = read_stsz(f); break; - case ATOM_STTS: ret = read_stts(f); break; - case ATOM_STSC: ret = read_stsc(f); break; - case ATOM_STCO: ret = read_stco(f); break; - case ATOM_STSD: ret = read_stsd(f); break; - case ATOM_MDHD: ret = read_mdhd(f); break; - case ATOM_META: - f->meta_offset = get_position(f) - header_size; - f->meta_size = size; - ret = read_meta(f, size); - break; - } - set_position(f, dest_position); - return ret; -} - static bool need_atom(uint8_t atom_type, bool meta_only) { /* these are needed in any case */ @@ -734,10 +556,21 @@ static int parse_sub_atoms(struct mp4 *f, uint64_t total_size, bool meta_only) } if (!need_atom(atom_type, meta_only)) continue; - if (atom_type < SUBATOMIC) /* atom contains subatoms */ + switch (atom_type) { + case ATOM_STSZ: ret = read_stsz(f); break; + case ATOM_STTS: ret = read_stts(f); break; + case ATOM_STSC: ret = read_stsc(f); break; + case ATOM_STCO: ret = read_stco(f); break; + case ATOM_STSD: ret = read_stsd(f); break; + case ATOM_MDHD: ret = read_mdhd(f); break; + case ATOM_META: + f->meta_offset = get_position(f) - header_size; + f->meta_size = size; + ret = read_meta(f, size); + break; + default: ret = parse_sub_atoms(f, size - header_size, meta_only); - else - ret = parse_leaf_atom(f, size, header_size, atom_type); + } if (ret <= 0) return ret; } @@ -753,7 +586,6 @@ static int open_file(const struct mp4_callback *cb, bool meta_only, struct mp4 * f->cb = cb; while ((ret = atom_read_header(f, &atom_type, &header_size, &size)) > 0) { - f->file_size += size; f->last_atom = atom_type; if (atom_type != ATOM_MOOV || size <= header_size) { /* skip */ set_position(f, get_position(f) + size - header_size); @@ -837,9 +669,9 @@ uint64_t mp4_get_duration(const struct mp4 *f) { const struct mp4_track *t = f->audio_track; - if (t->timeScale == 0) + if (t->time_scale == 0) return 0; - return t->duration * 1000 / t->timeScale; + return t->duration * 1000 / t->time_scale; } int mp4_set_sample_position(struct mp4 *f, int32_t sample) @@ -878,12 +710,12 @@ int32_t mp4_get_sample_size(const struct mp4 *f, int sample) uint32_t mp4_get_sample_rate(const struct mp4 *f) { - return f->audio_track->sampleRate; + return f->audio_track->sample_rate; } uint32_t mp4_get_channel_count(const struct mp4 *f) { - return f->audio_track->channelCount ; + return f->audio_track->channel_count; } int32_t mp4_num_samples(const struct mp4 *f) @@ -960,11 +792,6 @@ static void create_ilst(const struct mp4_metadata *meta, uint8_t *out) } } -static uint32_t fix_byte_order_32(uint32_t src) -{ - return read_u32_be(&src); -} - static void *modify_moov(struct mp4 *f, uint32_t *out_size) { int ret; @@ -990,7 +817,7 @@ static void *modify_moov(struct mp4 *f, uint32_t *out_size) ret = read_int32(f, &tmp); if (ret <= 0) return NULL; - *(uint32_t *)p_out = fix_byte_order_32(tmp + size_delta); + write_u32_be(p_out, tmp + size_delta); p_out += 4; ret = read_data(f, p_out, 4); if (ret <= 0) @@ -1003,7 +830,7 @@ static void *modify_moov(struct mp4 *f, uint32_t *out_size) ret = read_int32(f, &tmp); if (ret <= 0) return NULL; - *(uint32_t *)p_out = fix_byte_order_32(tmp + size_delta); + write_u32_be(p_out, tmp + size_delta); p_out += 4; ret = read_data(f, p_out, 4); if (ret <= 0) @@ -1016,7 +843,7 @@ static void *modify_moov(struct mp4 *f, uint32_t *out_size) ret = read_int32(f, &tmp); if (ret <= 0) return NULL; - *(uint32_t *)p_out = fix_byte_order_32(tmp + size_delta); + write_u32_be(p_out, tmp + size_delta); p_out += 4; ret = read_data(f, p_out, 4); if (ret <= 0) @@ -1032,28 +859,26 @@ static void *modify_moov(struct mp4 *f, uint32_t *out_size) return out_buffer; } -static int32_t write_data(struct mp4 *f, void *data, uint32_t size) -{ - int32_t result = 1; - - result = f->cb->write(f->cb->user_data, data, size); - - f->current_position += size; - - return result; -} - -static int32_t write_int32(struct mp4 *f, uint32_t data) +static int write_data(struct mp4 *f, void *data, size_t size) { - int8_t temp[4]; - write_u32_be(temp, data); - return write_data(f, temp, sizeof(temp)); + while (size > 0) { + ssize_t ret = f->cb->write(f->cb->user_data, data, size); + if (ret < 0) { + if (errno == EINTR) + continue; + return -ERRNO_TO_PARA_ERROR(errno); + } + size -= ret; + } + return 1; } -int32_t mp4_meta_update(struct mp4 *f) +int mp4_meta_update(struct mp4 *f) { void *new_moov_data; uint32_t new_moov_size; + uint8_t buf[8] = "----moov"; + int ret; set_position(f, 0); new_moov_data = modify_moov(f, &new_moov_size); @@ -1061,27 +886,27 @@ int32_t mp4_meta_update(struct mp4 *f) mp4_close(f); return 0; } - /* copy moov atom to end of the file */ if (f->last_atom != ATOM_MOOV) { - char *free_data = "free"; - - /* rename old moov to free */ set_position(f, f->moov_offset + 4); - write_data(f, free_data, 4); - - set_position(f, f->file_size); - write_int32(f, new_moov_size + 8); - write_data(f, "moov", 4); - write_data(f, new_moov_data, new_moov_size); - } else { + ret = write_data(f, "free", 4); /* rename old moov to free */ + if (ret < 0) + goto free_moov; + /* write new moov atom at EOF */ + f->cb->seek(f->cb->user_data, 0, SEEK_END); + } else /* overwrite old moov atom */ set_position(f, f->moov_offset); - write_int32(f, new_moov_size + 8); - write_data(f, "moov", 4); - write_data(f, new_moov_data, new_moov_size); - } - free(new_moov_data); + write_u32_be(buf, new_moov_size + 8); + ret = write_data(f, buf, sizeof(buf)); + if (ret < 0) + goto free_moov; + ret = write_data(f, new_moov_data, new_moov_size); + if (ret < 0) + goto free_moov; f->cb->truncate(f->cb->user_data); - return 1; + ret = 1; +free_moov: + free(new_moov_data); + return ret; } static char *meta_find_by_name(const struct mp4 *f, const char *item)