1 /* $Id: muxmp4.c,v 1.24 2005/11/04 13:09:41 titer Exp $
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. */
12 void AddIPodUUID(MP4FileHandle, MP4TrackId);
14 struct hb_mux_object_s
23 /* Cumulated durations so far, in timescale units (see MP4Mux) */
26 /* Chapter state information for muxing */
27 MP4TrackId chapter_track;
29 uint64_t chapter_duration;
37 struct hb_text_sample_s
44 /**********************************************************************
46 **********************************************************************
47 * Creates a buffer for a text track sample
48 *********************************************************************/
49 static struct hb_text_sample_s *MP4CreateTextSample( char *textString, uint64_t duration )
51 struct hb_text_sample_s *sample = NULL;
52 int stringLength = strlen(textString);
55 if( stringLength < 1024 )
57 sample = malloc( sizeof( struct hb_text_sample_s ) );
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;
63 // 2-byte length marker
64 sample->sample[0] = (stringLength >> 8) & 0xff;
65 sample->sample[1] = stringLength & 0xff;
67 strncpy( (char *)&(sample->sample[2]), textString, stringLength );
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;
78 sample->sample[x+4] = 'e';
79 sample->sample[x+5] = 'n';
80 sample->sample[x+6] = 'c';
81 sample->sample[x+7] = 'd';
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;
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 )
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;
105 tmp_buffer[0] = '\0';
107 if( chapter_data != NULL )
109 string = chapter_data->title;
112 if( strlen(string) == 0 || strlen(string) >= 1024 )
114 snprintf( tmp_buffer, 1023, "Chapter %03i", chapter );
118 return MP4CreateTextSample( string, duration );
122 /**********************************************************************
124 **********************************************************************
125 * Allocates hb_mux_data_t structures, create file and write headers
126 *********************************************************************/
127 static int MP4Init( hb_mux_object_t * m )
129 hb_job_t * job = m->job;
130 hb_title_t * title = job->title;
133 hb_mux_data_t * mux_data;
135 u_int16_t language_code;
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;
141 /* Create an empty mp4 file */
142 if (job->largeFileSize)
143 /* Use 64-bit MP4 file */
145 m->file = MP4Create( job->file, MP4_DETAILS_ERROR, MP4_CREATE_64BIT_DATA );
146 hb_log("Using 64-bit MP4 formatting.");
149 /* Limit MP4s to less than 4 GB */
151 m->file = MP4Create( job->file, MP4_DETAILS_ERROR, 0 );
154 if (m->file == MP4_INVALID_FILE_HANDLE)
156 hb_error("muxmp4.c: MP4Create failed!");
162 mux_data = malloc( sizeof( hb_mux_data_t ) );
163 job->mux_data = mux_data;
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
169 if (!(MP4SetTimeScale( m->file, job->arate )))
171 hb_error("muxmp4.c: MP4SetTimeScale failed!");
176 if( job->vcodec == HB_VCODEC_X264 )
178 /* Stolen from mp4creator */
179 if(!(MP4SetVideoProfileLevel( m->file, 0x7F )))
181 hb_error("muxmp4.c: MP4SetVideoProfileLevel failed!");
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 */
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 );
199 if( job->h264_level == 30 || job->ipod_atom)
201 hb_log("About to add iPod atom");
202 AddIPodUUID(m->file, mux_data->track);
206 else /* FFmpeg or XviD */
208 if(!(MP4SetVideoProfileLevel( m->file, MPEG4_SP_L3 )))
210 hb_error("muxmp4.c: MP4SetVideoProfileLevel failed!");
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)
219 hb_error("muxmp4.c: MP4AddVideoTrack failed!");
225 /* VOL from FFmpeg or XviD */
226 if (!(MP4SetTrackESConfiguration( m->file, mux_data->track,
227 job->config.mpeg4.bytes, job->config.mpeg4.length )))
229 hb_error("muxmp4.c: MP4SetTrackESConfiguration failed!");
235 /* apply the anamorphic transformation matrix if needed */
237 if( job->pixel_ratio ) {
241 uint32_t *ptr32 = (uint32_t*) (nval + 2);
244 MP4GetBytesProperty(m->file, "moov.trak.tkhd.reserved3", &val, &size);
248 memcpy(nval, val, size);
251 width = job->pixel_aspect_width;
252 height = job->pixel_aspect_height;
254 uint32_t pixelRatioInt;
257 pixelRatioInt = (uint32_t)((width / height) * 0x10000);
259 #ifdef WORDS_BIGENDIAN
260 ptr32[0] = pixelRatioInt;
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);
269 pixelRatioInt = (uint32_t)((height / width) * 0x10000);
270 #ifdef WORDS_BIGENDIAN
271 ptr32[4] = pixelRatioInt;
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);
279 if(!MP4SetBytesProperty(m->file, "moov.trak.tkhd.reserved3", nval, size)) {
280 hb_log("Problem setting transform matrix");
287 /* end of transformation matrix */
289 /* firstAudioTrack will be used to reference the first audio track when we add a chapter track */
290 MP4TrackId firstAudioTrack = 0;
292 /* add the audio tracks */
293 for( i = 0; i < hb_list_count( title->list_audio ); i++ )
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,
302 audio = hb_list_item( title->list_audio, i );
303 mux_data = malloc( sizeof( hb_mux_data_t ) );
304 audio->mux_data = mux_data;
306 if( job->acodec & HB_ACODEC_AC3 )
308 mux_data->track = MP4AddAC3AudioTrack(
310 job->arate, 1536, MP4_MPEG4_AUDIO_TYPE );
311 MP4SetTrackBytesProperty(
312 m->file, mux_data->track,
314 (const u_int8_t*)"Surround", strlen("Surround"));
316 mux_data->track = MP4AddAudioTrack(
318 job->arate, 1024, MP4_MPEG4_AUDIO_TYPE );
319 MP4SetTrackBytesProperty(
320 m->file, mux_data->track,
322 (const u_int8_t*)"Stereo", strlen("Stereo"));
324 MP4SetAudioProfileLevel( m->file, 0x0F );
325 MP4SetTrackESConfiguration(
326 m->file, mux_data->track,
327 audio->config.aac.bytes, audio->config.aac.length );
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));
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);
342 /* Set the audio track alternate group */
343 MP4SetTrackIntegerProperty(m->file, mux_data->track, "tkhd.alternate_group", 1);
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));
348 /* store a reference to the first audio track,
349 so we can use it to feed the chapter text track's sample rate */
351 firstAudioTrack = mux_data->track;
353 /* Enable the first audio track */
354 MP4SetTrackIntegerProperty(m->file, mux_data->track, "tkhd.flags", (TRACK_ENABLED | TRACK_IN_MOVIE));
358 /* Disable the other audio tracks so QuickTime doesn't play
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);
367 if (job->chapter_markers)
369 /* add a text track for the chapters */
370 MP4TrackId textTrack;
371 textTrack = MP4AddChapterTextTrack(m->file, firstAudioTrack);
373 m->chapter_track = textTrack;
374 m->chapter_duration = 0;
375 m->current_chapter = job->chapter_start;
378 /* Add encoded-by metadata listing version and build date */
380 tool_string = (char *)malloc(80);
381 snprintf( tool_string, 80, "HandBrake %s %i", HB_VERSION, HB_BUILD);
382 MP4SetMetadataTool(m->file, tool_string);
388 static int MP4Mux( hb_mux_object_t * m, hb_mux_data_t * mux_data,
391 hb_job_t * job = m->job;
395 if( mux_data == job->mux_data )
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 )
403 struct hb_text_sample_s *sample;
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;
412 if ( job->areBframes )
414 duration += buf->renderOffset * job->arate / 90000;
417 sample = MP4GenerateChapterSample( m, duration );
419 if( !MP4WriteSample(m->file,
426 hb_error("Failed to write to output file, disk full?");
430 m->current_chapter++;
431 m->chapter_duration += duration;
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;
445 duration = MP4_INVALID_DURATION;
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,
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) ) )
464 hb_error("Failed to write to output file, disk full?");
471 static int MP4End( hb_mux_object_t * m )
473 hb_job_t * job = m->job;
475 /* Write our final chapter marker */
476 if( m->job->chapter_markers )
478 struct hb_text_sample_s *sample = MP4GenerateChapterSample( m, (m->sum_dur - m->chapter_duration) );
480 if( !MP4WriteSample(m->file,
487 hb_error("Failed to write to output file, disk full?");
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 )
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);
510 if ( job->mp4_optimize )
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 );
517 rename( filename, job->file );
523 hb_mux_object_t * hb_mux_mp4_init( hb_job_t * job )
525 hb_mux_object_t * m = calloc( sizeof( hb_mux_object_t ), 1 );