git.sesse.net Git - x264/blob - muxers.c

   1 /*****************************************************************************
   2  * muxers.c: h264 file i/o plugins
   3  *****************************************************************************
   4  * Copyright (C) 2003-2008 x264 project
   5  *
   6  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
   7  *          Loren Merritt <lorenm@u.washington.edu>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111, USA.
  22  *****************************************************************************/
  23
  24 #include "common/common.h"
  25 #include "x264.h"
  26 #include "matroska.h"
  27 #include "muxers.h"
  28
  29 #ifndef _MSC_VER
  30 #include "config.h"
  31 #endif
  32
  33 #include <sys/types.h>
  34
  35 #ifdef AVIS_INPUT
  36 #include <windows.h>
  37 #include <vfw.h>
  38 #endif
  39
  40 #ifdef MP4_OUTPUT
  41 #include <gpac/isomedia.h>
  42 #endif
  43
  44 static int64_t gcd( int64_t a, int64_t b )
  45 {
  46     while (1)
  47     {
  48         int64_t c = a % b;
  49         if( !c )
  50             return b;
  51         a = b;
  52         b = c;
  53     }
  54 }
  55
  56 typedef struct {
  57     FILE *fh;
  58     int width, height;
  59     int next_frame;
  60 } yuv_input_t;
  61
  62 /* raw 420 yuv file operation */
  63 int open_file_yuv( char *psz_filename, hnd_t *p_handle, x264_param_t *p_param )
  64 {
  65     yuv_input_t *h = malloc(sizeof(yuv_input_t));
  66     h->width = p_param->i_width;
  67     h->height = p_param->i_height;
  68     h->next_frame = 0;
  69
  70     if( !strcmp(psz_filename, "-") )
  71         h->fh = stdin;
  72     else
  73         h->fh = fopen(psz_filename, "rb");
  74     if( h->fh == NULL )
  75         return -1;
  76
  77     *p_handle = (hnd_t)h;
  78     return 0;
  79 }
  80
  81 int get_frame_total_yuv( hnd_t handle )
  82 {
  83     yuv_input_t *h = handle;
  84     int i_frame_total = 0;
  85
  86     if( !fseek( h->fh, 0, SEEK_END ) )
  87     {
  88         uint64_t i_size = ftell( h->fh );
  89         fseek( h->fh, 0, SEEK_SET );
  90         i_frame_total = (int)(i_size / ( h->width * h->height * 3 / 2 ));
  91     }
  92
  93     return i_frame_total;
  94 }
  95
  96 int read_frame_yuv( x264_picture_t *p_pic, hnd_t handle, int i_frame )
  97 {
  98     yuv_input_t *h = handle;
  99
 100     if( i_frame != h->next_frame )
 101         if( fseek( h->fh, (uint64_t)i_frame * h->width * h->height * 3 / 2, SEEK_SET ) )
 102             return -1;
 103
 104     if( fread( p_pic->img.plane[0], 1, h->width * h->height, h->fh ) <= 0
 105             || fread( p_pic->img.plane[1], 1, h->width * h->height / 4, h->fh ) <= 0
 106             || fread( p_pic->img.plane[2], 1, h->width * h->height / 4, h->fh ) <= 0 )
 107         return -1;
 108
 109     h->next_frame = i_frame+1;
 110
 111     return 0;
 112 }
 113
 114 int close_file_yuv(hnd_t handle)
 115 {
 116     yuv_input_t *h = handle;
 117     if( !h || !h->fh )
 118         return 0;
 119     fclose( h->fh );
 120     free( h );
 121     return 0;
 122 }
 123
 124 /* YUV4MPEG2 raw 420 yuv file operation */
 125 typedef struct {
 126     FILE *fh;
 127     int width, height;
 128     int next_frame;
 129     int seq_header_len, frame_header_len;
 130     int frame_size;
 131 } y4m_input_t;
 132
 133 #define Y4M_MAGIC "YUV4MPEG2"
 134 #define MAX_YUV4_HEADER 80
 135 #define Y4M_FRAME_MAGIC "FRAME"
 136 #define MAX_FRAME_HEADER 80
 137
 138 int open_file_y4m( char *psz_filename, hnd_t *p_handle, x264_param_t *p_param )
 139 {
 140     int  i, n, d;
 141     int  interlaced;
 142     char header[MAX_YUV4_HEADER+10];
 143     char *tokstart, *tokend, *header_end;
 144     y4m_input_t *h = malloc(sizeof(y4m_input_t));
 145
 146     h->next_frame = 0;
 147
 148     if( !strcmp(psz_filename, "-") )
 149         h->fh = stdin;
 150     else
 151         h->fh = fopen(psz_filename, "rb");
 152     if( h->fh == NULL )
 153         return -1;
 154
 155     h->frame_header_len = strlen(Y4M_FRAME_MAGIC)+1;
 156
 157     /* Read header */
 158     for( i=0; i<MAX_YUV4_HEADER; i++ )
 159     {
 160         header[i] = fgetc(h->fh);
 161         if( header[i] == '\n' )
 162         {
 163             /* Add a space after last option. Makes parsing "444" vs
 164                "444alpha" easier. */
 165             header[i+1] = 0x20;
 166             header[i+2] = 0;
 167             break;
 168         }
 169     }
 170     if( i == MAX_YUV4_HEADER || strncmp(header, Y4M_MAGIC, strlen(Y4M_MAGIC)) )
 171         return -1;
 172
 173     /* Scan properties */
 174     header_end = &header[i+1]; /* Include space */
 175     h->seq_header_len = i+1;
 176     for( tokstart = &header[strlen(Y4M_MAGIC)+1]; tokstart < header_end; tokstart++ )
 177     {
 178         if(*tokstart==0x20) continue;
 179         switch(*tokstart++)
 180         {
 181         case 'W': /* Width. Required. */
 182             h->width = p_param->i_width = strtol(tokstart, &tokend, 10);
 183             tokstart=tokend;
 184             break;
 185         case 'H': /* Height. Required. */
 186             h->height = p_param->i_height = strtol(tokstart, &tokend, 10);
 187             tokstart=tokend;
 188             break;
 189         case 'C': /* Color space */
 190             if( strncmp("420", tokstart, 3) )
 191             {
 192                 fprintf(stderr, "Colorspace unhandled\n");
 193                 return -1;
 194             }
 195             tokstart = strchr(tokstart, 0x20);
 196             break;
 197         case 'I': /* Interlace type */
 198             switch(*tokstart++)
 199             {
 200             case 'p': interlaced = 0; break;
 201             case '?':
 202             case 't':
 203             case 'b':
 204             case 'm':
 205             default: interlaced = 1;
 206                 fprintf(stderr, "Warning, this sequence might be interlaced\n");
 207             }
 208             break;
 209         case 'F': /* Frame rate - 0:0 if unknown */
 210             if( sscanf(tokstart, "%d:%d", &n, &d) == 2 && n && d )
 211             {
 212                 x264_reduce_fraction( &n, &d );
 213                 p_param->i_fps_num = n;
 214                 p_param->i_fps_den = d;
 215             }
 216             tokstart = strchr(tokstart, 0x20);
 217             break;
 218         case 'A': /* Pixel aspect - 0:0 if unknown */
 219             if( sscanf(tokstart, "%d:%d", &n, &d) == 2 && n && d )
 220             {
 221                 x264_reduce_fraction( &n, &d );
 222                 p_param->vui.i_sar_width = n;
 223                 p_param->vui.i_sar_height = d;
 224             }
 225             tokstart = strchr(tokstart, 0x20);
 226             break;
 227         case 'X': /* Vendor extensions */
 228             if( !strncmp("YSCSS=",tokstart,6) )
 229             {
 230                 /* Older nonstandard pixel format representation */
 231                 tokstart += 6;
 232                 if( strncmp("420JPEG",tokstart,7) &&
 233                     strncmp("420MPEG2",tokstart,8) &&
 234                     strncmp("420PALDV",tokstart,8) )
 235                 {
 236                     fprintf(stderr, "Unsupported extended colorspace\n");
 237                     return -1;
 238                 }
 239             }
 240             tokstart = strchr(tokstart, 0x20);
 241             break;
 242         }
 243     }
 244
 245     fprintf(stderr, "yuv4mpeg: %ix%i@%i/%ifps, %i:%i\n",
 246             h->width, h->height, p_param->i_fps_num, p_param->i_fps_den,
 247             p_param->vui.i_sar_width, p_param->vui.i_sar_height);
 248
 249     *p_handle = (hnd_t)h;
 250     return 0;
 251 }
 252
 253 /* Most common case: frame_header = "FRAME" */
 254 int get_frame_total_y4m( hnd_t handle )
 255 {
 256     y4m_input_t *h             = handle;
 257     int          i_frame_total = 0;
 258     uint64_t     init_pos      = ftell(h->fh);
 259
 260     if( !fseek( h->fh, 0, SEEK_END ) )
 261     {
 262         uint64_t i_size = ftell( h->fh );
 263         fseek( h->fh, init_pos, SEEK_SET );
 264         i_frame_total = (int)((i_size - h->seq_header_len) /
 265                               (3*(h->width*h->height)/2+h->frame_header_len));
 266     }
 267
 268     return i_frame_total;
 269 }
 270
 271 int read_frame_y4m( x264_picture_t *p_pic, hnd_t handle, int i_frame )
 272 {
 273     int          slen = strlen(Y4M_FRAME_MAGIC);
 274     int          i    = 0;
 275     char         header[16];
 276     y4m_input_t *h    = handle;
 277
 278     if( i_frame != h->next_frame )
 279     {
 280         if (fseek(h->fh, (uint64_t)i_frame*(3*(h->width*h->height)/2+h->frame_header_len)
 281                   + h->seq_header_len, SEEK_SET))
 282             return -1;
 283     }
 284
 285     /* Read frame header - without terminating '\n' */
 286     if (fread(header, 1, slen, h->fh) != slen)
 287         return -1;
 288
 289     header[slen] = 0;
 290     if (strncmp(header, Y4M_FRAME_MAGIC, slen))
 291     {
 292         fprintf(stderr, "Bad header magic (%08X <=> %s)\n",
 293                 *((uint32_t*)header), header);
 294         return -1;
 295     }
 296
 297     /* Skip most of it */
 298     while (i<MAX_FRAME_HEADER && fgetc(h->fh) != '\n')
 299         i++;
 300     if (i == MAX_FRAME_HEADER)
 301     {
 302         fprintf(stderr, "Bad frame header!\n");
 303         return -1;
 304     }
 305     h->frame_header_len = i+slen+1;
 306
 307     if( fread(p_pic->img.plane[0], 1, h->width*h->height, h->fh) <= 0
 308         || fread(p_pic->img.plane[1], 1, h->width * h->height / 4, h->fh) <= 0
 309         || fread(p_pic->img.plane[2], 1, h->width * h->height / 4, h->fh) <= 0)
 310         return -1;
 311
 312     h->next_frame = i_frame+1;
 313
 314     return 0;
 315 }
 316
 317 int close_file_y4m(hnd_t handle)
 318 {
 319     y4m_input_t *h = handle;
 320     if( !h || !h->fh )
 321         return 0;
 322     fclose( h->fh );
 323     free( h );
 324     return 0;
 325 }
 326
 327 /* avs/avi input file support under cygwin */
 328
 329 #ifdef AVIS_INPUT
 330 typedef struct {
 331     PAVISTREAM p_avi;
 332     int width, height;
 333 } avis_input_t;
 334
 335 int open_file_avis( char *psz_filename, hnd_t *p_handle, x264_param_t *p_param )
 336 {
 337     avis_input_t *h = malloc(sizeof(avis_input_t));
 338     AVISTREAMINFO info;
 339     int i;
 340
 341     *p_handle = (hnd_t)h;
 342
 343     AVIFileInit();
 344     if( AVIStreamOpenFromFile( &h->p_avi, psz_filename, streamtypeVIDEO, 0, OF_READ, NULL ) )
 345     {
 346         AVIFileExit();
 347         return -1;
 348     }
 349
 350     if( AVIStreamInfo(h->p_avi, &info, sizeof(AVISTREAMINFO)) )
 351     {
 352         AVIStreamRelease(h->p_avi);
 353         AVIFileExit();
 354         return -1;
 355     }
 356
 357     // check input format
 358     if (info.fccHandler != MAKEFOURCC('Y', 'V', '1', '2'))
 359     {
 360         fprintf( stderr, "avis [error]: unsupported input format (%c%c%c%c)\n",
 361             (char)(info.fccHandler & 0xff), (char)((info.fccHandler >> 8) & 0xff),
 362             (char)((info.fccHandler >> 16) & 0xff), (char)((info.fccHandler >> 24)) );
 363
 364         AVIStreamRelease(h->p_avi);
 365         AVIFileExit();
 366
 367         return -1;
 368     }
 369
 370     h->width =
 371     p_param->i_width = info.rcFrame.right - info.rcFrame.left;
 372     h->height =
 373     p_param->i_height = info.rcFrame.bottom - info.rcFrame.top;
 374     i = gcd(info.dwRate, info.dwScale);
 375     p_param->i_fps_den = info.dwScale / i;
 376     p_param->i_fps_num = info.dwRate / i;
 377
 378     fprintf( stderr, "avis [info]: %dx%d @ %.2f fps (%d frames)\n",
 379         p_param->i_width, p_param->i_height,
 380         (double)p_param->i_fps_num / (double)p_param->i_fps_den,
 381         (int)info.dwLength );
 382
 383     return 0;
 384 }
 385
 386 int get_frame_total_avis( hnd_t handle )
 387 {
 388     avis_input_t *h = handle;
 389     AVISTREAMINFO info;
 390
 391     if( AVIStreamInfo(h->p_avi, &info, sizeof(AVISTREAMINFO)) )
 392         return -1;
 393
 394     return info.dwLength;
 395 }
 396
 397 int read_frame_avis( x264_picture_t *p_pic, hnd_t handle, int i_frame )
 398 {
 399     avis_input_t *h = handle;
 400
 401     p_pic->img.i_csp = X264_CSP_YV12;
 402
 403     if( AVIStreamRead(h->p_avi, i_frame, 1, p_pic->img.plane[0], h->width * h->height * 3 / 2, NULL, NULL ) )
 404         return -1;
 405
 406     return 0;
 407 }
 408
 409 int close_file_avis( hnd_t handle )
 410 {
 411     avis_input_t *h = handle;
 412     AVIStreamRelease(h->p_avi);
 413     AVIFileExit();
 414     free(h);
 415     return 0;
 416 }
 417 #endif
 418
 419
 420 #ifdef HAVE_PTHREAD
 421 typedef struct {
 422     int (*p_read_frame)( x264_picture_t *p_pic, hnd_t handle, int i_frame );
 423     int (*p_close_infile)( hnd_t handle );
 424     hnd_t p_handle;
 425     x264_picture_t pic;
 426     x264_pthread_t tid;
 427     int next_frame;
 428     int frame_total;
 429     struct thread_input_arg_t *next_args;
 430 } thread_input_t;
 431
 432 typedef struct thread_input_arg_t {
 433     thread_input_t *h;
 434     x264_picture_t *pic;
 435     int i_frame;
 436     int status;
 437 } thread_input_arg_t;
 438
 439 int open_file_thread( char *psz_filename, hnd_t *p_handle, x264_param_t *p_param )
 440 {
 441     thread_input_t *h = malloc(sizeof(thread_input_t));
 442     x264_picture_alloc( &h->pic, X264_CSP_I420, p_param->i_width, p_param->i_height );
 443     h->p_read_frame = p_read_frame;
 444     h->p_close_infile = p_close_infile;
 445     h->p_handle = *p_handle;
 446     h->next_frame = -1;
 447     h->next_args = malloc(sizeof(thread_input_arg_t));
 448     h->next_args->h = h;
 449     h->next_args->status = 0;
 450     h->frame_total = p_get_frame_total( h->p_handle );
 451
 452     *p_handle = (hnd_t)h;
 453     return 0;
 454 }
 455
 456 int get_frame_total_thread( hnd_t handle )
 457 {
 458     thread_input_t *h = handle;
 459     return h->frame_total;
 460 }
 461
 462 void read_frame_thread_int( thread_input_arg_t *i )
 463 {
 464     i->status = i->h->p_read_frame( i->pic, i->h->p_handle, i->i_frame );
 465 }
 466
 467 int read_frame_thread( x264_picture_t *p_pic, hnd_t handle, int i_frame )
 468 {
 469     thread_input_t *h = handle;
 470     UNUSED void *stuff;
 471     int ret = 0;
 472
 473     if( h->next_frame >= 0 )
 474     {
 475         x264_pthread_join( h->tid, &stuff );
 476         ret |= h->next_args->status;
 477     }
 478
 479     if( h->next_frame == i_frame )
 480     {
 481         XCHG( x264_picture_t, *p_pic, h->pic );
 482     }
 483     else
 484     {
 485         ret |= h->p_read_frame( p_pic, h->p_handle, i_frame );
 486     }
 487
 488     if( !h->frame_total || i_frame+1 < h->frame_total )
 489     {
 490         h->next_frame =
 491         h->next_args->i_frame = i_frame+1;
 492         h->next_args->pic = &h->pic;
 493         x264_pthread_create( &h->tid, NULL, (void*)read_frame_thread_int, h->next_args );
 494     }
 495     else
 496         h->next_frame = -1;
 497
 498     return ret;
 499 }
 500
 501 int close_file_thread( hnd_t handle )
 502 {
 503     thread_input_t *h = handle;
 504     h->p_close_infile( h->p_handle );
 505     x264_picture_clean( &h->pic );
 506     free( h );
 507     return 0;
 508 }
 509 #endif
 510
 511
 512 int open_file_bsf( char *psz_filename, hnd_t *p_handle )
 513 {
 514     if ((*p_handle = fopen(psz_filename, "w+b")) == NULL)
 515         return -1;
 516
 517     return 0;
 518 }
 519
 520 int set_param_bsf( hnd_t handle, x264_param_t *p_param )
 521 {
 522     return 0;
 523 }
 524
 525 int write_nalu_bsf( hnd_t handle, uint8_t *p_nalu, int i_size )
 526 {
 527     if (fwrite(p_nalu, i_size, 1, (FILE *)handle) > 0)
 528         return i_size;
 529     return -1;
 530 }
 531
 532 int set_eop_bsf( hnd_t handle,  x264_picture_t *p_picture )
 533 {
 534     return 0;
 535 }
 536
 537 int close_file_bsf( hnd_t handle )
 538 {
 539     if ((handle == NULL) || (handle == stdout))
 540         return 0;
 541
 542     return fclose((FILE *)handle);
 543 }
 544
 545 /* -- mp4 muxing support ------------------------------------------------- */
 546 #ifdef MP4_OUTPUT
 547
 548 typedef struct
 549 {
 550     GF_ISOFile *p_file;
 551     GF_AVCConfig *p_config;
 552     GF_ISOSample *p_sample;
 553     int i_track;
 554     uint32_t i_descidx;
 555     int i_time_inc;
 556     int i_time_res;
 557     int i_numframe;
 558     int i_init_delay;
 559     uint8_t b_sps;
 560     uint8_t b_pps;
 561 } mp4_t;
 562
 563
 564 void recompute_bitrate_mp4(GF_ISOFile *p_file, int i_track)
 565 {
 566     u32 i, count, di, timescale, time_wnd, rate;
 567     u64 offset;
 568     Double br;
 569     GF_ESD *esd;
 570
 571     esd = gf_isom_get_esd(p_file, i_track, 1);
 572     if (!esd) return;
 573
 574     esd->decoderConfig->avgBitrate = 0;
 575     esd->decoderConfig->maxBitrate = 0;
 576     rate = time_wnd = 0;
 577
 578     timescale = gf_isom_get_media_timescale(p_file, i_track);
 579     count = gf_isom_get_sample_count(p_file, i_track);
 580     for (i=0; i<count; i++) {
 581         GF_ISOSample *samp = gf_isom_get_sample_info(p_file, i_track, i+1, &di, &offset);
 582
 583         if (samp->dataLength>esd->decoderConfig->bufferSizeDB) esd->decoderConfig->bufferSizeDB = samp->dataLength;
 584
 585         if (esd->decoderConfig->bufferSizeDB < samp->dataLength) esd->decoderConfig->bufferSizeDB = samp->dataLength;
 586         esd->decoderConfig->avgBitrate += samp->dataLength;
 587         rate += samp->dataLength;
 588         if (samp->DTS > time_wnd + timescale) {
 589             if (rate > esd->decoderConfig->maxBitrate) esd->decoderConfig->maxBitrate = rate;
 590             time_wnd = samp->DTS;
 591             rate = 0;
 592         }
 593
 594         gf_isom_sample_del(&samp);
 595     }
 596
 597     br = (Double) (s64) gf_isom_get_media_duration(p_file, i_track);
 598     br /= timescale;
 599     esd->decoderConfig->avgBitrate = (u32) (esd->decoderConfig->avgBitrate / br);
 600     /*move to bps*/
 601     esd->decoderConfig->avgBitrate *= 8;
 602     esd->decoderConfig->maxBitrate *= 8;
 603
 604     gf_isom_change_mpeg4_description(p_file, i_track, 1, esd);
 605     gf_odf_desc_del((GF_Descriptor *) esd);
 606 }
 607
 608
 609 int close_file_mp4( hnd_t handle )
 610 {
 611     mp4_t *p_mp4 = (mp4_t *)handle;
 612
 613     if (p_mp4 == NULL)
 614         return 0;
 615
 616     if (p_mp4->p_config)
 617         gf_odf_avc_cfg_del(p_mp4->p_config);
 618
 619     if (p_mp4->p_sample)
 620     {
 621         if (p_mp4->p_sample->data)
 622             free(p_mp4->p_sample->data);
 623
 624         gf_isom_sample_del(&p_mp4->p_sample);
 625     }
 626
 627     if (p_mp4->p_file)
 628     {
 629         recompute_bitrate_mp4(p_mp4->p_file, p_mp4->i_track);
 630         gf_isom_set_pl_indication(p_mp4->p_file, GF_ISOM_PL_VISUAL, 0x15);
 631         gf_isom_set_storage_mode(p_mp4->p_file, GF_ISOM_STORE_FLAT);
 632         gf_isom_close(p_mp4->p_file);
 633     }
 634
 635     free(p_mp4);
 636
 637     return 0;
 638 }
 639
 640 int open_file_mp4( char *psz_filename, hnd_t *p_handle )
 641 {
 642     mp4_t *p_mp4;
 643
 644     *p_handle = NULL;
 645
 646     if ((p_mp4 = (mp4_t *)malloc(sizeof(mp4_t))) == NULL)
 647         return -1;
 648
 649     memset(p_mp4, 0, sizeof(mp4_t));
 650     p_mp4->p_file = gf_isom_open(psz_filename, GF_ISOM_OPEN_WRITE, NULL);
 651
 652     if ((p_mp4->p_sample = gf_isom_sample_new()) == NULL)
 653     {
 654         close_file_mp4( p_mp4 );
 655         return -1;
 656     }
 657
 658     gf_isom_set_brand_info(p_mp4->p_file, GF_ISOM_BRAND_AVC1, 0);
 659
 660     *p_handle = p_mp4;
 661
 662     return 0;
 663 }
 664
 665
 666 int set_param_mp4( hnd_t handle, x264_param_t *p_param )
 667 {
 668     mp4_t *p_mp4 = (mp4_t *)handle;
 669
 670     p_mp4->i_track = gf_isom_new_track(p_mp4->p_file, 0, GF_ISOM_MEDIA_VISUAL,
 671         p_param->i_fps_num);
 672
 673     p_mp4->p_config = gf_odf_avc_cfg_new();
 674     gf_isom_avc_config_new(p_mp4->p_file, p_mp4->i_track, p_mp4->p_config,
 675         NULL, NULL, &p_mp4->i_descidx);
 676
 677     gf_isom_set_track_enabled(p_mp4->p_file, p_mp4->i_track, 1);
 678
 679     gf_isom_set_visual_info(p_mp4->p_file, p_mp4->i_track, p_mp4->i_descidx,
 680         p_param->i_width, p_param->i_height);
 681
 682     if( p_param->vui.i_sar_width && p_param->vui.i_sar_height )
 683     {
 684         uint64_t dw = p_param->i_width << 16;
 685         uint64_t dh = p_param->i_height << 16;
 686         double sar = (double)p_param->vui.i_sar_width / p_param->vui.i_sar_height;
 687         if( sar > 1.0 )
 688             dw *= sar ;
 689         else
 690             dh /= sar;
 691         gf_isom_set_track_layout_info( p_mp4->p_file, p_mp4->i_track, dw, dh, 0, 0, 0 );
 692     }
 693
 694     p_mp4->p_sample->data = (char *)malloc(p_param->i_width * p_param->i_height * 3 / 2);
 695     if (p_mp4->p_sample->data == NULL)
 696         return -1;
 697
 698     p_mp4->i_time_res = p_param->i_fps_num;
 699     p_mp4->i_time_inc = p_param->i_fps_den;
 700     p_mp4->i_init_delay = p_param->i_bframe ? (p_param->b_bframe_pyramid ? 2 : 1) : 0;
 701     p_mp4->i_init_delay *= p_mp4->i_time_inc;
 702     fprintf(stderr, "mp4 [info]: initial delay %d (scale %d)\n",
 703         p_mp4->i_init_delay, p_mp4->i_time_res);
 704
 705     return 0;
 706 }
 707
 708
 709 int write_nalu_mp4( hnd_t handle, uint8_t *p_nalu, int i_size )
 710 {
 711     mp4_t *p_mp4 = (mp4_t *)handle;
 712     GF_AVCConfigSlot *p_slot;
 713     uint8_t type = p_nalu[4] & 0x1f;
 714     int psize;
 715
 716     switch(type)
 717     {
 718     // sps
 719     case 0x07:
 720         if (!p_mp4->b_sps)
 721         {
 722             p_mp4->p_config->configurationVersion = 1;
 723             p_mp4->p_config->AVCProfileIndication = p_nalu[5];
 724             p_mp4->p_config->profile_compatibility = p_nalu[6];
 725             p_mp4->p_config->AVCLevelIndication = p_nalu[7];
 726             p_slot = (GF_AVCConfigSlot *)malloc(sizeof(GF_AVCConfigSlot));
 727             p_slot->size = i_size - 4;
 728             p_slot->data = (char *)malloc(p_slot->size);
 729             memcpy(p_slot->data, p_nalu + 4, i_size - 4);
 730             gf_list_add(p_mp4->p_config->sequenceParameterSets, p_slot);
 731             p_slot = NULL;
 732             p_mp4->b_sps = 1;
 733         }
 734         break;
 735
 736     // pps
 737     case 0x08:
 738         if (!p_mp4->b_pps)
 739         {
 740             p_slot = (GF_AVCConfigSlot *)malloc(sizeof(GF_AVCConfigSlot));
 741             p_slot->size = i_size - 4;
 742             p_slot->data = (char *)malloc(p_slot->size);
 743             memcpy(p_slot->data, p_nalu + 4, i_size - 4);
 744             gf_list_add(p_mp4->p_config->pictureParameterSets, p_slot);
 745             p_slot = NULL;
 746             p_mp4->b_pps = 1;
 747             if (p_mp4->b_sps)
 748                 gf_isom_avc_config_update(p_mp4->p_file, p_mp4->i_track, 1, p_mp4->p_config);
 749         }
 750         break;
 751
 752     // slice, sei
 753     case 0x1:
 754     case 0x5:
 755     case 0x6:
 756         psize = i_size - 4 ;
 757         memcpy(p_mp4->p_sample->data + p_mp4->p_sample->dataLength, p_nalu, i_size);
 758         p_mp4->p_sample->data[p_mp4->p_sample->dataLength + 0] = (psize >> 24) & 0xff;
 759         p_mp4->p_sample->data[p_mp4->p_sample->dataLength + 1] = (psize >> 16) & 0xff;
 760         p_mp4->p_sample->data[p_mp4->p_sample->dataLength + 2] = (psize >> 8) & 0xff;
 761         p_mp4->p_sample->data[p_mp4->p_sample->dataLength + 3] = (psize >> 0) & 0xff;
 762         p_mp4->p_sample->dataLength += i_size;
 763         break;
 764     }
 765
 766     return i_size;
 767 }
 768
 769 int set_eop_mp4( hnd_t handle, x264_picture_t *p_picture )
 770 {
 771     mp4_t *p_mp4 = (mp4_t *)handle;
 772     uint64_t dts = (uint64_t)p_mp4->i_numframe * p_mp4->i_time_inc;
 773     uint64_t pts = (uint64_t)p_picture->i_pts;
 774     int32_t offset = p_mp4->i_init_delay + pts - dts;
 775
 776     p_mp4->p_sample->IsRAP = p_picture->i_type == X264_TYPE_IDR ? 1 : 0;
 777     p_mp4->p_sample->DTS = dts;
 778     p_mp4->p_sample->CTS_Offset = offset;
 779     gf_isom_add_sample(p_mp4->p_file, p_mp4->i_track, p_mp4->i_descidx, p_mp4->p_sample);
 780
 781     p_mp4->p_sample->dataLength = 0;
 782     p_mp4->i_numframe++;
 783
 784     return 0;
 785 }
 786
 787 #endif
 788
 789
 790 /* -- mkv muxing support ------------------------------------------------- */
 791 typedef struct
 792 {
 793     mk_Writer *w;
 794
 795     uint8_t   *sps, *pps;
 796     int       sps_len, pps_len;
 797
 798     int       width, height, d_width, d_height;
 799
 800     int64_t   frame_duration;
 801     int       fps_num;
 802
 803     int       b_header_written;
 804     char      b_writing_frame;
 805 } mkv_t;
 806
 807 int write_header_mkv( mkv_t *p_mkv )
 808 {
 809     int       ret;
 810     uint8_t   *avcC;
 811     int  avcC_len;
 812
 813     if( p_mkv->sps == NULL || p_mkv->pps == NULL ||
 814         p_mkv->width == 0 || p_mkv->height == 0 ||
 815         p_mkv->d_width == 0 || p_mkv->d_height == 0)
 816         return -1;
 817
 818     avcC_len = 5 + 1 + 2 + p_mkv->sps_len + 1 + 2 + p_mkv->pps_len;
 819     avcC = malloc(avcC_len);
 820     if (avcC == NULL)
 821         return -1;
 822
 823     avcC[0] = 1;
 824     avcC[1] = p_mkv->sps[1];
 825     avcC[2] = p_mkv->sps[2];
 826     avcC[3] = p_mkv->sps[3];
 827     avcC[4] = 0xff; // nalu size length is four bytes
 828     avcC[5] = 0xe1; // one sps
 829
 830     avcC[6] = p_mkv->sps_len >> 8;
 831     avcC[7] = p_mkv->sps_len;
 832
 833     memcpy(avcC+8, p_mkv->sps, p_mkv->sps_len);
 834
 835     avcC[8+p_mkv->sps_len] = 1; // one pps
 836     avcC[9+p_mkv->sps_len] = p_mkv->pps_len >> 8;
 837     avcC[10+p_mkv->sps_len] = p_mkv->pps_len;
 838
 839     memcpy( avcC+11+p_mkv->sps_len, p_mkv->pps, p_mkv->pps_len );
 840
 841     ret = mk_writeHeader( p_mkv->w, "x264", "V_MPEG4/ISO/AVC",
 842                           avcC, avcC_len, p_mkv->frame_duration, 50000,
 843                           p_mkv->width, p_mkv->height,
 844                           p_mkv->d_width, p_mkv->d_height );
 845
 846     free( avcC );
 847
 848     p_mkv->b_header_written = 1;
 849
 850     return ret;
 851 }
 852
 853 int open_file_mkv( char *psz_filename, hnd_t *p_handle )
 854 {
 855     mkv_t *p_mkv;
 856
 857     *p_handle = NULL;
 858
 859     p_mkv  = malloc(sizeof(*p_mkv));
 860     if (p_mkv == NULL)
 861         return -1;
 862
 863     memset(p_mkv, 0, sizeof(*p_mkv));
 864
 865     p_mkv->w = mk_createWriter(psz_filename);
 866     if (p_mkv->w == NULL)
 867     {
 868         free(p_mkv);
 869         return -1;
 870     }
 871
 872     *p_handle = p_mkv;
 873
 874     return 0;
 875 }
 876
 877 int set_param_mkv( hnd_t handle, x264_param_t *p_param )
 878 {
 879     mkv_t   *p_mkv = handle;
 880     int64_t dw, dh;
 881
 882     if( p_param->i_fps_num > 0 )
 883     {
 884         p_mkv->frame_duration = (int64_t)p_param->i_fps_den *
 885                                 (int64_t)1000000000 / p_param->i_fps_num;
 886         p_mkv->fps_num = p_param->i_fps_num;
 887     }
 888     else
 889     {
 890         p_mkv->frame_duration = 0;
 891         p_mkv->fps_num = 1;
 892     }
 893
 894     p_mkv->width = p_param->i_width;
 895     p_mkv->height = p_param->i_height;
 896
 897     if( p_param->vui.i_sar_width && p_param->vui.i_sar_height )
 898     {
 899         dw = (int64_t)p_param->i_width  * p_param->vui.i_sar_width;
 900         dh = (int64_t)p_param->i_height * p_param->vui.i_sar_height;
 901     }
 902     else
 903     {
 904         dw = p_param->i_width;
 905         dh = p_param->i_height;
 906     }
 907
 908     if( dw > 0 && dh > 0 )
 909     {
 910         int64_t x = gcd( dw, dh );
 911         dw /= x;
 912         dh /= x;
 913     }
 914
 915     p_mkv->d_width = (int)dw;
 916     p_mkv->d_height = (int)dh;
 917
 918     return 0;
 919 }
 920
 921 int write_nalu_mkv( hnd_t handle, uint8_t *p_nalu, int i_size )
 922 {
 923     mkv_t *p_mkv = handle;
 924     uint8_t type = p_nalu[4] & 0x1f;
 925     uint8_t dsize[4];
 926     int psize;
 927
 928     switch( type )
 929     {
 930     // sps
 931     case 0x07:
 932         if( !p_mkv->sps )
 933         {
 934             p_mkv->sps = malloc(i_size - 4);
 935             if (p_mkv->sps == NULL)
 936                 return -1;
 937             p_mkv->sps_len = i_size - 4;
 938             memcpy(p_mkv->sps, p_nalu + 4, i_size - 4);
 939         }
 940         break;
 941
 942     // pps
 943     case 0x08:
 944         if( !p_mkv->pps )
 945         {
 946             p_mkv->pps = malloc(i_size - 4);
 947             if (p_mkv->pps == NULL)
 948                 return -1;
 949             p_mkv->pps_len = i_size - 4;
 950             memcpy(p_mkv->pps, p_nalu + 4, i_size - 4);
 951         }
 952         break;
 953
 954     // slice, sei
 955     case 0x1:
 956     case 0x5:
 957     case 0x6:
 958         if( !p_mkv->b_writing_frame )
 959         {
 960             if( mk_startFrame(p_mkv->w) < 0 )
 961                 return -1;
 962             p_mkv->b_writing_frame = 1;
 963         }
 964         psize = i_size - 4 ;
 965         dsize[0] = psize >> 24;
 966         dsize[1] = psize >> 16;
 967         dsize[2] = psize >> 8;
 968         dsize[3] = psize;
 969         if( mk_addFrameData(p_mkv->w, dsize, 4) < 0 ||
 970             mk_addFrameData(p_mkv->w, p_nalu + 4, i_size - 4) < 0 )
 971             return -1;
 972         break;
 973
 974     default:
 975         break;
 976     }
 977
 978     if( !p_mkv->b_header_written && p_mkv->pps && p_mkv->sps &&
 979         write_header_mkv(p_mkv) < 0 )
 980         return -1;
 981
 982     return i_size;
 983 }
 984
 985 int set_eop_mkv( hnd_t handle, x264_picture_t *p_picture )
 986 {
 987     mkv_t *p_mkv = handle;
 988     int64_t i_stamp = (int64_t)(p_picture->i_pts * 1e9 / p_mkv->fps_num);
 989
 990     p_mkv->b_writing_frame = 0;
 991
 992     return mk_setFrameFlags( p_mkv->w, i_stamp,
 993                              p_picture->i_type == X264_TYPE_IDR );
 994 }
 995
 996 int close_file_mkv( hnd_t handle )
 997 {
 998     mkv_t *p_mkv = handle;
 999     int   ret;
1000
1001     if( p_mkv->sps )
1002         free( p_mkv->sps );
1003     if( p_mkv->pps )
1004         free( p_mkv->pps );
1005
1006     ret = mk_close(p_mkv->w);
1007
1008     free( p_mkv );
1009
1010     return ret;
1011 }
1012