libhb/muxmkv.c

   1 /* $Id:  $
   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 /* libmkv header */
   8 #include "libmkv.h"
   9
  10 #include <ogg/ogg.h>
  11
  12 #include "hb.h"
  13
  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
  17
  18 struct hb_mux_object_s
  19 {
  20     HB_MUX_COMMON;
  21
  22     hb_job_t * job;
  23
  24     mk_Writer * file;
  25 };
  26
  27 struct hb_mux_data_s
  28 {
  29     mk_Track  * track;
  30     uint64_t  prev_chapter_tc;
  31     uint16_t  current_chapter;
  32     int       codec;
  33     int       subtitle;
  34     int       sub_format;
  35 };
  36
  37 /**********************************************************************
  38  * MKVInit
  39  **********************************************************************
  40  * Allocates hb_mux_data_t structures, create file and write headers
  41  *********************************************************************/
  42 static int MKVInit( hb_mux_object_t * m )
  43 {
  44     hb_job_t   * job   = m->job;
  45     hb_title_t * title = job->title;
  46     hb_audio_t    * audio;
  47     hb_mux_data_t * mux_data;
  48
  49     uint8_t         *avcC = NULL;
  50     uint8_t         default_track_flag = 1;
  51     int             avcC_len, i;
  52     ogg_packet      *ogg_headers[3];
  53     mk_TrackConfig *track;
  54
  55     track = calloc(1, sizeof(mk_TrackConfig));
  56
  57     m->file = mk_createWriter(job->file, 1000000, 1);
  58
  59     if( !m->file )
  60     {
  61         hb_error( "Could not create output file, Disk Full?" );
  62         job->mux_data = NULL;
  63         *job->die = 1;
  64         return 0;
  65     }
  66
  67     /* Video track */
  68     mux_data      = calloc(1, sizeof( hb_mux_data_t ) );
  69     job->mux_data = mux_data;
  70
  71     track->trackType = MK_TRACK_VIDEO;
  72     track->flagDefault = 1;
  73     track->flagEnabled = 1;
  74     switch (job->vcodec)
  75     {
  76         case HB_VCODEC_X264:
  77             track->codecID = MK_VCODEC_MP4AVC;
  78             /* Taken from x264 muxers.c */
  79             avcC_len = 5 + 1 + 2 + job->config.h264.sps_length + 1 + 2 + job->config.h264.pps_length;
  80             avcC = malloc(avcC_len);
  81             if (avcC == NULL)
  82                 return -1;
  83
  84             avcC[0] = 1;
  85             avcC[1] = job->config.h264.sps[1];      /* AVCProfileIndication */
  86             avcC[2] = job->config.h264.sps[2];      /* profile_compat */
  87             avcC[3] = job->config.h264.sps[3];      /* AVCLevelIndication */
  88             avcC[4] = 0xff; // nalu size length is four bytes
  89             avcC[5] = 0xe1; // one sps
  90
  91             avcC[6] = job->config.h264.sps_length >> 8;
  92             avcC[7] = job->config.h264.sps_length;
  93
  94             memcpy(avcC+8, job->config.h264.sps, job->config.h264.sps_length);
  95
  96             avcC[8+job->config.h264.sps_length] = 1; // one pps
  97             avcC[9+job->config.h264.sps_length] = job->config.h264.pps_length >> 8;
  98             avcC[10+job->config.h264.sps_length] = job->config.h264.pps_length;
  99
 100             memcpy( avcC+11+job->config.h264.sps_length, job->config.h264.pps, job->config.h264.pps_length );
 101             track->codecPrivate = avcC;
 102             track->codecPrivateSize = avcC_len;
 103             if (job->areBframes)
 104                 track->minCache = 1;
 105             break;
 106         case HB_VCODEC_XVID:
 107         case HB_VCODEC_FFMPEG:
 108             track->codecID = MK_VCODEC_MP4ASP;
 109             track->codecPrivate = job->config.mpeg4.bytes;
 110             track->codecPrivateSize = job->config.mpeg4.length;
 111             break;
 112         case HB_VCODEC_THEORA:
 113             {
 114                 int i;
 115                 uint64_t cp_size = 0;
 116                 track->codecID = MK_VCODEC_THEORA;
 117                 uint64_t  header_sizes[3];
 118                 for (i = 0; i < 3; ++i)
 119                 {
 120                     ogg_headers[i] = (ogg_packet *)job->config.theora.headers[i];
 121                     ogg_headers[i]->packet = (unsigned char *)&job->config.theora.headers[i] + sizeof( ogg_packet );
 122                     header_sizes[i] = ogg_headers[i]->bytes;
 123                 }
 124                 track->codecPrivate = mk_laceXiph(header_sizes, 2, &cp_size);
 125                 track->codecPrivate = realloc(track->codecPrivate, cp_size + ogg_headers[0]->bytes + ogg_headers[1]->bytes + ogg_headers[2]->bytes);
 126                 for(i = 0; i < 3; ++i)
 127                 {
 128                     memcpy(track->codecPrivate + cp_size, ogg_headers[i]->packet, ogg_headers[i]->bytes);
 129                     cp_size += ogg_headers[i]->bytes;
 130                 }
 131                 track->codecPrivateSize = cp_size;
 132             }
 133             break;
 134         default:
 135             *job->die = 1;
 136             hb_error("muxmkv: Unknown video codec: %x", job->vcodec);
 137             return 0;
 138     }
 139
 140     track->extra.video.pixelWidth = job->width;
 141     track->extra.video.pixelHeight = job->height;
 142     track->extra.video.displayHeight = job->height;
 143     if( job->anamorphic.mode )
 144     {
 145         track->extra.video.displayWidth = job->width * ((double)job->anamorphic.par_width / (double)job->anamorphic.par_height);
 146     }
 147     else
 148     {
 149         track->extra.video.displayWidth = job->width;
 150     }
 151
 152
 153     track->defaultDuration = (int64_t)(((float)job->vrate_base / (float)job->vrate) * 1000000000);
 154
 155     mux_data->track = mk_createTrack(m->file, track);
 156
 157     memset(track, 0, sizeof(mk_TrackConfig));
 158
 159     /* add the audio tracks */
 160     for( i = 0; i < hb_list_count( title->list_audio ); i++ )
 161     {
 162         audio = hb_list_item( title->list_audio, i );
 163         mux_data = calloc(1, sizeof( hb_mux_data_t ) );
 164         audio->priv.mux_data = mux_data;
 165
 166         mux_data->codec = audio->config.out.codec;
 167
 168         switch (audio->config.out.codec)
 169         {
 170             case HB_ACODEC_DCA:
 171                 track->codecPrivate = NULL;
 172                 track->codecPrivateSize = 0;
 173                 track->codecID = MK_ACODEC_DTS;
 174                 break;
 175             case HB_ACODEC_AC3:
 176                 track->codecPrivate = NULL;
 177                 track->codecPrivateSize = 0;
 178                 track->codecID = MK_ACODEC_AC3;
 179                 break;
 180             case HB_ACODEC_LAME:
 181                 track->codecPrivate = NULL;
 182                 track->codecPrivateSize = 0;
 183                 track->codecID = MK_ACODEC_MP3;
 184                 break;
 185             case HB_ACODEC_VORBIS:
 186                 {
 187                     int i;
 188                     uint64_t cp_size = 0;
 189                     track->codecID = MK_ACODEC_VORBIS;
 190                     uint64_t  header_sizes[3];
 191                     for (i = 0; i < 3; ++i)
 192                     {
 193                         ogg_headers[i] = (ogg_packet *)audio->priv.config.vorbis.headers[i];
 194                         ogg_headers[i]->packet = (unsigned char *)&audio->priv.config.vorbis.headers[i] + sizeof( ogg_packet );
 195                         header_sizes[i] = ogg_headers[i]->bytes;
 196                     }
 197                     track->codecPrivate = mk_laceXiph(header_sizes, 2, &cp_size);
 198                     track->codecPrivate = realloc(track->codecPrivate, cp_size + ogg_headers[0]->bytes + ogg_headers[1]->bytes + ogg_headers[2]->bytes);
 199                     for(i = 0; i < 3; ++i)
 200                     {
 201                         memcpy(track->codecPrivate + cp_size, ogg_headers[i]->packet, ogg_headers[i]->bytes);
 202                         cp_size += ogg_headers[i]->bytes;
 203                     }
 204                     track->codecPrivateSize = cp_size;
 205                 }
 206                 break;
 207             case HB_ACODEC_FAAC:
 208                 track->codecPrivate = audio->priv.config.aac.bytes;
 209                 track->codecPrivateSize = audio->priv.config.aac.length;
 210                 track->codecID = MK_ACODEC_AAC;
 211                 break;
 212             default:
 213                 *job->die = 1;
 214                 hb_error("muxmkv: Unknown audio codec: %x", audio->config.out.codec);
 215                 return 0;
 216         }
 217
 218         if (default_track_flag)
 219         {
 220             track->flagDefault = 1;
 221             default_track_flag = 0;
 222         }
 223         else
 224         {
 225             track->flagDefault = 0;
 226         }
 227         track->flagEnabled = 1;
 228         track->trackType = MK_TRACK_AUDIO;
 229         track->language = audio->config.lang.iso639_2;
 230         track->extra.audio.samplingFreq = (float)audio->config.out.samplerate;
 231         if (audio->config.out.codec == HB_ACODEC_AC3 ||
 232             audio->config.out.codec == HB_ACODEC_DCA)
 233         {
 234             track->extra.audio.channels = HB_INPUT_CH_LAYOUT_GET_DISCRETE_COUNT(audio->config.in.channel_layout);
 235         }
 236         else
 237         {
 238             track->extra.audio.channels = HB_AMIXDOWN_GET_DISCRETE_CHANNEL_COUNT(audio->config.out.mixdown);
 239         }
 240 //        track->defaultDuration = job->arate * 1000;
 241         mux_data->track = mk_createTrack(m->file, track);
 242         if (audio->config.out.codec == HB_ACODEC_VORBIS && track->codecPrivate != NULL)
 243           free(track->codecPrivate);
 244     }
 245
 246     char * subidx_fmt =
 247         "size: %dx%d\n"
 248         "org: %d, %d\n"
 249         "scale: 100%%, 100%%\n"
 250         "alpha: 100%%\n"
 251         "smooth: OFF\n"
 252         "fadein/out: 50, 50\n"
 253         "align: OFF at LEFT TOP\n"
 254         "time offset: 0\n"
 255         "forced subs: %s\n"
 256         "palette: %06x, %06x, %06x, %06x, %06x, %06x, "
 257         "%06x, %06x, %06x, %06x, %06x, %06x, %06x, %06x, %06x, %06x\n"
 258         "custom colors: OFF, tridx: 0000, "
 259         "colors: 000000, 000000, 000000, 000000\n";
 260
 261     for( i = 0; i < hb_list_count( title->list_subtitle ); i++ )
 262     {
 263         hb_subtitle_t * subtitle;
 264         uint32_t      * palette;
 265         char            subidx[2048];
 266         int             len;
 267
 268         subtitle = hb_list_item( title->list_subtitle, i );
 269         if (subtitle->dest != PASSTHRUSUB)
 270             continue;
 271
 272         memset(track, 0, sizeof(mk_TrackConfig));
 273
 274         mux_data = calloc(1, sizeof( hb_mux_data_t ) );
 275         subtitle->mux_data = mux_data;
 276         mux_data->subtitle = 1;
 277         mux_data->sub_format = subtitle->format;
 278
 279         palette = title->palette;
 280         len = snprintf(subidx, 2048, subidx_fmt, title->width, title->height,
 281                  0, 0, "OFF",
 282                  palette[0], palette[1], palette[2], palette[3],
 283                  palette[4], palette[5], palette[6], palette[7],
 284                  palette[8], palette[9], palette[10], palette[11],
 285                  palette[12], palette[13], palette[14], palette[15]);
 286         track->codecPrivate = subidx;
 287         track->codecPrivateSize = len + 1;
 288         track->codecID = MK_SUBTITLE_VOBSUB;
 289         track->flagEnabled = 1;
 290         track->trackType = MK_TRACK_SUBTITLE;
 291         track->language = subtitle->iso639_2;
 292
 293         mux_data->track = mk_createTrack(m->file, track);
 294
 295     }
 296
 297     if( mk_writeHeader( m->file, "HandBrake " HB_PROJECT_VERSION) < 0 )
 298     {
 299         hb_error( "Failed to write to output file, disk full?");
 300         *job->die = 1;
 301     }
 302     if (track != NULL)
 303         free(track);
 304     if (avcC != NULL)
 305         free(avcC);
 306
 307     return 0;
 308 }
 309
 310 static int MKVMux( hb_mux_object_t * m, hb_mux_data_t * mux_data,
 311                    hb_buffer_t * buf )
 312 {
 313     ogg_packet  *op = NULL;
 314     hb_job_t * job = m->job;
 315     hb_title_t * title = job->title;
 316     uint64_t   timecode = 0;
 317     hb_chapter_t *chapter_data;
 318     char tmp_buffer[1024];
 319     char *string = tmp_buffer;
 320
 321     if (mux_data == job->mux_data)
 322     {
 323         /* Video */
 324         timecode = buf->start * TIMECODE_SCALE;
 325
 326         if (job->chapter_markers && (buf->new_chap || timecode == 0))
 327         {
 328             /* Make sure we're not writing a chapter that has 0 length */
 329             if (mux_data->prev_chapter_tc != timecode)
 330             {
 331                 if ( buf->new_chap )
 332                 {
 333                     mux_data->current_chapter = buf->new_chap - 2;
 334                 }
 335                 chapter_data = hb_list_item( title->list_chapter,
 336                                              mux_data->current_chapter++ );
 337                 tmp_buffer[0] = '\0';
 338
 339                 if( chapter_data != NULL )
 340                 {
 341                     string = chapter_data->title;
 342                 }
 343
 344                 if( strlen(string) == 0 || strlen(string) >= 1024 )
 345                 {
 346                     snprintf( tmp_buffer, 1023, "Chapter %02i", mux_data->current_chapter );
 347                     string = tmp_buffer;
 348                 }
 349                 mk_createChapterSimple(m->file, mux_data->prev_chapter_tc, mux_data->prev_chapter_tc, string);
 350             }
 351             mux_data->prev_chapter_tc = timecode;
 352         }
 353
 354         if (job->vcodec == HB_VCODEC_THEORA)
 355         {
 356             /* ughhh, theora is a pain :( */
 357             op = (ogg_packet *)buf->data;
 358             op->packet = buf->data + sizeof( ogg_packet );
 359             if (mk_startFrame(m->file, mux_data->track) < 0)
 360             {
 361                 hb_error( "Failed to write frame to output file, Disk Full?" );
 362                 *job->die = 1;
 363             }
 364             mk_addFrameData(m->file, mux_data->track, op->packet, op->bytes);
 365             mk_setFrameFlags(m->file, mux_data->track, timecode, 1);
 366             return 0;
 367         }
 368     }
 369     else if ( mux_data->subtitle )
 370     {
 371         timecode = buf->start * TIMECODE_SCALE;
 372         if( mux_data->sub_format == TEXTSUB )
 373         {
 374             hb_log("MuxMKV: Text Sub:%lld: %s", buf->start, buf->data);
 375             // TODO: add CC data to track
 376             return 0;
 377         }
 378     }
 379     else
 380     {
 381         /* Audio */
 382         timecode = buf->start * TIMECODE_SCALE;
 383         if (mux_data->codec == HB_ACODEC_VORBIS)
 384         {
 385             /* ughhh, vorbis is a pain :( */
 386             op = (ogg_packet *)buf->data;
 387             op->packet = buf->data + sizeof( ogg_packet );
 388             if (mk_startFrame(m->file, mux_data->track))
 389             {
 390                 hb_error( "Failed to write frame to output file, Disk Full?" );
 391                 *job->die = 1;
 392             }
 393             mk_addFrameData(m->file, mux_data->track, op->packet, op->bytes);
 394             mk_setFrameFlags(m->file, mux_data->track, timecode, 1);
 395             return 0;
 396         }
 397     }
 398
 399     if( mk_startFrame(m->file, mux_data->track) < 0)
 400     {
 401         hb_error( "Failed to write frame to output file, Disk Full?" );
 402         *job->die = 1;
 403     }
 404     mk_addFrameData(m->file, mux_data->track, buf->data, buf->size);
 405     mk_setFrameFlags(m->file, mux_data->track, timecode,
 406                      ((job->vcodec == HB_VCODEC_X264 && mux_data == job->mux_data) ? (buf->frametype == HB_FRAME_IDR) : ((buf->frametype & HB_FRAME_KEY) != 0)) );
 407     return 0;
 408 }
 409
 410 static int MKVEnd( hb_mux_object_t * m )
 411 {
 412     hb_job_t  *job = m->job;
 413     hb_mux_data_t *mux_data = job->mux_data;
 414     hb_title_t  *title = job->title;
 415     hb_chapter_t *chapter_data;
 416     char tmp_buffer[1024];
 417     char *string = tmp_buffer;
 418
 419     if( !job->mux_data )
 420     {
 421         /*
 422          * We must have failed to create the file in the first place.
 423          */
 424         return 0;
 425     }
 426
 427     chapter_data = hb_list_item( title->list_chapter, mux_data->current_chapter++ );
 428
 429     if(job->chapter_markers)
 430     {
 431         tmp_buffer[0] = '\0';
 432
 433         if( chapter_data != NULL )
 434         {
 435             string = chapter_data->title;
 436         }
 437
 438         if( strlen(string) == 0 || strlen(string) >= 1024 )
 439         {
 440             snprintf( tmp_buffer, 1023, "Chapter %02i", mux_data->current_chapter );
 441             string = tmp_buffer;
 442         }
 443         mk_createChapterSimple(m->file, mux_data->prev_chapter_tc, mux_data->prev_chapter_tc, string);
 444     }
 445
 446     if( title->metadata )
 447     {
 448         hb_metadata_t *md = title->metadata;
 449
 450         hb_deep_log( 2, "Writing Metadata to output file...");
 451         mk_createTagSimple( m->file, MK_TAG_TITLE, md->name );
 452         mk_createTagSimple( m->file, "ARTIST", md->artist );
 453         mk_createTagSimple( m->file, "COMPOSER", md->composer );
 454         mk_createTagSimple( m->file, MK_TAG_SYNOPSIS, md->comment );
 455         mk_createTagSimple( m->file, "DATE_RELEASED", md->release_date );
 456         // mk_createTagSimple( m->file, "", md->album );
 457         mk_createTagSimple( m->file, MK_TAG_GENRE, md->genre );
 458     }
 459
 460     if( mk_close(m->file) < 0 )
 461     {
 462         hb_error( "Failed to flush the last frame and close the output file, Disk Full?" );
 463         *job->die = 1;
 464     }
 465
 466     // TODO: Free what we alloc'd
 467
 468     return 0;
 469 }
 470
 471 hb_mux_object_t * hb_mux_mkv_init( hb_job_t * job )
 472 {
 473     hb_mux_object_t * m = calloc( sizeof( hb_mux_object_t ), 1 );
 474     m->init      = MKVInit;
 475     m->mux       = MKVMux;
 476     m->end       = MKVEnd;
 477     m->job       = job;
 478     return m;
 479 }