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