?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
h264: Fix infinite loop when series of byte stream end by
[L-SMASH.git] / cli / muxer.c
blobb0ec3dfd0393e43736e6fb9e7d58b6dc54e1a6a4
1 /*****************************************************************************
2 * muxer.c:
3 *****************************************************************************
4 * Copyright (C) 2010-2014 L-SMASH project
5 *
6 * Authors: Yusuke Nakamura <muken.the.vfrmaniac@gmail.com>
7 * Takashi Hirata <silverfilain@gmail.com>
8 *
9 * Permission to use, copy, modify, and/or distribute this software for any
10 * purpose with or without fee is hereby granted, provided that the above
11 * copyright notice and this permission notice appear in all copies.
12 *
13 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
14 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
15 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
16 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
17 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
18 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
19 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
20 *****************************************************************************/
21
22 /* This file is available under an ISC license. */
23
24 #include "cli.h"
25
26 #include <stdio.h>
27 #include <stdarg.h>
28 #include <string.h>
29 #include <stdlib.h>
30 #include <inttypes.h>
31
32 #include "config.h"
33
34 #include "importer/importer.h"
35
36 #define MAX_NUM_OF_BRANDS 50
37 #define MAX_NUM_OF_INPUTS 10
38 #define MAX_NUM_OF_TRACKS 1
39
40 typedef struct
41 {
42 char *album_name;
43 char *artist;
44 char *comment;
45 char *release_date;
46 char *encoder;
47 char *genre;
48 char *lyrics;
49 char *title;
50 char *composer;
51 char *album_artist;
52 char *copyright;
53 char *description;
54 char *grouping;
55 uint32_t beats_per_minute;
56 } itunes_metadata_t;
57
58 typedef struct
59 {
60 int help;
61 int version;
62 int isom;
63 int isom_version;
64 int itunes_movie;
65 int qtff;
66 int brand_3gx;
67 int optimize_pd;
68 int timeline_shift;
69 uint32_t interleave;
70 uint32_t num_of_brands;
71 uint32_t brands[MAX_NUM_OF_BRANDS];
72 uint32_t major_brand;
73 uint32_t minor_version;
74 uint32_t num_of_inputs;
75 uint32_t chap_track;
76 char *chap_file;
77 int add_bom_to_chpl;
78 char *copyright_notice;
79 uint16_t copyright_language;
80 itunes_metadata_t itunes_metadata;
81 uint16_t default_language;
82 } option_t;
83
84 typedef struct
85 {
86 char *raws;
87 int disable;
88 int sbr;
89 int user_fps;
90 uint32_t fps_num;
91 uint32_t fps_den;
92 uint32_t encoder_delay;
93 int16_t alternate_group;
94 uint16_t ISO_language;
95 uint16_t copyright_language;
96 char *copyright_notice;
97 char *handler_name;
98 } input_track_option_t;
99
100 typedef struct
101 {
102 lsmash_summary_t *summary;
103 input_track_option_t opt;
104 int active;
105 int lpcm;
106 } input_track_t;
107
108 typedef struct
109 {
110 char *whole_track_option;
111 int num_of_track_delimiters;
112 } input_option_t;
113
114 typedef struct
115 {
116 input_option_t opt;
117 char *file_name;
118 importer_t *importer;
119 input_track_t track[MAX_NUM_OF_TRACKS];
120 uint32_t num_of_tracks;
121 uint32_t num_of_active_tracks;
122 uint32_t current_track_number;
123 } input_t;
124
125 typedef struct
126 {
127 lsmash_summary_t *summary;
128 lsmash_sample_t *sample;
129 int active;
130 uint32_t track_ID;
131 uint32_t timescale;
132 uint32_t timebase;
133 uint32_t sample_entry;
134 uint32_t current_sample_number;
135 uint32_t ctd_shift;
136 uint32_t priming_samples;
137 uint32_t last_delta;
138 uint64_t prev_dts;
139 int64_t start_offset;
140 double dts;
141 int lpcm;
142 } output_track_t;
143
144 typedef struct
145 {
146 output_track_t *track;
147 uint32_t num_of_tracks;
148 uint32_t current_track_number;
149 } output_movie_t;
150
151 typedef struct
152 {
153 char *name;
154 lsmash_file_t *fh;
155 lsmash_file_parameters_t param;
156 output_movie_t movie;
157 } output_file_t;
158
159 typedef struct
160 {
161 lsmash_root_t *root;
162 output_file_t file;
163 } output_t;
164
165 typedef struct
166 {
167 option_t opt;
168 output_t output;
169 input_t input[MAX_NUM_OF_INPUTS];
170 uint32_t num_of_inputs;
171 } muxer_t;
172
173 static void cleanup_muxer( muxer_t *muxer )
174 {
175 if( !muxer )
176 return;
177 output_t *output = &muxer->output;
178 lsmash_close_file( &output->file.param );
179 lsmash_destroy_root( output->root );
180 if( output->file.movie.track )
181 {
182 for( uint32_t i = 0; i < output->file.movie.num_of_tracks; i++ )
183 {
184 output_track_t *out_track = &output->file.movie.track[i];
185 lsmash_delete_sample( out_track->sample );
186 }
187 lsmash_free( output->file.movie.track );
188 }
189 for( uint32_t i = 0; i < muxer->num_of_inputs; i++ )
190 {
191 input_t *input = &muxer->input[i];
192 lsmash_importer_close( input->importer );
193 for( uint32_t j = 0; j < input->num_of_tracks; j++ )
194 lsmash_cleanup_summary( input->track[j].summary );
195 }
196 }
197
198 #define eprintf( ... ) fprintf( stderr, __VA_ARGS__ )
199 #define REFRESH_CONSOLE eprintf( " \r" )
200
201 static int muxer_error( muxer_t *muxer, const char *message, ... )
202 {
203 cleanup_muxer( muxer );
204 REFRESH_CONSOLE;
205 eprintf( "Error: " );
206 va_list args;
207 va_start( args, message );
208 vfprintf( stderr, message, args );
209 va_end( args );
210 return -1;
211 }
212
213 static int error_message( const char *message, ... )
214 {
215 REFRESH_CONSOLE;
216 eprintf( "Error: " );
217 va_list args;
218 va_start( args, message );
219 vfprintf( stderr, message, args );
220 va_end( args );
221 return -1;
222 }
223
224 static void display_version( void )
225 {
226 eprintf( "\n"
227 "L-SMASH isom/mov multiplexer rev%s %s\n"
228 "Built on %s %s\n"
229 "Copyright (C) 2010-2014 L-SMASH project\n",
230 LSMASH_REV, LSMASH_GIT_HASH, __DATE__, __TIME__ );
231 }
232
233 static void display_help( void )
234 {
235 display_version();
236 eprintf( "\n"
237 "Usage: muxer [global_options] -i input1 [-i input2 -i input3 ...] -o output\n"
238 "Global options:\n"
239 " --help Display help\n"
240 " --version Display version information\n"
241 " --optimize-pd Optimize for progressive download\n"
242 " --interleave <integer> Specify time interval for media interleaving in milliseconds\n"
243 " --file-format <string> Specify output file format\n"
244 " Multiple file format can be specified by comma separators\n"
245 " The first is applied as the best used one\n"
246 " --isom-version <integer> Specify maximum compatible ISO Base Media version\n"
247 " --shift-timeline Enable composition to decode timeline shift\n"
248 " --chapter <string> Set chapters from the file.\n"
249 " --chpl-with-bom Add UTF-8 BOM to the chapter strings\n"
250 " in the chapter list. (experimental)\n"
251 " --chapter-track <integer> Set which track the chapter applies to.\n"
252 " This option takes effect only when reference\n"
253 " chapter is available.\n"
254 " If this option is not used, it defaults to 1.\n"
255 " --copyright-notice <arg> Specify copyright notice with or without language (latter string)\n"
256 " <arg> is <string> or <string>/<string>\n"
257 " --language <string> Specify the default language for all the output tracks.\n"
258 " This option is overridden by the track options.\n"
259 "Output file formats:\n"
260 " mp4, mov, 3gp, 3g2, m4a, m4v\n"
261 "\n"
262 "Track options:\n"
263 " disable Disable this track\n"
264 " fps=<arg> Specify video framerate\n"
265 " <arg> is <integer> or <integer>/<integer>\n"
266 " language=<string> Specify media language\n"
267 " alternate-group=<integer> Specify alternate group\n"
268 " encoder-delay=<integer> Represent audio encoder delay (priming samples) explicitly\n"
269 " copyright=<arg> Specify copyright notice with or without language (latter string)\n"
270 " <arg> is <string> or <string>/<string>\n"
271 " handler=<string> Set media handler name\n"
272 " sbr Enable backward-compatible SBR explicit signaling mode\n"
273 "How to use track options:\n"
274 " -i input?[track_option1],[track_option2]...\n"
275 "\n"
276 "iTunes Metadata:\n"
277 " --album-name <string> Album name\n"
278 " --artist <string> Artist\n"
279 " --comment <string> User comment\n"
280 " --release-date <string> Release date (YYYY-MM-DD)\n"
281 " --encoder <string> Person or company that encoded the recording\n"
282 " --genre <string> Genre\n"
283 " --lyrics <string> Lyrics\n"
284 " --title <string> Title or song name\n"
285 " --composer <string> Composer\n"
286 " --album-artist <string> Artist for the whole album (if different than the individual tracks)\n"
287 " --copyright <string> Copyright\n"
288 " --description <string> Description\n"
289 " --grouping <string> Grouping\n"
290 " --tempo <integer> Beats per minute\n" );
291 }
292
293 static int muxer_usage_error( void )
294 {
295 display_help();
296 return -1;
297 }
298
299 #define MUXER_ERR( ... ) muxer_error( &muxer, __VA_ARGS__ )
300 #define ERROR_MSG( ... ) error_message( __VA_ARGS__ )
301 #define MUXER_USAGE_ERR() muxer_usage_error();
302
303 static int add_brand( option_t *opt, uint32_t brand )
304 {
305 if( opt->num_of_brands >= MAX_NUM_OF_BRANDS )
306 return -1;
307 /* Avoid duplication. */
308 for( uint32_t i = 0; i < opt->num_of_brands; i++ )
309 if( opt->brands[i] == brand )
310 return -2;
311 opt->brands[opt->num_of_brands ++] = brand;
312 return 0;
313 }
314
315 static int setup_isom_version( option_t *opt )
316 {
317 add_brand( opt, ISOM_BRAND_TYPE_ISOM );
318 if( opt->isom_version > 6 )
319 return ERROR_MSG( "unknown ISO Base Media version.\n" );
320 #define SET_ISOM_VERSION( version ) \
321 if( opt->isom_version >= version ) \
322 add_brand( opt, ISOM_BRAND_TYPE_ISO##version )
323 SET_ISOM_VERSION( 2 );
324 SET_ISOM_VERSION( 3 );
325 SET_ISOM_VERSION( 4 );
326 SET_ISOM_VERSION( 5 );
327 SET_ISOM_VERSION( 6 );
328 #undef SET_ISOM_VERSION
329 return 0;
330 }
331
332 static int decide_brands( option_t *opt )
333 {
334 if( opt->num_of_brands == 0 )
335 {
336 /* default file format */
337 opt->major_brand = ISOM_BRAND_TYPE_MP42;
338 opt->minor_version = 0x00000000;
339 add_brand( opt, ISOM_BRAND_TYPE_MP42 );
340 add_brand( opt, ISOM_BRAND_TYPE_MP41 );
341 add_brand( opt, ISOM_BRAND_TYPE_ISOM );
342 opt->isom = 1;
343 eprintf( "MP4 muxing mode\n" );
344 return setup_isom_version( opt );
345 }
346 opt->major_brand = opt->brands[0]; /* Pick the first brand as major brand. */
347 for( uint32_t i = 0; i < opt->num_of_brands; i++ )
348 {
349 switch( opt->brands[i] )
350 {
351 case ISOM_BRAND_TYPE_3GP6 :
352 /* When being compatible with 3gp6, also compatible with 3g2a. */
353 add_brand( opt, ISOM_BRAND_TYPE_3G2A );
354 opt->brand_3gx = 1;
355 break;
356 case ISOM_BRAND_TYPE_3G2A :
357 opt->brand_3gx = 2;
358 break;
359 case ISOM_BRAND_TYPE_QT :
360 opt->qtff = 1;
361 break;
362 case ISOM_BRAND_TYPE_M4A :
363 case ISOM_BRAND_TYPE_M4V :
364 opt->itunes_movie = 1;
365 /* fall-through */
366 case ISOM_BRAND_TYPE_MP42 :
367 add_brand( opt, ISOM_BRAND_TYPE_MP42 );
368 add_brand( opt, ISOM_BRAND_TYPE_MP41 );
369 break;
370 default :
371 break;
372 }
373 if( opt->brands[i] != ISOM_BRAND_TYPE_QT )
374 opt->isom = 1;
375 }
376 switch( opt->major_brand )
377 {
378 case ISOM_BRAND_TYPE_MP42 :
379 opt->minor_version = 0x00000000;
380 eprintf( "MP4 muxing mode\n" );
381 break;
382 case ISOM_BRAND_TYPE_M4A :
383 case ISOM_BRAND_TYPE_M4V :
384 opt->minor_version = 0x00000000;
385 eprintf( "iTunes MP4 muxing mode\n" );
386 break;
387 case ISOM_BRAND_TYPE_3GP6 :
388 opt->minor_version = 0x00000000; /* means, 3gp(3gp6) 6.0.0 : "6" is not included in minor_version. */
389 eprintf( "3GPP muxing mode\n" );
390 break;
391 case ISOM_BRAND_TYPE_3G2A :
392 opt->minor_version = 0x00010000; /* means, 3g2(3g2a) 1.0.0 : a == 1 */
393 eprintf( "3GPP2 muxing mode\n" );
394 break;
395 case ISOM_BRAND_TYPE_QT :
396 opt->minor_version = 0x00000000; /* We don't know exact version of the spec to use QTFF features. */
397 eprintf( "QuickTime file format muxing mode\n" );
398 break;
399 default :
400 break;
401 }
402 /* Set up ISO Base Media version. */
403 if( opt->isom )
404 setup_isom_version( opt );
405 if( opt->num_of_brands > MAX_NUM_OF_BRANDS )
406 return ERROR_MSG( "exceed the maximum number of brands we can deal with.\n" );
407 return 0;
408 }
409
410 static int parse_global_options( int argc, char **argv, muxer_t *muxer )
411 {
412 if ( argc < 2 )
413 return -1;
414 else if( !strcasecmp( argv[1], "-h" ) || !strcasecmp( argv[1], "--help" ) )
415 {
416 muxer->opt.help = 1;
417 return 0;
418 }
419 else if( !strcasecmp( argv[1], "-v" ) || !strcasecmp( argv[1], "--version" ) )
420 {
421 muxer->opt.version = 1;
422 return 0;
423 }
424 else if( argc < 5 )
425 return -1;
426 uint32_t i = 1;
427 option_t *opt = &muxer->opt;
428 opt->chap_track = 1;
429 opt->add_bom_to_chpl = 0;
430 while( argc > i && *argv[i] == '-' )
431 {
432 #define CHECK_NEXT_ARG if( argc == ++i ) return -1
433 if( !strcasecmp( argv[i], "-i" ) || !strcasecmp( argv[i], "--input" ) )
434 {
435 CHECK_NEXT_ARG;
436 if( opt->num_of_inputs + 1 > MAX_NUM_OF_INPUTS )
437 return ERROR_MSG( "exceed the maximum number of input files.\n" );
438 input_t *input = &muxer->input[opt->num_of_inputs];
439 input_option_t *input_movie_opt = &input->opt;
440 char *p = argv[i];
441 while( *p )
442 input_movie_opt->num_of_track_delimiters += (*p++ == '?');
443 if( input_movie_opt->num_of_track_delimiters > MAX_NUM_OF_TRACKS )
444 return ERROR_MSG( "you specified options to exceed the maximum number of tracks per input files.\n" );
445 input->file_name = strtok( argv[i], "?" );
446 input_movie_opt->whole_track_option = strtok( NULL, "" );
447 if( input_movie_opt->num_of_track_delimiters )
448 {
449 input_track_option_t *track_opt = &input->track[0].opt;
450 track_opt->raws = strtok( input_movie_opt->whole_track_option, "?" );
451 #if (MAX_NUM_OF_TRACKS - 1)
452 for( uint32_t j = 1; j < input_movie_opt->num_of_track_delimiters; j++ )
453 {
454 track_opt = &input->track[j].opt;
455 track_opt->raws = strtok( NULL, "?" );
456 }
457 #endif
458 }
459 ++ opt->num_of_inputs;
460 }
461 else if( !strcasecmp( argv[i], "-o" ) || !strcasecmp( argv[i], "--output" ) )
462 {
463 CHECK_NEXT_ARG;
464 muxer->output.file.name = argv[i];
465 }
466 else if( !strcasecmp( argv[i], "--optimize-pd" ) )
467 opt->optimize_pd = 1;
468 else if( !strcasecmp( argv[i], "--interleave" ) )
469 {
470 CHECK_NEXT_ARG;
471 if( opt->interleave )
472 return ERROR_MSG( "you specified --interleave twice.\n" );
473 opt->interleave = atoi( argv[i] );
474 }
475 else if( !strcasecmp( argv[i], "--file-format" ) )
476 {
477 CHECK_NEXT_ARG;
478 static const struct
479 {
480 uint32_t brand_4cc;
481 char *file_format;
482 } file_format_list[]
483 = {
484 { ISOM_BRAND_TYPE_MP42, "mp4" },
485 { ISOM_BRAND_TYPE_QT, "mov" },
486 { ISOM_BRAND_TYPE_3GP6, "3gp" },
487 { ISOM_BRAND_TYPE_3G2A, "3g2" },
488 { ISOM_BRAND_TYPE_M4A, "m4a" },
489 { ISOM_BRAND_TYPE_M4V, "m4v" },
490 { 0, NULL }
491 };
492 char *file_format = NULL;
493 while( (file_format = strtok( file_format ? NULL : argv[i], "," )) != NULL )
494 {
495 int j;
496 for( j = 0; file_format_list[j].file_format; j++ )
497 if( !strcmp( file_format, file_format_list[j].file_format ) )
498 {
499 int ret = add_brand( opt, file_format_list[j].brand_4cc );
500 if( ret == -2 )
501 return ERROR_MSG( "you specified same output file format twice.\n" );
502 else if( ret == -1 )
503 return ERROR_MSG( "exceed the maximum number of brands we can deal with.\n" );
504 break;
505 }
506 if( !file_format_list[j].file_format )
507 return MUXER_USAGE_ERR();
508 }
509 }
510 else if( !strcasecmp( argv[i], "--isom-version" ) )
511 {
512 CHECK_NEXT_ARG;
513 if( opt->isom_version )
514 return ERROR_MSG( "you specified --isom-version twice.\n" );
515 opt->isom_version = atoi( argv[i] );
516 }
517 else if( !strcasecmp( argv[i], "--shift-timeline" ) )
518 opt->timeline_shift = 1;
519 else if( !strcasecmp( argv[i], "--chapter" ) )
520 {
521 CHECK_NEXT_ARG;
522 opt->chap_file = argv[i];
523 }
524 else if( !strcasecmp( argv[i], "--chapter-track" ) )
525 {
526 CHECK_NEXT_ARG;
527 opt->chap_track = atoi( argv[i] );
528 if( !opt->chap_track )
529 return ERROR_MSG( "%s is an invalid track number.\n", argv[i] );
530 }
531 else if( !strcasecmp( argv[i], "--chpl-with-bom" ) )
532 opt->add_bom_to_chpl = 1;
533 else if( !strcasecmp( argv[i], "--copyright-notice" ) )
534 {
535 CHECK_NEXT_ARG;
536 if( opt->copyright_notice )
537 return ERROR_MSG( "you specified --copyright-notice twice.\n" );
538 opt->copyright_notice = argv[i];
539 char *language = opt->copyright_notice;
540 while( *language )
541 {
542 if( *language == '/' )
543 {
544 *language++ = '\0';
545 break;
546 }
547 ++language;
548 }
549 opt->copyright_language = language ? lsmash_pack_iso_language( language ) : ISOM_LANGUAGE_CODE_UNDEFINED;
550 }
551 /* iTunes metadata */
552 #define CHECK_ITUNES_METADATA_ARG_STRING( argument, value ) \
553 else if( !strcasecmp( argv[i], "--"#argument ) ) \
554 { \
555 CHECK_NEXT_ARG; \
556 if( opt->itunes_metadata.value ) \
557 return ERROR_MSG( "you specified --"#argument" twice.\n" ); \
558 opt->itunes_metadata.value = argv[i]; \
559 }
560 CHECK_ITUNES_METADATA_ARG_STRING( album-name, album_name )
561 CHECK_ITUNES_METADATA_ARG_STRING( artist, artist )
562 CHECK_ITUNES_METADATA_ARG_STRING( comment, comment )
563 CHECK_ITUNES_METADATA_ARG_STRING( release-date, release_date )
564 CHECK_ITUNES_METADATA_ARG_STRING( encoder, encoder )
565 CHECK_ITUNES_METADATA_ARG_STRING( genre, genre )
566 CHECK_ITUNES_METADATA_ARG_STRING( lyrics, lyrics )
567 CHECK_ITUNES_METADATA_ARG_STRING( title, title )
568 CHECK_ITUNES_METADATA_ARG_STRING( composer, composer )
569 CHECK_ITUNES_METADATA_ARG_STRING( album-artist, album_artist )
570 CHECK_ITUNES_METADATA_ARG_STRING( copyright, copyright )
571 CHECK_ITUNES_METADATA_ARG_STRING( description, description )
572 CHECK_ITUNES_METADATA_ARG_STRING( grouping, grouping )
573 #undef CHECK_ITUNES_METADATA_ARG_STRING
574 else if( !strcasecmp( argv[i], "--tempo" ) )
575 {
576 CHECK_NEXT_ARG;
577 if( opt->itunes_metadata.beats_per_minute )
578 return ERROR_MSG( "you specified --tempo twice.\n" );
579 opt->itunes_metadata.beats_per_minute = atoi( argv[i] );
580 }
581 else if( !strcasecmp( argv[i], "--language" ) )
582 {
583 CHECK_NEXT_ARG;
584 opt->default_language = lsmash_pack_iso_language( argv[i] );
585 }
586 #undef CHECK_NEXT_ARG
587 else
588 return ERROR_MSG( "you specified invalid option: %s.\n", argv[i] );
589 ++i;
590 }
591 if( !muxer->output.file.name )
592 return ERROR_MSG( "output file name is not specified.\n" );
593 if( decide_brands( opt ) )
594 return ERROR_MSG( "failed to set up output file format.\n" );
595 if( opt->timeline_shift && !opt->qtff && opt->isom_version < 4 )
596 return ERROR_MSG( "timeline shift requires --file-format mov, or --isom-version 4 or later.\n" );
597 muxer->num_of_inputs = opt->num_of_inputs;
598 return 0;
599 }
600
601 static int parse_track_options( input_t *input )
602 {
603 for( input->current_track_number = 1;
604 input->current_track_number <= input->num_of_tracks;
605 input->current_track_number ++ )
606 {
607 input_track_t *in_track = &input->track[input->current_track_number - 1];
608 input_track_option_t *track_opt = &in_track->opt;
609 if( track_opt->raws == NULL )
610 break;
611 #if 0
612 if( !strchr( track_opt->raws, ':' )
613 || strchr( track_opt->raws, ':' ) == track_opt->raws )
614 return ERROR_MSG( "track number is not specified in %s\n", track_opt->raws );
615 if( strchr( track_opt->raws, ':' ) != strrchr( track_opt->raws, ':' ) )
616 return ERROR_MSG( "multiple colons inside one track option in %s.\n", track_opt->raws );
617 uint32_t track_number = atoi( strtok( track_opt->raws, ":" ) );
618 if( track_number == 0 || track_number > MAX_NUM_OF_TRACKS )
619 return ERROR_MSG( "%s is an invalid track number %"PRIu32".\n", strtok( track_opt->raws, ":" ), track_number );
620 in_track = &input->track[track_number - 1];
621 track_opt = &in_track->opt;
622 char *track_option;
623 while( (track_option = strtok( NULL, "," )) != NULL )
624 #else
625 char *track_option = NULL;
626 while( (track_option = strtok( track_option ? NULL : track_opt->raws, "," )) != NULL )
627 #endif
628 {
629 if( strchr( track_option, '=' ) != strrchr( track_option, '=' ) )
630 return ERROR_MSG( "multiple equal signs inside one track option in %s\n", track_option );
631 if( strstr( track_option, "disable" ) )
632 track_opt->disable = 1;
633 else if( strstr( track_option, "alternate-group=" ) )
634 {
635 char *track_parameter = strchr( track_option, '=' ) + 1;
636 track_opt->alternate_group = atoi( track_parameter );
637 }
638 else if( strstr( track_option, "encoder-delay=" ) )
639 {
640 char *track_parameter = strchr( track_option, '=' ) + 1;
641 track_opt->encoder_delay = atoi( track_parameter );
642 }
643 else if( strstr( track_option, "language=" ) )
644 {
645 char *track_parameter = strchr( track_option, '=' ) + 1;
646 track_opt->ISO_language = lsmash_pack_iso_language( track_parameter );
647 }
648 else if( strstr( track_option, "fps=" ) )
649 {
650 char *track_parameter = strchr( track_option, '=' ) + 1;
651 if( sscanf( track_parameter, "%"SCNu32"/%"SCNu32, &track_opt->fps_num, &track_opt->fps_den ) == 1 )
652 {
653 track_opt->fps_num = atoi( track_parameter );
654 track_opt->fps_den = 1;
655 }
656 track_opt->user_fps = 1;
657 }
658 else if( strstr( track_option, "copyright=" ) )
659 {
660 char *track_parameter = strchr( track_option, '=' ) + 1;
661 track_opt->copyright_notice = track_parameter;
662 while( *track_parameter )
663 {
664 if( *track_parameter == '/' )
665 {
666 *track_parameter++ = '\0';
667 break;
668 }
669 ++track_parameter;
670 }
671 track_opt->copyright_language = lsmash_pack_iso_language( track_parameter );
672 }
673 else if( strstr( track_option, "handler=" ) )
674 {
675 char *track_parameter = strchr( track_option, '=' ) + 1;
676 track_opt->handler_name = track_parameter;
677 }
678 else if( strstr( track_option, "sbr" ) )
679 track_opt->sbr = 1;
680 else
681 return ERROR_MSG( "unknown track option %s\n", track_option );
682 }
683 }
684 return 0;
685 }
686
687 static void display_codec_name( lsmash_codec_type_t codec_type, uint32_t track_number )
688 {
689 #define DISPLAY_CODEC_NAME( codec, codec_name ) \
690 else if( lsmash_check_codec_type_identical( codec_type, codec ) ) \
691 eprintf( "Track %"PRIu32": "#codec_name"\n", track_number )
692 if( 0 );
693 DISPLAY_CODEC_NAME( ISOM_CODEC_TYPE_AVC1_VIDEO, H.264 Advanced Video Coding );
694 DISPLAY_CODEC_NAME( ISOM_CODEC_TYPE_HVC1_VIDEO, H.265 High Efficiency Video Coding );
695 DISPLAY_CODEC_NAME( ISOM_CODEC_TYPE_VC_1_VIDEO, SMPTE VC-1 Advanced Profile );
696 DISPLAY_CODEC_NAME( ISOM_CODEC_TYPE_MP4A_AUDIO, MPEG-4 Audio );
697 DISPLAY_CODEC_NAME( QT_CODEC_TYPE_MP4A_AUDIO, MPEG-4 Audio );
698 DISPLAY_CODEC_NAME( ISOM_CODEC_TYPE_AC_3_AUDIO, AC-3 );
699 DISPLAY_CODEC_NAME( ISOM_CODEC_TYPE_EC_3_AUDIO, Enhanced AC-3 );
700 DISPLAY_CODEC_NAME( ISOM_CODEC_TYPE_DTSC_AUDIO, DTS );
701 DISPLAY_CODEC_NAME( ISOM_CODEC_TYPE_DTSE_AUDIO, DTS LBR );
702 DISPLAY_CODEC_NAME( ISOM_CODEC_TYPE_DTSH_AUDIO, DTS-HD );
703 DISPLAY_CODEC_NAME( ISOM_CODEC_TYPE_DTSL_AUDIO, DTS-HD Lossless );
704 DISPLAY_CODEC_NAME( ISOM_CODEC_TYPE_SAWB_AUDIO, Wideband AMR voice );
705 DISPLAY_CODEC_NAME( ISOM_CODEC_TYPE_SAMR_AUDIO, Narrowband AMR voice );
706 DISPLAY_CODEC_NAME( QT_CODEC_TYPE_LPCM_AUDIO, Uncompressed Audio );
707 #undef DISPLAY_CODEC_NAME
708 }
709
710 static int open_input_files( muxer_t *muxer )
711 {
712 output_movie_t *out_movie = &muxer->output.file.movie;
713 option_t *opt = &muxer->opt;
714 for( uint32_t current_input_number = 1; current_input_number <= muxer->num_of_inputs; current_input_number++ )
715 {
716 input_t *input = &muxer->input[current_input_number - 1];
717 /* Initialize importer framework. */
718 input->importer = lsmash_importer_open( input->file_name, "auto" );
719 if( !input->importer )
720 return ERROR_MSG( "failed to open input file.\n" );
721 input->num_of_tracks = lsmash_importer_get_track_count( input->importer );
722 if( input->num_of_tracks == 0 )
723 return ERROR_MSG( "there is no valid track in input file.\n" );
724 if( opt->default_language )
725 for( int i = 0; i < input->num_of_tracks; i ++ )
726 input->track[i].opt.ISO_language = opt->default_language;
727 /* Parse track options */
728 if( parse_track_options( input ) )
729 return ERROR_MSG( "failed to parse track options.\n" );
730 /* Activate tracks by CODEC type. */
731 for( input->current_track_number = 1;
732 input->current_track_number <= input->num_of_tracks;
733 input->current_track_number ++ )
734 {
735 input_track_t *in_track = &input->track[input->current_track_number - 1];
736 int err = lsmash_importer_construct_timeline( input->importer, input->current_track_number );
737 if( err < 0 && err != LSMASH_ERR_PATCH_WELCOME )
738 {
739 in_track->active = 0;
740 continue;
741 }
742 in_track->summary = lsmash_duplicate_summary( input->importer, input->current_track_number );
743 if( !in_track->summary )
744 return ERROR_MSG( "failed to get input summary.\n" );
745 /* Check codec type. */
746 lsmash_codec_type_t codec_type = in_track->summary->sample_type;
747 in_track->active = 1;
748 if( lsmash_check_codec_type_identical( codec_type, ISOM_CODEC_TYPE_AVC1_VIDEO ) )
749 {
750 if( opt->isom )
751 add_brand( opt, ISOM_BRAND_TYPE_AVC1 );
752 }
753 else if( lsmash_check_codec_type_identical( codec_type, ISOM_CODEC_TYPE_HVC1_VIDEO ) )
754 {
755 if( !opt->isom && opt->qtff )
756 return ERROR_MSG( "the input seems HEVC, at present available only for ISO Base Media file format.\n" );
757 }
758 else if( lsmash_check_codec_type_identical( codec_type, ISOM_CODEC_TYPE_VC_1_VIDEO ) )
759 {
760 if( !opt->isom && opt->qtff )
761 return ERROR_MSG( "the input seems VC-1, at present available only for ISO Base Media file format.\n" );
762 }
763 else if( lsmash_check_codec_type_identical( codec_type, ISOM_CODEC_TYPE_MP4A_AUDIO )
764 || lsmash_check_codec_type_identical( codec_type, QT_CODEC_TYPE_MP4A_AUDIO ) )
765 /* Do nothing. */;
766 else if( lsmash_check_codec_type_identical( codec_type, ISOM_CODEC_TYPE_AC_3_AUDIO )
767 || lsmash_check_codec_type_identical( codec_type, ISOM_CODEC_TYPE_EC_3_AUDIO ) )
768 {
769 if( !opt->isom && opt->qtff )
770 return ERROR_MSG( "the input seems (Enhanced) AC-3, at present available only for ISO Base Media file format.\n" );
771 add_brand( opt, ISOM_BRAND_TYPE_DBY1 );
772 }
773 else if( lsmash_check_codec_type_identical( codec_type, ISOM_CODEC_TYPE_DTSC_AUDIO )
774 || lsmash_check_codec_type_identical( codec_type, ISOM_CODEC_TYPE_DTSE_AUDIO )
775 || lsmash_check_codec_type_identical( codec_type, ISOM_CODEC_TYPE_DTSH_AUDIO )
776 || lsmash_check_codec_type_identical( codec_type, ISOM_CODEC_TYPE_DTSL_AUDIO ) )
777 {
778 if( !opt->isom && opt->qtff )
779 return ERROR_MSG( "the input seems DTS(-HD) Audio, at present available only for ISO Base Media file format.\n" );
780 }
781 else if( lsmash_check_codec_type_identical( codec_type, ISOM_CODEC_TYPE_SAWB_AUDIO )
782 || lsmash_check_codec_type_identical( codec_type, ISOM_CODEC_TYPE_SAMR_AUDIO ) )
783 {
784 if( !opt->brand_3gx )
785 return ERROR_MSG( "the input seems AMR-NB/WB, available for 3GPP(2) file format.\n" );
786 }
787 else if( lsmash_check_codec_type_identical( codec_type, QT_CODEC_TYPE_LPCM_AUDIO ) )
788 {
789 if( opt->isom && !opt->qtff )
790 return ERROR_MSG( "the input seems Uncompressed Audio, at present available only for QuickTime file format.\n" );
791 in_track->lpcm = 1;
792 }
793 else
794 {
795 lsmash_cleanup_summary( in_track->summary );
796 in_track->summary = NULL;
797 in_track->active = 0;
798 }
799 if( in_track->active )
800 {
801 ++ input->num_of_active_tracks;
802 display_codec_name( codec_type, out_movie->num_of_tracks + input->num_of_active_tracks );
803 }
804 }
805 out_movie->num_of_tracks += input->num_of_active_tracks;
806 }
807 if( out_movie->num_of_tracks == 0 )
808 return ERROR_MSG( "there is no media that can be stored in output movie.\n" );
809 return 0;
810 }
811
812 static int set_itunes_metadata( output_t *output, option_t *opt )
813 {
814 if( !opt->itunes_movie )
815 return 0;
816 itunes_metadata_t *metadata = &opt->itunes_metadata;
817 #define SET_ITUNES_METADATA( item, type, value ) \
818 if( value \
819 && lsmash_set_itunes_metadata( output->root, (lsmash_itunes_metadata_t){ item, ITUNES_METADATA_TYPE_NONE, { .type = value }, NULL, NULL } ) ) \
820 return -1
821 SET_ITUNES_METADATA( ITUNES_METADATA_ITEM_ENCODING_TOOL, string, "L-SMASH" );
822 SET_ITUNES_METADATA( ITUNES_METADATA_ITEM_ALBUM_NAME, string, metadata->album_name );
823 SET_ITUNES_METADATA( ITUNES_METADATA_ITEM_ARTIST, string, metadata->artist );
824 SET_ITUNES_METADATA( ITUNES_METADATA_ITEM_USER_COMMENT, string, metadata->comment );
825 SET_ITUNES_METADATA( ITUNES_METADATA_ITEM_RELEASE_DATE, string, metadata->release_date );
826 SET_ITUNES_METADATA( ITUNES_METADATA_ITEM_ENCODED_BY, string, metadata->encoder );
827 SET_ITUNES_METADATA( ITUNES_METADATA_ITEM_USER_GENRE, string, metadata->genre );
828 SET_ITUNES_METADATA( ITUNES_METADATA_ITEM_LYRICS, string, metadata->lyrics );
829 SET_ITUNES_METADATA( ITUNES_METADATA_ITEM_TITLE, string, metadata->title );
830 SET_ITUNES_METADATA( ITUNES_METADATA_ITEM_COMPOSER, string, metadata->composer );
831 SET_ITUNES_METADATA( ITUNES_METADATA_ITEM_ALBUM_ARTIST, string, metadata->album_artist );
832 SET_ITUNES_METADATA( ITUNES_METADATA_ITEM_COPYRIGHT, string, metadata->copyright );
833 SET_ITUNES_METADATA( ITUNES_METADATA_ITEM_DESCRIPTION, string, metadata->description );
834 SET_ITUNES_METADATA( ITUNES_METADATA_ITEM_GROUPING, string, metadata->grouping );
835 SET_ITUNES_METADATA( ITUNES_METADATA_ITEM_BEATS_PER_MINUTE, integer, metadata->beats_per_minute );
836 #undef SET_ITUNES_METADATA
837 return 0;
838 }
839
840 static int prepare_output( muxer_t *muxer )
841 {
842 option_t *opt = &muxer->opt;
843 output_t *output = &muxer->output;
844 output_file_t *out_file = &output->file;
845 output_movie_t *out_movie = &out_file->movie;
846 /* Allocate output tracks. */
847 out_movie->track = lsmash_malloc( out_movie->num_of_tracks * sizeof(output_track_t) );
848 if( !out_movie->track )
849 return ERROR_MSG( "failed to allocate output tracks.\n" );
850 memset( out_movie->track, 0, out_movie->num_of_tracks * sizeof(output_track_t) );
851 /* Initialize L-SMASH muxer */
852 output->root = lsmash_create_root();
853 if( !output->root )
854 return ERROR_MSG( "failed to create a ROOT.\n" );
855 lsmash_file_parameters_t *file_param = &out_file->param;
856 if( lsmash_open_file( out_file->name, 0, file_param ) < 0 )
857 return ERROR_MSG( "failed to open an output file.\n" );
858 file_param->major_brand = opt->major_brand;
859 file_param->brands = opt->brands;
860 file_param->brand_count = opt->num_of_brands;
861 file_param->minor_version = opt->minor_version;
862 if( opt->interleave )
863 file_param->max_chunk_duration = opt->interleave * 1e-3;
864 out_file->fh = lsmash_set_file( output->root, file_param );
865 if( !out_file->fh )
866 return ERROR_MSG( "failed to add an output file into a ROOT.\n" );
867 /* Initialize movie */
868 lsmash_movie_parameters_t movie_param;
869 lsmash_initialize_movie_parameters( &movie_param );
870 if( lsmash_set_movie_parameters( output->root, &movie_param ) )
871 return ERROR_MSG( "failed to set movie parameters.\n" );
872 if( opt->copyright_notice
873 && lsmash_set_copyright( output->root, 0, opt->copyright_language, opt->copyright_notice ) )
874 return ERROR_MSG( "failed to set a copyright notice for the entire movie.\n" );
875 if( set_itunes_metadata( output, opt ) )
876 return ERROR_MSG( "failed to set iTunes metadata.\n" );
877 out_movie->current_track_number = 1;
878 for( uint32_t current_input_number = 1; current_input_number <= muxer->num_of_inputs; current_input_number++ )
879 {
880 input_t *input = &muxer->input[current_input_number - 1];
881 for( input->current_track_number = 1;
882 input->current_track_number <= input->num_of_tracks;
883 input->current_track_number ++ )
884 {
885 input_track_t *in_track = &input->track[ input->current_track_number - 1 ];
886 if( !in_track->active )
887 continue;
888 input_track_option_t *track_opt = &in_track->opt;
889 output_track_t *out_track = &out_movie->track[ out_movie->current_track_number - 1 ];
890 /* Set up track parameters. */
891 lsmash_track_parameters_t track_param;
892 lsmash_initialize_track_parameters( &track_param );
893 track_param.mode = ISOM_TRACK_IN_MOVIE | ISOM_TRACK_IN_PREVIEW;
894 if( !track_opt->disable )
895 track_param.mode |= ISOM_TRACK_ENABLED;
896 if( opt->qtff )
897 track_param.mode |= QT_TRACK_IN_POSTER;
898 track_param.alternate_group = track_opt->alternate_group;
899 lsmash_media_parameters_t media_param;
900 lsmash_initialize_media_parameters( &media_param );
901 media_param.ISO_language = track_opt->ISO_language;
902 switch( in_track->summary->summary_type )
903 {
904 case LSMASH_SUMMARY_TYPE_VIDEO :
905 {
906 out_track->track_ID = lsmash_create_track( output->root, ISOM_MEDIA_HANDLER_TYPE_VIDEO_TRACK );
907 if( !out_track->track_ID )
908 return ERROR_MSG( "failed to create a track.\n" );
909 lsmash_video_summary_t *summary = (lsmash_video_summary_t *)in_track->summary;
910 uint64_t display_width = (uint64_t)summary->width << 16;
911 uint64_t display_height = (uint64_t)summary->height << 16;
912 if( summary->par_h && summary->par_v )
913 {
914 double sar = (double)summary->par_h / summary->par_v;
915 if( sar > 1.0 )
916 display_width *= sar;
917 else
918 display_height /= sar;
919 }
920 track_param.display_width = display_width <= UINT32_MAX ? display_width : UINT32_MAX;
921 track_param.display_height = display_height <= UINT32_MAX ? display_height : UINT32_MAX;
922 /* Initialize media */
923 uint32_t timescale = 25; /* default value */
924 uint32_t timebase = 1; /* default value */
925 if( track_opt->user_fps )
926 {
927 timescale = track_opt->fps_num << (!!summary->sample_per_field);
928 timebase = track_opt->fps_den;
929 }
930 else if( !summary->vfr )
931 {
932 if( lsmash_check_codec_type_identical( summary->sample_type, ISOM_CODEC_TYPE_AVC1_VIDEO )
933 || lsmash_check_codec_type_identical( summary->sample_type, ISOM_CODEC_TYPE_HVC1_VIDEO ) )
934 {
935 uint32_t compare_timebase = summary->timebase;
936 uint32_t compare_timescale = summary->timescale;
937 static const struct
938 {
939 uint32_t timescale;
940 uint32_t timebase;
941 } well_known_fps[]
942 = {
943 { 24000, 1001 }, { 30000, 1001 }, { 60000, 1001 }, { 120000, 1001 }, { 72000, 1001 },
944 { 25, 1 }, { 50, 1 }, { 24, 1 }, { 30, 1 }, { 60, 1 }, { 120, 1 }, { 72, 1 }, { 0, 0 }
945 };
946 for( int i = 0; well_known_fps[i].timescale; i++ )
947 if( well_known_fps[i].timescale == compare_timescale
948 && well_known_fps[i].timebase == compare_timebase )
949 {
950 timescale = well_known_fps[i].timescale;
951 timebase = well_known_fps[i].timebase;
952 break;
953 }
954 lsmash_codec_specific_t *bitrate = lsmash_create_codec_specific_data( LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_H264_BITRATE,
955 LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED );
956 if( bitrate )
957 lsmash_add_codec_specific_data( in_track->summary, bitrate );
958 lsmash_destroy_codec_specific_data( bitrate );
959 }
960 else
961 {
962 timescale = summary->timescale;
963 timebase = summary->timebase;
964 }
965 }
966 media_param.timescale = timescale;
967 media_param.media_handler_name = track_opt->handler_name ? track_opt->handler_name : "L-SMASH Video Handler";
968 media_param.roll_grouping = 1;
969 media_param.rap_grouping = opt->isom_version >= 6;
970 out_track->timescale = timescale;
971 out_track->timebase = timebase;
972 break;
973 }
974 case LSMASH_SUMMARY_TYPE_AUDIO :
975 {
976 out_track->track_ID = lsmash_create_track( output->root, ISOM_MEDIA_HANDLER_TYPE_AUDIO_TRACK );
977 if( !out_track->track_ID )
978 return ERROR_MSG( "failed to create a track.\n" );
979 lsmash_audio_summary_t *summary = (lsmash_audio_summary_t *)in_track->summary;
980 if( track_opt->sbr )
981 {
982 /* Check if explicit SBR is valid or not. */
983 if( lsmash_mp4sys_get_object_type_indication( (lsmash_summary_t *)summary ) != MP4SYS_OBJECT_TYPE_Audio_ISO_14496_3 )
984 return ERROR_MSG( "--sbr is only valid with MPEG-4 Audio.\n" );
985 summary->sbr_mode = MP4A_AAC_SBR_BACKWARD_COMPATIBLE;
986 if( lsmash_setup_AudioSpecificConfig( summary ) )
987 return ERROR_MSG( "failed to set SBR mode.\n" );
988 }
989 media_param.timescale = summary->frequency;
990 media_param.media_handler_name = track_opt->handler_name ? track_opt->handler_name : "L-SMASH Audio Handler";
991 media_param.roll_grouping = (opt->isom_version >= 2 || (opt->qtff && !in_track->lpcm));
992 out_track->priming_samples = track_opt->encoder_delay;
993 out_track->timescale = summary->frequency;
994 out_track->timebase = 1;
995 out_track->lpcm = in_track->lpcm;
996 break;
997 }
998 default :
999 return ERROR_MSG( "not supported stream type.\n" );
1000 }
1001 /* Reset the movie timescale in order to match the media timescale if only one track is there. */
1002 if( muxer->num_of_inputs == 1
1003 && current_input_number == 1
1004 && input->current_track_number == 1 )
1005 {
1006 movie_param.timescale = media_param.timescale;
1007 if( lsmash_set_movie_parameters( output->root, &movie_param ) )
1008 return ERROR_MSG( "failed to set movie parameters.\n" );
1009 }
1010 /* Set copyright information. */
1011 if( track_opt->copyright_notice
1012 && lsmash_set_copyright( output->root, out_track->track_ID, track_opt->copyright_language, track_opt->copyright_notice ) )
1013 return ERROR_MSG( "failed to set a copyright notice.\n" );
1014 /* Set track parameters. */
1015 if( lsmash_set_track_parameters( output->root, out_track->track_ID, &track_param ) )
1016 return ERROR_MSG( "failed to set track parameters.\n" );
1017 /* Set media parameters. */
1018 if( lsmash_set_media_parameters( output->root, out_track->track_ID, &media_param ) )
1019 return ERROR_MSG( "failed to set media parameters.\n" );
1020 out_track->summary = in_track->summary;
1021 out_track->sample_entry = lsmash_add_sample_entry( output->root, out_track->track_ID, out_track->summary );
1022 if( !out_track->sample_entry )
1023 return ERROR_MSG( "failed to add sample description entry.\n" );
1024 out_track->active = 1;
1025 ++ out_movie->current_track_number;
1026 }
1027 input->current_track_number = 1;
1028 }
1029 out_movie->current_track_number = 1;
1030 return 0;
1031 }
1032
1033 static void set_reference_chapter_track( output_t *output, option_t *opt )
1034 {
1035 if( !opt->chap_file || (!opt->qtff && !opt->itunes_movie) || (opt->brand_3gx == 1) )
1036 return;
1037 lsmash_create_reference_chapter_track( output->root, opt->chap_track, opt->chap_file );
1038 }
1039
1040 static int do_mux( muxer_t *muxer )
1041 {
1042 #define LSMASH_MAX( a, b ) ((a) > (b) ? (a) : (b))
1043 option_t *opt = &muxer->opt;
1044 output_t *output = &muxer->output;
1045 output_movie_t *out_movie = &output->file.movie;
1046 set_reference_chapter_track( output, opt );
1047 double largest_dts = 0;
1048 uint32_t current_input_number = 1;
1049 uint32_t num_consecutive_sample_skip = 0;
1050 uint32_t num_active_input_tracks = out_movie->num_of_tracks;
1051 uint64_t total_media_size = 0;
1052 uint8_t sample_count = 0;
1053 while( 1 )
1054 {
1055 input_t *input = &muxer->input[current_input_number - 1];
1056 output_track_t *out_track = &out_movie->track[ out_movie->current_track_number - 1 ];
1057 if( out_track->active )
1058 {
1059 lsmash_sample_t *sample = out_track->sample;
1060 /* Get a new sample data if the track doesn't hold any one. */
1061 if( !sample )
1062 {
1063 /* lsmash_importer_get_access_unit() returns 1 if there're any changes in stream's properties. */
1064 int ret = lsmash_importer_get_access_unit( input->importer, input->current_track_number, &sample );
1065 if( ret == LSMASH_ERR_MEMORY_ALLOC )
1066 return ERROR_MSG( "failed to alloc memory for buffer.\n" );
1067 else if( ret <= -1 )
1068 {
1069 lsmash_delete_sample( sample );
1070 ERROR_MSG( "failed to get a frame from input file. Maybe corrupted.\n"
1071 "Aborting muxing operation and trying to let output be valid file.\n" );
1072 break;
1073 }
1074 else if( ret == 1 ) /* a change of stream's properties */
1075 {
1076 input_track_t *in_track = &input->track[input->current_track_number - 1];
1077 lsmash_cleanup_summary( in_track->summary );
1078 in_track->summary = lsmash_duplicate_summary( input->importer, input->current_track_number );
1079 out_track->summary = in_track->summary;
1080 out_track->sample_entry = lsmash_add_sample_entry( output->root, out_track->track_ID, out_track->summary );
1081 if( !out_track->sample_entry )
1082 {
1083 ERROR_MSG( "failed to add sample description entry.\n" );
1084 break;
1085 }
1086 }
1087 else if( ret == 2 ) /* EOF */
1088 {
1089 /* No more appendable samples in this track. */
1090 lsmash_delete_sample( sample );
1091 sample = NULL;
1092 out_track->active = 0;
1093 out_track->last_delta = lsmash_importer_get_last_delta( input->importer, input->current_track_number );
1094 if( out_track->last_delta == 0 )
1095 ERROR_MSG( "failed to get the last sample delta.\n" );
1096 out_track->last_delta *= out_track->timebase;
1097 if( --num_active_input_tracks == 0 )
1098 break; /* Reached the end of whole tracks. */
1099 }
1100 if( sample )
1101 {
1102 sample->index = out_track->sample_entry;
1103 sample->dts *= out_track->timebase;
1104 sample->cts *= out_track->timebase;
1105 if( opt->timeline_shift )
1106 {
1107 if( out_track->current_sample_number == 0 )
1108 out_track->ctd_shift = sample->cts;
1109 sample->cts -= out_track->ctd_shift;
1110 }
1111 out_track->dts = (double)sample->dts / out_track->timescale;
1112 out_track->sample = sample;
1113 }
1114 }
1115 if( sample )
1116 {
1117 /* Append a sample if meeting a condition. */
1118 if( out_track->dts <= largest_dts || num_consecutive_sample_skip == num_active_input_tracks )
1119 {
1120 uint64_t sample_size = sample->length; /* sample might be deleted internally after appending. */
1121 uint64_t sample_dts = sample->dts; /* same as above */
1122 uint64_t sample_cts = sample->cts; /* same as above */
1123 if( lsmash_append_sample( output->root, out_track->track_ID, sample ) )
1124 return ERROR_MSG( "failed to append a sample.\n" );
1125 if( out_track->current_sample_number == 0 )
1126 out_track->start_offset = sample_cts;
1127 else
1128 out_track->last_delta = sample_dts - out_track->prev_dts; /* for any changes in stream's properties */
1129 out_track->prev_dts = sample_dts;
1130 out_track->sample = NULL;
1131 largest_dts = LSMASH_MAX( largest_dts, out_track->dts );
1132 total_media_size += sample_size;
1133 ++ out_track->current_sample_number;
1134 num_consecutive_sample_skip = 0;
1135 /* Print, per 256 samples, total size of imported media. */
1136 if( ++sample_count == 0 )
1137 {
1138 REFRESH_CONSOLE;
1139 eprintf( "Importing: %"PRIu64" bytes\r", total_media_size );
1140 }
1141 }
1142 else
1143 ++num_consecutive_sample_skip; /* Skip appendig sample. */
1144 }
1145 }
1146 if( ++ out_movie->current_track_number > out_movie->num_of_tracks )
1147 out_movie->current_track_number = 1; /* Back the first output track. */
1148 /* Move the next track. */
1149 if( ++ input->current_track_number > input->num_of_tracks )
1150 {
1151 /* Move the next input movie. */
1152 input->current_track_number = 1;
1153 if( ++ current_input_number > muxer->num_of_inputs )
1154 current_input_number = 1; /* Back the first input movie. */
1155 }
1156 }
1157 for( out_movie->current_track_number = 1;
1158 out_movie->current_track_number <= out_movie->num_of_tracks;
1159 out_movie->current_track_number ++ )
1160 {
1161 /* Close track. */
1162 output_track_t *out_track = &out_movie->track[ out_movie->current_track_number - 1 ];
1163 uint32_t last_sample_delta = out_track->lpcm ? 1 : out_track->last_delta;
1164 if( lsmash_flush_pooled_samples( output->root, out_track->track_ID, last_sample_delta ) )
1165 ERROR_MSG( "failed to flush the rest of samples.\n" );
1166 /* Create edit list.
1167 * Don't trust media duration basically. It's just duration of media, not duration of track presentation. */
1168 uint64_t actual_duration = out_track->lpcm
1169 ? lsmash_get_media_duration( output->root, out_track->track_ID )
1170 : out_track->prev_dts + last_sample_delta;
1171 actual_duration -= out_track->priming_samples;
1172 lsmash_edit_t edit;
1173 edit.duration = actual_duration * ((double)lsmash_get_movie_timescale( output->root ) / out_track->timescale);
1174 edit.start_time = out_track->priming_samples + out_track->start_offset;
1175 edit.rate = ISOM_EDIT_MODE_NORMAL;
1176 if( lsmash_create_explicit_timeline_map( output->root, out_track->track_ID, edit ) )
1177 ERROR_MSG( "failed to set timeline map.\n" );
1178 }
1179 return 0;
1180 #undef LSMASH_MAX
1181 }
1182
1183 static int moov_to_front_callback( void *param, uint64_t written_movie_size, uint64_t total_movie_size )
1184 {
1185 REFRESH_CONSOLE;
1186 eprintf( "Finalizing: [%5.2lf%%]\r", total_movie_size ? ((double)written_movie_size / total_movie_size) * 100.0 : 0 );
1187 return 0;
1188 }
1189
1190 static int finish_movie( output_t *output, option_t *opt )
1191 {
1192 /* Set chapter list. */
1193 if( opt->chap_file )
1194 lsmash_set_tyrant_chapter( output->root, opt->chap_file, opt->add_bom_to_chpl );
1195 /* Close movie. */
1196 REFRESH_CONSOLE;
1197 if( opt->optimize_pd )
1198 {
1199 lsmash_adhoc_remux_t moov_to_front;
1200 moov_to_front.func = moov_to_front_callback;
1201 moov_to_front.buffer_size = 4*1024*1024; /* 4MiB */
1202 moov_to_front.param = NULL;
1203 return lsmash_finish_movie( output->root, &moov_to_front );
1204 }
1205 if( lsmash_finish_movie( output->root, NULL ) )
1206 return -1;
1207 return lsmash_write_lsmash_indicator( output->root );
1208 }
1209
1210 int main( int argc, char *argv[] )
1211 {
1212 muxer_t muxer = { { 0 } };
1213 lsmash_get_mainargs( &argc, &argv );
1214 if( parse_global_options( argc, argv, &muxer ) )
1215 return MUXER_USAGE_ERR();
1216 if( muxer.opt.help )
1217 {
1218 display_help();
1219 cleanup_muxer( &muxer );
1220 return 0;
1221 }
1222 else if( muxer.opt.version )
1223 {
1224 display_version();
1225 cleanup_muxer( &muxer );
1226 return 0;
1227 }
1228 if( open_input_files( &muxer ) )
1229 return MUXER_ERR( "failed to open input files.\n" );
1230 if( prepare_output( &muxer ) )
1231 return MUXER_ERR( "failed to set up preparation for output.\n" );
1232 if( do_mux( &muxer ) )
1233 return MUXER_ERR( "failed to do muxing.\n" );
1234 if( finish_movie( &muxer.output, &muxer.opt ) )
1235 return MUXER_ERR( "failed to finish movie.\n" );
1236 REFRESH_CONSOLE;
1237 eprintf( "Muxing completed!\n" );
1238 cleanup_muxer( &muxer ); /* including lsmash_destroy_root() */
1239 return 0;
1240 }
A simple tool for mp4.