src/m4af.c

   1 /*
   2  * Copyright (C) 2013 nu774
   3  * For conditions of distribution and use, see copyright notice in COPYING
   4  */
   5 #if HAVE_CONFIG_H
   6 #  include "config.h"
   7 #endif
   8 #include <stdio.h>
   9 #include <stdlib.h>
  10 #include <string.h>
  11 #include <assert.h>
  12 #include <time.h>
  13 #if HAVE_STDINT_H
  14 #  include <stdint.h>
  15 #endif
  16 #if HAVE_INTTYPES_H
  17 #  include <inttypes.h>
  18 #elif defined _MSC_VER
  19 #  define PRId64 "I64d"
  20 #endif
  21 #include "m4af.h"
  22 #include "m4af_endian.h"
  23
  24 #define m4af_realloc(memory,size) realloc(memory, size)
  25 #define m4af_free(memory) free(memory)
  26 #define m4af_max(a,b) ((a)<(b)?(b):(a))
  27
  28 #define M4AF_ATOM_WILD  0xffffffff
  29
  30 typedef struct m4af_sample_entry_t {
  31     uint32_t size;
  32     uint32_t delta;
  33 } m4af_sample_entry_t;
  34
  35 typedef struct m4af_chunk_entry_t {
  36     int64_t offset;
  37     uint32_t size;
  38     uint32_t samples_per_chunk;
  39     uint32_t duration;
  40 } m4af_chunk_entry_t;
  41
  42 typedef struct m4af_track_t {
  43     uint32_t codec;
  44     uint32_t timescale;
  45     int64_t creation_time;
  46     int64_t modification_time;
  47     int64_t duration;
  48     uint32_t frame_duration;
  49     uint32_t encoder_delay;
  50     uint32_t padding;
  51     uint8_t *decSpecificInfo;
  52     uint32_t decSpecificInfoSize;
  53     uint32_t bufferSizeDB;
  54     uint32_t maxBitrate;
  55     uint32_t avgBitrate;
  56
  57     m4af_sample_entry_t *sample_table;
  58     uint32_t num_samples;
  59     uint32_t sample_table_capacity;
  60
  61     m4af_chunk_entry_t *chunk_table;
  62     uint32_t num_chunks;
  63     uint32_t chunk_table_capacity;
  64
  65     uint8_t *chunk_buffer;
  66     uint32_t chunk_size;
  67     uint32_t chunk_capacity;
  68
  69     /* temporary, to help parsing */
  70     uint64_t stsc_pos;
  71     uint64_t stsc_size;
  72
  73     uint64_t stts_pos;
  74     uint64_t stts_size;
  75 } m4af_track_t;
  76
  77 struct m4af_ctx_t {
  78     uint32_t timescale;
  79     int64_t creation_time;
  80     int64_t modification_time;
  81     int64_t mdat_pos;
  82     int64_t mdat_size;
  83     int priming_mode;
  84     int last_error;
  85
  86     m4af_itmf_entry_t *itmf_table;
  87     uint32_t num_tags;
  88     uint32_t itmf_table_capacity;
  89
  90     m4af_io_callbacks_t io;
  91     void *io_cookie;
  92
  93     uint16_t num_tracks;
  94     m4af_track_t track[2];
  95
  96     m4af_itmf_entry_t current_tag;
  97 };
  98
  99 typedef struct m4af_box_parser_t {
 100     uint32_t name;
 101     int (*handler)(m4af_ctx_t *ctx, uint32_t name, uint64_t size);
 102 } m4af_box_parser_t;
 103
 104 static
 105 int64_t m4af_timestamp(void)
 106 {
 107     return (int64_t)(time(0)) + (((1970 - 1904) * 365) + 17) * 24 * 60 * 60;
 108 }
 109
 110 /*
 111  * http://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
 112  */
 113 static
 114 uint32_t m4af_roundup(uint32_t n)
 115 {
 116     n--;
 117     n |= n >> 1;
 118     n |= n >> 2;
 119     n |= n >> 4;
 120     n |= n >> 8;
 121     n |= n >> 16;
 122     n++;
 123     return n;
 124 }
 125
 126 static
 127 int64_t m4af_tell(m4af_ctx_t *ctx)
 128 {
 129     int64_t pos = -1;
 130     if ((pos = ctx->io.tell(ctx->io_cookie)) < 0)
 131         ctx->last_error = M4AF_IO_ERROR;
 132     return pos;
 133 }
 134
 135 static
 136 int m4af_set_pos(m4af_ctx_t *ctx, int64_t pos)
 137 {
 138     int rc = -1;
 139     if ((rc = ctx->io.seek(ctx->io_cookie, pos, SEEK_SET)) < 0)
 140         ctx->last_error = M4AF_IO_ERROR;
 141     return rc;
 142 }
 143
 144 static
 145 int m4af_write(m4af_ctx_t *ctx, const void *data, uint32_t size)
 146 {
 147     int rc = -1;
 148     if ((rc = ctx->io.write(ctx->io_cookie, data, size)) < 0)
 149         ctx->last_error = M4AF_IO_ERROR;
 150     return rc;
 151 }
 152
 153 static
 154 int m4af_write16(m4af_ctx_t *ctx, uint32_t data)
 155 {
 156     data = m4af_htob16(data);
 157     return m4af_write(ctx, &data, 2);
 158 }
 159
 160 static
 161 int m4af_write32(m4af_ctx_t *ctx, uint32_t data)
 162 {
 163     data = m4af_htob32(data);
 164     return m4af_write(ctx, &data, 4);
 165 }
 166
 167 static
 168 int m4af_write64(m4af_ctx_t *ctx, uint64_t data)
 169 {
 170     data = m4af_htob64(data);
 171     return m4af_write(ctx, &data, 8);
 172 }
 173
 174 static
 175 int m4af_write24(m4af_ctx_t *ctx, uint32_t data)
 176 {
 177     data = m4af_htob32(data << 8);
 178     return m4af_write(ctx, &data, 3);
 179 }
 180
 181 static
 182 void m4af_write32_at(m4af_ctx_t *ctx, int64_t pos, uint32_t value)
 183 {
 184     int64_t current_pos = m4af_tell(ctx);
 185     m4af_set_pos(ctx, pos);
 186     m4af_write32(ctx, value);
 187     m4af_set_pos(ctx, current_pos);
 188 }
 189
 190 m4af_ctx_t *m4af_create(uint32_t codec, uint32_t timescale,
 191                         m4af_io_callbacks_t *io, void *io_cookie)
 192 {
 193     m4af_ctx_t *ctx;
 194     int64_t timestamp;
 195
 196     if (codec != M4AF_FOURCC('m','p','4','a') &&
 197         codec != M4AF_FOURCC('a','l','a','c'))
 198         return 0;
 199     if ((ctx = m4af_realloc(0, sizeof(m4af_ctx_t))) == 0)
 200         return 0;
 201     memset(ctx, 0, sizeof(m4af_ctx_t));
 202     memcpy(&ctx->io, io, sizeof(m4af_io_callbacks_t));
 203     ctx->io_cookie = io_cookie;
 204     ctx->timescale = timescale;
 205     timestamp = m4af_timestamp();
 206     ctx->creation_time = timestamp;
 207     ctx->modification_time = timestamp;
 208     ctx->num_tracks = 1;
 209     ctx->track[0].codec = codec;
 210     ctx->track[0].timescale = timescale;
 211     ctx->track[0].creation_time = timestamp;
 212     ctx->track[0].modification_time = timestamp;
 213     return ctx;
 214 }
 215
 216 static
 217 void m4af_free_itmf_table(m4af_ctx_t *ctx)
 218 {
 219     uint32_t i;
 220     m4af_itmf_entry_t *entry = ctx->itmf_table;
 221     for (i = 0; i < ctx->num_tags; ++i, ++entry) {
 222         if (entry->fcc == M4AF_FOURCC('-','-','-','-'))
 223             m4af_free(entry->name);
 224         m4af_free(entry->data);
 225     }
 226     m4af_free(ctx->itmf_table);
 227 }
 228
 229 static
 230 void m4af_clear_track(m4af_ctx_t *ctx, int track_idx)
 231 {
 232     m4af_track_t *track = ctx->track + track_idx;
 233     if (track->decSpecificInfo)
 234         m4af_free(track->decSpecificInfo);
 235     if (track->sample_table)
 236         m4af_free(track->sample_table);
 237     if (track->chunk_table)
 238         m4af_free(track->chunk_table);
 239     if (track->chunk_buffer)
 240         m4af_free(track->chunk_buffer);
 241     memset(track, 0, sizeof(m4af_track_t));
 242 }
 243
 244 void m4af_teardown(m4af_ctx_t **ctxp)
 245 {
 246     unsigned i;
 247     m4af_ctx_t *ctx = *ctxp;
 248     for (i = 0; i < ctx->num_tracks; ++i)
 249         m4af_clear_track(ctx, i);
 250     if (ctx->itmf_table)
 251         m4af_free_itmf_table(ctx);
 252     m4af_free(ctx);
 253     *ctxp = 0;
 254 }
 255
 256 void m4af_set_fixed_frame_duration(m4af_ctx_t *ctx, uint32_t track_idx,
 257                                    uint32_t length)
 258 {
 259     ctx->track[track_idx].frame_duration = length;
 260 }
 261
 262 int m4af_set_decoder_specific_info(m4af_ctx_t *ctx, uint32_t track_idx,
 263                                    uint8_t *data, uint32_t size)
 264 {
 265     m4af_track_t *track = &ctx->track[track_idx];
 266     if (size > track->decSpecificInfoSize) {
 267         uint8_t *memory = m4af_realloc(track->decSpecificInfo, size);
 268         if (memory == 0) {
 269             ctx->last_error = M4AF_NO_MEMORY;
 270             goto DONE;
 271         }
 272         track->decSpecificInfo = memory;
 273     }
 274     if (size > 0)
 275         memcpy(track->decSpecificInfo, data, size);
 276     track->decSpecificInfoSize = size;
 277 DONE:
 278     return ctx->last_error;
 279 }
 280
 281 void m4af_set_priming(m4af_ctx_t *ctx, uint32_t track_idx,
 282                       uint32_t encoder_delay, uint32_t padding)
 283 {
 284     m4af_track_t *track = &ctx->track[track_idx];
 285     track->encoder_delay = encoder_delay;
 286     track->padding = padding;
 287 }
 288
 289 void m4af_set_priming_mode(m4af_ctx_t *ctx, int mode)
 290 {
 291     ctx->priming_mode = mode;
 292 }
 293
 294 static
 295 int m4af_add_sample_entry(m4af_ctx_t *ctx, uint32_t track_idx,
 296                           uint32_t size, uint32_t delta)
 297 {
 298     m4af_track_t *track = &ctx->track[track_idx];
 299     m4af_sample_entry_t *entry;
 300
 301     if (ctx->last_error)
 302         return -1;
 303     if (track->num_samples == track->sample_table_capacity) {
 304         uint32_t new_size = track->sample_table_capacity;
 305         new_size = new_size ? new_size * 2 : 1;
 306         entry = m4af_realloc(track->sample_table, new_size * sizeof(*entry));
 307         if (entry == 0) {
 308             ctx->last_error = M4AF_NO_MEMORY;
 309             return -1;
 310         }
 311         track->sample_table = entry;
 312         track->sample_table_capacity = new_size;
 313     }
 314     entry = track->sample_table + track->num_samples;
 315     entry->size = size;
 316     entry->delta = delta;
 317     ++track->num_samples;
 318     return 0;
 319 }
 320
 321 static
 322 int m4af_flush_chunk(m4af_ctx_t *ctx, uint32_t track_idx)
 323 {
 324     m4af_track_t *track = &ctx->track[track_idx];
 325     m4af_chunk_entry_t *entry;
 326     if (!track->num_chunks || !track->chunk_size)
 327         return 0;
 328     entry = &track->chunk_table[track->num_chunks - 1];
 329     entry->offset = m4af_tell(ctx);
 330     m4af_write(ctx, track->chunk_buffer, track->chunk_size);
 331     ctx->mdat_size += track->chunk_size;
 332     track->chunk_size = 0;
 333     return ctx->last_error ? -1 : 0;
 334 }
 335
 336 static
 337 int m4af_add_chunk_entry(m4af_ctx_t *ctx, uint32_t track_idx)
 338 {
 339     m4af_track_t *track = &ctx->track[track_idx];
 340     m4af_chunk_entry_t *entry;
 341     if (track->num_chunks == track->chunk_table_capacity) {
 342         uint32_t new_size = track->chunk_table_capacity;
 343         new_size = new_size ? new_size * 2 : 1;
 344         entry = m4af_realloc(track->chunk_table, new_size * sizeof(*entry));
 345         if (entry == 0) {
 346             ctx->last_error = M4AF_NO_MEMORY;
 347             return -1;
 348         }
 349         track->chunk_table = entry;
 350         track->chunk_table_capacity = new_size;
 351     }
 352     memset(&track->chunk_table[track->num_chunks++], 0,
 353            sizeof(m4af_chunk_entry_t));
 354     return 0;
 355 }
 356
 357 static
 358 int m4af_update_chunk_table(m4af_ctx_t *ctx, uint32_t track_idx,
 359                             uint32_t size, uint32_t delta)
 360 {
 361     m4af_track_t *track = &ctx->track[track_idx];
 362     m4af_chunk_entry_t *entry;
 363     int add_new_chunk = 0;
 364
 365     if (ctx->last_error)
 366         return -1;
 367     if (track->num_chunks == 0)
 368         add_new_chunk = 1;
 369     else {
 370         entry = &track->chunk_table[track->num_chunks - 1];
 371         if (entry->duration + delta > track->timescale / 2)
 372             add_new_chunk = 1;
 373     }
 374     if (add_new_chunk) {
 375         m4af_flush_chunk(ctx, track_idx);
 376         if (m4af_add_chunk_entry(ctx, track_idx) < 0)
 377             return -1;
 378     }
 379     entry = &track->chunk_table[track->num_chunks - 1];
 380     entry->size += size;
 381     ++entry->samples_per_chunk;
 382     entry->duration += delta;
 383     return 0;
 384 }
 385
 386 static
 387 void m4af_update_max_bitrate(m4af_ctx_t *ctx, uint32_t track_idx)
 388 {
 389     m4af_track_t *track = &ctx->track[track_idx];
 390     uint32_t duration = 0, size = 0, bitrate;
 391     m4af_sample_entry_t *ent = track->sample_table + track->num_samples - 1;
 392
 393     for (; ent >= track->sample_table && duration < track->timescale; --ent) {
 394         duration += ent->delta;
 395         size += ent->size;
 396     }
 397     bitrate = (uint32_t)(size * 8.0 * track->timescale / duration + .5);
 398     if (bitrate > track->maxBitrate)
 399         track->maxBitrate = bitrate;
 400 }
 401
 402 static
 403 int m4af_append_sample_to_chunk(m4af_ctx_t *ctx, uint32_t track_idx,
 404                                 const void *data, uint32_t size)
 405 {
 406     m4af_track_t *track = &ctx->track[track_idx];
 407     uint32_t newsize = track->chunk_size + size;
 408
 409     if (ctx->last_error)
 410         return -1;
 411     if (track->chunk_capacity < newsize) {
 412         uint32_t capacity = m4af_roundup(newsize);
 413         uint8_t *memory = realloc(track->chunk_buffer, capacity);
 414         if (!memory) {
 415             ctx->last_error = M4AF_NO_MEMORY;
 416             return -1;
 417         }
 418         track->chunk_buffer = memory;
 419         track->chunk_capacity = capacity;
 420     }
 421     memcpy(track->chunk_buffer + track->chunk_size, data, size);
 422     track->chunk_size = newsize;
 423     return 0;
 424 }
 425
 426 int m4af_write_sample(m4af_ctx_t *ctx, uint32_t track_idx, const void *data,
 427                       uint32_t size, uint32_t duration)
 428 {
 429     m4af_track_t *track = &ctx->track[track_idx];
 430     if (track->frame_duration)
 431         duration = track->frame_duration;
 432     if (size > track->bufferSizeDB)
 433         track->bufferSizeDB = size;
 434     track->duration += duration;
 435     m4af_add_sample_entry(ctx, track_idx, size, duration);
 436     m4af_update_chunk_table(ctx, track_idx, size, duration);
 437     m4af_update_max_bitrate(ctx, track_idx);
 438     m4af_append_sample_to_chunk(ctx, track_idx, data, size);
 439     return ctx->last_error;
 440 }
 441
 442 static
 443 m4af_itmf_entry_t *m4af_find_itmf_slot(m4af_ctx_t *ctx, uint32_t fcc,
 444                                        const char *name)
 445 {
 446     m4af_itmf_entry_t *entry = ctx->itmf_table;
 447
 448     if (name)
 449         fcc = M4AF_FOURCC('-','-','-','-');
 450
 451     if (fcc != M4AF_TAG_ARTWORK)
 452         for (; entry != ctx->itmf_table + ctx->num_tags; ++entry)
 453             if (fcc == entry->fcc && (!name || !strcmp(name, entry->name)))
 454                 return entry;
 455
 456     if (ctx->num_tags == ctx->itmf_table_capacity) {
 457         uint32_t new_size = ctx->itmf_table_capacity;
 458         new_size = new_size ? new_size * 2 : 1;
 459         entry = m4af_realloc(ctx->itmf_table, new_size * sizeof(*entry));
 460         if (entry == 0) {
 461             ctx->last_error = M4AF_NO_MEMORY;
 462             return 0;
 463         }
 464         ctx->itmf_table = entry;
 465         ctx->itmf_table_capacity = new_size;
 466     }
 467     entry = &ctx->itmf_table[ctx->num_tags++];
 468     memset(entry, 0, sizeof(m4af_itmf_entry_t));
 469     entry->fcc = fcc;
 470     if (name) {
 471         char *name_copy = m4af_realloc(0, strlen(name) + 1);
 472         if (!name_copy) {
 473             ctx->last_error = M4AF_NO_MEMORY;
 474             --ctx->num_tags;
 475             return 0;
 476         }
 477         strcpy(name_copy, name);
 478         entry->name = name_copy;
 479     }
 480     return entry;
 481 }
 482
 483 int m4af_add_itmf_long_tag(m4af_ctx_t *ctx, const char *name,
 484                            const char *data)
 485 {
 486     m4af_itmf_entry_t *entry;
 487     char *data_copy = 0;
 488     size_t name_len = strlen(name);
 489     size_t data_len = strlen(data);
 490     if (!name_len || !data_len)
 491         return 0;
 492
 493     if ((entry = m4af_find_itmf_slot(ctx, 0, name)) == 0)
 494         goto FAIL;
 495     entry->type_code = M4AF_UTF8;
 496     if ((data_copy = m4af_realloc(entry->data, data_len)) == 0) {
 497         ctx->last_error = M4AF_NO_MEMORY;
 498         goto FAIL;
 499     }
 500     memcpy(data_copy, data, data_len);
 501     entry->data = data_copy;
 502     entry->data_size = data_len;
 503     return 0;
 504 FAIL:
 505     return ctx->last_error;
 506 }
 507
 508 int m4af_add_itmf_short_tag(m4af_ctx_t *ctx, uint32_t fcc,
 509                             uint32_t type_code, const void *data,
 510                             uint32_t data_size)
 511 {
 512     m4af_itmf_entry_t *entry;
 513     char *data_copy = 0;
 514
 515     if (!data_size)
 516         return 0;
 517     if ((entry = m4af_find_itmf_slot(ctx, fcc, 0)) == 0)
 518         goto FAIL;
 519     entry->type_code = type_code;
 520     if ((data_copy = m4af_realloc(entry->data, data_size)) == 0) {
 521         ctx->last_error = M4AF_NO_MEMORY;
 522         goto FAIL;
 523     }
 524     memcpy(data_copy, data, data_size);
 525     entry->data = data_copy;
 526     entry->data_size = data_size;
 527     return 0;
 528 FAIL:
 529     return ctx->last_error;
 530 }
 531
 532 int m4af_add_itmf_string_tag(m4af_ctx_t *ctx, uint32_t fcc, const char *data)
 533 {
 534     return m4af_add_itmf_short_tag(ctx, fcc, M4AF_UTF8, data, strlen(data));
 535 }
 536
 537 int m4af_add_itmf_int8_tag(m4af_ctx_t *ctx, uint32_t fcc, int value)
 538 {
 539     uint8_t data = value;
 540     return m4af_add_itmf_short_tag(ctx, fcc, M4AF_INTEGER, &data, 1);
 541 }
 542
 543 int m4af_add_itmf_int16_tag(m4af_ctx_t *ctx, uint32_t fcc, int value)
 544 {
 545     uint16_t data = m4af_htob16(value);
 546     return m4af_add_itmf_short_tag(ctx, fcc, M4AF_INTEGER, &data, 2);
 547 }
 548
 549 int m4af_add_itmf_int32_tag(m4af_ctx_t *ctx, uint32_t fcc, uint32_t value)
 550 {
 551     uint32_t data = m4af_htob32(value);
 552     return m4af_add_itmf_short_tag(ctx, fcc, M4AF_INTEGER, &data, 4);
 553 }
 554
 555 int m4af_add_itmf_int64_tag(m4af_ctx_t *ctx, uint32_t fcc, uint64_t value)
 556 {
 557     uint64_t data = m4af_htob64(value);
 558     return m4af_add_itmf_short_tag(ctx, fcc, M4AF_INTEGER, &data, 8);
 559 }
 560
 561 int m4af_add_itmf_track_tag(m4af_ctx_t *ctx, int track, int total)
 562 {
 563     uint16_t data[4] = { 0 };
 564     data[1] = m4af_htob16(track);
 565     data[2] = m4af_htob16(total);
 566     return m4af_add_itmf_short_tag(ctx, M4AF_FOURCC('t','r','k','n'),
 567                                    M4AF_IMPLICIT, &data, 8);
 568 }
 569
 570 int m4af_add_itmf_disk_tag(m4af_ctx_t *ctx, int disk, int total)
 571 {
 572     uint16_t data[3] = { 0 };
 573     data[1] = m4af_htob16(disk);
 574     data[2] = m4af_htob16(total);
 575     return m4af_add_itmf_short_tag(ctx, M4AF_FOURCC('d','i','s','k'),
 576                                    M4AF_IMPLICIT, &data, 6);
 577 }
 578
 579 int m4af_add_itmf_genre_tag(m4af_ctx_t *ctx, int genre)
 580 {
 581     uint16_t data = m4af_htob16(genre);
 582     return m4af_add_itmf_short_tag(ctx, M4AF_FOURCC('g','n','r','e'),
 583                                    M4AF_IMPLICIT, &data, 2);
 584 }
 585
 586 static
 587 int m4af_set_iTunSMPB(m4af_ctx_t *ctx)
 588 {
 589     const char *fmt = " 00000000 %08X %08X %08X%08X 00000000 00000000 "
 590         "00000000 00000000 00000000 00000000 00000000 00000000";
 591     m4af_track_t *track = &ctx->track[0];
 592     char buf[256];
 593     uint64_t length = track->duration - track->encoder_delay - track->padding;
 594     sprintf(buf, fmt, track->encoder_delay, track->padding,
 595             (uint32_t)(length >> 32), (uint32_t)length);
 596     return m4af_add_itmf_long_tag(ctx, "iTunSMPB", buf);
 597 }
 598
 599 static
 600 uint32_t m4af_update_box_size(m4af_ctx_t *ctx, int64_t pos)
 601 {
 602     int64_t current_pos = m4af_tell(ctx);
 603     m4af_set_pos(ctx, pos);
 604     m4af_write32(ctx, current_pos - pos);
 605     m4af_set_pos(ctx, current_pos);
 606     return current_pos - pos;
 607 }
 608
 609 static
 610 void m4af_write_descriptor(m4af_ctx_t *ctx, uint32_t tag, uint32_t size)
 611 {
 612     uint8_t buf[5];
 613     buf[0] = tag;
 614     buf[1] = ((size >> 21) | 0x80);
 615     buf[2] = ((size >> 14) | 0x80);
 616     buf[3] = ((size >>  7) | 0x80);
 617     buf[4] = (size & 0x7f);
 618     m4af_write(ctx, buf, 5);
 619 }
 620
 621 static
 622 void m4af_write_ftyp_box(m4af_ctx_t *ctx)
 623 {
 624     m4af_write(ctx, "\0\0\0\040""ftypM4A \0\0\0\0M4A mp42isom\0\0\0\0", 32);
 625 }
 626
 627 static
 628 void m4af_write_free_box(m4af_ctx_t *ctx, uint32_t size)
 629 {
 630     int64_t pos = m4af_tell(ctx);
 631     m4af_write32(ctx, size + 8);
 632     m4af_write(ctx, "free", 4);
 633     if (size > 0)
 634         m4af_set_pos(ctx, pos + size + 8);
 635 }
 636
 637 int m4af_begin_write(m4af_ctx_t *ctx)
 638 {
 639     m4af_write_ftyp_box(ctx);
 640     m4af_write_free_box(ctx, 0);
 641     m4af_write(ctx, "\0\0\0\0mdat", 8);
 642     ctx->mdat_pos = m4af_tell(ctx);
 643     return ctx->last_error;
 644 }
 645
 646 static
 647 void m4af_write_stco_box(m4af_ctx_t *ctx, uint32_t track_idx)
 648 {
 649     m4af_track_t *track = &ctx->track[track_idx];
 650     uint32_t i;
 651     m4af_chunk_entry_t *index = track->chunk_table;
 652     int is_co64 = (ctx->mdat_pos + ctx->mdat_size > UINT32_MAX);
 653     int64_t pos = m4af_tell(ctx);
 654
 655     m4af_write32(ctx, 0); /* size */
 656     m4af_write(ctx, is_co64 ? "co64" : "stco", 4);
 657     m4af_write32(ctx, 0); /* version and flags */
 658     m4af_write32(ctx, track->num_chunks);
 659     for (i = 0; i < track->num_chunks; ++i, ++index) {
 660         if (is_co64)
 661             m4af_write64(ctx, index->offset);
 662         else
 663             m4af_write32(ctx, index->offset);
 664     }
 665     m4af_update_box_size(ctx, pos);
 666 }
 667
 668 static
 669 void m4af_write_stsz_box(m4af_ctx_t *ctx, uint32_t track_idx)
 670 {
 671     m4af_track_t *track = &ctx->track[track_idx];
 672     m4af_sample_entry_t *index = track->sample_table;
 673     uint32_t i;
 674     int64_t pos = m4af_tell(ctx);
 675     m4af_write(ctx,
 676                "\0\0\0\0"  /* size                     */
 677                "stsz"      /* type                     */
 678                "\0"        /* version                  */
 679                "\0\0\0"    /* flags                    */
 680                "\0\0\0\0"  /* sample_size: 0(variable) */
 681                , 16);
 682     m4af_write32(ctx, track->num_samples);
 683     for (i = 0; i < track->num_samples; ++i, ++index)
 684         m4af_write32(ctx, index->size);
 685     m4af_update_box_size(ctx, pos);
 686 }
 687
 688 static
 689 void m4af_write_stsc_box(m4af_ctx_t *ctx, uint32_t track_idx)
 690 {
 691     m4af_track_t *track = &ctx->track[track_idx];
 692     m4af_chunk_entry_t *index = track->chunk_table;
 693     uint32_t i, prev_samples_per_chunk = 0, entry_count = 0;
 694     int64_t pos = m4af_tell(ctx);
 695     m4af_write(ctx,
 696                "\0\0\0\0"  /* size        */
 697                "stsc"      /* type        */
 698                "\0"        /* version     */
 699                "\0\0\0"    /* flags       */
 700                "\0\0\0\0"  /* entry_count */
 701                , 16);
 702
 703     for (i = 0; i < track->num_chunks; ++i, ++index) {
 704         if (index->samples_per_chunk != prev_samples_per_chunk) {
 705             ++entry_count;
 706             m4af_write32(ctx, i + 1);
 707             m4af_write32(ctx, index->samples_per_chunk);
 708             m4af_write32(ctx, 1); /* sample_description_index */
 709             prev_samples_per_chunk = index->samples_per_chunk;
 710         }
 711     }
 712     m4af_write32_at(ctx, pos + 12, entry_count);
 713     m4af_update_box_size(ctx, pos);
 714 }
 715
 716 static
 717 void m4af_write_stts_box(m4af_ctx_t *ctx, uint32_t track_idx)
 718 {
 719     m4af_track_t *track = &ctx->track[track_idx];
 720     m4af_sample_entry_t *index = track->sample_table;
 721     uint32_t i, prev_delta = 0, entry_count = 0, sample_count = 0;
 722     int64_t pos = m4af_tell(ctx);
 723     m4af_write(ctx,
 724                "\0\0\0\0"  /* size        */
 725                "stts"      /* type        */
 726                "\0"        /* version     */
 727                "\0\0\0"    /* flags       */
 728                "\0\0\0\0"  /* entry_count */
 729                , 16);
 730
 731     for (i = 0; i < track->num_samples; ++i, ++index) {
 732         if (index->delta == prev_delta)
 733             ++sample_count;
 734         else {
 735             ++entry_count;
 736             if (sample_count) {
 737                 m4af_write32(ctx, sample_count);
 738                 m4af_write32(ctx, prev_delta);
 739             }
 740             prev_delta = index->delta;
 741             sample_count = 1;
 742         }
 743     }
 744     if (sample_count) {
 745         m4af_write32(ctx, sample_count);
 746         m4af_write32(ctx, prev_delta);
 747     }
 748     m4af_write32_at(ctx, pos + 12, entry_count);
 749     m4af_update_box_size(ctx, pos);
 750 }
 751
 752 static
 753 void m4af_write_esds_box(m4af_ctx_t *ctx, uint32_t track_idx)
 754 {
 755     m4af_track_t *track = &ctx->track[track_idx];
 756     int64_t pos = m4af_tell(ctx);
 757     m4af_write(ctx, "\0\0\0\0esds", 8);
 758     m4af_write32(ctx, 0); /* version + flags */
 759
 760     /* ES_Descriptor */
 761     m4af_write_descriptor(ctx, 3, 32 + track->decSpecificInfoSize);
 762     m4af_write(ctx, "\0\0\0", 3);
 763     /* DecoderConfigDescriptor */
 764     m4af_write_descriptor(ctx, 4, 18 + track->decSpecificInfoSize);
 765     m4af_write(ctx,
 766                "\x40"   /* objectTypeIndication: 0x40(Audio ISO/IEC 14496-3)*/
 767                "\x15"   /* streamType(6): 0x05(AudioStream)
 768                          * upStream(1)  : 0
 769                          * reserved(1)  : 1
 770                          */
 771                , 2);
 772     m4af_write24(ctx, track->bufferSizeDB);
 773     m4af_write32(ctx, track->maxBitrate);
 774 #if 0
 775     m4af_write32(ctx, track->avgBitrate);
 776 #else
 777     m4af_write32(ctx, 0);
 778 #endif
 779     /* DecoderSpecificInfo */
 780     m4af_write_descriptor(ctx, 5, track->decSpecificInfoSize);
 781     m4af_write(ctx, track->decSpecificInfo, track->decSpecificInfoSize);
 782     /* SLConfigDescriptor */
 783     m4af_write_descriptor(ctx, 6, 1);
 784     m4af_write(ctx, "\002", 1); /* predefined */
 785
 786     m4af_update_box_size(ctx, pos);
 787 }
 788
 789 static
 790 void m4af_write_alac_box(m4af_ctx_t *ctx, uint32_t track_idx)
 791 {
 792     m4af_track_t *track = &ctx->track[track_idx];
 793     int64_t pos = m4af_tell(ctx);
 794     m4af_write(ctx,
 795                "\0\0\0\0"  /* size        */
 796                "alac"      /* type        */
 797                "\0"        /* version     */
 798                "\0\0\0"    /* flags       */
 799                , 12);
 800     m4af_write(ctx, track->decSpecificInfo, track->decSpecificInfoSize);
 801     m4af_update_box_size(ctx, pos);
 802 }
 803
 804 static
 805 void m4af_write_mp4a_box(m4af_ctx_t *ctx, uint32_t track_idx)
 806 {
 807     m4af_track_t *track = &ctx->track[track_idx];
 808     int64_t pos = m4af_tell(ctx);
 809     m4af_write32(ctx, 0);   /* size         */
 810     m4af_write32(ctx, track->codec); /* mp4a or alac */
 811     m4af_write(ctx,
 812                "\0\0\0\0\0\0" /* reserved                */
 813                "\0\001"       /* data_reference_index: 1 */
 814                "\0\0\0\0"     /* reserved[0]             */
 815                "\0\0\0\0"     /* reserved[1]             */
 816                "\0\002"       /* channelcount: 2         */
 817                "\0\020"       /* samplesize: 16          */
 818                "\0\0"         /* pre_defined             */
 819                "\0\0"         /* reserved                */
 820                ,24);
 821     if (track->codec == M4AF_FOURCC('m','p','4','a')) {
 822         m4af_write32(ctx, track->timescale << 16);
 823         m4af_write_esds_box(ctx, track_idx);
 824     } else {
 825         m4af_write32(ctx, 44100 << 16);
 826         m4af_write_alac_box(ctx, track_idx);
 827     }
 828     m4af_update_box_size(ctx, pos);
 829 }
 830
 831 static
 832 void m4af_write_stsd_box(m4af_ctx_t *ctx, uint32_t track_idx)
 833 {
 834     int64_t pos = m4af_tell(ctx);
 835     m4af_write(ctx, "\0\0\0\0stsd", 8);
 836     m4af_write(ctx,
 837                "\0"          /* version        */
 838                "\0\0\0"      /* flags          */
 839                "\0\0\0\001"  /* entry_count: 1 */
 840                , 8);
 841     m4af_write_mp4a_box(ctx, track_idx);
 842     m4af_update_box_size(ctx, pos);
 843 }
 844
 845 static
 846 void m4af_write_sbgp_box(m4af_ctx_t *ctx, uint32_t track_idx)
 847 {
 848     m4af_track_t *track = &ctx->track[track_idx];
 849     m4af_write(ctx,
 850                "\0\0\0\034"  /* size: 28                */
 851                "sbgp"        /* type                    */
 852                "\0"          /* version                 */
 853                "\0\0\0"      /* flags                   */
 854                "roll"        /* grouping_type           */
 855                "\0\0\0\001"  /* entry_count: 1          */
 856                , 20);
 857     m4af_write32(ctx, track->num_samples);
 858     m4af_write32(ctx, 1);    /* group_description_index */
 859 }
 860
 861 static
 862 void m4af_write_sgpd_box(m4af_ctx_t *ctx, uint32_t track_idx)
 863 {
 864     m4af_track_t *track = &ctx->track[track_idx];
 865     m4af_write(ctx,
 866                "\0\0\0\032"  /* size               */
 867                "sgpd"        /* type               */
 868                "\001"        /* version            */
 869                "\0\0\0"      /* flags              */
 870                "roll"        /* grouping_type      */
 871                "\0\0\0\002"  /* default_length: 2  */
 872                "\0\0\0\001"  /* entry_count: 1     */
 873                "\377\377"    /* payload_data: -1   */
 874                , 26);
 875 }
 876
 877 static
 878 void m4af_write_stbl_box(m4af_ctx_t *ctx, uint32_t track_idx)
 879 {
 880     m4af_track_t *track = &ctx->track[track_idx];
 881     int64_t pos = m4af_tell(ctx);
 882     m4af_write(ctx, "\0\0\0\0stbl", 8);
 883     m4af_write_stsd_box(ctx, track_idx);
 884     if ((ctx->priming_mode & M4AF_PRIMING_MODE_EDTS) &&
 885         (track->encoder_delay || track->padding)) {
 886         m4af_write_sbgp_box(ctx, track_idx);
 887         m4af_write_sgpd_box(ctx, track_idx);
 888     }
 889     m4af_write_stts_box(ctx, track_idx);
 890     m4af_write_stsc_box(ctx, track_idx);
 891     m4af_write_stsz_box(ctx, track_idx);
 892     m4af_write_stco_box(ctx, track_idx);
 893     m4af_update_box_size(ctx, pos);
 894 }
 895
 896 static
 897 void m4af_write_url_box(m4af_ctx_t *ctx, uint32_t track_idx)
 898 {
 899     m4af_write(ctx,
 900                "\0\0\0\014"  /* size                       */
 901                "url "        /* type                       */
 902                "\0"          /* version                    */
 903                "\0\0\001"    /* flags: 1(in the same file) */
 904                , 12);
 905 }
 906
 907 static
 908 void m4af_write_dref_box(m4af_ctx_t *ctx, uint32_t track_idx)
 909 {
 910     int64_t pos = m4af_tell(ctx);
 911     m4af_write(ctx, "\0\0\0\0dref", 8);
 912     m4af_write(ctx,
 913                "\0"          /* version        */
 914                "\0\0\0"      /* flags          */
 915                "\0\0\0\001"  /* entry_count: 1 */
 916                ,8);
 917     m4af_write_url_box(ctx, track_idx);
 918     m4af_update_box_size(ctx, pos);
 919 }
 920
 921 static
 922 void m4af_write_dinf_box(m4af_ctx_t *ctx, uint32_t track_idx)
 923 {
 924     int64_t pos = m4af_tell(ctx);
 925     m4af_write(ctx, "\0\0\0\0dinf", 8);
 926     m4af_write_dref_box(ctx, track_idx);
 927     m4af_update_box_size(ctx, pos);
 928 }
 929
 930 static
 931 void m4af_write_smhd_box(m4af_ctx_t *ctx, uint32_t track_idx)
 932 {
 933     m4af_write(ctx,
 934                "\0\0\0\020"  /* size          */
 935                "smhd"        /* type          */
 936                "\0"          /* version       */
 937                "\0\0\0"      /* flags         */
 938                "\0\0"        /* balance       */
 939                "\0\0"        /* reserved      */
 940                , 16);
 941 }
 942
 943 static
 944 void m4af_write_minf_box(m4af_ctx_t *ctx, uint32_t track_idx)
 945 {
 946     m4af_track_t *track = &ctx->track[track_idx];
 947     int64_t pos = m4af_tell(ctx);
 948     m4af_write(ctx, "\0\0\0\0minf", 8);
 949     /* TODO: add TEXT support */
 950     if (track->codec != M4AF_CODEC_TEXT)
 951         m4af_write_smhd_box(ctx, track_idx);
 952     m4af_write_dinf_box(ctx, track_idx);
 953     m4af_write_stbl_box(ctx, track_idx);
 954     m4af_update_box_size(ctx, pos);
 955 }
 956
 957 static
 958 void m4af_write_mdhd_box(m4af_ctx_t *ctx, uint32_t track_idx)
 959 {
 960     m4af_track_t *track = &ctx->track[track_idx];
 961     int64_t pos = m4af_tell(ctx);
 962     uint8_t version = (track->creation_time > UINT32_MAX ||
 963                        track->modification_time > UINT32_MAX ||
 964                        track->duration > UINT32_MAX);
 965
 966     m4af_write(ctx, "\0\0\0\0mdhd", 8);
 967     m4af_write(ctx, &version, 1);
 968     m4af_write(ctx, "\0\0\0", 3); /* flags */
 969     if (version) {
 970         m4af_write64(ctx, track->creation_time);
 971         m4af_write64(ctx, track->modification_time);
 972         m4af_write32(ctx, track->timescale);
 973         m4af_write64(ctx, track->duration);
 974     } else {
 975         m4af_write32(ctx, track->creation_time);
 976         m4af_write32(ctx, track->modification_time);
 977         m4af_write32(ctx, track->timescale);
 978         m4af_write32(ctx, track->duration);
 979     }
 980     m4af_write(ctx,
 981                "\x55\xc4"  /* language: und */
 982                "\0\0"      /* pre_defined   */
 983                , 4);
 984     m4af_update_box_size(ctx, pos);
 985 }
 986
 987 static
 988 void m4af_write_hdlr_box(m4af_ctx_t *ctx, uint32_t track_idx, const char *type)
 989 {
 990     int64_t pos = m4af_tell(ctx);
 991     static const char reserved_and_name[10] = { 0 };
 992
 993     m4af_write(ctx,
 994                "\0\0\0\0"  /* size          */
 995                "hdlr"      /* type          */
 996                "\0"        /* version       */
 997                "\0\0\0"    /* flags         */
 998                "\0\0\0\0"  /* pre_defined   */
 999                , 16);
1000     m4af_write(ctx, type, 4); /* handler_type */
1001     /* reserved[0] */
1002     m4af_write(ctx, !strcmp(type, "mdir") ? "appl" : "\0\0\0\0", 4);
1003     /* reserved[1], reserved[2], name */
1004     m4af_write(ctx, reserved_and_name, (pos & 1) ? 9 : 10);
1005     m4af_update_box_size(ctx, pos);
1006 }
1007
1008 static
1009 void m4af_write_mdia_box(m4af_ctx_t *ctx, uint32_t track_idx)
1010 {
1011     m4af_track_t *track = &ctx->track[track_idx];
1012     const char *hdlr =
1013         (track->codec == M4AF_CODEC_TEXT) ? "text" : "soun";
1014     int64_t pos = m4af_tell(ctx);
1015     m4af_write(ctx, "\0\0\0\0mdia", 8);
1016     m4af_write_mdhd_box(ctx, track_idx);
1017     m4af_write_hdlr_box(ctx, track_idx, hdlr);
1018     m4af_write_minf_box(ctx, track_idx);
1019     m4af_update_box_size(ctx, pos);
1020 }
1021
1022 static
1023 void m4af_write_elst_box(m4af_ctx_t *ctx, uint32_t track_idx)
1024 {
1025     m4af_track_t *track = &ctx->track[track_idx];
1026     uint8_t version;
1027     int64_t duration = track->duration - track->encoder_delay - track->padding;
1028     int64_t pos = m4af_tell(ctx);
1029     duration = (double)duration / track->timescale * ctx->timescale + .5;
1030     version  = (duration > UINT32_MAX);
1031
1032     m4af_write(ctx, "\0\0\0\0elst", 8);
1033     m4af_write(ctx, &version, 1);
1034     m4af_write(ctx, "\0\0\0", 3);  /* flags          */
1035     m4af_write32(ctx, 1);          /* entry_count: 1 */
1036     if (version) {
1037         m4af_write64(ctx, duration);
1038         m4af_write64(ctx, track->encoder_delay);
1039     } else {
1040         m4af_write32(ctx, duration);
1041         m4af_write32(ctx, track->encoder_delay);
1042     }
1043     m4af_write16(ctx, 1);    /* media_rate_integer  */
1044     m4af_write16(ctx, 0);    /* media_rate_fraction */
1045     m4af_update_box_size(ctx, pos);
1046 }
1047
1048 static
1049 void m4af_write_edts_box(m4af_ctx_t *ctx, uint32_t track_idx)
1050 {
1051     m4af_track_t *track = &ctx->track[track_idx];
1052     int64_t pos = m4af_tell(ctx);
1053     m4af_write(ctx, "\0\0\0\0edts", 8);
1054     m4af_write_elst_box(ctx, track_idx);
1055     m4af_update_box_size(ctx, pos);
1056 }
1057
1058 static
1059 void m4af_write_tkhd_box(m4af_ctx_t *ctx, uint32_t track_idx)
1060 {
1061     m4af_track_t *track = &ctx->track[track_idx];
1062     int64_t pos = m4af_tell(ctx);
1063     int64_t duration =
1064         (double)track->duration / track->timescale * ctx->timescale + .5;
1065     uint8_t version = (track->creation_time > UINT32_MAX ||
1066                        track->modification_time > UINT32_MAX ||
1067                        duration > UINT32_MAX);
1068     m4af_write(ctx, "\0\0\0\0tkhd", 8);
1069     m4af_write(ctx, &version, 1);
1070     m4af_write(ctx, "\0\0\007", 3);  /* flags  */
1071     if (version) {
1072         m4af_write64(ctx, track->creation_time);
1073         m4af_write64(ctx, track->modification_time);
1074         m4af_write32(ctx, track_idx + 1);
1075         m4af_write(ctx, "\0\0\0\0"   /* reserved    */
1076                         , 4);
1077         m4af_write64(ctx, duration);
1078     } else {
1079         m4af_write32(ctx, track->creation_time);
1080         m4af_write32(ctx, track->modification_time);
1081         m4af_write32(ctx, track_idx + 1);
1082         m4af_write(ctx, "\0\0\0\0"   /* reserved    */
1083                         , 4);
1084         m4af_write32(ctx, duration);
1085     }
1086     m4af_write(ctx,
1087                "\0\0\0\0"   /* reserved[0]      */
1088                "\0\0\0\0"   /* reserved[1]      */
1089                "\0\0"       /* layer            */
1090                "\0\0"       /* alternate_group  */
1091                "\001\0"     /* volume: 1.0      */
1092                "\0\0"       /* reserved         */
1093                "\0\001\0\0" /* matrix[0]        */
1094                "\0\0\0\0"   /* matrix[1]        */
1095                "\0\0\0\0"   /* matrix[2]        */
1096                "\0\0\0\0"   /* matrix[3]        */
1097                "\0\001\0\0" /* matrix[4]        */
1098                "\0\0\0\0"   /* matrix[5]        */
1099                "\0\0\0\0"   /* matrix[6]        */
1100                "\0\0\0\0"   /* matrix[7]        */
1101                "\100\0\0\0" /* matrix[8]        */
1102                "\0\0\0\0"   /* width            */
1103                "\0\0\0\0"   /* height           */
1104                , 60);
1105     m4af_update_box_size(ctx, pos);
1106 }
1107
1108 static
1109 void m4af_write_trak_box(m4af_ctx_t *ctx, uint32_t track_idx)
1110 {
1111     m4af_track_t *track = &ctx->track[track_idx];
1112     int64_t pos = m4af_tell(ctx);
1113     m4af_write(ctx, "\0\0\0\0trak", 8);
1114     m4af_write_tkhd_box(ctx, track_idx);
1115     if ((ctx->priming_mode & M4AF_PRIMING_MODE_EDTS) &&
1116         (track->encoder_delay || track->padding))
1117         m4af_write_edts_box(ctx, track_idx);
1118     m4af_write_mdia_box(ctx, track_idx);
1119     m4af_update_box_size(ctx, pos);
1120 }
1121
1122 static
1123 int64_t m4af_movie_duration(m4af_ctx_t *ctx)
1124 {
1125     int64_t movie_duration = 0;
1126     unsigned i;
1127     for (i = 0; i < ctx->num_tracks; ++i) {
1128         double x = ctx->track[i].duration;
1129         int64_t duration = x / ctx->track[i].timescale * ctx->timescale + .5;
1130         if (duration > movie_duration)
1131             movie_duration = duration;
1132     }
1133     return movie_duration;
1134 }
1135
1136 static
1137 void m4af_write_mvhd_box(m4af_ctx_t *ctx)
1138 {
1139     int64_t pos = m4af_tell(ctx);
1140     int64_t movie_duration = m4af_movie_duration(ctx);
1141     uint8_t version = (ctx->creation_time > UINT32_MAX ||
1142                        ctx->modification_time > UINT32_MAX ||
1143                        movie_duration > UINT32_MAX);
1144
1145     m4af_write(ctx, "\0\0\0\0mvhd", 8);
1146     m4af_write(ctx, &version, 1);
1147     m4af_write(ctx, "\0\0\0", 3); /* flags */
1148     if (version) {
1149         m4af_write64(ctx, ctx->creation_time);
1150         m4af_write64(ctx, ctx->modification_time);
1151         m4af_write32(ctx, ctx->timescale);
1152         m4af_write64(ctx, movie_duration);
1153     } else {
1154         m4af_write32(ctx, ctx->creation_time);
1155         m4af_write32(ctx, ctx->modification_time);
1156         m4af_write32(ctx, ctx->timescale);
1157         m4af_write32(ctx, movie_duration);
1158     }
1159     m4af_write(ctx,
1160                "\0\001\0\0" /* rate: 1.0        */
1161                "\001\0"     /* volume: 1.0      */
1162                "\0\0"       /* reserved         */
1163                "\0\0\0\0"   /* reserved[0]      */
1164                "\0\0\0\0"   /* reserved[1]      */
1165                "\0\001\0\0" /* matrix[0]        */
1166                "\0\0\0\0"   /* matrix[1]        */
1167                "\0\0\0\0"   /* matrix[2]        */
1168                "\0\0\0\0"   /* matrix[3]        */
1169                "\0\001\0\0" /* matrix[4]        */
1170                "\0\0\0\0"   /* matrix[5]        */
1171                "\0\0\0\0"   /* matrix[6]        */
1172                "\0\0\0\0"   /* matrix[7]        */
1173                "\100\0\0\0" /* matrix[8]        */
1174                "\0\0\0\0"   /* pre_defined[0]   */
1175                "\0\0\0\0"   /* pre_defined[1]   */
1176                "\0\0\0\0"   /* pre_defined[2]   */
1177                "\0\0\0\0"   /* pre_defined[3]   */
1178                "\0\0\0\0"   /* pre_defined[4]   */
1179                "\0\0\0\0"   /* pre_defined[5]   */
1180                , 76);
1181     m4af_write32(ctx, ctx->num_tracks + 1);
1182     m4af_update_box_size(ctx, pos);
1183 }
1184
1185 static
1186 void m4af_write_mean_box(m4af_ctx_t *ctx)
1187 {
1188     m4af_write(ctx,
1189                "\0\0\0\034"       /* size           */
1190                "mean"
1191                "\0"               /* version        */
1192                "\0\0\0"           /* flags          */
1193                "com.apple.iTunes" /* meaning-string */
1194                , 28);
1195 }
1196
1197 static
1198 void m4af_write_name_box(m4af_ctx_t *ctx, const char *name)
1199 {
1200     int64_t pos = m4af_tell(ctx);
1201     m4af_write(ctx,
1202                "\0\0\0\0"  /* size    */
1203                "name"      /* type    */
1204                "\0"        /* version */
1205                "\0\0\0"    /* flags   */
1206                , 12);
1207     m4af_write(ctx, name, strlen(name));
1208     m4af_update_box_size(ctx, pos);
1209 }
1210
1211 static
1212 void m4af_write_data_box(m4af_ctx_t *ctx, uint32_t type_code,
1213                          const char *data, uint32_t data_size)
1214 {
1215     int64_t pos = m4af_tell(ctx);
1216     uint8_t code = type_code;
1217     m4af_write(ctx,
1218                "\0\0\0\0"  /* size              */
1219                "data"      /* type              */
1220                "\0\0"      /* reserved          */
1221                "\0"        /* type_set_indifier */
1222                ,11);
1223     m4af_write(ctx, &code, 1);
1224     m4af_write(ctx, "\0\0\0\0", 4);   /* locale */
1225     m4af_write(ctx, data, data_size);
1226     m4af_update_box_size(ctx, pos);
1227 }
1228
1229 static
1230 void m4af_write_metadata(m4af_ctx_t *ctx, m4af_itmf_entry_t *entry)
1231 {
1232     int64_t pos = m4af_tell(ctx);
1233     m4af_write(ctx, "\0\0\0\0", 4);
1234     m4af_write32(ctx, entry->fcc);
1235     if (entry->fcc != M4AF_FOURCC('-','-','-','-'))
1236         m4af_write_data_box(ctx, entry->type_code,
1237                             entry->data, entry->data_size);
1238     else {
1239         m4af_write_mean_box(ctx);
1240         m4af_write_name_box(ctx, entry->name);
1241         m4af_write_data_box(ctx, 1, entry->data, entry->data_size);
1242     }
1243     m4af_update_box_size(ctx, pos);
1244 }
1245
1246 static
1247 void m4af_write_ilst_box(m4af_ctx_t *ctx)
1248 {
1249     uint32_t i;
1250     int64_t pos = m4af_tell(ctx);
1251     m4af_write(ctx, "\0\0\0\0ilst", 8);
1252     for (i = 0; i < ctx->num_tags; ++i)
1253         m4af_write_metadata(ctx, &ctx->itmf_table[i]);
1254     m4af_update_box_size(ctx, pos);
1255 }
1256
1257 static
1258 void m4af_write_meta_box(m4af_ctx_t *ctx)
1259 {
1260     int64_t pos = m4af_tell(ctx);
1261     m4af_write(ctx,
1262                "\0\0\0\0"  /* size                     */
1263                "meta"      /* type                     */
1264                "\0"        /* version                  */
1265                "\0\0\0"    /* flags                    */
1266                , 12);
1267     m4af_write_hdlr_box(ctx, 0, "mdir");
1268     m4af_write_ilst_box(ctx);
1269     m4af_update_box_size(ctx, pos);
1270 }
1271
1272 static
1273 void m4af_write_udta_box(m4af_ctx_t *ctx)
1274 {
1275     int64_t pos = m4af_tell(ctx);
1276     m4af_write(ctx, "\0\0\0\0udta", 8);
1277     m4af_write_meta_box(ctx);
1278     m4af_update_box_size(ctx, pos);
1279 }
1280
1281 static
1282 uint32_t m4af_write_moov_box(m4af_ctx_t *ctx)
1283 {
1284     unsigned i;
1285     int64_t pos = m4af_tell(ctx);
1286     m4af_write(ctx, "\0\0\0\0moov", 8);
1287     m4af_write_mvhd_box(ctx);
1288     for (i = 0; i < ctx->num_tracks; ++i)
1289         m4af_write_trak_box(ctx, i);
1290     if (ctx->num_tags)
1291         m4af_write_udta_box(ctx);
1292     return m4af_update_box_size(ctx, pos);
1293 }
1294
1295 static
1296 void m4af_finalize_mdat(m4af_ctx_t *ctx)
1297 {
1298     if (ctx->mdat_size + 8 > UINT32_MAX) {
1299         m4af_set_pos(ctx, ctx->mdat_pos - 16);
1300         m4af_write32(ctx, 1);
1301         m4af_write(ctx, "mdat", 4);
1302         m4af_write64(ctx, ctx->mdat_size + 16);
1303     } else {
1304         m4af_set_pos(ctx, ctx->mdat_pos - 8);
1305         m4af_write32(ctx, ctx->mdat_size + 8);
1306     }
1307     m4af_set_pos(ctx, ctx->mdat_pos + ctx->mdat_size);
1308 }
1309
1310 static
1311 void m4af_shift_mdat_pos(m4af_ctx_t *ctx, uint32_t offset)
1312 {
1313     unsigned i, j;
1314     int64_t begin, end;
1315     char buf[8192];
1316
1317     end = ctx->mdat_pos + ctx->mdat_size;
1318     for (; (begin = m4af_max(ctx->mdat_pos, end - 8192)) < end; end = begin) {
1319         m4af_set_pos(ctx, begin);
1320         ctx->io.read(ctx->io_cookie, buf, end - begin);
1321         m4af_set_pos(ctx, begin + offset);
1322         m4af_write(ctx, buf, end - begin);
1323     }
1324     for (i = 0; i < ctx->num_tracks; ++i)
1325         for (j = 0; j < ctx->track[i].num_chunks; ++j)
1326             ctx->track[i].chunk_table[j].offset += offset;
1327     ctx->mdat_pos += offset;
1328     m4af_set_pos(ctx, ctx->mdat_pos - 16);
1329     m4af_write_free_box(ctx, 0);
1330     m4af_write(ctx, "\0\0\0\0mdat", 8);
1331     m4af_finalize_mdat(ctx);
1332 }
1333
1334 int m4af_finalize(m4af_ctx_t *ctx, int optimize)
1335 {
1336     unsigned i;
1337     m4af_track_t *track;
1338     uint32_t moov_size;
1339
1340     for (i = 0; i < ctx->num_tracks; ++i) {
1341         track = ctx->track + i;
1342         if (track->duration) {
1343             int64_t track_size = 0;
1344             unsigned j;
1345             for (j = 0; j < track->num_chunks; ++j)
1346                 track_size += track->chunk_table[j].size;
1347             track->avgBitrate =
1348                 8.0 * track_size * track->timescale / track->duration + .5;
1349         }
1350         m4af_flush_chunk(ctx, i);
1351     }
1352     track = ctx->track;
1353     if ((ctx->priming_mode & M4AF_PRIMING_MODE_ITUNSMPB) &&
1354         (track->encoder_delay || track->padding))
1355         m4af_set_iTunSMPB(ctx);
1356     m4af_finalize_mdat(ctx);
1357     moov_size = m4af_write_moov_box(ctx);
1358     if (optimize) {
1359         int64_t pos;
1360         m4af_shift_mdat_pos(ctx, moov_size + 1024);
1361         m4af_set_pos(ctx, 32);
1362         m4af_write_moov_box(ctx);
1363         pos = m4af_tell(ctx);
1364         m4af_write_free_box(ctx, ctx->mdat_pos - pos - 24);
1365     }
1366     return ctx->last_error;
1367 }