libhb/muxmp4.c

   1 /* $Id: muxmp4.c,v 1.24 2005/11/04 13:09:41 titer Exp $
   2
   3    This file is part of the HandBrake source code.
   4    Homepage: <http://handbrake.fr/>.
   5    It may be used under the terms of the GNU General Public License. */
   6
   7 #include "mp4v2/mp4v2.h"
   8 #include "a52dec/a52.h"
   9
  10 #include "hb.h"
  11
  12 void AddIPodUUID(MP4FileHandle, MP4TrackId);
  13
  14 struct hb_mux_object_s
  15 {
  16     HB_MUX_COMMON;
  17
  18     hb_job_t * job;
  19
  20     /* libmp4v2 handle */
  21     MP4FileHandle file;
  22
  23     /* Cumulated durations so far, in output & input timescale units (see MP4Mux) */
  24     int64_t sum_dur;        // duration in output timescale units
  25     int64_t sum_dur_in;     // duration in input 90KHz timescale units
  26
  27     // bias to keep render offsets in ctts atom positive (set up by encx264)
  28     int64_t init_delay;
  29
  30     /* Chapter state information for muxing */
  31     MP4TrackId chapter_track;
  32     int current_chapter;
  33     uint64_t chapter_duration;
  34
  35     /* Sample rate of the first audio track.
  36      * Used for the timescale
  37      */
  38     int samplerate;
  39 };
  40
  41 struct hb_mux_data_s
  42 {
  43     MP4TrackId track;
  44 };
  45
  46
  47 /**********************************************************************
  48  * MP4Init
  49  **********************************************************************
  50  * Allocates hb_mux_data_t structures, create file and write headers
  51  *********************************************************************/
  52 static int MP4Init( hb_mux_object_t * m )
  53 {
  54     hb_job_t   * job   = m->job;
  55     hb_title_t * title = job->title;
  56
  57     hb_audio_t    * audio;
  58     hb_mux_data_t * mux_data;
  59     int i;
  60     uint16_t language_code;
  61
  62     /* Flags for enabling/disabling tracks in an MP4. */
  63     typedef enum { TRACK_DISABLED = 0x0, TRACK_ENABLED = 0x1, TRACK_IN_MOVIE = 0x2, TRACK_IN_PREVIEW = 0x4, TRACK_IN_POSTER = 0x8}  track_header_flags;
  64
  65     if( (audio = hb_list_item(title->list_audio, 0)) != NULL )
  66     {
  67         /* Need the sample rate of the first audio track to use as the timescale. */
  68         m->samplerate = audio->config.out.samplerate;
  69         audio = NULL;
  70     }
  71     else
  72     {
  73         m->samplerate = 90000;
  74     }
  75
  76     /* Create an empty mp4 file */
  77     if (job->largeFileSize)
  78     /* Use 64-bit MP4 file */
  79     {
  80         m->file = MP4Create( job->file, MP4_DETAILS_ERROR, MP4_CREATE_64BIT_DATA );
  81         hb_deep_log( 2, "muxmp4: using 64-bit MP4 formatting.");
  82     }
  83     else
  84     /* Limit MP4s to less than 4 GB */
  85     {
  86         m->file = MP4Create( job->file, MP4_DETAILS_ERROR, 0 );
  87     }
  88
  89     if (m->file == MP4_INVALID_FILE_HANDLE)
  90     {
  91         hb_error("muxmp4.c: MP4Create failed!");
  92         *job->die = 1;
  93         return 0;
  94     }
  95
  96     /* Video track */
  97     mux_data      = malloc( sizeof( hb_mux_data_t ) );
  98     job->mux_data = mux_data;
  99
 100     /* When using the standard 90000 timescale, QuickTime tends to have
 101        synchronization issues (audio not playing at the correct speed).
 102        To workaround this, we use the audio samplerate as the
 103        timescale */
 104     if (!(MP4SetTimeScale( m->file, m->samplerate )))
 105     {
 106         hb_error("muxmp4.c: MP4SetTimeScale failed!");
 107         *job->die = 1;
 108         return 0;
 109     }
 110
 111     if( job->vcodec == HB_VCODEC_X264 )
 112     {
 113         /* Stolen from mp4creator */
 114         MP4SetVideoProfileLevel( m->file, 0x7F );
 115                 mux_data->track = MP4AddH264VideoTrack( m->file, m->samplerate,
 116                         MP4_INVALID_DURATION, job->width, job->height,
 117                         job->config.h264.sps[1], /* AVCProfileIndication */
 118                         job->config.h264.sps[2], /* profile_compat */
 119                         job->config.h264.sps[3], /* AVCLevelIndication */
 120                         3 );      /* 4 bytes length before each NAL unit */
 121
 122
 123         MP4AddH264SequenceParameterSet( m->file, mux_data->track,
 124                 job->config.h264.sps, job->config.h264.sps_length );
 125         MP4AddH264PictureParameterSet( m->file, mux_data->track,
 126                 job->config.h264.pps, job->config.h264.pps_length );
 127
 128                 if( job->h264_level == 30 || job->ipod_atom)
 129                 {
 130                         hb_deep_log( 2, "muxmp4: adding iPod atom");
 131                         MP4AddIPodUUID(m->file, mux_data->track);
 132                 }
 133
 134         m->init_delay = job->config.h264.init_delay;
 135     }
 136     else /* FFmpeg or XviD */
 137     {
 138         MP4SetVideoProfileLevel( m->file, MPEG4_SP_L3 );
 139         mux_data->track = MP4AddVideoTrack( m->file, m->samplerate,
 140                 MP4_INVALID_DURATION, job->width, job->height,
 141                 MP4_MPEG4_VIDEO_TYPE );
 142         if (mux_data->track == MP4_INVALID_TRACK_ID)
 143         {
 144             hb_error("muxmp4.c: MP4AddVideoTrack failed!");
 145             *job->die = 1;
 146             return 0;
 147         }
 148
 149
 150         /* VOL from FFmpeg or XviD */
 151         if (!(MP4SetTrackESConfiguration( m->file, mux_data->track,
 152                 job->config.mpeg4.bytes, job->config.mpeg4.length )))
 153         {
 154             hb_error("muxmp4.c: MP4SetTrackESConfiguration failed!");
 155             *job->die = 1;
 156             return 0;
 157         }
 158     }
 159
 160     // COLR atom for color and gamma correction.
 161     // Per the notes at:
 162     //   http://developer.apple.com/quicktime/icefloe/dispatch019.html#colr
 163     //   http://forum.doom9.org/showthread.php?t=133982#post1090068
 164     // the user can set it from job->color_matrix, otherwise by default
 165     // we say anything that's likely to be HD content is ITU BT.709 and
 166     // DVD, SD TV & other content is ITU BT.601.  We look at the title height
 167     // rather than the job height here to get uncropped input dimensions.
 168     if( job->color_matrix == 1 )
 169     {
 170         // ITU BT.601 DVD or SD TV content
 171         MP4AddColr(m->file, mux_data->track, 6, 1, 6);
 172     }
 173     else if( job->color_matrix == 2 )
 174     {
 175         // ITU BT.709 HD content
 176         MP4AddColr(m->file, mux_data->track, 1, 1, 1);
 177     }
 178     else if ( job->title->width >= 1280 || job->title->height >= 720 )
 179     {
 180         // we guess that 720p or above is ITU BT.709 HD content
 181         MP4AddColr(m->file, mux_data->track, 1, 1, 1);
 182     }
 183     else
 184     {
 185         // ITU BT.601 DVD or SD TV content
 186         MP4AddColr(m->file, mux_data->track, 6, 1, 6);
 187     }
 188
 189     if( job->pixel_ratio )
 190     {
 191         /* PASP atom for anamorphic video */
 192         float width, height;
 193
 194         width = job->pixel_aspect_width;
 195
 196         height = job->pixel_aspect_height;
 197
 198         MP4AddPixelAspectRatio(m->file, mux_data->track, (uint32_t)width, (uint32_t)height);
 199
 200         MP4SetTrackFloatProperty(m->file, mux_data->track, "tkhd.width", job->width * (width / height));
 201     }
 202
 203         /* add the audio tracks */
 204     for( i = 0; i < hb_list_count( title->list_audio ); i++ )
 205     {
 206         static uint8_t reserved2[16] = {
 207                 0x00, 0x00, 0x00, 0x00,
 208                 0x00, 0x00, 0x00, 0x00,
 209                 0x00, 0x02, 0x00, 0x10,
 210                 0x00, 0x00, 0x00, 0x00,
 211             };
 212
 213         audio = hb_list_item( title->list_audio, i );
 214         mux_data = malloc( sizeof( hb_mux_data_t ) );
 215         audio->priv.mux_data = mux_data;
 216
 217         if( audio->config.out.codec == HB_ACODEC_AC3 )
 218         {
 219             uint8_t fscod = 0;
 220             uint8_t bsid = audio->config.in.version;
 221             uint8_t bsmod = audio->config.in.mode;
 222             uint8_t acmod = audio->config.flags.ac3 & 0x7;
 223             uint8_t lfeon = (audio->config.flags.ac3 & A52_LFE) ? 1 : 0;
 224             uint8_t bit_rate_code = 0;
 225
 226             /*
 227              * Rewrite AC3 information into correct format for dac3 atom
 228              */
 229             switch( audio->config.in.samplerate )
 230             {
 231             case 48000:
 232                 fscod = 0;
 233                 break;
 234             case 44100:
 235                 fscod = 1;
 236                 break;
 237             case 32000:
 238                 fscod = 2;
 239                 break;
 240             default:
 241                 /*
 242                  * Error value, tells decoder to not decode this audio.
 243                  */
 244                 fscod = 3;
 245                 break;
 246             }
 247
 248             switch( audio->config.in.bitrate )
 249             {
 250             case 32000:
 251                 bit_rate_code = 0;
 252                 break;
 253             case 40000:
 254                 bit_rate_code = 1;
 255                 break;
 256             case 48000:
 257                 bit_rate_code = 2;
 258                 break;
 259             case 56000:
 260                 bit_rate_code = 3;
 261                 break;
 262             case 64000:
 263                 bit_rate_code = 4;
 264                 break;
 265             case 80000:
 266                 bit_rate_code = 5;
 267                 break;
 268             case 96000:
 269                 bit_rate_code = 6;
 270                 break;
 271             case 112000:
 272                 bit_rate_code = 7;
 273                 break;
 274             case 128000:
 275                 bit_rate_code = 8;
 276                 break;
 277             case 160000:
 278                 bit_rate_code = 9;
 279                 break;
 280             case 192000:
 281                 bit_rate_code = 10;
 282                 break;
 283             case 224000:
 284                 bit_rate_code = 11;
 285                 break;
 286             case 256000:
 287                 bit_rate_code = 12;
 288                 break;
 289             case 320000:
 290                 bit_rate_code = 13;
 291                 break;
 292             case 384000:
 293                 bit_rate_code = 14;
 294                 break;
 295             case 448000:
 296                 bit_rate_code = 15;
 297                 break;
 298             case 512000:
 299                 bit_rate_code = 16;
 300                 break;
 301             case 576000:
 302                 bit_rate_code = 17;
 303                 break;
 304             case 640000:
 305                 bit_rate_code = 18;
 306                 break;
 307             default:
 308                 hb_error("Unknown AC3 bitrate");
 309                 bit_rate_code = 0;
 310                 break;
 311             }
 312
 313             mux_data->track = MP4AddAC3AudioTrack(
 314                 m->file,
 315                 m->samplerate,
 316                 fscod,
 317                 bsid,
 318                 bsmod,
 319                 acmod,
 320                 lfeon,
 321                 bit_rate_code);
 322
 323             if (audio->config.out.name == NULL) {
 324                 MP4SetTrackBytesProperty(
 325                     m->file, mux_data->track,
 326                     "udta.name.value",
 327                     (const uint8_t*)"Surround", strlen("Surround"));
 328             }
 329             else {
 330                 MP4SetTrackBytesProperty(
 331                     m->file, mux_data->track,
 332                     "udta.name.value",
 333                     (const uint8_t*)(audio->config.out.name),
 334                     strlen(audio->config.out.name));
 335             }
 336         } else {
 337             mux_data->track = MP4AddAudioTrack(
 338                 m->file,
 339                 m->samplerate, 1024, MP4_MPEG4_AUDIO_TYPE );
 340             if (audio->config.out.name == NULL) {
 341                 MP4SetTrackBytesProperty(
 342                     m->file, mux_data->track,
 343                     "udta.name.value",
 344                     (const uint8_t*)"Stereo", strlen("Stereo"));
 345             }
 346             else {
 347                 MP4SetTrackBytesProperty(
 348                     m->file, mux_data->track,
 349                     "udta.name.value",
 350                     (const uint8_t*)(audio->config.out.name),
 351                     strlen(audio->config.out.name));
 352             }
 353
 354             MP4SetAudioProfileLevel( m->file, 0x0F );
 355             MP4SetTrackESConfiguration(
 356                 m->file, mux_data->track,
 357                 audio->priv.config.aac.bytes, audio->priv.config.aac.length );
 358
 359             /* Set the correct number of channels for this track */
 360              MP4SetTrackIntegerProperty(m->file, mux_data->track, "mdia.minf.stbl.stsd.mp4a.channels", (uint16_t)HB_AMIXDOWN_GET_DISCRETE_CHANNEL_COUNT(audio->config.out.mixdown));
 361         }
 362
 363         /* Set the language for this track */
 364         MP4SetTrackLanguage(m->file, mux_data->track, audio->config.lang.iso639_2);
 365
 366         if( hb_list_count( title->list_audio ) > 1 )
 367         {
 368             /* Set the audio track alternate group */
 369             MP4SetTrackIntegerProperty(m->file, mux_data->track, "tkhd.alternate_group", 1);
 370         }
 371
 372         if (i == 0) {
 373             /* Enable the first audio track */
 374             MP4SetTrackIntegerProperty(m->file, mux_data->track, "tkhd.flags", (TRACK_ENABLED | TRACK_IN_MOVIE));
 375         }
 376         else
 377             /* Disable the other audio tracks so QuickTime doesn't play
 378                them all at once. */
 379         {
 380             MP4SetTrackIntegerProperty(m->file, mux_data->track, "tkhd.flags", (TRACK_DISABLED | TRACK_IN_MOVIE));
 381             hb_deep_log( 2, "muxp4: disabled extra audio track %i", mux_data->track-1);
 382         }
 383
 384     }
 385
 386     if (job->chapter_markers)
 387     {
 388         /* add a text track for the chapters. We add the 'chap' atom to track
 389            one which is usually the video track & should never be disabled.
 390            The Quicktime spec says it doesn't matter which media track the
 391            chap atom is on but it has to be an enabled track. */
 392         MP4TrackId textTrack;
 393         textTrack = MP4AddChapterTextTrack(m->file, 1, 0);
 394
 395         m->chapter_track = textTrack;
 396         m->chapter_duration = 0;
 397         m->current_chapter = job->chapter_start;
 398     }
 399
 400     /* Add encoded-by metadata listing version and build date */
 401     char *tool_string;
 402     tool_string = (char *)malloc(80);
 403     snprintf( tool_string, 80, "HandBrake %s %i", HB_VERSION, HB_BUILD);
 404     MP4SetMetadataTool(m->file, tool_string);
 405     free(tool_string);
 406
 407     return 0;
 408 }
 409
 410 static int MP4Mux( hb_mux_object_t * m, hb_mux_data_t * mux_data,
 411                    hb_buffer_t * buf )
 412 {
 413     hb_job_t * job = m->job;
 414     int64_t duration;
 415     int64_t offset = 0;
 416
 417     if( mux_data == job->mux_data )
 418     {
 419         /* Video */
 420
 421         // if there are b-frames compute the render offset
 422         // (we'll need it for both the video frame & the chapter track)
 423         if ( m->init_delay )
 424         {
 425             offset = ( buf->start + m->init_delay ) * m->samplerate / 90000 -
 426                      m->sum_dur;
 427         }
 428
 429         /* Add the sample before the new frame.
 430            It is important that this be calculated prior to the duration
 431            of the new video sample, as we want to sync to right after it.
 432            (This is because of how durations for text tracks work in QT) */
 433         if( job->chapter_markers && buf->new_chap )
 434         {
 435             hb_chapter_t *chapter = NULL;
 436
 437             // this chapter is postioned by writing out the previous chapter.
 438             // the duration of the previous chapter is the duration up to but
 439             // not including the current frame minus the duration of all
 440             // chapters up to the previous.
 441             duration = m->sum_dur - m->chapter_duration + offset;
 442             if ( duration <= 0 )
 443             {
 444                 /* The initial & final chapters can have very short durations
 445                  * (less than the error in our total duration estimate) so
 446                  * the duration calc above can result in a negative number.
 447                  * when this happens give the chapter a short duration (1/3
 448                  * of an ntsc frame time). */
 449                 duration = 1000 * m->samplerate / 90000;
 450             }
 451
 452             chapter = hb_list_item( m->job->title->list_chapter,
 453                                     buf->new_chap - 2 );
 454
 455             MP4AddChapter( m->file,
 456                            m->chapter_track,
 457                            duration,
 458                            (chapter != NULL) ? chapter->title : NULL);
 459
 460             m->current_chapter = buf->new_chap;
 461             m->chapter_duration += duration;
 462         }
 463
 464         // since we're changing the sample rate we need to keep track of
 465         // the truncation bias so that the audio and video don't go out
 466         // of sync. m->sum_dur_in is the sum of the input durations so far.
 467         // m->sum_dur is the sum of the output durations. Their difference
 468         // (in output sample rate units) is the accumulated truncation bias.
 469         int64_t bias = ( m->sum_dur_in * m->samplerate / 90000 ) - m->sum_dur;
 470         int64_t dur_in = buf->stop - buf->start;
 471         duration = dur_in * m->samplerate / 90000 + bias;
 472         if ( duration <= 0 )
 473         {
 474             /* We got an illegal mp4/h264 duration. This shouldn't
 475                be possible and usually indicates a bug in the upstream code.
 476                Complain in the hope that someone will go find the bug but
 477                try to fix the error so that the file will still be playable. */
 478             hb_log("MP4Mux: illegal duration %lld, bias %lld, start %lld (%lld),"
 479                    "stop %lld (%lld), sum_dur %lld",
 480                    duration, bias, buf->start * m->samplerate / 90000, buf->start,
 481                    buf->stop * m->samplerate / 90000, buf->stop, m->sum_dur );
 482             /* we don't know when the next frame starts so we can't pick a
 483                valid duration for this one so we pick something "short"
 484                (roughly 1/3 of an NTSC frame time) and rely on the bias calc
 485                for the next frame to correct things (a duration underestimate
 486                just results in a large bias on the next frame). */
 487             duration = 1000 * m->samplerate / 90000;
 488         }
 489         m->sum_dur += duration;
 490         m->sum_dur_in += dur_in;
 491     }
 492     else
 493     {
 494         /* Audio */
 495         duration = MP4_INVALID_DURATION;
 496     }
 497
 498     // Here's where the sample actually gets muxed.
 499     if( !MP4WriteSample( m->file,
 500                          mux_data->track,
 501                          buf->data,
 502                          buf->size,
 503                          duration,
 504                          offset,
 505                          ((buf->frametype & HB_FRAME_KEY) != 0) ) )
 506     {
 507         hb_error("Failed to write to output file, disk full?");
 508         *job->die = 1;
 509     }
 510
 511     return 0;
 512 }
 513
 514 static int MP4End( hb_mux_object_t * m )
 515 {
 516     hb_job_t   * job   = m->job;
 517     hb_title_t * title = job->title;
 518
 519     /* Write our final chapter marker */
 520     if( m->job->chapter_markers )
 521     {
 522         hb_chapter_t *chapter = NULL;
 523         int64_t duration = m->sum_dur - m->chapter_duration;
 524         /* The final chapter can have a very short duration - if it's less
 525          * than a second just skip it. */
 526         if ( duration >= m->samplerate )
 527         {
 528
 529             chapter = hb_list_item( m->job->title->list_chapter,
 530                                     m->current_chapter - 1 );
 531
 532             MP4AddChapter( m->file,
 533                            m->chapter_track,
 534                            duration,
 535                            (chapter != NULL) ? chapter->title : NULL);
 536         }
 537     }
 538
 539     if (job->areBframes)
 540     {
 541            // Insert track edit to get A/V back in sync.  The edit amount is
 542            // the init_delay.
 543            int64_t edit_amt = m->init_delay * m->samplerate / 90000;
 544            MP4AddTrackEdit(m->file, 1, MP4_INVALID_EDIT_ID, edit_amt,
 545                            MP4GetTrackDuration(m->file, 1), 0);
 546             if ( m->job->chapter_markers )
 547             {
 548                 // apply same edit to chapter track to keep it in sync with video
 549                 MP4AddTrackEdit(m->file, m->chapter_track, MP4_INVALID_EDIT_ID,
 550                                 edit_amt,
 551                                 MP4GetTrackDuration(m->file, m->chapter_track), 0);
 552             }
 553      }
 554
 555     /*
 556      * Write the MP4 iTunes metadata if we have any metadata
 557      */
 558     if( title->metadata )
 559     {
 560         hb_metadata_t *md = title->metadata;
 561
 562         hb_deep_log( 2, "Writing Metadata to output file...");
 563
 564         MP4SetMetadataName( m->file, md->name );
 565         MP4SetMetadataArtist( m->file, md->artist );
 566         MP4SetMetadataComposer( m->file, md->composer );
 567         MP4SetMetadataComment( m->file, md->comment );
 568         MP4SetMetadataReleaseDate( m->file, md->release_date );
 569         MP4SetMetadataAlbum( m->file, md->album );
 570         MP4SetMetadataGenre( m->file, md->genre );
 571         if( md->coverart )
 572         {
 573             MP4SetMetadataCoverArt( m->file, md->coverart, md->coverart_size);
 574         }
 575     }
 576
 577     MP4Close( m->file );
 578
 579     if ( job->mp4_optimize )
 580     {
 581         hb_log( "muxmp4: optimizing file" );
 582         char filename[1024]; memset( filename, 0, 1024 );
 583         snprintf( filename, 1024, "%s.tmp", job->file );
 584         MP4Optimize( job->file, filename, MP4_DETAILS_ERROR );
 585         remove( job->file );
 586         rename( filename, job->file );
 587     }
 588
 589     return 0;
 590 }
 591
 592 hb_mux_object_t * hb_mux_mp4_init( hb_job_t * job )
 593 {
 594     hb_mux_object_t * m = calloc( sizeof( hb_mux_object_t ), 1 );
 595     m->init      = MP4Init;
 596     m->mux       = MP4Mux;
 597     m->end       = MP4End;
 598     m->job       = job;
 599     return m;
 600 }
 601