#define m4af_realloc(memory,size) realloc(memory, size)
#define m4af_free(memory) free(memory)
+#define m4af_max(a,b) ((a)<(b)?(b):(a))
#define M4AF_ATOM_WILD 0xffffffff
int64_t modification_time;
int64_t mdat_pos;
int64_t mdat_size;
+ int priming_mode;
int last_error;
m4af_itmf_entry_t *itmf_table;
return rc;
}
+static
+int m4af_write16(m4af_ctx_t *ctx, uint32_t data)
+{
+ data = m4af_htob16(data);
+ return m4af_write(ctx, &data, 2);
+}
+
static
int m4af_write32(m4af_ctx_t *ctx, uint32_t data)
{
track->padding = padding;
}
+void m4af_set_priming_mode(m4af_ctx_t *ctx, int mode)
+{
+ ctx->priming_mode = mode;
+}
+
static
int m4af_add_sample_entry(m4af_ctx_t *ctx, uint32_t track_idx,
uint32_t size, uint32_t delta)
}
static
-int m4af_add_itmf_entry(m4af_ctx_t *ctx)
+m4af_itmf_entry_t *m4af_find_itmf_slot(m4af_ctx_t *ctx, uint32_t fcc,
+ const char *name)
{
- m4af_itmf_entry_t *entry;
+ m4af_itmf_entry_t *entry = ctx->itmf_table;
+
+ if (name)
+ fcc = M4AF_FOURCC('-','-','-','-');
+
+ if (fcc != M4AF_TAG_ARTWORK)
+ for (; entry != ctx->itmf_table + ctx->num_tags; ++entry)
+ if (fcc == entry->fcc && (!name || !strcmp(name, entry->name)))
+ return entry;
+
if (ctx->num_tags == ctx->itmf_table_capacity) {
uint32_t new_size = ctx->itmf_table_capacity;
new_size = new_size ? new_size * 2 : 1;
entry = m4af_realloc(ctx->itmf_table, new_size * sizeof(*entry));
if (entry == 0) {
ctx->last_error = M4AF_NO_MEMORY;
- return -1;
+ return 0;
}
ctx->itmf_table = entry;
ctx->itmf_table_capacity = new_size;
}
- ++ctx->num_tags;
- return 0;
+ entry = &ctx->itmf_table[ctx->num_tags++];
+ memset(entry, 0, sizeof(m4af_itmf_entry_t));
+ entry->fcc = fcc;
+ if (name) {
+ char *name_copy = m4af_realloc(0, strlen(name) + 1);
+ if (!name_copy) {
+ ctx->last_error = M4AF_NO_MEMORY;
+ --ctx->num_tags;
+ return 0;
+ }
+ strcpy(name_copy, name);
+ entry->name = name_copy;
+ }
+ return entry;
}
int m4af_add_itmf_long_tag(m4af_ctx_t *ctx, const char *name,
const char *data)
{
m4af_itmf_entry_t *entry;
+ char *data_copy = 0;
size_t name_len = strlen(name);
size_t data_len = strlen(data);
- char *name_copy = m4af_realloc(0, name_len + 1);
- char *data_copy = m4af_realloc(0, data_len);
- if (!name_copy || !data_copy) {
+ if (!name_len || !data_len)
+ return 0;
+
+ if ((entry = m4af_find_itmf_slot(ctx, 0, name)) == 0)
+ goto FAIL;
+ entry->type_code = M4AF_UTF8;
+ if ((data_copy = m4af_realloc(entry->data, data_len)) == 0) {
ctx->last_error = M4AF_NO_MEMORY;
goto FAIL;
}
- if (m4af_add_itmf_entry(ctx) < 0)
- goto FAIL;
- memcpy(name_copy, name, name_len + 1);
memcpy(data_copy, data, data_len);
- entry = ctx->itmf_table + ctx->num_tags - 1;
- entry->fcc = M4AF_FOURCC('-','-','-','-');
- entry->name = name_copy;
- entry->type_code = M4AF_UTF8;
entry->data = data_copy;
entry->data_size = data_len;
return 0;
FAIL:
- if (name_copy)
- m4af_free(name_copy);
- if (data_copy)
- m4af_free(data_copy);
return ctx->last_error;
}
uint32_t data_size)
{
m4af_itmf_entry_t *entry;
- char *data_copy = m4af_realloc(0, data_size);
- if (!data_copy) {
+ char *data_copy = 0;
+
+ if (!data_size)
+ return 0;
+ if ((entry = m4af_find_itmf_slot(ctx, fcc, 0)) == 0)
+ goto FAIL;
+ entry->type_code = type_code;
+ if ((data_copy = m4af_realloc(entry->data, data_size)) == 0) {
ctx->last_error = M4AF_NO_MEMORY;
goto FAIL;
}
- if (m4af_add_itmf_entry(ctx) < 0)
- goto FAIL;
- entry = ctx->itmf_table + ctx->num_tags - 1;
- entry->fcc = fcc;
- entry->name = 0;
- entry->type_code = type_code;
memcpy(data_copy, data, data_size);
entry->data = data_copy;
entry->data_size = data_size;
return 0;
FAIL:
- if (data_copy)
- m4af_free(data_copy);
return ctx->last_error;
}
}
static
-void m4af_update_box_size(m4af_ctx_t *ctx, int64_t pos)
+uint32_t m4af_update_box_size(m4af_ctx_t *ctx, int64_t pos)
{
int64_t current_pos = m4af_tell(ctx);
m4af_set_pos(ctx, pos);
m4af_write32(ctx, current_pos - pos);
m4af_set_pos(ctx, current_pos);
+ return current_pos - pos;
}
static
, 2);
m4af_write24(ctx, track->bufferSizeDB);
m4af_write32(ctx, track->maxBitrate);
+#if 0
m4af_write32(ctx, track->avgBitrate);
+#else
+ m4af_write32(ctx, 0);
+#endif
/* DecoderSpecificInfo */
m4af_write_descriptor(ctx, 5, track->decSpecificInfoSize);
m4af_write(ctx, track->decSpecificInfo, track->decSpecificInfoSize);
m4af_update_box_size(ctx, pos);
}
+static
+void m4af_write_sbgp_box(m4af_ctx_t *ctx, uint32_t track_idx)
+{
+ m4af_track_t *track = &ctx->track[track_idx];
+ m4af_write(ctx,
+ "\0\0\0\034" /* size: 28 */
+ "sbgp" /* type */
+ "\0" /* version */
+ "\0\0\0" /* flags */
+ "roll" /* grouping_type */
+ "\0\0\0\001" /* entry_count: 1 */
+ , 20);
+ m4af_write32(ctx, track->num_samples);
+ m4af_write32(ctx, 1); /* group_description_index */
+}
+
+static
+void m4af_write_sgpd_box(m4af_ctx_t *ctx, uint32_t track_idx)
+{
+ m4af_track_t *track = &ctx->track[track_idx];
+ m4af_write(ctx,
+ "\0\0\0\032" /* size */
+ "sgpd" /* type */
+ "\001" /* version */
+ "\0\0\0" /* flags */
+ "roll" /* grouping_type */
+ "\0\0\0\002" /* default_length: 2 */
+ "\0\0\0\001" /* entry_count: 1 */
+ "\377\377" /* payload_data: -1 */
+ , 26);
+}
+
static
void m4af_write_stbl_box(m4af_ctx_t *ctx, uint32_t track_idx)
{
+ m4af_track_t *track = &ctx->track[track_idx];
int64_t pos = m4af_tell(ctx);
m4af_write(ctx, "\0\0\0\0stbl", 8);
m4af_write_stsd_box(ctx, track_idx);
+ if ((ctx->priming_mode & M4AF_PRIMING_MODE_EDTS) &&
+ (track->encoder_delay || track->padding)) {
+ m4af_write_sbgp_box(ctx, track_idx);
+ m4af_write_sgpd_box(ctx, track_idx);
+ }
m4af_write_stts_box(ctx, track_idx);
m4af_write_stsc_box(ctx, track_idx);
m4af_write_stsz_box(ctx, track_idx);
m4af_update_box_size(ctx, pos);
}
+static
+void m4af_write_elst_box(m4af_ctx_t *ctx, uint32_t track_idx)
+{
+ m4af_track_t *track = &ctx->track[track_idx];
+ uint8_t version;
+ int64_t duration = track->duration - track->encoder_delay - track->padding;
+ int64_t pos = m4af_tell(ctx);
+ duration = (double)duration / track->timescale * ctx->timescale + .5;
+ version = (duration > UINT32_MAX);
+
+ m4af_write(ctx, "\0\0\0\0elst", 8);
+ m4af_write(ctx, &version, 1);
+ m4af_write(ctx, "\0\0\0", 3); /* flags */
+ m4af_write32(ctx, 1); /* entry_count: 1 */
+ if (version) {
+ m4af_write64(ctx, duration);
+ m4af_write64(ctx, track->encoder_delay);
+ } else {
+ m4af_write32(ctx, duration);
+ m4af_write32(ctx, track->encoder_delay);
+ }
+ m4af_write16(ctx, 1); /* media_rate_integer */
+ m4af_write16(ctx, 0); /* media_rate_fraction */
+ m4af_update_box_size(ctx, pos);
+}
+
+static
+void m4af_write_edts_box(m4af_ctx_t *ctx, uint32_t track_idx)
+{
+ m4af_track_t *track = &ctx->track[track_idx];
+ int64_t pos = m4af_tell(ctx);
+ m4af_write(ctx, "\0\0\0\0edts", 8);
+ m4af_write_elst_box(ctx, track_idx);
+ m4af_update_box_size(ctx, pos);
+}
+
static
void m4af_write_tkhd_box(m4af_ctx_t *ctx, uint32_t track_idx)
{
static
void m4af_write_trak_box(m4af_ctx_t *ctx, uint32_t track_idx)
{
+ m4af_track_t *track = &ctx->track[track_idx];
int64_t pos = m4af_tell(ctx);
m4af_write(ctx, "\0\0\0\0trak", 8);
m4af_write_tkhd_box(ctx, track_idx);
+ if ((ctx->priming_mode & M4AF_PRIMING_MODE_EDTS) &&
+ (track->encoder_delay || track->padding))
+ m4af_write_edts_box(ctx, track_idx);
m4af_write_mdia_box(ctx, track_idx);
m4af_update_box_size(ctx, pos);
}
}
static
-void m4af_write_moov_box(m4af_ctx_t *ctx)
+uint32_t m4af_write_moov_box(m4af_ctx_t *ctx)
{
unsigned i;
int64_t pos = m4af_tell(ctx);
m4af_write_trak_box(ctx, i);
if (ctx->num_tags)
m4af_write_udta_box(ctx);
- m4af_update_box_size(ctx, pos);
+ return m4af_update_box_size(ctx, pos);
}
static
m4af_set_pos(ctx, ctx->mdat_pos + ctx->mdat_size);
}
-int m4af_finalize(m4af_ctx_t *ctx)
+static
+void m4af_shift_mdat_pos(m4af_ctx_t *ctx, uint32_t offset)
+{
+ unsigned i, j;
+ int64_t begin, end;
+ char buf[8192];
+
+ end = ctx->mdat_pos + ctx->mdat_size;
+ for (; (begin = m4af_max(ctx->mdat_pos, end - 8192)) < end; end = begin) {
+ m4af_set_pos(ctx, begin);
+ ctx->io.read(ctx->io_cookie, buf, end - begin);
+ m4af_set_pos(ctx, begin + offset);
+ m4af_write(ctx, buf, end - begin);
+ }
+ for (i = 0; i < ctx->num_tracks; ++i)
+ for (j = 0; j < ctx->track[i].num_chunks; ++j)
+ ctx->track[i].chunk_table[j].offset += offset;
+ ctx->mdat_pos += offset;
+ m4af_set_pos(ctx, ctx->mdat_pos - 16);
+ m4af_write_free_box(ctx, 0);
+ m4af_write(ctx, "\0\0\0\0mdat", 8);
+ m4af_finalize_mdat(ctx);
+}
+
+int m4af_finalize(m4af_ctx_t *ctx, int optimize)
{
unsigned i;
m4af_track_t *track;
+ uint32_t moov_size;
for (i = 0; i < ctx->num_tracks; ++i) {
track = ctx->track + i;
}
m4af_flush_chunk(ctx, i);
}
- if (ctx->track[0].encoder_delay || ctx->track[0].padding)
+ track = ctx->track;
+ if ((ctx->priming_mode & M4AF_PRIMING_MODE_ITUNSMPB) &&
+ (track->encoder_delay || track->padding))
m4af_set_iTunSMPB(ctx);
m4af_finalize_mdat(ctx);
- m4af_write_moov_box(ctx);
+ moov_size = m4af_write_moov_box(ctx);
+ if (optimize) {
+ int64_t pos;
+ m4af_shift_mdat_pos(ctx, moov_size + 1024);
+ m4af_set_pos(ctx, 32);
+ m4af_write_moov_box(ctx);
+ pos = m4af_tell(ctx);
+ m4af_write_free_box(ctx, ctx->mdat_pos - pos - 24);
+ }
return ctx->last_error;
}
projects / fdkaac.git / blobdiff