movenc.c 27.7 KB
Newer Older
1 2 3
/*
 * MOV, 3GP, MP4 encoder.
 * Copyright (c) 2003 Thomas Raivio.
4
 * Enhancements by Gildas Bazin <gbazin@netcourrier.com>
5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
#include "avformat.h"
21
#include "avi.h"
22 23
#include "avio.h"

24 25 26
#undef NDEBUG
#include <assert.h>

27 28 29 30
#define MOV_INDEX_CLUSTER_SIZE 16384
#define globalTimescale 1000

typedef struct MOVIentry {
31 32
    unsigned int flags, pos, size;
    unsigned int samplesInChunk;
33
    char         key_frame;
34 35 36 37 38 39 40 41 42
    unsigned int entries;
} MOVIentry;

typedef struct MOVIndex {
    int         entry;
    int         mdat_size;
    int         ents_allocated;
    long        timescale;
    long        time;
43
    long        trackDuration;
44 45
    long        sampleCount;
    long        sampleDuration;
46
    int         hasKeyframes;
47 48 49 50
    int         trackID;
    AVCodecContext *enc;

    int         vosLen;
51
    uint8_t     *vosData;
52 53 54 55 56 57
    MOVIentry** cluster;
} MOVTrack;

typedef struct {
    long    time;
    int     nb_streams;
58 59
    int     mdat_written;
    offset_t mdat_pos;
60 61 62 63 64
    offset_t movi_list;
    long    timescale;
    MOVTrack tracks[MAX_STREAMS];
} MOVContext;

65 66
static int mov_write_esds_tag(ByteIOContext *pb, MOVTrack* track);

67 68
//FIXME supprt 64bit varaint with wide placeholders
static int updateSize (ByteIOContext *pb, int pos)
69 70 71
{
    long curpos = url_ftell(pb);
    url_fseek(pb, pos, SEEK_SET);
72
    put_be32(pb, curpos - pos); /* rewrite size */
73
    url_fseek(pb, curpos, SEEK_SET);
74 75

    return curpos - pos;
76 77
}

78
/* Chunk offset atom */
79
static int mov_write_stco_tag(ByteIOContext *pb, MOVTrack* track)
80 81
{
    int i;
82 83
    int pos = url_ftell(pb);
    put_be32(pb, 0); /* size */
84 85 86 87 88 89 90 91
    put_tag(pb, "stco");
    put_be32(pb, 0); /* version & flags */
    put_be32(pb, track->entry); /* entry count */
    for (i=0; i<track->entry; i++) {
        int cl = i / MOV_INDEX_CLUSTER_SIZE;
        int id = i % MOV_INDEX_CLUSTER_SIZE;
        put_be32(pb, track->cluster[cl][id].pos);
    }
92
    return updateSize (pb, pos);
93 94
}

95
/* Sample size atom */
96
static int mov_write_stsz_tag(ByteIOContext *pb, MOVTrack* track)
97
{
98
    int equalChunks = 1;
99
    int i, j, entries = 0, tst = -1, oldtst = -1;
100

101 102
    int pos = url_ftell(pb);
    put_be32(pb, 0); /* size */
103 104 105
    put_tag(pb, "stsz");
    put_be32(pb, 0); /* version & flags */

106 107 108
    for (i=0; i<track->entry; i++) {
        int cl = i / MOV_INDEX_CLUSTER_SIZE;
        int id = i % MOV_INDEX_CLUSTER_SIZE;
109 110 111
        tst = track->cluster[cl][id].size/track->cluster[cl][id].entries;
        if(oldtst != -1 && tst != oldtst) {
            equalChunks = 0;
112 113
        }
        oldtst = tst;
114
        entries += track->cluster[cl][id].entries;
115
    }
116 117
    if (equalChunks) {
        int sSize = track->cluster[0][0].size/track->cluster[0][0].entries;
118
        put_be32(pb, sSize); // sample size 
119
        put_be32(pb, entries); // sample count
120
    }
121 122
    else {
        put_be32(pb, 0); // sample size 
123
        put_be32(pb, entries); // sample count 
124
        for (i=0; i<track->entry; i++) {
125 126
            int cl = i / MOV_INDEX_CLUSTER_SIZE;
            int id = i % MOV_INDEX_CLUSTER_SIZE;
127 128 129 130
            for ( j=0; j<track->cluster[cl][id].entries; j++) {
                put_be32(pb, track->cluster[cl][id].size /
                         track->cluster[cl][id].entries);
            }
131 132
        }
    }
133
    return updateSize (pb, pos);
134 135
}

136
/* Sample to chunk atom */
137
static int mov_write_stsc_tag(ByteIOContext *pb, MOVTrack* track)
138
{
139 140 141 142
    int index = 0, oldval = -1, i, entryPos, curpos;

    int pos = url_ftell(pb);
    put_be32(pb, 0); /* size */
143 144
    put_tag(pb, "stsc");
    put_be32(pb, 0); // version & flags 
145 146 147 148 149
    entryPos = url_ftell(pb);
    put_be32(pb, track->entry); // entry count 
    for (i=0; i<track->entry; i++) {
        int cl = i / MOV_INDEX_CLUSTER_SIZE;
        int id = i % MOV_INDEX_CLUSTER_SIZE;
150
        if(oldval != track->cluster[cl][id].samplesInChunk)
151
        {
152
            put_be32(pb, i+1); // first chunk 
153
            put_be32(pb, track->cluster[cl][id].samplesInChunk); // samples per chunk
154
            put_be32(pb, 0x1); // sample description index 
155
            oldval = track->cluster[cl][id].samplesInChunk;
156
            index++;
157 158
        }
    }
159 160 161 162
    curpos = url_ftell(pb);
    url_fseek(pb, entryPos, SEEK_SET);
    put_be32(pb, index); // rewrite size 
    url_fseek(pb, curpos, SEEK_SET);
163

164
    return updateSize (pb, pos);
165 166
}

167
/* Sync sample atom */
168
static int mov_write_stss_tag(ByteIOContext *pb, MOVTrack* track)
169
{
170 171 172 173
    long curpos;
    int i, index = 0, entryPos;
    int pos = url_ftell(pb);
    put_be32(pb, 0); // size 
174
    put_tag(pb, "stss");
175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190
    put_be32(pb, 0); // version & flags 
    entryPos = url_ftell(pb);
    put_be32(pb, track->entry); // entry count 
    for (i=0; i<track->entry; i++) {
        int cl = i / MOV_INDEX_CLUSTER_SIZE;
        int id = i % MOV_INDEX_CLUSTER_SIZE;
        if(track->cluster[cl][id].key_frame == 1) {
            put_be32(pb, i+1);
            index++;
        }
    }
    curpos = url_ftell(pb);
    url_fseek(pb, entryPos, SEEK_SET);
    put_be32(pb, index); // rewrite size 
    url_fseek(pb, curpos, SEEK_SET);
    return updateSize (pb, pos);
191 192
}

193
static int mov_write_damr_tag(ByteIOContext *pb)
194 195 196 197 198
{
    put_be32(pb, 0x11); /* size */
    put_tag(pb, "damr");
    put_tag(pb, "FFMP");
    put_byte(pb, 0);
199 200 201 202 203

    put_be16(pb, 0x80); /* Mode set (all modes for AMR_NB) */
    put_be16(pb, 0xa); /* Mode change period (no restriction) */
    //put_be16(pb, 0x81ff); /* Mode set (all modes for AMR_NB) */
    //put_be16(pb, 1); /* Mode change period (no restriction) */
204 205 206
    return 0x11;
}

207
static int mov_write_audio_tag(ByteIOContext *pb, MOVTrack* track)
208
{
209
    int pos = url_ftell(pb);
210
    put_be32(pb, 0); /* size */
211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228

    if(track->enc->codec_id == CODEC_ID_PCM_MULAW)
      put_tag(pb, "ulaw");
    else if(track->enc->codec_id == CODEC_ID_PCM_ALAW)
      put_tag(pb, "alaw");
    else if(track->enc->codec_id == CODEC_ID_ADPCM_IMA_QT)
      put_tag(pb, "ima4");
    else if(track->enc->codec_id == CODEC_ID_MACE3)
      put_tag(pb, "MAC3");
    else if(track->enc->codec_id == CODEC_ID_MACE6)
      put_tag(pb, "MAC6");
    else if(track->enc->codec_id == CODEC_ID_AAC)
      put_tag(pb, "mp4a");
    else if(track->enc->codec_id == CODEC_ID_AMR_NB)
      put_tag(pb, "samr");
    else
      put_tag(pb, "    ");

229 230 231
    put_be32(pb, 0); /* Reserved */
    put_be16(pb, 0); /* Reserved */
    put_be16(pb, 1); /* Data-reference index, XXX  == 1 */
232 233 234
    /* SoundDescription */
    put_be16(pb, 0); /* Version */
    put_be16(pb, 0); /* Revision level */
235 236
    put_be32(pb, 0); /* Reserved */

237 238
    put_be16(pb, track->enc->channels); /* Number of channels */
    /* TODO: Currently hard-coded to 16-bit, there doesn't seem
239
                 to be a good way to get number of bits of audio */
240
    put_be16(pb, 0x10); /* Reserved */
241 242
    put_be16(pb, 0); /* compression ID (= 0) */
    put_be16(pb, 0); /* packet size (= 0) */
243 244 245
    put_be16(pb, track->timescale); /* Time scale */
    put_be16(pb, 0); /* Reserved */

246 247
    if(track->enc->codec_id == CODEC_ID_AAC)
        mov_write_esds_tag(pb, track);
248 249
    if(track->enc->codec_id == CODEC_ID_AMR_NB)
        mov_write_damr_tag(pb);
250
    return updateSize (pb, pos);
251 252
}

253
static int mov_write_d263_tag(ByteIOContext *pb)
254 255 256 257 258 259 260 261 262
{
    put_be32(pb, 0xf); /* size */
    put_tag(pb, "d263");
    put_tag(pb, "FFMP");
    put_be16(pb, 0x0a);
    put_byte(pb, 0);
    return 0xf;
}

263 264
/* TODO: No idea about these values */
static int mov_write_svq3_tag(ByteIOContext *pb)
265
{
266 267 268 269 270 271 272 273
    put_be32(pb, 0x15);
    put_tag(pb, "SMI ");
    put_tag(pb, "SEQH");
    put_be32(pb, 0x5);
    put_be32(pb, 0xe2c0211d);
    put_be32(pb, 0xc0000000);
    put_byte(pb, 0);   
    return 0x15;
274 275
}

276 277 278 279 280 281 282 283 284 285 286 287 288
static unsigned int descrLength(unsigned int len)
{
    if (len < 0x00000080)
        return 2 + len;
    else if (len < 0x00004000)
        return 3 + len;
    else if(len < 0x00200000)
        return 4 + len;
    else
        return 5 + len;
}

static void putDescr(ByteIOContext *pb, int tag, int size)
289
{
290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325
    uint32_t len;
    uint8_t  vals[4];

    len = size;
    vals[3] = (uint8_t)(len & 0x7f);
    len >>= 7;
    vals[2] = (uint8_t)((len & 0x7f) | 0x80); 
    len >>= 7;
    vals[1] = (uint8_t)((len & 0x7f) | 0x80); 
    len >>= 7;
    vals[0] = (uint8_t)((len & 0x7f) | 0x80);

    put_byte(pb, tag); // DescriptorTag

    if (size < 0x00000080)
    {
        put_byte(pb, vals[3]);
    }
    else if (size < 0x00004000)
    {
        put_byte(pb, vals[2]);
        put_byte(pb, vals[3]);
    }
    else if (size < 0x00200000)
    {
        put_byte(pb, vals[1]);
        put_byte(pb, vals[2]);
        put_byte(pb, vals[3]);
    }
    else if (size < 0x10000000)
    {
        put_byte(pb, vals[0]);
        put_byte(pb, vals[1]);
        put_byte(pb, vals[2]);
        put_byte(pb, vals[3]);
    }
326 327
}

328
static int mov_write_esds_tag(ByteIOContext *pb, MOVTrack* track) // Basic
329
{
330 331 332 333
    int decoderSpecificInfoLen = track->vosLen ? descrLength(track->vosLen):0;
    int pos = url_ftell(pb);

    put_be32(pb, 0);               // size
334
    put_tag(pb, "esds");
335
    put_be32(pb, 0);               // Version
336

337 338 339 340
    // ES descriptor
    putDescr(pb, 0x03, 3 + descrLength(13 + decoderSpecificInfoLen) +
             descrLength(1));
    put_be16(pb, 0x0001);          // ID (= 1)
341 342
    put_byte(pb, 0x00);            // flags (= no flags)

343 344 345 346 347 348 349 350 351 352 353 354 355
    // DecoderConfig descriptor
    putDescr(pb, 0x04, 13 + decoderSpecificInfoLen);

    if(track->enc->codec_id == CODEC_ID_AAC)
        put_byte(pb, 0x40);        // Object type indication
    else if(track->enc->codec_id == CODEC_ID_MPEG4)
        put_byte(pb, 0x20);        // Object type indication (Visual 14496-2)

    if(track->enc->codec_type == CODEC_TYPE_AUDIO)
        put_byte(pb, 0x15);            // flags (= Audiostream)
    else
        put_byte(pb, 0x11);            // flags (= Visualstream)

356 357 358 359 360 361 362
    put_byte(pb, 0x0);             // Buffersize DB (24 bits)
    put_be16(pb, 0x0dd2);          // Buffersize DB

    // TODO: find real values for these
    put_be32(pb, 0x0002e918);     // maxbitrate
    put_be32(pb, 0x00017e6b);     // avg bitrate

363 364 365 366 367 368 369 370 371
    if (track->vosLen)
    {
        // DecoderSpecific info descriptor
        putDescr(pb, 0x05, track->vosLen);
        put_buffer(pb, track->vosData, track->vosLen);
    }

    // SL descriptor
    putDescr(pb, 0x06, descrLength(1));
372
    put_byte(pb, 0x02);
373
    return updateSize (pb, pos);
374 375
}

376
static int mov_write_video_tag(ByteIOContext *pb, MOVTrack* track)
377
{
378
    int pos = url_ftell(pb);
379 380 381 382 383 384 385 386 387 388 389
    put_be32(pb, 0); /* size */
    if(track->enc->codec_id == CODEC_ID_SVQ1)
      put_tag(pb, "SVQ1");
    else if(track->enc->codec_id == CODEC_ID_SVQ3)
      put_tag(pb, "SVQ3");
    else if(track->enc->codec_id == CODEC_ID_MPEG4)
      put_tag(pb, "mp4v");
    else if(track->enc->codec_id == CODEC_ID_H263)
      put_tag(pb, "s263");
    else
      put_tag(pb, "    "); /* Unknown tag */
390

391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423
    put_be32(pb, 0); /* Reserved */
    put_be16(pb, 0); /* Reserved */
    put_be16(pb, 1); /* Data-reference index */

    put_be32(pb, 0); /* Reserved (= 02000c) */
    put_be32(pb, 0); /* Reserved ("SVis")*/
    put_be32(pb, 0); /* Reserved */
    put_be32(pb, 0); /* Reserved (400)*/
    put_be16(pb, track->enc->width); /* Video width */
    put_be16(pb, track->enc->height); /* Video height */
    put_be32(pb, 0x00480000); /* Reserved */
    put_be32(pb, 0x00480000); /* Reserved */
    put_be32(pb, 0); /* Reserved */
    put_be32(pb, 0); /* Reserved */
    put_be32(pb, 0); /* Reserved */
    put_be32(pb, 0); /* Reserved */
    put_be32(pb, 0); /* Reserved */
    put_be32(pb, 0); /* Reserved */

    put_be16(pb, 0); /* Reserved */
    put_be32(pb, 0); /* Reserved */
    put_be32(pb, 0); /* Reserved */
    put_be32(pb, 0); /* Reserved */
    put_be16(pb, 0x18); /* Reserved */
    put_be16(pb, 0xffff); /* Reserved */
    if(track->enc->codec_id == CODEC_ID_MPEG4)
        mov_write_esds_tag(pb, track);
    else if(track->enc->codec_id == CODEC_ID_H263)
        mov_write_d263_tag(pb);
    else if(track->enc->codec_id == CODEC_ID_SVQ3)
        mov_write_svq3_tag(pb);    

    return updateSize (pb, pos);
424 425
}

426
static int mov_write_stsd_tag(ByteIOContext *pb, MOVTrack* track)
427
{
428
    int pos = url_ftell(pb);
429 430 431 432
    put_be32(pb, 0); /* size */
    put_tag(pb, "stsd");
    put_be32(pb, 0); /* version & flags */
    put_be32(pb, 1); /* entry count */
433 434 435 436
    if (track->enc->codec_type == CODEC_TYPE_VIDEO)
        mov_write_video_tag(pb, track);
    else if (track->enc->codec_type == CODEC_TYPE_AUDIO)
        mov_write_audio_tag(pb, track);
437
    return updateSize(pb, pos);
438 439
}

440
/* TODO?: Currently all samples/frames seem to have same duration */
441
/* Time to sample atom */
442
static int mov_write_stts_tag(ByteIOContext *pb, MOVTrack* track)
443 444 445 446 447 448
{
    put_be32(pb, 0x18); /* size */
    put_tag(pb, "stts");
    put_be32(pb, 0); /* version & flags */
    put_be32(pb, 1); /* entry count */

449 450
    put_be32(pb, track->sampleCount); /* sample count */
    put_be32(pb, track->sampleDuration); /* sample duration */
451 452 453
    return 0x18;
}

454
static int mov_write_dref_tag(ByteIOContext *pb)
455 456 457 458 459 460 461 462 463 464 465 466 467
{
    put_be32(pb, 28); /* size */
    put_tag(pb, "dref");
    put_be32(pb, 0); /* version & flags */
    put_be32(pb, 1); /* entry count */

    put_be32(pb, 0xc); /* size */
    put_tag(pb, "url ");
    put_be32(pb, 1); /* version & flags */

    return 28;
}

468
static int mov_write_stbl_tag(ByteIOContext *pb, MOVTrack* track)
469
{
470
    int pos = url_ftell(pb);
471 472
    put_be32(pb, 0); /* size */
    put_tag(pb, "stbl");
473 474
    mov_write_stsd_tag(pb, track);
    mov_write_stts_tag(pb, track);
475 476 477
    if (track->enc->codec_type == CODEC_TYPE_VIDEO &&
        track->hasKeyframes)
        mov_write_stss_tag(pb, track);
478 479 480 481
    mov_write_stsc_tag(pb, track);
    mov_write_stsz_tag(pb, track);
    mov_write_stco_tag(pb, track);
    return updateSize(pb, pos);
482 483
}

484
static int mov_write_dinf_tag(ByteIOContext *pb)
485
{
486
    int pos = url_ftell(pb);
487 488
    put_be32(pb, 0); /* size */
    put_tag(pb, "dinf");
489 490
    mov_write_dref_tag(pb);
    return updateSize(pb, pos);
491 492
}

493
static int mov_write_smhd_tag(ByteIOContext *pb)
494 495 496 497 498 499 500 501 502
{
    put_be32(pb, 16); /* size */
    put_tag(pb, "smhd");
    put_be32(pb, 0); /* version & flags */
    put_be16(pb, 0); /* reserved (balance, normally = 0) */
    put_be16(pb, 0); /* reserved */
    return 16;
}

503
static int mov_write_vmhd_tag(ByteIOContext *pb)
504 505 506 507 508 509 510 511
{
    put_be32(pb, 0x14); /* size (always 0x14) */
    put_tag(pb, "vmhd");
    put_be32(pb, 0x01); /* version & flags */
    put_be64(pb, 0); /* reserved (graphics mode = copy) */
    return 0x14;
}

512
static int mov_write_minf_tag(ByteIOContext *pb, MOVTrack* track)
513
{
514
    int pos = url_ftell(pb);
515 516 517
    put_be32(pb, 0); /* size */
    put_tag(pb, "minf");
    if(track->enc->codec_type == CODEC_TYPE_VIDEO)
518
        mov_write_vmhd_tag(pb);
519
    else
520 521 522 523
        mov_write_smhd_tag(pb);
    mov_write_dinf_tag(pb);
    mov_write_stbl_tag(pb, track);
    return updateSize(pb, pos);
524 525
}

526
static int mov_write_hdlr_tag(ByteIOContext *pb, MOVTrack* track)
527
{
528 529 530
    char *str;
    int pos = url_ftell(pb);
    put_be32(pb, 0); /* size */
531 532 533 534 535 536 537
    put_tag(pb, "hdlr");
    put_be32(pb, 0); /* Version & flags */
    put_be32(pb, 0); /* reserved */
    if(track->enc->codec_type == CODEC_TYPE_VIDEO)
        put_tag(pb, "vide"); /* handler type */
    else
        put_tag(pb, "soun"); /* handler type */
538 539 540
    put_be32(pb ,0); /* reserved */
    put_be32(pb ,0); /* reserved */
    put_be32(pb ,0); /* reserved */
541
    if(track->enc->codec_type == CODEC_TYPE_VIDEO)
542
        str = "VideoHandler";
543
    else
544 545 546 547
        str = "SoundHandler";
    put_byte(pb, strlen(str)); /* string counter */
    put_buffer(pb, str, strlen(str));
    return updateSize(pb, pos);
548 549
}

550
static int mov_write_mdhd_tag(ByteIOContext *pb, MOVTrack* track)
551 552 553 554 555 556
{
    put_be32(pb, 32); /* size */
    put_tag(pb, "mdhd");
    put_be32(pb, 0); /* Version & flags */
    put_be32(pb, track->time); /* creation time */
    put_be32(pb, track->time); /* modification time */
557 558
    put_be32(pb, track->timescale); /* time scale (sample rate for audio) */ 
    put_be32(pb, track->trackDuration); /* duration */
559 560 561 562 563
    put_be16(pb, 0); /* language, 0 = english */
    put_be16(pb, 0); /* reserved (quality) */
    return 32;
}

564
static int mov_write_mdia_tag(ByteIOContext *pb, MOVTrack* track)
565
{
566
    int pos = url_ftell(pb);
567 568
    put_be32(pb, 0); /* size */
    put_tag(pb, "mdia");
569 570 571 572
    mov_write_mdhd_tag(pb, track);
    mov_write_hdlr_tag(pb, track);
    mov_write_minf_tag(pb, track);
    return updateSize(pb, pos);
573 574
}

575
static int mov_write_tkhd_tag(ByteIOContext *pb, MOVTrack* track)
576
{
577
    int64_t maxTrackLenTemp;
578 579
    put_be32(pb, 0x5c); /* size (always 0x5c) */
    put_tag(pb, "tkhd");
580
    put_be32(pb, 0xf); /* version & flags (track enabled) */
581 582 583 584
    put_be32(pb, track->time); /* creation time */
    put_be32(pb, track->time); /* modification time */
    put_be32(pb, track->trackID); /* track-id */
    put_be32(pb, 0); /* reserved */
585 586
    maxTrackLenTemp = ((int64_t)globalTimescale*(int64_t)track->trackDuration)/(int64_t)track->timescale;
    put_be32(pb, (long)maxTrackLenTemp); /* duration */
587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610

    put_be32(pb, 0); /* reserved */
    put_be32(pb, 0); /* reserved */
    put_be32(pb, 0x0); /* reserved (Layer & Alternate group) */
    /* Volume, only for audio */
    if(track->enc->codec_type == CODEC_TYPE_AUDIO)
        put_be16(pb, 0x0100);
    else
        put_be16(pb, 0);
    put_be16(pb, 0); /* reserved */

    /* Matrix structure */
    put_be32(pb, 0x00010000); /* reserved */
    put_be32(pb, 0x0); /* reserved */
    put_be32(pb, 0x0); /* reserved */
    put_be32(pb, 0x0); /* reserved */
    put_be32(pb, 0x00010000); /* reserved */
    put_be32(pb, 0x0); /* reserved */
    put_be32(pb, 0x0); /* reserved */
    put_be32(pb, 0x0); /* reserved */
    put_be32(pb, 0x40000000); /* reserved */

    /* Track width and height, for visual only */
    if(track->enc->codec_type == CODEC_TYPE_VIDEO) {
611 612
        put_be32(pb, track->enc->width*0x10000);
        put_be32(pb, track->enc->height*0x10000);
613 614 615 616 617 618 619 620
    }
    else {
        put_be32(pb, 0);
        put_be32(pb, 0);
    }
    return 0x5c;
}

621
static int mov_write_trak_tag(ByteIOContext *pb, MOVTrack* track)
622
{
623
    int pos = url_ftell(pb);
624 625
    put_be32(pb, 0); /* size */
    put_tag(pb, "trak");
626 627 628
    mov_write_tkhd_tag(pb, track);
    mov_write_mdia_tag(pb, track);
    return updateSize(pb, pos);
629 630 631
}

/* TODO: Not sorted out, but not necessary either */
632
static int mov_write_iods_tag(ByteIOContext *pb, MOVContext *mov)
633 634 635 636 637 638 639 640 641 642 643 644
{
    put_be32(pb, 0x15); /* size */
    put_tag(pb, "iods");
    put_be32(pb, 0);    /* version & flags */
    put_be16(pb, 0x1007);
    put_byte(pb, 0);
    put_be16(pb, 0x4fff);
    put_be16(pb, 0xfffe);
    put_be16(pb, 0x01ff);
    return 0x15;
}

645
static int mov_write_mvhd_tag(ByteIOContext *pb, MOVContext *mov)
646 647
{
    int maxTrackID = 1, maxTrackLen = 0, i;
648
    int64_t maxTrackLenTemp;
649 650 651 652 653 654 655 656 657

    put_be32(pb, 0x6c); /* size (always 0x6c) */
    put_tag(pb, "mvhd");
    put_be32(pb, 0); /* version & flags */
    put_be32(pb, mov->time); /* creation time */
    put_be32(pb, mov->time); /* modification time */
    put_be32(pb, mov->timescale); /* timescale */
    for (i=0; i<MAX_STREAMS; i++) {
        if(mov->tracks[i].entry > 0) {
658 659 660
            maxTrackLenTemp = ((int64_t)globalTimescale*(int64_t)mov->tracks[i].trackDuration)/(int64_t)mov->tracks[i].timescale;
            if(maxTrackLen < maxTrackLenTemp)
                maxTrackLen = maxTrackLenTemp;
661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693
            if(maxTrackID < mov->tracks[i].trackID)
                maxTrackID = mov->tracks[i].trackID;
        }
    }
    put_be32(pb, maxTrackLen); /* duration of longest track */

    put_be32(pb, 0x00010000); /* reserved (preferred rate) 1.0 = normal */
    put_be16(pb, 0x0100); /* reserved (preferred volume) 1.0 = normal */
    put_be16(pb, 0); /* reserved */
    put_be32(pb, 0); /* reserved */
    put_be32(pb, 0); /* reserved */

    /* Matrix structure */
    put_be32(pb, 0x00010000); /* reserved */
    put_be32(pb, 0x0); /* reserved */
    put_be32(pb, 0x0); /* reserved */
    put_be32(pb, 0x0); /* reserved */
    put_be32(pb, 0x00010000); /* reserved */
    put_be32(pb, 0x0); /* reserved */
    put_be32(pb, 0x0); /* reserved */
    put_be32(pb, 0x0); /* reserved */
    put_be32(pb, 0x40000000); /* reserved */

    put_be32(pb, 0); /* reserved (preview time) */
    put_be32(pb, 0); /* reserved (preview duration) */
    put_be32(pb, 0); /* reserved (poster time) */
    put_be32(pb, 0); /* reserved (selection time) */
    put_be32(pb, 0); /* reserved (selection duration) */
    put_be32(pb, 0); /* reserved (current time) */
    put_be32(pb, maxTrackID+1); /* Next track id */
    return 0x6c;
}

694
static int mov_write_moov_tag(ByteIOContext *pb, MOVContext *mov)
695
{
696
    int pos, i;
697 698 699 700 701 702
    pos = url_ftell(pb);
    put_be32(pb, 0); /* size placeholder*/
    put_tag(pb, "moov");
    mov->timescale = globalTimescale;

    for (i=0; i<MAX_STREAMS; i++) {
703 704 705 706 707 708 709 710 711 712 713
        if(mov->tracks[i].entry <= 0) continue;

        if(mov->tracks[i].enc->codec_type == CODEC_TYPE_VIDEO) {
            mov->tracks[i].timescale = mov->tracks[i].enc->frame_rate;
            mov->tracks[i].sampleDuration = mov->tracks[i].enc->frame_rate_base;
        }
        else if(mov->tracks[i].enc->codec_type == CODEC_TYPE_AUDIO) {
            /* If AMR, track timescale = 8000, AMR_WB = 16000 */
            if(mov->tracks[i].enc->codec_id == CODEC_ID_AMR_NB) {
                mov->tracks[i].sampleDuration = 160;  // Bytes per chunk
                mov->tracks[i].timescale = 8000;
714
            }
715 716 717
            else {
                mov->tracks[i].timescale = mov->tracks[i].enc->sample_rate;
                mov->tracks[i].sampleDuration = mov->tracks[i].enc->frame_size;
718 719
            }
        }
720 721 722 723 724

        mov->tracks[i].trackDuration = 
            mov->tracks[i].sampleCount * mov->tracks[i].sampleDuration;
        mov->tracks[i].time = mov->time;
        mov->tracks[i].trackID = i+1;
725 726
    }

727 728
    mov_write_mvhd_tag(pb, mov);
    //mov_write_iods_tag(pb, mov);
729 730
    for (i=0; i<MAX_STREAMS; i++) {
        if(mov->tracks[i].entry > 0) {
731
            mov_write_trak_tag(pb, &(mov->tracks[i]));
732 733 734
        }
    }

735
    return updateSize(pb, pos);
736 737
}

738
int mov_write_mdat_tag(ByteIOContext *pb, MOVContext* mov)
739
{
740
    mov->mdat_pos = url_ftell(pb); 
741 742 743 744 745 746
    put_be32(pb, 0); /* size placeholder*/
    put_tag(pb, "mdat");
    return 0;
}

/* TODO: This needs to be more general */
747
int mov_write_ftyp_tag(ByteIOContext *pb, AVFormatContext *s)
748 749 750
{
    put_be32(pb, 0x14 ); /* size */
    put_tag(pb, "ftyp");
751 752 753 754 755 756

    if (!strcmp("3gp", s->oformat->name))
        put_tag(pb, "3gp4");
    else
        put_tag(pb, "isom");

757
    put_be32(pb, 0x200 );
758 759 760 761 762 763

    if (!strcmp("3gp", s->oformat->name))
        put_tag(pb, "3gp4");
    else
        put_tag(pb, "mp41");

764 765 766 767 768 769 770
    return 0x14;
}

static int mov_write_header(AVFormatContext *s)
{
    ByteIOContext *pb = &s->pb;

771
    if(s->oformat != NULL) {
772 773
    if(!strcmp("3gp", s->oformat->name) || !strcmp("mp4", s->oformat->name))
        mov_write_ftyp_tag(pb,s);
774 775
    }

776 777 778 779 780 781
    put_flush_packet(pb);

    return 0;
}

static int Timestamp() {
782
    return 1067949799U+(24107*86400); //its the modification time of this line :)
783 784 785
}

static int mov_write_packet(AVFormatContext *s, int stream_index,
786
                            const uint8_t *buf, int size, int64_t pts)
787 788 789
{
    MOVContext *mov = s->priv_data;
    ByteIOContext *pb = &s->pb;
790 791
    AVCodecContext *enc = &s->streams[stream_index]->codec;
    MOVTrack* trk = &mov->tracks[stream_index];
792
    int cl, id;
793
    unsigned int samplesInChunk = 0;
794

795 796
    if (url_is_streamed(&s->pb)) return 0; /* Can't handle that */
    if (!size) return 0; /* Discard 0 sized packets */
797

798 799 800 801 802
    if (enc->codec_type == CODEC_TYPE_VIDEO ) {
        samplesInChunk = 1;
    }
    else if (enc->codec_type == CODEC_TYPE_AUDIO ) {
        if( enc->codec_id == CODEC_ID_AMR_NB) {
803
            /* We must find out how many AMR blocks there are in one packet */
804 805 806 807 808 809 810
            static uint16_t packed_size[16] =
                {13, 14, 16, 18, 20, 21, 27, 32, 6, 0, 0, 0, 0, 0, 0, 0};
            int len = 0;

            while (len < size && samplesInChunk < 100) {
                len += packed_size[(buf[len] >> 3) & 0x0F];
                samplesInChunk++;
811
            }
812
        }
813 814
        else if(enc->codec_id == CODEC_ID_PCM_ALAW) {
            samplesInChunk = size/enc->channels;
815
        }
816 817
        else {
            samplesInChunk = 1;
818
        }
819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854
    }

    if ((enc->codec_id == CODEC_ID_MPEG4 || enc->codec_id == CODEC_ID_AAC)
        && trk->vosLen == 0) {
        assert(enc->extradata_size);

        trk->vosLen = enc->extradata_size;
        trk->vosData = av_malloc(trk->vosLen);
        memcpy(trk->vosData, enc->extradata, trk->vosLen);
    }

    cl = trk->entry / MOV_INDEX_CLUSTER_SIZE;
    id = trk->entry % MOV_INDEX_CLUSTER_SIZE;

    if (trk->ents_allocated <= trk->entry) {
        trk->cluster = av_realloc(trk->cluster, (cl+1)*sizeof(void*)); 
        if (!trk->cluster)
            return -1;
        trk->cluster[cl] = av_malloc(MOV_INDEX_CLUSTER_SIZE*sizeof(MOVIentry));
        if (!trk->cluster[cl])
            return -1;
        trk->ents_allocated += MOV_INDEX_CLUSTER_SIZE;
    }
    if (mov->mdat_written == 0) {
        mov_write_mdat_tag(pb, mov);
        mov->mdat_written = 1;
        mov->time = Timestamp();
    }

    trk->cluster[cl][id].pos = url_ftell(pb) - mov->movi_list;
    trk->cluster[cl][id].samplesInChunk = samplesInChunk;
    trk->cluster[cl][id].size = size;
    trk->cluster[cl][id].entries = samplesInChunk;
    if(enc->codec_type == CODEC_TYPE_VIDEO) {
        trk->cluster[cl][id].key_frame = enc->coded_frame->key_frame;
        if(enc->coded_frame->pict_type == FF_I_TYPE)
855
            trk->hasKeyframes = 1;
856
    }
857 858 859 860 861
    trk->enc = enc;
    trk->entry++;
    trk->sampleCount += samplesInChunk;
    trk->mdat_size += size;

862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884
    put_buffer(pb, buf, size);

    put_flush_packet(pb);
    return 0;
}

static int mov_write_trailer(AVFormatContext *s)
{
    MOVContext *mov = s->priv_data;
    ByteIOContext *pb = &s->pb;
    int res = 0;
    int i, j;
    offset_t file_size;

    file_size = url_ftell(pb);
    j = 0;

    /* Write size of mdat tag */
    for (i=0; i<MAX_STREAMS; i++) {
        if(mov->tracks[i].ents_allocated > 0) {
            j += mov->tracks[i].mdat_size;
        }
    }
885
    url_fseek(pb, mov->mdat_pos, SEEK_SET);
886 887 888 889 890 891 892 893 894 895
    put_be32(pb, j+8);
    url_fseek(pb, file_size, SEEK_SET);

    mov_write_moov_tag(pb, mov);

    for (i=0; i<MAX_STREAMS; i++) {
        for (j=0; j<mov->tracks[i].ents_allocated/MOV_INDEX_CLUSTER_SIZE; j++) {
            av_free(mov->tracks[i].cluster[j]);
        }
        av_free(mov->tracks[i].cluster);
896 897
        if( mov->tracks[i].vosLen ) av_free( mov->tracks[i].vosData );

898 899 900 901 902 903 904 905 906 907 908 909 910 911
        mov->tracks[i].cluster = NULL;
        mov->tracks[i].ents_allocated = mov->tracks[i].entry = 0;
    }
    put_flush_packet(pb);

    return res;
}

static AVOutputFormat mov_oformat = {
    "mov",
    "mov format",
    NULL,
    "mov",
    sizeof(MOVContext),
912
    CODEC_ID_PCM_ALAW,
913
    CODEC_ID_MPEG4,
914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934
    mov_write_header,
    mov_write_packet,
    mov_write_trailer,
};

static AVOutputFormat _3gp_oformat = {
    "3gp",
    "3gp format",
    NULL,
    "3gp",
    sizeof(MOVContext),
    CODEC_ID_AMR_NB,
    CODEC_ID_H263,
    mov_write_header,
    mov_write_packet,
    mov_write_trailer,
};

static AVOutputFormat mp4_oformat = {
    "mp4",
    "mp4 format",
935 936
    "application/mp4",
    "mp4,m4a",
937 938 939 940 941 942 943 944 945 946 947 948 949 950 951
    sizeof(MOVContext),
    CODEC_ID_AAC,
    CODEC_ID_MPEG4,
    mov_write_header,
    mov_write_packet,
    mov_write_trailer,
};

int movenc_init(void)
{
    av_register_output_format(&mov_oformat);
    av_register_output_format(&_3gp_oformat);
    av_register_output_format(&mp4_oformat);
    return 0;
}