int mk_flushFrame(mk_Writer *w, mk_Track *track)
{
mk_Context *c, *tp;
int64_t delta, ref = 0;
unsigned fsize, bgsize;
uint8_t flags, c_delta[2];
int i;
char *laced = NULL;
uint64_t length = 0;
uint64_t block_duration = 0;
if (!track->in_frame)
return 0;
delta = track->frame.timecode / w->timescale - w->cluster.tc_scaled;
block_duration = track->frame.duration / w->timescale;
/* NOTE: If we switch rapidly back-and-forth between tracks with
* drastically different timecodes this causes a new cluster to
* be written each time a switch is made. This causes unnecessary
* overhead. The calling application is assumed to have interleaved
* track samples based on timestamp.
*/
/* Soft limit: If the frame is a video keyframe and we are not closer than
* 2 seconds to the last cluster, start a new cluster.
*/
if (track->track_type == MK_TRACK_VIDEO && track->frame.keyframe && delta > 2000ll)
CHECK(mk_closeCluster(w));
/* Hard limit: if the current cluster is greater than 20 seconds,
* start a new cluster
*/
if (delta > 20000ll || delta < -20000ll)
CHECK(mk_closeCluster(w));
if (w->cluster.context == NULL) {
w->cluster.tc_scaled = track->frame.timecode / w->timescale;
/* Cluster */
w->cluster.context = mk_createContext(w, w->root, MATROSKA_ID_CLUSTER);
if (w->cluster.context == NULL)
return -1;
w->cluster.pointer = w->f_pos - w->segment_ptr;
/* Cluster SeekEntry */
CHECK(mk_writeSeek(w, w->cluster.seekhead, MATROSKA_ID_CLUSTER,
w->cluster.pointer));
/* Cluster Timecode */
CHECK(mk_writeUInt(w->cluster.context, MATROSKA_ID_CLUSTERTIMECODE, w->cluster.tc_scaled));
delta = 0;
w->cluster.block_count = 0;
}
/* Calculate the encoded lacing sizes. */
switch (track->frame.lacing) {
case MK_LACING_XIPH:
laced = mk_laceXiph(track->frame.lacing_sizes,
track->frame.lacing_num_frames, &length);
break;
case MK_LACING_EBML:
{
uint64_t u_size = 0;
/* Add one below for the frame count. */
length += mk_ebmlSizeSize(track->frame.lacing_sizes[0]) + 1;
for (i = 1; i < track->frame.lacing_num_frames; i++) {
u_size = llabs(track->frame.lacing_sizes[i] -
track->frame.lacing_sizes[i - 1]);
/* Shift by one so we get the right size for a signed number. */
length += mk_ebmlSizeSize((u_size) << 1);
}
break;
}
case MK_LACING_FIXED:
{
laced = calloc(1, sizeof(*laced));
laced[0] = track->frame.lacing_num_frames;
++length;
break;
}
default:
break;
}
fsize = track->frame.data ? track->frame.data->d_cur : 0;
bgsize = fsize + 4 + mk_ebmlSizeSize(fsize + 4 + length) + 1 + length;
if (!track->frame.keyframe) {
ref = track->prev_frame_tc_scaled - w->cluster.tc_scaled - delta;
bgsize += 1 + 1 + mk_ebmlSIntSize(ref);
}
if (block_duration > 0) /* BlockDuration */
{
bgsize += 1 + 1 + mk_ebmlUIntSize(block_duration);
}
CHECK(mk_writeID(w->cluster.context, MATROSKA_ID_BLOCKGROUP)); /* BlockGroup */
CHECK(mk_writeSize(w->cluster.context, bgsize));
CHECK(mk_writeID(w->cluster.context, MATROSKA_ID_BLOCK)); /* Block */
CHECK(mk_writeSize(w->cluster.context, fsize + 4 + length)); /* BlockSize */
CHECK(mk_writeSize(w->cluster.context, track->track_id)); /* track number */
w->cluster.block_count++;
c_delta[0] = delta >> 8;
c_delta[1] = delta;
/* Timecode relative to Cluster. */
CHECK(mk_appendContextData(w->cluster.context, c_delta, 2));
/* flags = ( track->frame.keyframe << 8 ) | track->frame.lacing; */
flags = track->frame.lacing << 1; /* Flags: Bit 5-6 describe what type of lacing to use. */
CHECK(mk_appendContextData(w->cluster.context, &flags, 1));
if (track->frame.lacing) {
if (track->frame.lacing == MK_LACING_EBML) {
/* Number of frames in lace - 1 */
CHECK(mk_appendContextData(w->cluster.context, &track->frame.lacing_num_frames, 1));
/* Size of 1st frame. */
CHECK(mk_writeSize(w->cluster.context, track->frame.lacing_sizes[0]));
for (i = 1; i < track->frame.lacing_num_frames; i++) {
/* Size difference between previous size and this size. */
CHECK(mk_writeSSize(w->cluster.context, track->frame.lacing_sizes[i] - track->frame.lacing_sizes[i - 1]));
}
} else if (length > 0 && laced != NULL) {
CHECK(mk_appendContextData(w->cluster.context, laced, length));
free(laced);
laced = NULL;
}
}
if (track->frame.data) {
CHECK(mk_appendContextData(w->cluster.context, track->frame.data->data,
track->frame.data->d_cur));
track->frame.data->d_cur = 0;
}
if (!track->frame.keyframe) /* ReferenceBlock */
CHECK(mk_writeSInt(w->cluster.context, MATROSKA_ID_REFERENCEBLOCK, ref));
if (block_duration > 0) /* BlockDuration */
CHECK(mk_writeUInt(w->cluster.context, 0x9b, block_duration));
/* This may get a little out of hand, but it seems sane enough for now. */
if (track->frame.keyframe && (track->track_type == MK_TRACK_VIDEO)) {
/* if (track->frame.keyframe && (track->track_type & MK_TRACK_VIDEO) && ((track->prev_cue_pos + 3*CLSIZE) <= w->f_pos || track->frame.timecode == 0)) { */
/* CuePoint */
if ((c = mk_createContext(w, w->cues, MATROSKA_ID_CUEPOINT)) == NULL)
return -1;
/* CueTime */
CHECK(mk_writeUInt(c, MATROSKA_ID_CUETIME, (track->frame.timecode / w->timescale)));
/* CueTrackPositions */
if ((tp = mk_createContext(w, c, MATROSKA_ID_CUETRACKPOSITIONS)) == NULL)
return -1;
/* CueTrack */
CHECK(mk_writeUInt(tp, MATROSKA_ID_CUETRACK, track->track_id));
/* CueClusterPosition */
CHECK(mk_writeUInt(tp, MATROSKA_ID_CUECLUSTERPOSITION, w->cluster.pointer));
/* CueBlockNumber */
/* CHECK(mk_writeUInt(c, MATROSKA_ID_CUEBLOCKNUMBER, w->cluster.block_count)); */
CHECK(mk_closeContext(tp, 0));
CHECK(mk_closeContext(c, 0));
track->prev_cue_pos = w->f_pos;
}
track->in_frame = 0;
track->prev_frame_tc_scaled = w->cluster.tc_scaled + delta;
return 0;
}
/**********************************************************************
* MKVInit
**********************************************************************
* Allocates hb_mux_data_t structures, create file and write headers
*********************************************************************/
static int MKVInit( hb_mux_object_t * m )
{
hb_job_t * job = m->job;
hb_audio_t * audio;
hb_mux_data_t * mux_data;
uint8_t *avcC = NULL;
uint8_t default_track_flag = 1;
uint8_t need_fonts = 0;
int avcC_len, i, j;
ogg_packet *ogg_headers[3];
mk_TrackConfig *track;
iso639_lang_t *lang;
track = calloc(1, sizeof(mk_TrackConfig));
m->file = mk_createWriter(job->file, 1000000, 1);
if( !m->file )
{
hb_error( "Could not create output file, Disk Full?" );
job->mux_data = NULL;
*job->die = 1;
free(track);
return 0;
}
/* Video track */
mux_data = calloc(1, sizeof( hb_mux_data_t ) );
job->mux_data = mux_data;
track->trackType = MK_TRACK_VIDEO;
track->flagDefault = 1;
track->flagEnabled = 1;
switch (job->vcodec)
{
case HB_VCODEC_X264:
track->codecID = MK_VCODEC_MP4AVC;
/* Taken from x264 muxers.c */
avcC_len = 5 + 1 + 2 + job->config.h264.sps_length + 1 + 2 + job->config.h264.pps_length;
avcC = malloc(avcC_len);
if (avcC == NULL) {
free(track);
return -1;
}
avcC[0] = 1;
avcC[1] = job->config.h264.sps[1]; /* AVCProfileIndication */
avcC[2] = job->config.h264.sps[2]; /* profile_compat */
avcC[3] = job->config.h264.sps[3]; /* AVCLevelIndication */
avcC[4] = 0xff; // nalu size length is four bytes
avcC[5] = 0xe1; // one sps
avcC[6] = job->config.h264.sps_length >> 8;
avcC[7] = job->config.h264.sps_length;
memcpy(avcC+8, job->config.h264.sps, job->config.h264.sps_length);
avcC[8+job->config.h264.sps_length] = 1; // one pps
avcC[9+job->config.h264.sps_length] = job->config.h264.pps_length >> 8;
avcC[10+job->config.h264.sps_length] = job->config.h264.pps_length;
memcpy( avcC+11+job->config.h264.sps_length, job->config.h264.pps, job->config.h264.pps_length );
track->codecPrivate = avcC;
track->codecPrivateSize = avcC_len;
if (job->areBframes)
track->minCache = 1;
break;
case HB_VCODEC_FFMPEG_MPEG4:
track->codecID = MK_VCODEC_MP4ASP;
track->codecPrivate = job->config.mpeg4.bytes;
track->codecPrivateSize = job->config.mpeg4.length;
if (job->areBframes)
track->minCache = 1;
break;
case HB_VCODEC_FFMPEG_MPEG2:
track->codecID = MK_VCODEC_MPEG2;
track->codecPrivate = job->config.mpeg4.bytes;
track->codecPrivateSize = job->config.mpeg4.length;
if (job->areBframes)
track->minCache = 1;
break;
case HB_VCODEC_THEORA:
{
int i;
uint64_t cp_size = 0;
track->codecID = MK_VCODEC_THEORA;
uint64_t header_sizes[3];
for (i = 0; i < 3; ++i)
{
ogg_headers[i] = (ogg_packet *)job->config.theora.headers[i];
ogg_headers[i]->packet = (unsigned char *)&job->config.theora.headers[i] + sizeof( ogg_packet );
header_sizes[i] = ogg_headers[i]->bytes;
}
track->codecPrivate = mk_laceXiph(header_sizes, 2, &cp_size);
track->codecPrivate = realloc(track->codecPrivate, cp_size + ogg_headers[0]->bytes + ogg_headers[1]->bytes + ogg_headers[2]->bytes);
for(i = 0; i < 3; ++i)
{
memcpy(track->codecPrivate + cp_size, ogg_headers[i]->packet, ogg_headers[i]->bytes);
cp_size += ogg_headers[i]->bytes;
}
track->codecPrivateSize = cp_size;
}
break;
default:
*job->die = 1;
hb_error("muxmkv: Unknown video codec: %x", job->vcodec);
free(track);
return 0;
}
track->extra.video.pixelWidth = job->width;
track->extra.video.pixelHeight = job->height;
track->extra.video.displayHeight = job->height;
if( job->anamorphic.mode )
{
track->extra.video.displayWidth = job->width * ((double)job->anamorphic.par_width / (double)job->anamorphic.par_height);
}
else
{
track->extra.video.displayWidth = job->width;
}
int vrate_base, vrate;
if( job->pass == 2 )
{
hb_interjob_t * interjob = hb_interjob_get( job->h );
vrate_base = interjob->vrate_base;
vrate = interjob->vrate;
}
else
{
vrate_base = job->vrate_base;
vrate = job->vrate;
}
track->defaultDuration = (int64_t)(((float)vrate_base / (float)vrate) * 1000000000);
mux_data->track = mk_createTrack(m->file, track);
/* add the audio tracks */
for( i = 0; i < hb_list_count( job->list_audio ); i++ )
{
audio = hb_list_item( job->list_audio, i );
mux_data = calloc(1, sizeof( hb_mux_data_t ) );
audio->priv.mux_data = mux_data;
mux_data->codec = audio->config.out.codec;
memset(track, 0, sizeof(mk_TrackConfig));
switch (audio->config.out.codec & HB_ACODEC_MASK)
{
case HB_ACODEC_DCA:
case HB_ACODEC_DCA_HD:
track->codecPrivate = NULL;
track->codecPrivateSize = 0;
track->codecID = MK_ACODEC_DTS;
break;
case HB_ACODEC_AC3:
track->codecPrivate = NULL;
track->codecPrivateSize = 0;
track->codecID = MK_ACODEC_AC3;
break;
case HB_ACODEC_LAME:
case HB_ACODEC_MP3:
track->codecPrivate = NULL;
track->codecPrivateSize = 0;
track->codecID = MK_ACODEC_MP3;
break;
case HB_ACODEC_VORBIS:
{
int i;
uint64_t cp_size = 0;
track->codecID = MK_ACODEC_VORBIS;
uint64_t header_sizes[3];
for (i = 0; i < 3; ++i)
{
ogg_headers[i] = (ogg_packet *)audio->priv.config.vorbis.headers[i];
ogg_headers[i]->packet = (unsigned char *)&audio->priv.config.vorbis.headers[i] + sizeof( ogg_packet );
header_sizes[i] = ogg_headers[i]->bytes;
}
track->codecPrivate = mk_laceXiph(header_sizes, 2, &cp_size);
track->codecPrivate = realloc(track->codecPrivate, cp_size + ogg_headers[0]->bytes + ogg_headers[1]->bytes + ogg_headers[2]->bytes);
for(i = 0; i < 3; ++i)
{
memcpy(track->codecPrivate + cp_size, ogg_headers[i]->packet, ogg_headers[i]->bytes);
cp_size += ogg_headers[i]->bytes;
}
track->codecPrivateSize = cp_size;
}
break;
case HB_ACODEC_FFFLAC:
case HB_ACODEC_FFFLAC24:
if (audio->priv.config.extradata.bytes)
{
track->codecPrivate = create_flac_header(audio->priv.config.extradata.bytes,
audio->priv.config.extradata.length);
track->codecPrivateSize = audio->priv.config.extradata.length + 8;
}
track->codecID = MK_ACODEC_FLAC;
break;
case HB_ACODEC_FAAC:
case HB_ACODEC_FFAAC:
case HB_ACODEC_CA_AAC:
case HB_ACODEC_CA_HAAC:
case HB_ACODEC_FDK_AAC:
case HB_ACODEC_FDK_HAAC:
track->codecPrivate = audio->priv.config.extradata.bytes;
track->codecPrivateSize = audio->priv.config.extradata.length;
track->codecID = MK_ACODEC_AAC;
break;
default:
*job->die = 1;
hb_error("muxmkv: Unknown audio codec: %x", audio->config.out.codec);
return 0;
}
if( default_track_flag )
{
track->flagDefault = 1;
default_track_flag = 0;
}
else
{
track->flagDefault = 0;
}
track->flagEnabled = 1;
track->trackType = MK_TRACK_AUDIO;
// MKV lang codes should be ISO-639-2/B
lang = lang_for_code2( audio->config.lang.iso639_2 );
track->language = lang->iso639_2b ? lang->iso639_2b : lang->iso639_2;
// sample rate
if ((audio->config.out.codec == HB_ACODEC_CA_HAAC) ||
(audio->config.out.codec == HB_ACODEC_FDK_HAAC) ||
(audio->config.out.codec == HB_ACODEC_AAC_PASS &&
audio->config.in.samples_per_frame > 1024))
{
// For HE-AAC, write outputSamplingFreq too
// samplingFreq is half of outputSamplingFreq
track->extra.audio.outputSamplingFreq = (float)audio->config.out.samplerate;
track->extra.audio.samplingFreq = track->extra.audio.outputSamplingFreq / 2.;
}
else
{
track->extra.audio.samplingFreq = (float)audio->config.out.samplerate;
}
if (audio->config.out.codec & HB_ACODEC_PASS_FLAG)
{
track->extra.audio.channels = av_get_channel_layout_nb_channels(audio->config.in.channel_layout);
}
else
{
track->extra.audio.channels = hb_mixdown_get_discrete_channel_count(audio->config.out.mixdown);
}
mux_data->track = mk_createTrack(m->file, track);
if (audio->config.out.codec == HB_ACODEC_VORBIS ||
audio->config.out.codec == HB_ACODEC_FFFLAC ||
audio->config.out.codec == HB_ACODEC_FFFLAC24)
free(track->codecPrivate);
}
char * subidx_fmt =
"size: %dx%d\n"
"org: %d, %d\n"
"scale: 100%%, 100%%\n"
"alpha: 100%%\n"
"smooth: OFF\n"
"fadein/out: 50, 50\n"
"align: OFF at LEFT TOP\n"
"time offset: 0\n"
"forced subs: %s\n"
"palette: %06x, %06x, %06x, %06x, %06x, %06x, "
"%06x, %06x, %06x, %06x, %06x, %06x, %06x, %06x, %06x, %06x\n"
"custom colors: OFF, tridx: 0000, "
"colors: 000000, 000000, 000000, 000000\n";
for( i = 0; i < hb_list_count( job->list_subtitle ); i++ )
{
hb_subtitle_t * subtitle;
uint32_t rgb[16];
char subidx[2048];
int len;
subtitle = hb_list_item( job->list_subtitle, i );
if (subtitle->config.dest != PASSTHRUSUB)
continue;
memset(track, 0, sizeof(mk_TrackConfig));
switch (subtitle->source)
{
case VOBSUB:
track->codecID = MK_SUBTITLE_VOBSUB;
for (j = 0; j < 16; j++)
rgb[j] = hb_yuv2rgb(subtitle->palette[j]);
len = snprintf(subidx, 2048, subidx_fmt,
subtitle->width, subtitle->height,
0, 0, "OFF",
rgb[0], rgb[1], rgb[2], rgb[3],
rgb[4], rgb[5], rgb[6], rgb[7],
rgb[8], rgb[9], rgb[10], rgb[11],
rgb[12], rgb[13], rgb[14], rgb[15]);
track->codecPrivate = subidx;
track->codecPrivateSize = len + 1;
break;
case PGSSUB:
track->codecPrivate = NULL;
track->codecPrivateSize = 0;
track->codecID = MK_SUBTITLE_PGS;
break;
case SSASUB:
track->codecID = MK_SUBTITLE_SSA;
need_fonts = 1;
track->codecPrivate = subtitle->extradata;
track->codecPrivateSize = subtitle->extradata_size;
break;
case CC608SUB:
case CC708SUB:
case UTF8SUB:
case TX3GSUB:
case SRTSUB:
track->codecPrivate = NULL;
track->codecPrivateSize = 0;
track->codecID = MK_SUBTITLE_UTF8;
break;
default:
continue;
}
if ( subtitle->config.default_track )
{
track->flagDefault = 1;
}
mux_data = calloc(1, sizeof( hb_mux_data_t ) );
subtitle->mux_data = mux_data;
mux_data->subtitle = 1;
mux_data->sub_format = subtitle->format;
track->flagEnabled = 1;
track->trackType = MK_TRACK_SUBTITLE;
// MKV lang codes should be ISO-639-2/B
lang = lang_for_code2( subtitle->iso639_2 );
track->language = lang->iso639_2b ? lang->iso639_2b : lang->iso639_2;
mux_data->track = mk_createTrack(m->file, track);
}
if (need_fonts)
{
hb_list_t * list_attachment = job->list_attachment;
int i;
for ( i = 0; i < hb_list_count(list_attachment); i++ )
{
hb_attachment_t * attachment = hb_list_item( list_attachment, i );
if ( attachment->type == FONT_TTF_ATTACH )
{
mk_createAttachment(
m->file,
attachment->name,
NULL,
"application/x-truetype-font",
attachment->data,
attachment->size);
}
}
}
if( mk_writeHeader( m->file, "HandBrake " HB_PROJECT_VERSION) < 0 )
{
hb_error( "Failed to write to output file, disk full?");
*job->die = 1;
}
if (track != NULL)
free(track);
if (avcC != NULL)
free(avcC);
return 0;
}
