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 static int yuv2rgb(int yuv)
  38 {
  39     double y, Cr, Cb;
  40     int r, g, b;
  41
  42     y =  (yuv >> 16) & 0xff;
  43     Cb = (yuv >>  8) & 0xff;
  44     Cr = (yuv      ) & 0xff;
  45
  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);
  49     r = (r < 0) ? 0 : r;
  50     g = (g < 0) ? 0 : g;
  51     b = (b < 0) ? 0 : b;
  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;
  56 }
  57
  58 /**********************************************************************
  59  * MKVInit
  60  **********************************************************************
  61  * Allocates hb_mux_data_t structures, create file and write headers
  62  *********************************************************************/
  63 static int MKVInit( hb_mux_object_t * m )
  64 {
  65     hb_job_t   * job   = m->job;
  66     hb_title_t * title = job->title;
  67     hb_audio_t    * audio;
  68     hb_mux_data_t * mux_data;
  69
  70     uint8_t         *avcC = NULL;
  71     uint8_t         default_track_flag = 1;
  72     int             avcC_len, i, j;
  73     ogg_packet      *ogg_headers[3];
  74     mk_TrackConfig *track;
  75
  76     track = calloc(1, sizeof(mk_TrackConfig));
  77
  78     m->file = mk_createWriter(job->file, 1000000, 1);
  79
  80     if( !m->file )
  81     {
  82         hb_error( "Could not create output file, Disk Full?" );
  83         job->mux_data = NULL;
  84         *job->die = 1;
  85         return 0;
  86     }
  87
  88     /* Video track */
  89     mux_data      = calloc(1, sizeof( hb_mux_data_t ) );
  90     job->mux_data = mux_data;
  91
  92     track->trackType = MK_TRACK_VIDEO;
  93     track->flagDefault = 1;
  94     track->flagEnabled = 1;
  95     switch (job->vcodec)
  96     {
  97         case HB_VCODEC_X264:
  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);
 102             if (avcC == NULL)
 103                 return -1;
 104
 105             avcC[0] = 1;
 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
 111
 112             avcC[6] = job->config.h264.sps_length >> 8;
 113             avcC[7] = job->config.h264.sps_length;
 114
 115             memcpy(avcC+8, job->config.h264.sps, job->config.h264.sps_length);
 116
 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;
 120
 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;
 124             if (job->areBframes)
 125                 track->minCache = 1;
 126             break;
 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;
 131             break;
 132         case HB_VCODEC_THEORA:
 133             {
 134                 int i;
 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)
 139                 {
 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;
 143                 }
 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)
 147                 {
 148                     memcpy(track->codecPrivate + cp_size, ogg_headers[i]->packet, ogg_headers[i]->bytes);
 149                     cp_size += ogg_headers[i]->bytes;
 150                 }
 151                 track->codecPrivateSize = cp_size;
 152             }
 153             break;
 154         default:
 155             *job->die = 1;
 156             hb_error("muxmkv: Unknown video codec: %x", job->vcodec);
 157             return 0;
 158     }
 159
 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 )
 164     {
 165         track->extra.video.displayWidth = job->width * ((double)job->anamorphic.par_width / (double)job->anamorphic.par_height);
 166     }
 167     else
 168     {
 169         track->extra.video.displayWidth = job->width;
 170     }
 171
 172
 173     track->defaultDuration = (int64_t)(((float)job->vrate_base / (float)job->vrate) * 1000000000);
 174
 175     mux_data->track = mk_createTrack(m->file, track);
 176
 177     memset(track, 0, sizeof(mk_TrackConfig));
 178
 179     /* add the audio tracks */
 180     for( i = 0; i < hb_list_count( title->list_audio ); i++ )
 181     {
 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;
 185
 186         mux_data->codec = audio->config.out.codec;
 187
 188         switch (audio->config.out.codec)
 189         {
 190             case HB_ACODEC_DCA:
 191                 track->codecPrivate = NULL;
 192                 track->codecPrivateSize = 0;
 193                 track->codecID = MK_ACODEC_DTS;
 194                 break;
 195             case HB_ACODEC_AC3:
 196                 track->codecPrivate = NULL;
 197                 track->codecPrivateSize = 0;
 198                 track->codecID = MK_ACODEC_AC3;
 199                 break;
 200             case HB_ACODEC_LAME:
 201                 track->codecPrivate = NULL;
 202                 track->codecPrivateSize = 0;
 203                 track->codecID = MK_ACODEC_MP3;
 204                 break;
 205             case HB_ACODEC_VORBIS:
 206                 {
 207                     int i;
 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)
 212                     {
 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;
 216                     }
 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)
 220                     {
 221                         memcpy(track->codecPrivate + cp_size, ogg_headers[i]->packet, ogg_headers[i]->bytes);
 222                         cp_size += ogg_headers[i]->bytes;
 223                     }
 224                     track->codecPrivateSize = cp_size;
 225                 }
 226                 break;
 227             case HB_ACODEC_FAAC:
 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;
 232                 break;
 233             default:
 234                 *job->die = 1;
 235                 hb_error("muxmkv: Unknown audio codec: %x", audio->config.out.codec);
 236                 return 0;
 237         }
 238
 239         if (default_track_flag)
 240         {
 241             track->flagDefault = 1;
 242             default_track_flag = 0;
 243         }
 244         else
 245         {
 246             track->flagDefault = 0;
 247         }
 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)
 254         {
 255             track->extra.audio.channels = HB_INPUT_CH_LAYOUT_GET_DISCRETE_COUNT(audio->config.in.channel_layout);
 256         }
 257         else
 258         {
 259             track->extra.audio.channels = HB_AMIXDOWN_GET_DISCRETE_CHANNEL_COUNT(audio->config.out.mixdown);
 260         }
 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);
 265     }
 266
 267     char * subidx_fmt =
 268         "size: %dx%d\n"
 269         "org: %d, %d\n"
 270         "scale: 100%%, 100%%\n"
 271         "alpha: 100%%\n"
 272         "smooth: OFF\n"
 273         "fadein/out: 50, 50\n"
 274         "align: OFF at LEFT TOP\n"
 275         "time offset: 0\n"
 276         "forced subs: %s\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";
 281
 282     for( i = 0; i < hb_list_count( title->list_subtitle ); i++ )
 283     {
 284         hb_subtitle_t * subtitle;
 285         uint32_t        rgb[16];
 286         char            subidx[2048];
 287         int             len;
 288
 289         subtitle = hb_list_item( title->list_subtitle, i );
 290         if (subtitle->config.dest != PASSTHRUSUB)
 291             continue;
 292
 293         memset(track, 0, sizeof(mk_TrackConfig));
 294         switch (subtitle->format)
 295         {
 296             case PICTURESUB:
 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,
 302                         0, 0, "OFF",
 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;
 309                 break;
 310             case TEXTSUB:
 311                 track->codecID = MK_SUBTITLE_UTF8;
 312                 break;
 313             default:
 314                 continue;
 315         }
 316         if ( subtitle->config.default_track )
 317         {
 318             track->flagDefault = 1;
 319         }
 320
 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;
 325
 326         track->flagEnabled = 1;
 327         track->trackType = MK_TRACK_SUBTITLE;
 328         track->language = subtitle->iso639_2;
 329
 330         mux_data->track = mk_createTrack(m->file, track);
 331     }
 332
 333     if( mk_writeHeader( m->file, "HandBrake " HB_PROJECT_VERSION) < 0 )
 334     {
 335         hb_error( "Failed to write to output file, disk full?");
 336         *job->die = 1;
 337     }
 338     if (track != NULL)
 339         free(track);
 340     if (avcC != NULL)
 341         free(avcC);
 342
 343     return 0;
 344 }
 345
 346 static int MKVMux( hb_mux_object_t * m, hb_mux_data_t * mux_data,
 347                    hb_buffer_t * buf )
 348 {
 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;
 356
 357     if (mux_data == job->mux_data)
 358     {
 359         /* Video */
 360         timecode = buf->start * TIMECODE_SCALE;
 361
 362         if (job->chapter_markers && (buf->new_chap || timecode == 0))
 363         {
 364             /* Make sure we're not writing a chapter that has 0 length */
 365             if (mux_data->prev_chapter_tc != timecode)
 366             {
 367                 if ( buf->new_chap )
 368                 {
 369                     mux_data->current_chapter = buf->new_chap - 2;
 370                 }
 371                 chapter_data = hb_list_item( title->list_chapter,
 372                                              mux_data->current_chapter++ );
 373                 tmp_buffer[0] = '\0';
 374
 375                 if( chapter_data != NULL )
 376                 {
 377                     string = chapter_data->title;
 378                 }
 379
 380                 if( strlen(string) == 0 || strlen(string) >= 1024 )
 381                 {
 382                     snprintf( tmp_buffer, 1023, "Chapter %02i", mux_data->current_chapter );
 383                     string = tmp_buffer;
 384                 }
 385                 mk_createChapterSimple(m->file, mux_data->prev_chapter_tc, mux_data->prev_chapter_tc, string);
 386             }
 387             mux_data->prev_chapter_tc = timecode;
 388         }
 389
 390         if (job->vcodec == HB_VCODEC_THEORA)
 391         {
 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)
 396             {
 397                 hb_error( "Failed to write frame to output file, Disk Full?" );
 398                 *job->die = 1;
 399             }
 400             mk_addFrameData(m->file, mux_data->track, op->packet, op->bytes);
 401             mk_setFrameFlags(m->file, mux_data->track, timecode, 1, 0);
 402             hb_buffer_close( &buf );
 403             return 0;
 404         }
 405     }
 406     else if ( mux_data->subtitle )
 407     {
 408         uint64_t   duration;
 409         timecode = buf->start * TIMECODE_SCALE;
 410         if( mk_startFrame(m->file, mux_data->track) < 0)
 411         {
 412             hb_error( "Failed to write frame to output file, Disk Full?" );
 413             *job->die = 1;
 414         }
 415
 416         duration = buf->stop * TIMECODE_SCALE - timecode;
 417         if( mux_data->sub_format == TEXTSUB )
 418         {
 419             mk_addFrameData(m->file, mux_data->track, buf->data, buf->size);
 420             mk_setFrameFlags(m->file, mux_data->track, timecode, 1, duration);
 421         }
 422         else
 423         {
 424             mk_addFrameData(m->file, mux_data->track, buf->data, buf->size);
 425             mk_setFrameFlags(m->file, mux_data->track, timecode, 1, duration);
 426         }
 427         mk_flushFrame(m->file, mux_data->track);
 428         hb_buffer_close( &buf );
 429         return 0;
 430     }
 431     else
 432     {
 433         /* Audio */
 434         timecode = buf->start * TIMECODE_SCALE;
 435         if (mux_data->codec == HB_ACODEC_VORBIS)
 436         {
 437             /* ughhh, vorbis is a pain :( */
 438             op = (ogg_packet *)buf->data;
 439             op->packet = buf->data + sizeof( ogg_packet );
 440             if (mk_startFrame(m->file, mux_data->track))
 441             {
 442                 hb_error( "Failed to write frame to output file, Disk Full?" );
 443                 *job->die = 1;
 444             }
 445             mk_addFrameData(m->file, mux_data->track, op->packet, op->bytes);
 446             mk_setFrameFlags(m->file, mux_data->track, timecode, 1, 0);
 447             hb_buffer_close( &buf );
 448             return 0;
 449         }
 450     }
 451
 452     if( mk_startFrame(m->file, mux_data->track) < 0)
 453     {
 454         hb_error( "Failed to write frame to output file, Disk Full?" );
 455         *job->die = 1;
 456     }
 457     mk_addFrameData(m->file, mux_data->track, buf->data, buf->size);
 458     mk_setFrameFlags(m->file, mux_data->track, timecode,
 459                      ((job->vcodec == HB_VCODEC_X264 &&
 460                        mux_data == job->mux_data) ?
 461                             (buf->frametype == HB_FRAME_IDR) :
 462                             ((buf->frametype & HB_FRAME_KEY) != 0)), 0 );
 463     hb_buffer_close( &buf );
 464     return 0;
 465 }
 466
 467 static int MKVEnd( hb_mux_object_t * m )
 468 {
 469     hb_job_t  *job = m->job;
 470     hb_mux_data_t *mux_data = job->mux_data;
 471     hb_title_t  *title = job->title;
 472     hb_chapter_t *chapter_data;
 473     char tmp_buffer[1024];
 474     char *string = tmp_buffer;
 475
 476     if( !job->mux_data )
 477     {
 478         /*
 479          * We must have failed to create the file in the first place.
 480          */
 481         return 0;
 482     }
 483
 484     chapter_data = hb_list_item( title->list_chapter, mux_data->current_chapter++ );
 485
 486     if(job->chapter_markers)
 487     {
 488         tmp_buffer[0] = '\0';
 489
 490         if( chapter_data != NULL )
 491         {
 492             string = chapter_data->title;
 493         }
 494
 495         if( strlen(string) == 0 || strlen(string) >= 1024 )
 496         {
 497             snprintf( tmp_buffer, 1023, "Chapter %02i", mux_data->current_chapter );
 498             string = tmp_buffer;
 499         }
 500         mk_createChapterSimple(m->file, mux_data->prev_chapter_tc, mux_data->prev_chapter_tc, string);
 501     }
 502
 503     if( title->metadata )
 504     {
 505         hb_metadata_t *md = title->metadata;
 506
 507         hb_deep_log( 2, "Writing Metadata to output file...");
 508         mk_createTagSimple( m->file, MK_TAG_TITLE, md->name );
 509         mk_createTagSimple( m->file, "ARTIST", md->artist );
 510         mk_createTagSimple( m->file, "COMPOSER", md->composer );
 511         mk_createTagSimple( m->file, MK_TAG_SYNOPSIS, md->comment );
 512         mk_createTagSimple( m->file, "DATE_RELEASED", md->release_date );
 513         // mk_createTagSimple( m->file, "", md->album );
 514         mk_createTagSimple( m->file, MK_TAG_GENRE, md->genre );
 515     }
 516
 517     if( mk_close(m->file) < 0 )
 518     {
 519         hb_error( "Failed to flush the last frame and close the output file, Disk Full?" );
 520         *job->die = 1;
 521     }
 522
 523     // TODO: Free what we alloc'd
 524
 525     return 0;
 526 }
 527
 528 hb_mux_object_t * hb_mux_mkv_init( hb_job_t * job )
 529 {
 530     hb_mux_object_t * m = calloc( sizeof( hb_mux_object_t ), 1 );
 531     m->init      = MKVInit;
 532     m->mux       = MKVMux;
 533     m->end       = MKVEnd;
 534     m->job       = job;
 535     return m;
 536 }