libhb/muxmkv.c

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