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;
}
