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