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. */
14 /* Scale factor to apply to timecodes to convert from HandBrake's
15 * 1/90000s to nanoseconds as expected by libmkv */
16 #define TIMECODE_SCALE 1000000000 / 90000
18 struct hb_mux_object_s
30 uint64_t prev_chapter_tc;
31 uint16_t current_chapter;
37 static int yuv2rgb(int yuv)
42 y = (yuv >> 16) & 0xff;
43 Cb = (yuv >> 8) & 0xff;
46 r = 1.164 * (y - 16) + 2.018 * (Cb - 128);
47 g = 1.164 * (y - 16) - 0.813 * (Cr - 128) - 0.391 * (Cb - 128);
48 b = 1.164 * (y - 16) + 1.596 * (Cr - 128);
52 r = (r > 255) ? 255 : r;
53 g = (g > 255) ? 255 : g;
54 b = (b > 255) ? 255 : b;
55 return (r << 16) | (g << 8) | b;
58 /**********************************************************************
60 **********************************************************************
61 * Allocates hb_mux_data_t structures, create file and write headers
62 *********************************************************************/
63 static int MKVInit( hb_mux_object_t * m )
65 hb_job_t * job = m->job;
66 hb_title_t * title = job->title;
68 hb_mux_data_t * mux_data;
71 uint8_t default_track_flag = 1;
73 ogg_packet *ogg_headers[3];
74 mk_TrackConfig *track;
76 track = calloc(1, sizeof(mk_TrackConfig));
78 m->file = mk_createWriter(job->file, 1000000, 1);
82 hb_error( "Could not create output file, Disk Full?" );
89 mux_data = calloc(1, sizeof( hb_mux_data_t ) );
90 job->mux_data = mux_data;
92 track->trackType = MK_TRACK_VIDEO;
93 track->flagDefault = 1;
94 track->flagEnabled = 1;
98 track->codecID = MK_VCODEC_MP4AVC;
99 /* Taken from x264 muxers.c */
100 avcC_len = 5 + 1 + 2 + job->config.h264.sps_length + 1 + 2 + job->config.h264.pps_length;
101 avcC = malloc(avcC_len);
106 avcC[1] = job->config.h264.sps[1]; /* AVCProfileIndication */
107 avcC[2] = job->config.h264.sps[2]; /* profile_compat */
108 avcC[3] = job->config.h264.sps[3]; /* AVCLevelIndication */
109 avcC[4] = 0xff; // nalu size length is four bytes
110 avcC[5] = 0xe1; // one sps
112 avcC[6] = job->config.h264.sps_length >> 8;
113 avcC[7] = job->config.h264.sps_length;
115 memcpy(avcC+8, job->config.h264.sps, job->config.h264.sps_length);
117 avcC[8+job->config.h264.sps_length] = 1; // one pps
118 avcC[9+job->config.h264.sps_length] = job->config.h264.pps_length >> 8;
119 avcC[10+job->config.h264.sps_length] = job->config.h264.pps_length;
121 memcpy( avcC+11+job->config.h264.sps_length, job->config.h264.pps, job->config.h264.pps_length );
122 track->codecPrivate = avcC;
123 track->codecPrivateSize = avcC_len;
127 case HB_VCODEC_FFMPEG:
128 track->codecID = MK_VCODEC_MP4ASP;
129 track->codecPrivate = job->config.mpeg4.bytes;
130 track->codecPrivateSize = job->config.mpeg4.length;
132 case HB_VCODEC_THEORA:
135 uint64_t cp_size = 0;
136 track->codecID = MK_VCODEC_THEORA;
137 uint64_t header_sizes[3];
138 for (i = 0; i < 3; ++i)
140 ogg_headers[i] = (ogg_packet *)job->config.theora.headers[i];
141 ogg_headers[i]->packet = (unsigned char *)&job->config.theora.headers[i] + sizeof( ogg_packet );
142 header_sizes[i] = ogg_headers[i]->bytes;
144 track->codecPrivate = mk_laceXiph(header_sizes, 2, &cp_size);
145 track->codecPrivate = realloc(track->codecPrivate, cp_size + ogg_headers[0]->bytes + ogg_headers[1]->bytes + ogg_headers[2]->bytes);
146 for(i = 0; i < 3; ++i)
148 memcpy(track->codecPrivate + cp_size, ogg_headers[i]->packet, ogg_headers[i]->bytes);
149 cp_size += ogg_headers[i]->bytes;
151 track->codecPrivateSize = cp_size;
156 hb_error("muxmkv: Unknown video codec: %x", job->vcodec);
160 track->extra.video.pixelWidth = job->width;
161 track->extra.video.pixelHeight = job->height;
162 track->extra.video.displayHeight = job->height;
163 if( job->anamorphic.mode )
165 track->extra.video.displayWidth = job->width * ((double)job->anamorphic.par_width / (double)job->anamorphic.par_height);
169 track->extra.video.displayWidth = job->width;
173 track->defaultDuration = (int64_t)(((float)job->vrate_base / (float)job->vrate) * 1000000000);
175 mux_data->track = mk_createTrack(m->file, track);
177 memset(track, 0, sizeof(mk_TrackConfig));
179 /* add the audio tracks */
180 for( i = 0; i < hb_list_count( title->list_audio ); i++ )
182 audio = hb_list_item( title->list_audio, i );
183 mux_data = calloc(1, sizeof( hb_mux_data_t ) );
184 audio->priv.mux_data = mux_data;
186 mux_data->codec = audio->config.out.codec;
188 switch (audio->config.out.codec)
191 track->codecPrivate = NULL;
192 track->codecPrivateSize = 0;
193 track->codecID = MK_ACODEC_DTS;
196 track->codecPrivate = NULL;
197 track->codecPrivateSize = 0;
198 track->codecID = MK_ACODEC_AC3;
201 track->codecPrivate = NULL;
202 track->codecPrivateSize = 0;
203 track->codecID = MK_ACODEC_MP3;
205 case HB_ACODEC_VORBIS:
208 uint64_t cp_size = 0;
209 track->codecID = MK_ACODEC_VORBIS;
210 uint64_t header_sizes[3];
211 for (i = 0; i < 3; ++i)
213 ogg_headers[i] = (ogg_packet *)audio->priv.config.vorbis.headers[i];
214 ogg_headers[i]->packet = (unsigned char *)&audio->priv.config.vorbis.headers[i] + sizeof( ogg_packet );
215 header_sizes[i] = ogg_headers[i]->bytes;
217 track->codecPrivate = mk_laceXiph(header_sizes, 2, &cp_size);
218 track->codecPrivate = realloc(track->codecPrivate, cp_size + ogg_headers[0]->bytes + ogg_headers[1]->bytes + ogg_headers[2]->bytes);
219 for(i = 0; i < 3; ++i)
221 memcpy(track->codecPrivate + cp_size, ogg_headers[i]->packet, ogg_headers[i]->bytes);
222 cp_size += ogg_headers[i]->bytes;
224 track->codecPrivateSize = cp_size;
228 case HB_ACODEC_CA_AAC:
229 track->codecPrivate = audio->priv.config.aac.bytes;
230 track->codecPrivateSize = audio->priv.config.aac.length;
231 track->codecID = MK_ACODEC_AAC;
235 hb_error("muxmkv: Unknown audio codec: %x", audio->config.out.codec);
239 if (default_track_flag)
241 track->flagDefault = 1;
242 default_track_flag = 0;
246 track->flagDefault = 0;
248 track->flagEnabled = 1;
249 track->trackType = MK_TRACK_AUDIO;
250 track->language = audio->config.lang.iso639_2;
251 track->extra.audio.samplingFreq = (float)audio->config.out.samplerate;
252 if (audio->config.out.codec == HB_ACODEC_AC3 ||
253 audio->config.out.codec == HB_ACODEC_DCA)
255 track->extra.audio.channels = HB_INPUT_CH_LAYOUT_GET_DISCRETE_COUNT(audio->config.in.channel_layout);
259 track->extra.audio.channels = HB_AMIXDOWN_GET_DISCRETE_CHANNEL_COUNT(audio->config.out.mixdown);
261 // track->defaultDuration = job->arate * 1000;
262 mux_data->track = mk_createTrack(m->file, track);
263 if (audio->config.out.codec == HB_ACODEC_VORBIS && track->codecPrivate != NULL)
264 free(track->codecPrivate);
270 "scale: 100%%, 100%%\n"
273 "fadein/out: 50, 50\n"
274 "align: OFF at LEFT TOP\n"
277 "palette: %06x, %06x, %06x, %06x, %06x, %06x, "
278 "%06x, %06x, %06x, %06x, %06x, %06x, %06x, %06x, %06x, %06x\n"
279 "custom colors: OFF, tridx: 0000, "
280 "colors: 000000, 000000, 000000, 000000\n";
282 for( i = 0; i < hb_list_count( title->list_subtitle ); i++ )
284 hb_subtitle_t * subtitle;
289 subtitle = hb_list_item( title->list_subtitle, i );
290 if (subtitle->config.dest != PASSTHRUSUB)
293 memset(track, 0, sizeof(mk_TrackConfig));
294 switch (subtitle->format)
297 track->codecID = MK_SUBTITLE_VOBSUB;
298 for (j = 0; j < 16; j++)
299 rgb[j] = yuv2rgb(title->palette[j]);
300 len = snprintf(subidx, 2048, subidx_fmt,
301 title->width, title->height,
303 rgb[0], rgb[1], rgb[2], rgb[3],
304 rgb[4], rgb[5], rgb[6], rgb[7],
305 rgb[8], rgb[9], rgb[10], rgb[11],
306 rgb[12], rgb[13], rgb[14], rgb[15]);
307 track->codecPrivate = subidx;
308 track->codecPrivateSize = len + 1;
311 track->codecID = MK_SUBTITLE_UTF8;
316 if ( subtitle->config.default_track )
318 track->flagDefault = 1;
321 mux_data = calloc(1, sizeof( hb_mux_data_t ) );
322 subtitle->mux_data = mux_data;
323 mux_data->subtitle = 1;
324 mux_data->sub_format = subtitle->format;
326 track->flagEnabled = 1;
327 track->trackType = MK_TRACK_SUBTITLE;
328 track->language = subtitle->iso639_2;
330 mux_data->track = mk_createTrack(m->file, track);
333 if( mk_writeHeader( m->file, "HandBrake " HB_PROJECT_VERSION) < 0 )
335 hb_error( "Failed to write to output file, disk full?");
346 static int MKVMux( hb_mux_object_t * m, hb_mux_data_t * mux_data,
349 ogg_packet *op = NULL;
350 hb_job_t * job = m->job;
351 hb_title_t * title = job->title;
352 uint64_t timecode = 0;
353 hb_chapter_t *chapter_data;
354 char tmp_buffer[1024];
355 char *string = tmp_buffer;
357 if (mux_data == job->mux_data)
360 timecode = buf->start * TIMECODE_SCALE;
362 if (job->chapter_markers && (buf->new_chap || timecode == 0))
364 /* Make sure we're not writing a chapter that has 0 length */
365 if (mux_data->prev_chapter_tc != timecode)
369 mux_data->current_chapter = buf->new_chap - 2;
371 chapter_data = hb_list_item( title->list_chapter,
372 mux_data->current_chapter++ );
373 tmp_buffer[0] = '\0';
375 if( chapter_data != NULL )
377 string = chapter_data->title;
380 if( strlen(string) == 0 || strlen(string) >= 1024 )
382 snprintf( tmp_buffer, 1023, "Chapter %02i", mux_data->current_chapter );
385 mk_createChapterSimple(m->file, mux_data->prev_chapter_tc, mux_data->prev_chapter_tc, string);
387 mux_data->prev_chapter_tc = timecode;
390 if (job->vcodec == HB_VCODEC_THEORA)
392 /* ughhh, theora is a pain :( */
393 op = (ogg_packet *)buf->data;
394 op->packet = buf->data + sizeof( ogg_packet );
395 if (mk_startFrame(m->file, mux_data->track) < 0)
397 hb_error( "Failed to write frame to output file, Disk Full?" );
400 mk_addFrameData(m->file, mux_data->track, op->packet, op->bytes);
401 mk_setFrameFlags(m->file, mux_data->track, timecode, 1, 0);
405 else if ( mux_data->subtitle )
408 timecode = buf->start * TIMECODE_SCALE;
409 if( mk_startFrame(m->file, mux_data->track) < 0)
411 hb_error( "Failed to write frame to output file, Disk Full?" );
415 duration = buf->stop * TIMECODE_SCALE - timecode;
416 if( mux_data->sub_format == TEXTSUB )
418 mk_addFrameData(m->file, mux_data->track, buf->data, buf->size);
419 mk_setFrameFlags(m->file, mux_data->track, timecode, 1, duration);
423 mk_addFrameData(m->file, mux_data->track, buf->data, buf->size);
424 mk_setFrameFlags(m->file, mux_data->track, timecode, 1, duration);
426 mk_flushFrame(m->file, mux_data->track);
432 timecode = buf->start * TIMECODE_SCALE;
433 if (mux_data->codec == HB_ACODEC_VORBIS)
435 /* ughhh, vorbis is a pain :( */
436 op = (ogg_packet *)buf->data;
437 op->packet = buf->data + sizeof( ogg_packet );
438 if (mk_startFrame(m->file, mux_data->track))
440 hb_error( "Failed to write frame to output file, Disk Full?" );
443 mk_addFrameData(m->file, mux_data->track, op->packet, op->bytes);
444 mk_setFrameFlags(m->file, mux_data->track, timecode, 1, 0);
449 if( mk_startFrame(m->file, mux_data->track) < 0)
451 hb_error( "Failed to write frame to output file, Disk Full?" );
454 mk_addFrameData(m->file, mux_data->track, buf->data, buf->size);
455 mk_setFrameFlags(m->file, mux_data->track, timecode,
456 ((job->vcodec == HB_VCODEC_X264 &&
457 mux_data == job->mux_data) ?
458 (buf->frametype == HB_FRAME_IDR) :
459 ((buf->frametype & HB_FRAME_KEY) != 0)), 0 );
463 static int MKVEnd( hb_mux_object_t * m )
465 hb_job_t *job = m->job;
466 hb_mux_data_t *mux_data = job->mux_data;
467 hb_title_t *title = job->title;
468 hb_chapter_t *chapter_data;
469 char tmp_buffer[1024];
470 char *string = tmp_buffer;
475 * We must have failed to create the file in the first place.
480 chapter_data = hb_list_item( title->list_chapter, mux_data->current_chapter++ );
482 if(job->chapter_markers)
484 tmp_buffer[0] = '\0';
486 if( chapter_data != NULL )
488 string = chapter_data->title;
491 if( strlen(string) == 0 || strlen(string) >= 1024 )
493 snprintf( tmp_buffer, 1023, "Chapter %02i", mux_data->current_chapter );
496 mk_createChapterSimple(m->file, mux_data->prev_chapter_tc, mux_data->prev_chapter_tc, string);
499 if( title->metadata )
501 hb_metadata_t *md = title->metadata;
503 hb_deep_log( 2, "Writing Metadata to output file...");
504 mk_createTagSimple( m->file, MK_TAG_TITLE, md->name );
505 mk_createTagSimple( m->file, "ARTIST", md->artist );
506 mk_createTagSimple( m->file, "COMPOSER", md->composer );
507 mk_createTagSimple( m->file, MK_TAG_SYNOPSIS, md->comment );
508 mk_createTagSimple( m->file, "DATE_RELEASED", md->release_date );
509 // mk_createTagSimple( m->file, "", md->album );
510 mk_createTagSimple( m->file, MK_TAG_GENRE, md->genre );
513 if( mk_close(m->file) < 0 )
515 hb_error( "Failed to flush the last frame and close the output file, Disk Full?" );
519 // TODO: Free what we alloc'd
524 hb_mux_object_t * hb_mux_mkv_init( hb_job_t * job )
526 hb_mux_object_t * m = calloc( sizeof( hb_mux_object_t ), 1 );