int vc1_setup_parser( vc1_info_t *info, int parse_only, uint32_t (*update)( vc1_info_t *, void *, uint32_t ) ) { if( !info ) return -1; memset( info, 0, sizeof(vc1_info_t) ); vc1_stream_buffer_t *buffer = &info->buffer; buffer->bank = lsmash_create_multiple_buffers( parse_only ? 2 : 4, VC1_DEFAULT_BUFFER_SIZE ); if( !buffer->bank ) return -1; buffer->start = lsmash_withdraw_buffer( buffer->bank, 1 ); buffer->rbdu = lsmash_withdraw_buffer( buffer->bank, 2 ); buffer->pos = buffer->start; buffer->end = buffer->start; buffer->update = update; if( !parse_only ) { info->access_unit.data = lsmash_withdraw_buffer( buffer->bank, 3 ); info->access_unit.incomplete_data = lsmash_withdraw_buffer( buffer->bank, 4 ); } info->bits = lsmash_bits_adhoc_create(); if( !info->bits ) { lsmash_destroy_multiple_buffers( info->buffer.bank ); info->buffer.bank = NULL; return -1; } 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; }
int vc1_setup_parser ( vc1_info_t *info, lsmash_stream_buffers_t *sb, int parse_only, lsmash_stream_buffers_type type, void *stream ) { assert( sb ); if( !info ) return -1; memset( info, 0, sizeof(vc1_info_t) ); vc1_stream_buffer_t *hb = &info->buffer; hb->sb = sb; lsmash_stream_buffers_setup( sb, type, stream ); sb->bank = lsmash_create_multiple_buffers( parse_only ? 2 : 4, VC1_DEFAULT_BUFFER_SIZE ); if( !sb->bank ) return -1; sb->start = lsmash_withdraw_buffer( sb->bank, 1 ); hb->rbdu = lsmash_withdraw_buffer( sb->bank, 2 ); sb->pos = sb->start; sb->end = sb->start; if( !parse_only ) { info->access_unit.data = lsmash_withdraw_buffer( sb->bank, 3 ); info->access_unit.incomplete_data = lsmash_withdraw_buffer( sb->bank, 4 ); } info->bits = lsmash_bits_adhoc_create(); if( !info->bits ) { lsmash_stream_buffers_cleanup( sb ); return -1; } return 0; }
static int dts_importer_get_next_accessunit_internal( importer_t *importer ) { int au_completed = 0; dts_importer_t *dts_imp = (dts_importer_t *)importer->info; dts_info_t *info = &dts_imp->info; lsmash_bs_t *bs = info->bits->bs; while( !au_completed ) { /* Read data from the stream if needed. */ dts_imp->next_frame_pos += info->frame_size; lsmash_bs_read_seek( bs, dts_imp->next_frame_pos, SEEK_SET ); uint64_t remain_size = lsmash_bs_get_remaining_buffer_size( bs ); if( remain_size < DTS_MAX_EXSS_SIZE ) { int err = lsmash_bs_read( bs, bs->buffer.max_size ); if( err < 0 ) { lsmash_log( importer, LSMASH_LOG_ERROR, "failed to read data from the stream.\n" ); return err; } remain_size = lsmash_bs_get_remaining_buffer_size( bs ); } memcpy( dts_imp->buffer, lsmash_bs_get_buffer_data( bs ), LSMASH_MIN( remain_size, DTS_MAX_EXSS_SIZE ) ); /* Check the remainder length of the buffer. * If there is enough length, then parse the frame in it. * The length 10 is the required byte length to get frame size. */ if( bs->eob || (bs->eof && remain_size < 10) ) { /* Reached the end of stream. */ importer->status = IMPORTER_EOF; au_completed = !!dts_imp->incomplete_au_length; if( !au_completed ) { /* No more access units in the stream. */ if( lsmash_bs_get_remaining_buffer_size( bs ) ) { lsmash_log( importer, LSMASH_LOG_WARNING, "the stream is truncated at the end.\n" ); return LSMASH_ERR_INVALID_DATA; } return 0; } if( !info->ddts_param_initialized ) dts_update_specific_param( info ); } else { /* Parse substream frame. */ dts_substream_type prev_substream_type = info->substream_type; info->substream_type = dts_get_substream_type( info ); int err; int (*dts_parse_frame)( dts_info_t * ) = NULL; switch( info->substream_type ) { /* Decide substream frame parser and check if this frame and the previous frame belong to the same AU. */ case DTS_SUBSTREAM_TYPE_CORE : if( prev_substream_type != DTS_SUBSTREAM_TYPE_NONE ) au_completed = 1; dts_parse_frame = dts_parse_core_substream; break; case DTS_SUBSTREAM_TYPE_EXTENSION : { uint8_t prev_exss_index = info->exss_index; if( (err = dts_get_exss_index( info, &info->exss_index )) < 0 ) { lsmash_log( importer, LSMASH_LOG_ERROR, "failed to get the index of an extension substream.\n" ); return err; } if( prev_substream_type == DTS_SUBSTREAM_TYPE_EXTENSION && info->exss_index <= prev_exss_index ) au_completed = 1; dts_parse_frame = dts_parse_extension_substream; break; } default : lsmash_log( importer, LSMASH_LOG_ERROR, "unknown substream type is detected.\n" ); return LSMASH_ERR_NAMELESS; } if( !info->ddts_param_initialized && au_completed ) dts_update_specific_param( info ); info->frame_size = 0; if( (err = dts_parse_frame( info )) < 0 ) { lsmash_log( importer, LSMASH_LOG_ERROR, "failed to parse a frame.\n" ); return err; } } if( au_completed ) { memcpy( dts_imp->au, dts_imp->incomplete_au, dts_imp->incomplete_au_length ); dts_imp->au_length = dts_imp->incomplete_au_length; dts_imp->incomplete_au_length = 0; info->exss_count = (info->substream_type == DTS_SUBSTREAM_TYPE_EXTENSION); if( importer->status == IMPORTER_EOF ) break; } /* Increase buffer size to store AU if short. */ if( dts_imp->incomplete_au_length + info->frame_size > dts_imp->au_buffers->buffer_size ) { lsmash_multiple_buffers_t *temp = lsmash_resize_multiple_buffers( dts_imp->au_buffers, dts_imp->au_buffers->buffer_size + DTS_MAX_EXSS_SIZE ); if( !temp ) return LSMASH_ERR_MEMORY_ALLOC; dts_imp->au_buffers = temp; dts_imp->au = lsmash_withdraw_buffer( dts_imp->au_buffers, 1 ); dts_imp->incomplete_au = lsmash_withdraw_buffer( dts_imp->au_buffers, 2 ); } /* Append frame data. */ memcpy( dts_imp->incomplete_au + dts_imp->incomplete_au_length, dts_imp->buffer, info->frame_size ); dts_imp->incomplete_au_length += info->frame_size; } return bs->error ? LSMASH_ERR_NAMELESS : 0; }