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.m0k.org/>.
   5    It may be used under the terms of the GNU General Public License. */
   6
   7 /* libmp4v2 header */
   8 #include "mp4.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 timescale units (see MP4Mux) */
  24     uint64_t sum_dur;
  25
  26     /* Chapter state information for muxing */
  27     MP4TrackId chapter_track;
  28     int current_chapter;
  29     uint64_t chapter_duration;
  30 };
  31
  32 struct hb_mux_data_s
  33 {
  34     MP4TrackId track;
  35 };
  36
  37 struct hb_text_sample_s
  38 {
  39     uint8_t     sample[1280];
  40     uint32_t    length;
  41     MP4Duration duration;
  42 };
  43
  44 /**********************************************************************
  45  * MP4CreateTextSample
  46  **********************************************************************
  47  * Creates a buffer for a text track sample
  48  *********************************************************************/
  49 static struct hb_text_sample_s *MP4CreateTextSample( char *textString, uint64_t duration )
  50 {
  51     struct hb_text_sample_s *sample = NULL;
  52     int stringLength = strlen(textString);
  53     int x;
  54
  55     if( stringLength < 1024 )
  56     {
  57         sample = malloc( sizeof( struct hb_text_sample_s ) );
  58
  59         //textLength = (stringLength; // Account for BOM
  60         sample->length = stringLength + 2 + 12; // Account for text length code and other marker
  61         sample->duration = (MP4Duration)duration;
  62
  63         // 2-byte length marker
  64         sample->sample[0] = (stringLength >> 8) & 0xff;
  65         sample->sample[1] = stringLength & 0xff;
  66
  67         strncpy( (char *)&(sample->sample[2]), textString, stringLength );
  68
  69         x = 2 + stringLength;
  70
  71         // Modifier Length Marker
  72         sample->sample[x] = 0x00;
  73         sample->sample[x+1] = 0x00;
  74         sample->sample[x+2] = 0x00;
  75         sample->sample[x+3] = 0x0C;
  76
  77         // Modifier Type Code
  78         sample->sample[x+4] = 'e';
  79         sample->sample[x+5] = 'n';
  80         sample->sample[x+6] = 'c';
  81         sample->sample[x+7] = 'd';
  82
  83         // Modifier Value
  84         sample->sample[x+8] = 0x00;
  85         sample->sample[x+9] = 0x00;
  86         sample->sample[x+10] = (256 >> 8) & 0xff;
  87         sample->sample[x+11] = 256 & 0xff;
  88     }
  89
  90     return sample;
  91 }
  92
  93 /**********************************************************************
  94  * MP4GenerateChapterSample
  95  **********************************************************************
  96  * Creates a buffer for a text track sample
  97  *********************************************************************/
  98 static struct hb_text_sample_s *MP4GenerateChapterSample( hb_mux_object_t * m, uint64_t duration )
  99 {
 100     int chapter = m->current_chapter;
 101     hb_chapter_t *chapter_data = hb_list_item( m->job->title->list_chapter, chapter - 1 );
 102     char tmp_buffer[1024];
 103     char *string = tmp_buffer;
 104
 105     tmp_buffer[0] = '\0';
 106
 107     if( chapter_data != NULL )
 108     {
 109         string = chapter_data->title;
 110     }
 111
 112     if( strlen(string) == 0 || strlen(string) >= 1024 )
 113     {
 114         snprintf( tmp_buffer, 1023, "Chapter %03i", chapter );
 115         string = tmp_buffer;
 116     }
 117
 118     return MP4CreateTextSample( string, duration );
 119 }
 120
 121
 122 /**********************************************************************
 123  * MP4Init
 124  **********************************************************************
 125  * Allocates hb_mux_data_t structures, create file and write headers
 126  *********************************************************************/
 127 static int MP4Init( hb_mux_object_t * m )
 128 {
 129     hb_job_t   * job   = m->job;
 130     hb_title_t * title = job->title;
 131
 132     hb_audio_t    * audio;
 133     hb_mux_data_t * mux_data;
 134     int i;
 135     u_int16_t language_code;
 136
 137     /* Flags for enabling/disabling tracks in an MP4. */
 138     typedef enum { TRACK_DISABLED = 0x0, TRACK_ENABLED = 0x1, TRACK_IN_MOVIE = 0x2, TRACK_IN_PREVIEW = 0x4, TRACK_IN_POSTER = 0x8}  track_header_flags;
 139
 140
 141     /* Create an empty mp4 file */
 142     if (job->largeFileSize)
 143     /* Use 64-bit MP4 file */
 144     {
 145         m->file = MP4Create( job->file, MP4_DETAILS_ERROR, MP4_CREATE_64BIT_DATA );
 146         hb_log("Using 64-bit MP4 formatting.");
 147     }
 148     else
 149     /* Limit MP4s to less than 4 GB */
 150     {
 151         m->file = MP4Create( job->file, MP4_DETAILS_ERROR, 0 );
 152     }
 153
 154     if (m->file == MP4_INVALID_FILE_HANDLE)
 155     {
 156         hb_error("muxmp4.c: MP4Create failed!");
 157         *job->die = 1;
 158         return 0;
 159     }
 160
 161     /* Video track */
 162     mux_data      = malloc( sizeof( hb_mux_data_t ) );
 163     job->mux_data = mux_data;
 164
 165     /* When using the standard 90000 timescale, QuickTime tends to have
 166        synchronization issues (audio not playing at the correct speed).
 167        To workaround this, we use the audio samplerate as the
 168        timescale */
 169     if (!(MP4SetTimeScale( m->file, job->arate )))
 170     {
 171         hb_error("muxmp4.c: MP4SetTimeScale failed!");
 172         *job->die = 1;
 173         return 0;
 174     }
 175
 176     if( job->vcodec == HB_VCODEC_X264 )
 177     {
 178         /* Stolen from mp4creator */
 179         if(!(MP4SetVideoProfileLevel( m->file, 0x7F )))
 180         {
 181             hb_error("muxmp4.c: MP4SetVideoProfileLevel failed!");
 182             *job->die = 1;
 183             return 0;
 184         }
 185
 186                 mux_data->track = MP4AddH264VideoTrack( m->file, job->arate,
 187                         MP4_INVALID_DURATION, job->width, job->height,
 188                         job->config.h264.sps[1], /* AVCProfileIndication */
 189                         job->config.h264.sps[2], /* profile_compat */
 190                         job->config.h264.sps[3], /* AVCLevelIndication */
 191                         3 );      /* 4 bytes length before each NAL unit */
 192
 193
 194         MP4AddH264SequenceParameterSet( m->file, mux_data->track,
 195                 job->config.h264.sps, job->config.h264.sps_length );
 196         MP4AddH264PictureParameterSet( m->file, mux_data->track,
 197                 job->config.h264.pps, job->config.h264.pps_length );
 198
 199                 if( job->h264_level == 30 || job->ipod_atom)
 200                 {
 201                         hb_log("About to add iPod atom");
 202                         AddIPodUUID(m->file, mux_data->track);
 203                 }
 204
 205     }
 206     else /* FFmpeg or XviD */
 207     {
 208         if(!(MP4SetVideoProfileLevel( m->file, MPEG4_SP_L3 )))
 209         {
 210             hb_error("muxmp4.c: MP4SetVideoProfileLevel failed!");
 211             *job->die = 1;
 212             return 0;
 213         }
 214         mux_data->track = MP4AddVideoTrack( m->file, job->arate,
 215                 MP4_INVALID_DURATION, job->width, job->height,
 216                 MP4_MPEG4_VIDEO_TYPE );
 217         if (mux_data->track == MP4_INVALID_TRACK_ID)
 218         {
 219             hb_error("muxmp4.c: MP4AddVideoTrack failed!");
 220             *job->die = 1;
 221             return 0;
 222         }
 223
 224
 225         /* VOL from FFmpeg or XviD */
 226         if (!(MP4SetTrackESConfiguration( m->file, mux_data->track,
 227                 job->config.mpeg4.bytes, job->config.mpeg4.length )))
 228         {
 229             hb_error("muxmp4.c: MP4SetTrackESConfiguration failed!");
 230             *job->die = 1;
 231             return 0;
 232         }
 233     }
 234
 235         /* apply the anamorphic transformation matrix if needed */
 236
 237         if( job->pixel_ratio ) {
 238
 239                 uint8_t* val;
 240                 uint8_t nval[38];
 241                 uint32_t *ptr32 = (uint32_t*) (nval + 2);
 242                 uint32_t size;
 243
 244                 MP4GetBytesProperty(m->file, "moov.trak.tkhd.reserved3", &val, &size);
 245
 246                 if (size == 38) {
 247
 248                         memcpy(nval, val, size);
 249
 250                         float width, height;
 251                         width = job->pixel_aspect_width;
 252                         height = job->pixel_aspect_height;
 253
 254            uint32_t pixelRatioInt;
 255            if (width >= height)
 256            {
 257                pixelRatioInt = (uint32_t)((width / height) * 0x10000);
 258
 259 #ifdef WORDS_BIGENDIAN
 260                ptr32[0] = pixelRatioInt;
 261 #else
 262                /* we need to switch the endianness, as the file format expects big endian */
 263                ptr32[0] = ((pixelRatioInt & 0x000000FF) << 24) + ((pixelRatioInt & 0x0000FF00) << 8) + ((pixelRatioInt & 0x00FF0000) >> 8) + ((pixelRatioInt & 0xFF000000) >> 24);
 264 #endif
 265
 266            }
 267            else
 268            {
 269                pixelRatioInt = (uint32_t)((height / width) * 0x10000);
 270 #ifdef WORDS_BIGENDIAN
 271                ptr32[4] = pixelRatioInt;
 272 #else
 273                 /* we need to switch the endianness, as the file format expects big endian */
 274                 ptr32[4] = ((pixelRatioInt & 0x000000FF) << 24) + ((pixelRatioInt & 0x0000FF00) << 8) + ((pixelRatioInt & 0x00FF0000) >> 8) + ((pixelRatioInt & 0xFF000000) >> 24);
 275 #endif
 276             }
 277
 278
 279                         if(!MP4SetBytesProperty(m->file, "moov.trak.tkhd.reserved3", nval, size)) {
 280                                 hb_log("Problem setting transform matrix");
 281                         }
 282
 283                 }
 284
 285         }
 286
 287         /* end of transformation matrix */
 288
 289         /* firstAudioTrack will be used to reference the first audio track when we add a chapter track */
 290         MP4TrackId firstAudioTrack = 0;
 291
 292         /* add the audio tracks */
 293     for( i = 0; i < hb_list_count( title->list_audio ); i++ )
 294     {
 295         static u_int8_t reserved2[16] = {
 296                 0x00, 0x00, 0x00, 0x00,
 297                 0x00, 0x00, 0x00, 0x00,
 298                 0x00, 0x02, 0x00, 0x10,
 299                 0x00, 0x00, 0x00, 0x00,
 300             };
 301
 302         audio = hb_list_item( title->list_audio, i );
 303         mux_data = malloc( sizeof( hb_mux_data_t ) );
 304         audio->mux_data = mux_data;
 305
 306         if( job->acodec & HB_ACODEC_AC3 )
 307         {
 308             mux_data->track = MP4AddAC3AudioTrack(
 309                 m->file,
 310                 job->arate, 1536, MP4_MPEG4_AUDIO_TYPE );
 311             MP4SetTrackBytesProperty(
 312                 m->file, mux_data->track,
 313                 "udta.name.value",
 314                 (const u_int8_t*)"Surround", strlen("Surround"));
 315         } else {
 316             mux_data->track = MP4AddAudioTrack(
 317                 m->file,
 318                 job->arate, 1024, MP4_MPEG4_AUDIO_TYPE );
 319             MP4SetTrackBytesProperty(
 320                 m->file, mux_data->track,
 321                 "udta.name.value",
 322                 (const u_int8_t*)"Stereo", strlen("Stereo"));
 323
 324             MP4SetAudioProfileLevel( m->file, 0x0F );
 325             MP4SetTrackESConfiguration(
 326                 m->file, mux_data->track,
 327                 audio->config.aac.bytes, audio->config.aac.length );
 328
 329             /* Set the correct number of channels for this track */
 330             reserved2[9] = (u_int8_t)HB_AMIXDOWN_GET_DISCRETE_CHANNEL_COUNT(audio->amixdown);
 331             MP4SetTrackBytesProperty(m->file, mux_data->track, "mdia.minf.stbl.stsd.mp4a.reserved2", reserved2, sizeof(reserved2));
 332
 333         }
 334         /* Set the language for this track */
 335         /* The language is stored as 5-bit text - 0x60 */
 336         language_code = audio->iso639_2[0] - 0x60;   language_code <<= 5;
 337         language_code |= audio->iso639_2[1] - 0x60;  language_code <<= 5;
 338         language_code |= audio->iso639_2[2] - 0x60;
 339         MP4SetTrackIntegerProperty(m->file, mux_data->track, "mdia.mdhd.language", language_code);
 340
 341
 342         /* Set the audio track alternate group */
 343         MP4SetTrackIntegerProperty(m->file, mux_data->track, "tkhd.alternate_group", 1);
 344
 345         /* If we ever upgrade mpeg4ip, the line above should be replaced with the line below.*/
 346 //        MP4SetTrackIntegerProperty(m->file, mux_data->track, "mdia.minf.stbl.stsd.mp4a.channels",  (u_int16_t)HB_AMIXDOWN_GET_DISCRETE_CHANNEL_COUNT(audio->amixdown));
 347
 348         /* store a reference to the first audio track,
 349         so we can use it to feed the chapter text track's sample rate */
 350         if (i == 0) {
 351             firstAudioTrack = mux_data->track;
 352
 353             /* Enable the first audio track */
 354             MP4SetTrackIntegerProperty(m->file, mux_data->track, "tkhd.flags", (TRACK_ENABLED | TRACK_IN_MOVIE));
 355         }
 356
 357         else
 358             /* Disable the other audio tracks so QuickTime doesn't play
 359                them all at once. */
 360         {
 361             MP4SetTrackIntegerProperty(m->file, mux_data->track, "tkhd.flags", (TRACK_DISABLED | TRACK_IN_MOVIE));
 362             hb_log("Disabled extra audio track %i", mux_data->track-1);
 363         }
 364
 365     }
 366
 367         if (job->chapter_markers)
 368     {
 369                 /* add a text track for the chapters */
 370                 MP4TrackId textTrack;
 371                 textTrack = MP4AddChapterTextTrack(m->file, firstAudioTrack);
 372
 373         m->chapter_track = textTrack;
 374         m->chapter_duration = 0;
 375         m->current_chapter = job->chapter_start;
 376         }
 377
 378     /* Add encoded-by metadata listing version and build date */
 379     char *tool_string;
 380     tool_string = (char *)malloc(80);
 381     snprintf( tool_string, 80, "HandBrake %s %i", HB_VERSION, HB_BUILD);
 382     MP4SetMetadataTool(m->file, tool_string);
 383     free(tool_string);
 384
 385     return 0;
 386 }
 387
 388 static int MP4Mux( hb_mux_object_t * m, hb_mux_data_t * mux_data,
 389                    hb_buffer_t * buf )
 390 {
 391     hb_job_t * job = m->job;
 392
 393     uint64_t duration;
 394
 395     if( mux_data == job->mux_data )
 396     {
 397         /* Add the sample before the new frame.
 398            It is important that this be calculated prior to the duration
 399            of the new video sample, as we want to sync to right after it.
 400            (This is because of how durations for text tracks work in QT) */
 401         if( job->chapter_markers && buf->new_chap )
 402         {
 403             struct hb_text_sample_s *sample;
 404
 405             /* If this is an x264 encode with bframes the IDR frame we're
 406                trying to mark will be displayed offset by its renderOffset
 407                so we need to offset the chapter by the same amount.
 408                MP4 render offsets don't seem to work for text tracks so
 409                we have to fudge the duration instead. */
 410             duration = m->sum_dur - m->chapter_duration;
 411
 412             if ( job->areBframes )
 413             {
 414                 duration += buf->renderOffset * job->arate / 90000;
 415             }
 416
 417             sample = MP4GenerateChapterSample( m, duration );
 418
 419             if( !MP4WriteSample(m->file,
 420                                 m->chapter_track,
 421                                 sample->sample,
 422                                 sample->length,
 423                                 sample->duration,
 424                                 0, true) )
 425             {
 426                 hb_error("Failed to write to output file, disk full?");
 427                 *job->die = 1;
 428             }
 429             free(sample);
 430             m->current_chapter++;
 431             m->chapter_duration += duration;
 432         }
 433
 434         /* Video */
 435         /* Because we use the audio samplerate as the timescale,
 436            we have to use potentially variable durations so the video
 437            doesn't go out of sync */
 438         int64_t bias = ( buf->start * job->arate / 90000 ) - m->sum_dur;
 439         duration = ( buf->stop - buf->start ) * job->arate / 90000 + bias;
 440         m->sum_dur += duration;
 441     }
 442     else
 443     {
 444         /* Audio */
 445         duration = MP4_INVALID_DURATION;
 446     }
 447
 448     /* Here's where the sample actually gets muxed.
 449        If it's an audio sample, don't offset the sample's playback.
 450        If it's a video sample and there are no b-frames, ditto.
 451        If there are b-frames, offset by the initDelay plus the
 452        difference between the presentation time stamp x264 gives
 453        and the decoding time stamp from the buffer data. */
 454     if( !MP4WriteSample( m->file,
 455                          mux_data->track,
 456                          buf->data,
 457                          buf->size,
 458                          duration,
 459                          ((mux_data->track != 1) ||
 460                           (job->areBframes==0) ||
 461                           (job->vcodec != HB_VCODEC_X264)) ? 0 : (  buf->renderOffset * job->arate / 90000),
 462                          ((buf->frametype & HB_FRAME_KEY) != 0) ) )
 463     {
 464         hb_error("Failed to write to output file, disk full?");
 465         *job->die = 1;
 466     }
 467
 468     return 0;
 469 }
 470
 471 static int MP4End( hb_mux_object_t * m )
 472 {
 473     hb_job_t   * job   = m->job;
 474
 475     /* Write our final chapter marker */
 476     if( m->job->chapter_markers )
 477     {
 478         struct hb_text_sample_s *sample = MP4GenerateChapterSample( m, (m->sum_dur - m->chapter_duration) );
 479
 480         if( !MP4WriteSample(m->file,
 481                             m->chapter_track,
 482                             sample->sample,
 483                             sample->length,
 484                             sample->duration,
 485                             0, true) )
 486         {
 487             hb_error("Failed to write to output file, disk full?");
 488             *job->die = 1;
 489         }
 490         free(sample);
 491     }
 492
 493     if (job->areBframes)
 494     {
 495            // Insert track edit to get A/V back in sync.  The edit amount is
 496            // the rendering offset of the first sample.
 497            MP4AddTrackEdit(m->file, 1, MP4_INVALID_EDIT_ID, MP4GetSampleRenderingOffset(m->file,1,1),
 498                MP4GetTrackDuration(m->file, 1), 0);
 499             if ( m->job->chapter_markers )
 500             {
 501                 // apply same edit to chapter track to keep it in sync with video
 502                 MP4AddTrackEdit(m->file, m->chapter_track, MP4_INVALID_EDIT_ID,
 503                                 MP4GetSampleRenderingOffset(m->file,1,1),
 504                                 MP4GetTrackDuration(m->file, m->chapter_track), 0);
 505             }
 506      }
 507
 508     MP4Close( m->file );
 509
 510     if ( job->mp4_optimize )
 511     {
 512         hb_log( "muxmp4: optimizing file" );
 513         char filename[1024]; memset( filename, 0, 1024 );
 514         snprintf( filename, 1024, "%s.tmp", job->file );
 515         MP4Optimize( job->file, filename, MP4_DETAILS_ERROR );
 516         remove( job->file );
 517         rename( filename, job->file );
 518     }
 519
 520     return 0;
 521 }
 522
 523 hb_mux_object_t * hb_mux_mp4_init( hb_job_t * job )
 524 {
 525     hb_mux_object_t * m = calloc( sizeof( hb_mux_object_t ), 1 );
 526     m->init      = MP4Init;
 527     m->mux       = MP4Mux;
 528     m->end       = MP4End;
 529     m->job       = job;
 530     return m;
 531 }
 532