static int isom_add_chpl_entry( isom_chpl_t *chpl, isom_chapter_entry_t *chap_data ) { if( !chap_data->chapter_name || !chpl || !chpl->list ) return LSMASH_ERR_FUNCTION_PARAM; isom_chpl_entry_t *data = lsmash_malloc( sizeof(isom_chpl_entry_t) ); if( !data ) return LSMASH_ERR_MEMORY_ALLOC; data->start_time = chap_data->start_time; data->chapter_name_length = strlen( chap_data->chapter_name ); data->chapter_name = (char *)lsmash_malloc( data->chapter_name_length + 1 ); if( !data->chapter_name ) { lsmash_free( data ); return LSMASH_ERR_MEMORY_ALLOC; } memcpy( data->chapter_name, chap_data->chapter_name, data->chapter_name_length ); data->chapter_name[ data->chapter_name_length ] = '\0'; if( lsmash_add_entry( chpl->list, data ) < 0 ) { lsmash_free( data->chapter_name ); lsmash_free( data ); return LSMASH_ERR_MEMORY_ALLOC; } return 0; }
static void remove_vc1_importer( vc1_importer_t *vc1_imp ) { if( !vc1_imp ) return; vc1_cleanup_parser( &vc1_imp->info ); lsmash_free( vc1_imp->ts_list.timestamp ); lsmash_free( vc1_imp ); }
static void vc1_destroy_header( lsmash_vc1_header_t *hdr ) { if( !hdr ) return; if( hdr->ebdu ) lsmash_free( hdr->ebdu ); lsmash_free( hdr ); }
FILE *lsmash_win32_fopen( const char *name, const char *mode ) { wchar_t *wname = NULL, *wmode = NULL; lsmash_string_to_wchar( CP_UTF8, name, &wname ); lsmash_string_to_wchar( CP_UTF8, mode, &wmode ); FILE *fp = _wfopen( wname, wmode ); if( !fp ) fp = fopen( name, mode ); lsmash_free( wname ); lsmash_free( wmode ); return fp; }
void vc1_destruct_specific_data( void *data ) { if( !data ) return; lsmash_destroy_vc1_headers( data ); lsmash_free( data ); }
static void remove_mp4sys_adts_importer ( mp4sys_adts_importer_t *adts_imp ) { lsmash_free( adts_imp ); }
lsmash_summary_t *lsmash_create_summary( lsmash_summary_type summary_type ) { size_t summary_size; switch( summary_type ) { case LSMASH_SUMMARY_TYPE_VIDEO : summary_size = sizeof(lsmash_video_summary_t); break; case LSMASH_SUMMARY_TYPE_AUDIO : summary_size = sizeof(lsmash_audio_summary_t); break; default : summary_size = sizeof(lsmash_summary_t); return NULL; } lsmash_summary_t *summary = (lsmash_summary_t *)lsmash_malloc_zero( summary_size ); if( !summary ) return NULL; summary->opaque = (lsmash_codec_specific_list_t *)lsmash_malloc_zero( sizeof(lsmash_codec_specific_list_t) ); if( !summary->opaque ) { lsmash_free( summary ); return NULL; } summary->summary_type = summary_type; summary->data_ref_index = 1; return summary; }
void lsmash_bs_cleanup( lsmash_bs_t *bs ) { if( !bs ) return; bs_buffer_free( bs ); lsmash_free( bs ); }
void lsmash_cleanup_summary( lsmash_summary_t *summary ) { if( !summary ) return; if( summary->opaque ) { for( lsmash_entry_t *entry = summary->opaque->list.head; entry; ) { lsmash_entry_t *next = entry->next; lsmash_destroy_codec_specific_data( (lsmash_codec_specific_t *)entry->data ); lsmash_free( entry ); entry = next; } lsmash_free( summary->opaque ); } lsmash_free( summary ); }
static void remove_dts_importer( dts_importer_t *dts_imp ) { if( !dts_imp ) return; lsmash_destroy_multiple_buffers( dts_imp->au_buffers ); lsmash_bits_cleanup( dts_imp->info.bits ); lsmash_free( dts_imp ); }
static void bs_buffer_free( lsmash_bs_t *bs ) { if( bs->buffer.internal ) lsmash_free( bs->buffer.data ); bs->buffer.data = NULL; bs->buffer.alloc = 0; bs->buffer.store = 0; bs->buffer.pos = 0; }
/* create AudioSpecificConfig as memory block from summary, and set it into that summary itself */ int lsmash_setup_AudioSpecificConfig( lsmash_audio_summary_t *summary ) { if( !summary || !summary->opaque ) return LSMASH_ERR_FUNCTION_PARAM; /* Remove an old one. */ for( lsmash_entry_t *entry = summary->opaque->list.head; entry; entry = entry->next ) { lsmash_codec_specific_t *cs = (lsmash_codec_specific_t *)entry->data; if( !cs || cs->type != LSMASH_CODEC_SPECIFIC_DATA_TYPE_MP4SYS_DECODER_CONFIG ) continue; lsmash_remove_entry_direct( &summary->opaque->list, entry, lsmash_destroy_codec_specific_data ); } /* Create and add a new one. */ uint32_t data_length; uint8_t *data = mp4a_export_AudioSpecificConfig( summary->aot, summary->frequency, summary->channels, summary->sbr_mode, NULL, /* FIXME */ 0, /* FIXME */ &data_length ); if( !data ) return LSMASH_ERR_NAMELESS; lsmash_codec_specific_t *cs = lsmash_create_codec_specific_data( LSMASH_CODEC_SPECIFIC_DATA_TYPE_MP4SYS_DECODER_CONFIG, LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED ); if( !cs ) { lsmash_free( data ); return LSMASH_ERR_MEMORY_ALLOC; } lsmash_mp4sys_decoder_parameters_t *param = (lsmash_mp4sys_decoder_parameters_t *)cs->data.structured; param->objectTypeIndication = MP4SYS_OBJECT_TYPE_Audio_ISO_14496_3; param->streamType = MP4SYS_STREAM_TYPE_AudioStream; int err = lsmash_set_mp4sys_decoder_specific_info( param, data, data_length ); lsmash_free( data ); if( err < 0 || (err = lsmash_add_entry( &summary->opaque->list, cs )) < 0 ) { lsmash_destroy_codec_specific_data( cs ); return err; } return 0; }
static dts_importer_t *create_dts_importer( importer_t *importer ) { dts_importer_t *dts_imp = (dts_importer_t *)lsmash_malloc_zero( sizeof(dts_importer_t) ); if( !dts_imp ) return NULL; dts_info_t *dts_info = &dts_imp->info; dts_info->bits = lsmash_bits_create( importer->bs ); if( !dts_info->bits ) { lsmash_free( dts_imp ); return NULL; } dts_imp->au_buffers = lsmash_create_multiple_buffers( 2, DTS_MAX_EXSS_SIZE ); if( !dts_imp->au_buffers ) { lsmash_bits_cleanup( dts_info->bits ); lsmash_free( dts_imp ); return NULL; } dts_imp->au = lsmash_withdraw_buffer( dts_imp->au_buffers, 1 ); dts_imp->incomplete_au = lsmash_withdraw_buffer( dts_imp->au_buffers, 2 ); dts_setup_parser( dts_info ); return dts_imp; }
static int vc1_analyze_whole_stream ( importer_t *importer ) { /* Parse all EBDU in the stream for preparation of calculating timestamps. */ uint32_t cts_alloc = (1 << 12) * sizeof(uint64_t); uint64_t *cts = lsmash_malloc( cts_alloc ); if( !cts ) return LSMASH_ERR_MEMORY_ALLOC; /* Failed to allocate CTS list */ uint32_t num_access_units = 0; uint32_t num_consecutive_b = 0; lsmash_class_t *logger = &(lsmash_class_t){ "VC-1" }; lsmash_log( &logger, LSMASH_LOG_INFO, "Analyzing stream as VC-1\r" ); vc1_importer_t *vc1_imp = (vc1_importer_t *)importer->info; vc1_info_t *info = &vc1_imp->info; importer->status = IMPORTER_OK; int err; while( importer->status != IMPORTER_EOF ) { #if 0 lsmash_log( &logger, LSMASH_LOG_INFO, "Analyzing stream as VC-1: %"PRIu32"\n", num_access_units + 1 ); #endif if( (err = vc1_importer_get_access_unit_internal( importer, 1 )) < 0 ) goto fail; vc1_importer_check_eof( importer, &info->access_unit ); /* In the case where B-pictures exist * Decode order * I[0]P[1]P[2]B[3]B[4]P[5]... * DTS * 0 1 2 3 4 5 ... * Composition order * I[0]P[1]B[3]B[4]P[2]P[5]... * CTS * 1 2 3 4 5 6 ... * We assumes B or BI-pictures always be present in the stream here. */ if( !info->access_unit.disposable ) { /* Apply CTS of the last B-picture plus 1 to the last non-B-picture. */ if( num_access_units > num_consecutive_b ) cts[ num_access_units - num_consecutive_b - 1 ] = num_access_units; num_consecutive_b = 0; } else /* B or BI-picture */ { /* B and BI-pictures shall be output or displayed in the same order as they are encoded. */ cts[ num_access_units ] = num_access_units; ++num_consecutive_b; info->dvc1_param.bframe_present = 1; } if( cts_alloc <= num_access_units * sizeof(uint64_t) ) { uint32_t alloc = 2 * num_access_units * sizeof(uint64_t); uint64_t *temp = lsmash_realloc( cts, alloc ); if( !temp ) { err = LSMASH_ERR_MEMORY_ALLOC; goto fail; /* Failed to re-allocate CTS list */ } cts = temp; cts_alloc = alloc; } vc1_imp->max_au_length = LSMASH_MAX( info->access_unit.data_length, vc1_imp->max_au_length ); ++num_access_units; } if( num_access_units > num_consecutive_b ) cts[ num_access_units - num_consecutive_b - 1 ] = num_access_units; else { err = LSMASH_ERR_INVALID_DATA; goto fail; } /* Construct timestamps. */ lsmash_media_ts_t *timestamp = lsmash_malloc( num_access_units * sizeof(lsmash_media_ts_t) ); if( !timestamp ) { err = LSMASH_ERR_MEMORY_ALLOC; goto fail; /* Failed to allocate timestamp list */ } for( uint32_t i = 1; i < num_access_units; i++ ) if( cts[i] < cts[i - 1] ) { vc1_imp->composition_reordering_present = 1; break; } if( vc1_imp->composition_reordering_present ) for( uint32_t i = 0; i < num_access_units; i++ ) { timestamp[i].cts = cts[i]; timestamp[i].dts = i; } else for( uint32_t i = 0; i < num_access_units; i++ ) timestamp[i].cts = timestamp[i].dts = i; lsmash_free( cts ); lsmash_log_refresh_line( &logger ); #if 0 for( uint32_t i = 0; i < num_access_units; i++ ) fprintf( stderr, "Timestamp[%"PRIu32"]: DTS=%"PRIu64", CTS=%"PRIu64"\n", i, timestamp[i].dts, timestamp[i].cts ); #endif vc1_imp->ts_list.sample_count = num_access_units; vc1_imp->ts_list.timestamp = timestamp; return 0; fail: lsmash_log_refresh_line( &logger ); lsmash_free( cts ); return err; }
int main( int argc, char *argv[] ) { if ( argc < 2 ) { display_help(); return -1; } else if( !strcasecmp( argv[1], "-h" ) || !strcasecmp( argv[1], "--help" ) ) { display_help(); return 0; } else if( !strcasecmp( argv[1], "-v" ) || !strcasecmp( argv[1], "--version" ) ) { display_version(); return 0; } int dump_box = 1; int chapter = 0; char *filename; lsmash_get_mainargs( &argc, &argv ); if( argc > 2 ) { if( !strcasecmp( argv[1], "--box" ) ) DO_NOTHING; else if( !strcasecmp( argv[1], "--chapter" ) ) chapter = 1; else if( !strcasecmp( argv[1], "--timestamp" ) ) dump_box = 0; else { display_help(); return -1; } filename = argv[2]; } else { filename = argv[1]; } /* Open the input file. */ lsmash_root_t *root = lsmash_create_root(); if( !root ) { fprintf( stderr, "Failed to create a ROOT.\n" ); return -1; } lsmash_file_parameters_t file_param = { 0 }; if( lsmash_open_file( filename, 1, &file_param ) < 0 ) return BOXDUMPER_ERR( "Failed to open an input file.\n" ); if( dump_box ) file_param.mode |= LSMASH_FILE_MODE_DUMP; lsmash_file_t *file = lsmash_set_file( root, &file_param ); if( !file ) return BOXDUMPER_ERR( "Failed to add a file into a ROOT.\n" ); if( lsmash_read_file( file, &file_param ) < 0 ) return BOXDUMPER_ERR( "Failed to read a file\n" ); /* Dump the input file. */ if( chapter ) { if( lsmash_print_chapter_list( root ) ) return BOXDUMPER_ERR( "Failed to extract chapter.\n" ); } else if( dump_box ) { if( lsmash_print_movie( root, "-" ) ) return BOXDUMPER_ERR( "Failed to dump box structure.\n" ); } else { lsmash_movie_parameters_t movie_param; lsmash_initialize_movie_parameters( &movie_param ); lsmash_get_movie_parameters( root, &movie_param ); uint32_t num_tracks = movie_param.number_of_tracks; for( uint32_t track_number = 1; track_number <= num_tracks; track_number++ ) { uint32_t track_ID = lsmash_get_track_ID( root, track_number ); if( !track_ID ) return BOXDUMPER_ERR( "Failed to get track_ID.\n" ); lsmash_media_parameters_t media_param; lsmash_initialize_media_parameters( &media_param ); if( lsmash_get_media_parameters( root, track_ID, &media_param ) ) return BOXDUMPER_ERR( "Failed to get media parameters.\n" ); if( lsmash_construct_timeline( root, track_ID ) ) return BOXDUMPER_ERR( "Failed to construct timeline.\n" ); uint32_t timeline_shift; if( lsmash_get_composition_to_decode_shift_from_media_timeline( root, track_ID, &timeline_shift ) ) return BOXDUMPER_ERR( "Failed to get timestamps.\n" ); lsmash_media_ts_list_t ts_list; if( lsmash_get_media_timestamps( root, track_ID, &ts_list ) ) return BOXDUMPER_ERR( "Failed to get timestamps.\n" ); fprintf( stdout, "track_ID: %"PRIu32"\n", track_ID ); fprintf( stdout, "Media timescale: %"PRIu32"\n", media_param.timescale ); lsmash_media_ts_t *ts_array = ts_list.timestamp; if( !ts_array ) { fprintf( stdout, "\n" ); continue; } for( uint32_t i = 0; i < ts_list.sample_count; i++ ) fprintf( stdout, "DTS = %"PRIu64", CTS = %"PRIu64"\n", ts_array[i].dts, ts_array[i].cts + timeline_shift ); lsmash_free( ts_array ); fprintf( stdout, "\n" ); } } lsmash_destroy_root( root ); return 0; }
static int isom_set_brands ( lsmash_file_t *file, lsmash_brand_type major_brand, uint32_t minor_version, lsmash_brand_type *brands, uint32_t brand_count ) { if( brand_count > 50 ) return LSMASH_ERR_FUNCTION_PARAM; /* We support setting brands up to 50. */ if( major_brand == 0 && (!brands || brand_count == 0 || brands[0] == 0) ) { if( file->flags & LSMASH_FILE_MODE_INITIALIZATION ) { /* Absence of File Type Box means this file is a QuickTime or MP4 version 1 format file. */ isom_remove_box_by_itself( file->ftyp ); /* Anyway we use QTFF as a default file format. */ isom_clear_compat_flags( file ); file->qt_compatible = 1; } else { /* The absence of the Segment Type Box is allowed. * We set brands from the initialization segment after switching to this segment. */ for( lsmash_entry_t *entry = file->styp_list.head; entry; entry = entry->next ) isom_remove_box_by_itself( entry->data ); if( file->initializer ) { /* Copy flags for compatibility. */ memcpy( (int8_t *)file + COMPAT_FLAGS_OFFSET, file->initializer, sizeof(lsmash_file_t) - COMPAT_FLAGS_OFFSET ); file->isom_compatible = 1; file->allow_moof_base = 1; file->media_segment = 1; if( file->min_isom_version < 5 ) file->min_isom_version = 5; if( file->max_isom_version < 6 ) file->max_isom_version = 6; } } return 0; } else if( major_brand == 0 ) { major_brand = brands[0]; lsmash_log( NULL, LSMASH_LOG_WARNING, "major_brand is not specified. Use the first brand in the compatible brand list as major_brand.\n" ); } else if( !brands ) brand_count = 0; isom_ftyp_t *ftyp; if( file->flags & LSMASH_FILE_MODE_INITIALIZATION ) { /* Add File Type Box if absent yet. */ if( !file->ftyp && !isom_add_ftyp( file ) ) return LSMASH_ERR_NAMELESS; ftyp = file->ftyp; } else { /* Add Segment Type Box if absent yet. */ ftyp = file->styp_list.head && file->styp_list.head->data ? (isom_styp_t *)file->styp_list.head->data : isom_add_styp( file ); if( !ftyp ) return LSMASH_ERR_NAMELESS; } /* Allocate an array of compatible brands. * ISO/IEC 14496-12 doesn't forbid the absence of brands in the compatible brand list. * For a reason of safety, however, we set at least one brand in the list. */ size_t alloc_size = (brand_count ? brand_count : 1) * sizeof(uint32_t); lsmash_brand_type *compatible_brands; if( !file->compatible_brands ) compatible_brands = lsmash_malloc( alloc_size ); else compatible_brands = lsmash_realloc( file->compatible_brands, alloc_size ); if( !compatible_brands ) return LSMASH_ERR_MEMORY_ALLOC; /* Set compatible brands. */ if( brand_count ) for( uint32_t i = 0; i < brand_count; i++ ) compatible_brands[i] = brands[i]; else { /* At least one compatible brand. */ compatible_brands[0] = major_brand; brand_count = 1; } file->compatible_brands = compatible_brands; /* Duplicate an array of compatible brands. */ lsmash_free( ftyp->compatible_brands ); ftyp->compatible_brands = lsmash_memdup( compatible_brands, alloc_size ); if( !ftyp->compatible_brands ) { lsmash_freep( &file->compatible_brands ); return LSMASH_ERR_MEMORY_ALLOC; } ftyp->size = ISOM_BASEBOX_COMMON_SIZE + 8 + brand_count * 4; ftyp->major_brand = major_brand; ftyp->minor_version = minor_version; ftyp->brand_count = brand_count; file->brand_count = brand_count; return isom_check_compatibility( file ); }
static void remove_wave_importer( wave_importer_t *wave_imp ) { if( !wave_imp ) return; lsmash_free( wave_imp ); }
int lsmash_create_reference_chapter_track( lsmash_root_t *root, uint32_t track_ID, char *file_name ) { if( isom_check_initializer_present( root ) < 0 ) goto error_message; lsmash_file_t *file = root->file; if( !file || !file->moov || !file->moov->mvhd ) goto error_message; if( file->forbid_tref || (!file->qt_compatible && !file->itunes_movie) ) { lsmash_log( NULL, LSMASH_LOG_ERROR, "reference chapter is not available for this file.\n" ); goto error_message; } FILE *chapter = NULL; /* shut up 'uninitialized' warning */ /* Create a Track Reference Box. */ isom_trak_t *trak = isom_get_trak( file, track_ID ); if( !trak ) { lsmash_log( NULL, LSMASH_LOG_ERROR, "the specified track ID to apply the chapter doesn't exist.\n" ); goto error_message; } if( !trak->tref && !isom_add_tref( trak ) ) goto error_message; /* Create a track_ID for a new chapter track. */ uint32_t *id = (uint32_t *)lsmash_malloc( sizeof(uint32_t) ); if( !id ) goto error_message; uint32_t chapter_track_ID = *id = file->moov->mvhd->next_track_ID; /* Create a Track Reference Type Box. */ isom_tref_type_t *chap = isom_add_track_reference_type( trak->tref, QT_TREF_TYPE_CHAP ); if( !chap ) { lsmash_free( id ); goto error_message; } chap->ref_count = 1; chap->track_ID = id; /* Create a reference chapter track. */ if( chapter_track_ID != lsmash_create_track( root, ISOM_MEDIA_HANDLER_TYPE_TEXT_TRACK ) ) goto error_message; /* Set track parameters. */ lsmash_track_parameters_t track_param; lsmash_initialize_track_parameters( &track_param ); track_param.mode = ISOM_TRACK_IN_MOVIE | ISOM_TRACK_IN_PREVIEW; if( lsmash_set_track_parameters( root, chapter_track_ID, &track_param ) < 0 ) goto fail; /* Set media parameters. */ uint64_t media_timescale = lsmash_get_media_timescale( root, track_ID ); if( !media_timescale ) goto fail; lsmash_media_parameters_t media_param; lsmash_initialize_media_parameters( &media_param ); media_param.timescale = media_timescale; media_param.ISO_language = file->max_3gpp_version >= 6 || file->itunes_movie ? ISOM_LANGUAGE_CODE_UNDEFINED : 0; media_param.MAC_language = 0; if( lsmash_set_media_parameters( root, chapter_track_ID, &media_param ) < 0 ) goto fail; /* Create a sample description. */ lsmash_codec_type_t sample_type = file->max_3gpp_version >= 6 || file->itunes_movie ? ISOM_CODEC_TYPE_TX3G_TEXT : QT_CODEC_TYPE_TEXT_TEXT; lsmash_summary_t summary = { .sample_type = sample_type, .data_ref_index = 1 }; uint32_t sample_entry = lsmash_add_sample_entry( root, chapter_track_ID, &summary ); if( !sample_entry ) goto fail; /* Check each line format. */ fn_get_chapter_data fnc = isom_check_chap_line( file_name ); if( !fnc ) goto fail; /* Open chapter format file. */ chapter = lsmash_fopen( file_name, "rb" ); if( !chapter ) { lsmash_log( NULL, LSMASH_LOG_ERROR, "failed to open the chapter file \"%s\".\n", file_name ); goto fail; } /* Parse the file and write text samples. */ isom_chapter_entry_t data; while( !fnc( chapter, &data ) ) { /* set start_time */ data.start_time = data.start_time * 1e-9 * media_timescale + 0.5; /* write a text sample here */ int is_qt_text = lsmash_check_codec_type_identical( sample_type, QT_CODEC_TYPE_TEXT_TEXT ); uint16_t name_length = strlen( data.chapter_name ); lsmash_sample_t *sample = lsmash_create_sample( 2 + name_length + 12 * is_qt_text ); if( !sample ) { lsmash_free( data.chapter_name ); goto fail; } sample->data[0] = (name_length >> 8) & 0xff; sample->data[1] = name_length & 0xff; memcpy( sample->data + 2, data.chapter_name, name_length ); if( is_qt_text ) { /* QuickTime Player requires Text Encoding Attribute Box ('encd') if media language is ISO language codes : undefined. * Also this box can avoid garbling if the QuickTime text sample is encoded by Unicode characters. * Note: 3GPP Timed Text supports only UTF-8 or UTF-16, so this box isn't needed. */ static const uint8_t encd[12] = { 0x00, 0x00, 0x00, 0x0C, /* size: 12 */ 0x65, 0x6E, 0x63, 0x64, /* type: 'encd' */ 0x00, 0x00, 0x01, 0x00 /* Unicode Encoding */ }; memcpy( sample->data + 2 + name_length, encd, 12 ); } sample->dts = data.start_time; sample->cts = data.start_time; sample->prop.ra_flags = ISOM_SAMPLE_RANDOM_ACCESS_FLAG_SYNC; sample->index = sample_entry; if( lsmash_append_sample( root, chapter_track_ID, sample ) < 0 ) { lsmash_free( data.chapter_name ); goto fail; } lsmash_freep( &data.chapter_name ); } if( lsmash_flush_pooled_samples( root, chapter_track_ID, 0 ) < 0 ) goto fail; isom_trak_t *chapter_trak = isom_get_trak( file, chapter_track_ID ); if( !chapter_trak ) goto fail; fclose( chapter ); chapter_trak->is_chapter = 1; chapter_trak->related_track_ID = track_ID; return 0; fail: if( chapter ) fclose( chapter ); /* Remove chapter track reference. */ if( trak->tref->ref_list.tail ) isom_remove_box_by_itself( trak->tref->ref_list.tail->data ); if( trak->tref->ref_list.entry_count == 0 ) isom_remove_box_by_itself( trak->tref ); /* Remove the reference chapter track attached at tail of the list. */ if( file->moov->trak_list.tail ) isom_remove_box_by_itself( file->moov->trak_list.tail->data ); error_message: lsmash_log( NULL, LSMASH_LOG_ERROR, "failed to set reference chapter.\n" ); return LSMASH_ERR_NAMELESS; } uint32_t lsmash_count_tyrant_chapter( lsmash_root_t *root ) { if( isom_check_initializer_present( root ) < 0 && root->file->initializer->moov && root->file->initializer->moov->udta && root->file->initializer->moov->udta->chpl && root->file->initializer->moov->udta->chpl->list ) return root->file->initializer->moov->udta->chpl->list->entry_count; return 0; } char *lsmash_get_tyrant_chapter( lsmash_root_t *root, uint32_t index, double *timestamp ) { if( isom_check_initializer_present( root ) < 0 ) return NULL; lsmash_file_t *file = root->file->initializer; if( !file->moov || !file->moov->mvhd || !file->moov->udta || !file->moov->udta->chpl ) return NULL; isom_chpl_t *chpl = file->moov->udta->chpl; isom_chpl_entry_t *data = (isom_chpl_entry_t *)lsmash_get_entry_data( chpl->list, index ); if( !data ) return NULL; double timescale = chpl->version ? 10000000.0 : file->moov->mvhd->timescale; *timestamp = data->start_time / timescale; if( !memcmp( data->chapter_name, UTF8_BOM, UTF8_BOM_LENGTH ) ) return data->chapter_name + UTF8_BOM_LENGTH; return data->chapter_name; } int lsmash_print_chapter_list( lsmash_root_t *root ) { if( isom_check_initializer_present( root ) < 0 || !(root->file->initializer->flags & LSMASH_FILE_MODE_READ) ) return LSMASH_ERR_FUNCTION_PARAM; lsmash_file_t *file = root->file->initializer; if( file->moov && file->moov->udta && file->moov->udta->chpl ) { isom_chpl_t *chpl = file->moov->udta->chpl; uint32_t timescale; if( !chpl->version ) { if( !file->moov && !file->moov->mvhd ) return LSMASH_ERR_NAMELESS; timescale = file->moov->mvhd->timescale; } else timescale = 10000000; uint32_t i = 1; for( lsmash_entry_t *entry = chpl->list->head; entry; entry = entry->next ) { isom_chpl_entry_t *data = (isom_chpl_entry_t *)entry->data; int64_t start_time = data->start_time / timescale; int hh = start_time / 3600; int mm = (start_time / 60) % 60; int ss = start_time % 60; int ms = ((data->start_time / (double)timescale) - hh * 3600 - mm * 60 - ss) * 1e3 + 0.5; if( !memcmp( data->chapter_name, UTF8_BOM, UTF8_BOM_LENGTH ) ) /* detect BOM */ { data->chapter_name += UTF8_BOM_LENGTH; #ifdef _WIN32 if( i == 1 ) printf( UTF8_BOM ); /* add BOM on Windows */ #endif } printf( "CHAPTER%02"PRIu32"=%02d:%02d:%02d.%03d\n", i, hh, mm, ss, ms ); printf( "CHAPTER%02"PRIu32"NAME=%s\n", i++, data->chapter_name ); } return 0; } lsmash_log( NULL, LSMASH_LOG_ERROR, "this file doesn't have a chapter list.\n" ); return LSMASH_ERR_NAMELESS; }
int lsmash_set_tyrant_chapter( lsmash_root_t *root, char *file_name, int add_bom ) { if( isom_check_initializer_present( root ) < 0 ) goto error_message; /* This function should be called after updating of the latest movie duration. */ lsmash_file_t *file = root->file; if( !file || !file->moov || !file->moov->mvhd || file->moov->mvhd->timescale == 0 || file->moov->mvhd->duration == 0 ) goto error_message; /* check each line format */ fn_get_chapter_data fnc = isom_check_chap_line( file_name ); if( !fnc ) goto error_message; FILE *chapter = lsmash_fopen( file_name, "rb" ); if( !chapter ) { lsmash_log( NULL, LSMASH_LOG_ERROR, "failed to open the chapter file \"%s\".\n", file_name ); goto error_message; } if( (!file->moov->udta && !isom_add_udta( file->moov )) || (!file->moov->udta->chpl && !isom_add_chpl( file->moov->udta )) ) goto fail; file->moov->udta->chpl->version = 1; /* version = 1 is popular. */ isom_chapter_entry_t data = { 0 }; while( !fnc( chapter, &data ) ) { if( add_bom ) { char *chapter_name_with_bom = (char *)lsmash_malloc( strlen( data.chapter_name ) + 1 + UTF8_BOM_LENGTH ); if( !chapter_name_with_bom ) goto fail2; sprintf( chapter_name_with_bom, "%s%s", UTF8_BOM, data.chapter_name ); lsmash_free( data.chapter_name ); data.chapter_name = chapter_name_with_bom; } data.start_time = (data.start_time + 50) / 100; /* convert to 100ns unit */ if( data.start_time / 1e7 > (double)file->moov->mvhd->duration / file->moov->mvhd->timescale ) { lsmash_log( NULL, LSMASH_LOG_WARNING, "a chapter point exceeding the actual duration detected." "This chapter point and the following ones (if any) will be cut off.\n" ); lsmash_free( data.chapter_name ); break; } if( isom_add_chpl_entry( file->moov->udta->chpl, &data ) < 0 ) goto fail2; lsmash_freep( &data.chapter_name ); } fclose( chapter ); return 0; fail2: lsmash_free( data.chapter_name ); fail: fclose( chapter ); error_message: lsmash_log( NULL, LSMASH_LOG_ERROR, "failed to set chapter list.\n" ); return LSMASH_ERR_NAMELESS; }