static text_style_t* DuplicateAndPushStyle(style_stack_t** pp_stack)
{
text_style_t* p_dup = ( *pp_stack ) ? text_style_Duplicate( (*pp_stack)->p_style ) : text_style_Create( STYLE_NO_DEFAULTS );
if ( unlikely( !p_dup ) )
return NULL;
style_stack_t* p_entry = malloc( sizeof( *p_entry ) );
if ( unlikely( !p_entry ) )
{
free( p_dup );
return NULL;
}
// Give the style ownership to the segment.
p_entry->p_style = p_dup;
p_entry->p_next = *pp_stack;
*pp_stack = p_entry;
return p_dup;
}
static bool SegmentSplit( tx3g_segment_t *p_prev, tx3g_segment_t **pp_segment,
const uint16_t i_start, const uint16_t i_end,
const text_style_t *p_styles )
{
tx3g_segment_t *p_segment_left = NULL, *p_segment_middle = NULL, *p_segment_right = NULL;
if ( (*pp_segment)->i_size == 0 ) return false;
if ( i_start > i_end ) return false;
if ( (size_t)(i_end - i_start) > (*pp_segment)->i_size - 1 ) return false;
if ( i_end > (*pp_segment)->i_size - 1 ) return false;
SegmentDoSplit( *pp_segment, i_start, i_end, &p_segment_left, &p_segment_middle, &p_segment_right );
if ( !p_segment_middle )
{
/* Failed */
text_segment_Delete( p_segment_left->s );
free( p_segment_left );
text_segment_Delete( p_segment_right->s );
free( p_segment_right );
return false;
}
tx3g_segment_t *p_next3g = (*pp_segment)->p_next3g;
text_segment_Delete( (*pp_segment)->s );
free( *pp_segment );
*pp_segment = ( p_segment_left ) ? p_segment_left : p_segment_middle ;
if ( p_prev ) p_prev->p_next3g = *pp_segment;
if ( p_segment_right )
p_segment_right->p_next3g = p_next3g;
else
p_segment_middle->p_next3g = p_next3g;
text_style_Delete( p_segment_middle->s->style );
p_segment_middle->s->style = text_style_Duplicate( p_styles );
return true;
}
text_segment_t *text_segment_Copy( text_segment_t *p_src )
{
text_segment_t *p_dst = NULL, *p_dst0 = NULL;
while( p_src ) {
text_segment_t *p_new = text_segment_New( p_src->psz_text );
if( p_new )
p_new->style = text_style_Duplicate( p_src->style );
if( p_dst == NULL )
{
p_dst = p_dst0 = p_new;
}
else
{
p_dst->p_next = p_new;
p_dst = p_dst->p_next;
}
p_src = p_src->p_next;
}
return p_dst0;
}
/****************************************************************************
* Filter: the whole thing
****************************************************************************
* This function outputs subpictures at regular time intervals.
****************************************************************************/
static subpicture_t *Filter( filter_t *p_filter, mtime_t date )
{
filter_sys_t *p_sys = p_filter->p_sys;
subpicture_t *p_spu = NULL;
video_format_t fmt;
vlc_mutex_lock( &p_sys->lock );
if( p_sys->last_time + p_sys->i_refresh > date )
goto out;
if( p_sys->b_need_update == false )
goto out;
p_spu = filter_NewSubpicture( p_filter );
if( !p_spu )
goto out;
memset( &fmt, 0, sizeof(video_format_t) );
fmt.i_chroma = VLC_CODEC_TEXT;
fmt.i_aspect = 0;
fmt.i_width = fmt.i_height = 0;
fmt.i_x_offset = 0;
fmt.i_y_offset = 0;
p_spu->p_region = subpicture_region_New( &fmt );
if( !p_spu->p_region )
{
p_filter->pf_sub_buffer_del( p_filter, p_spu );
p_spu = NULL;
goto out;
}
p_sys->last_time = date;
if( !strchr( p_sys->psz_marquee, '%' )
&& !strchr( p_sys->psz_marquee, '$' ) )
p_sys->b_need_update = false;
p_spu->p_region->psz_text = str_format( p_filter, p_sys->psz_marquee );
p_spu->i_start = date;
p_spu->i_stop = p_sys->i_timeout == 0 ? 0 : date + p_sys->i_timeout * 1000;
p_spu->b_ephemer = true;
/* where to locate the string: */
if( p_sys->i_pos < 0 )
{ /* set to an absolute xy */
p_spu->p_region->i_align = OSD_ALIGN_LEFT | OSD_ALIGN_TOP;
p_spu->b_absolute = true;
}
else
{ /* set to one of the 9 relative locations */
p_spu->p_region->i_align = p_sys->i_pos;
p_spu->b_absolute = false;
}
p_spu->p_region->i_x = p_sys->i_xoff;
p_spu->p_region->i_y = p_sys->i_yoff;
p_spu->p_region->p_style = text_style_Duplicate( p_sys->p_style );
out:
vlc_mutex_unlock( &p_sys->lock );
return p_spu;
}
/****************************************************************************
* Filter: the whole thing
****************************************************************************
* This function outputs subpictures at regular time intervals.
****************************************************************************/
static subpicture_t *Filter( filter_t *p_filter, mtime_t date )
{
filter_sys_t *p_sys = p_filter->p_sys;
subpicture_t *p_spu;
video_format_t fmt;
subpicture_region_t *p_region;
int i_feed, i_item;
rss_feed_t *p_feed;
memset( &fmt, 0, sizeof(video_format_t) );
vlc_mutex_lock( &p_sys->lock );
/* Check if the feeds have been fetched and that we have some feeds */
/* TODO: check that we have items for each feeds */
if( !p_sys->b_fetched && p_sys->i_feeds > 0 )
{
vlc_mutex_unlock( &p_sys->lock );
return NULL;
}
if( p_sys->last_date
+ ( p_sys->i_cur_char == 0 && p_sys->i_cur_item == ( p_sys->i_title == scroll_title ? -1 : 0 ) ? 5 : 1 )
/* ( ... ? 5 : 1 ) means "wait 5 times more for the 1st char" */
* p_sys->i_speed > date )
{
vlc_mutex_unlock( &p_sys->lock );
return NULL;
}
p_sys->last_date = date;
p_sys->i_cur_char++;
if( p_sys->i_cur_item == -1 ? p_sys->p_feeds[p_sys->i_cur_feed].psz_title[p_sys->i_cur_char] == 0 : p_sys->p_feeds[p_sys->i_cur_feed].p_items[p_sys->i_cur_item].psz_title[p_sys->i_cur_char] == 0 )
{
p_sys->i_cur_char = 0;
p_sys->i_cur_item++;
if( p_sys->i_cur_item >= p_sys->p_feeds[p_sys->i_cur_feed].i_items )
{
if( p_sys->i_title == scroll_title )
p_sys->i_cur_item = -1;
else
p_sys->i_cur_item = 0;
p_sys->i_cur_feed = (p_sys->i_cur_feed + 1)%p_sys->i_feeds;
}
}
p_spu = filter_NewSubpicture( p_filter );
if( !p_spu )
{
vlc_mutex_unlock( &p_sys->lock );
return NULL;
}
fmt.i_chroma = VLC_CODEC_TEXT;
p_spu->p_region = subpicture_region_New( &fmt );
if( !p_spu->p_region )
{
p_filter->pf_sub_buffer_del( p_filter, p_spu );
vlc_mutex_unlock( &p_sys->lock );
return NULL;
}
/* Generate the string that will be displayed. This string is supposed to
be p_sys->i_length characters long. */
i_item = p_sys->i_cur_item;
i_feed = p_sys->i_cur_feed;
p_feed = &p_sys->p_feeds[i_feed];
if( ( p_feed->p_pic && p_sys->i_title == default_title )
|| p_sys->i_title == hide_title )
{
/* Don't display the feed's title if we have an image */
_snprintf( p_sys->psz_marquee, p_sys->i_length, "%s",
p_sys->p_feeds[i_feed].p_items[i_item].psz_title
+p_sys->i_cur_char ); // sunqueen modify
}
else if( ( !p_feed->p_pic && p_sys->i_title == default_title )
|| p_sys->i_title == prepend_title )
{
_snprintf( p_sys->psz_marquee, p_sys->i_length, "%s : %s",
p_sys->p_feeds[i_feed].psz_title,
p_sys->p_feeds[i_feed].p_items[i_item].psz_title
+p_sys->i_cur_char ); // sunqueen modify
}
else /* scrolling title */
{
if( i_item == -1 )
_snprintf( p_sys->psz_marquee, p_sys->i_length, "%s : %s",
p_sys->p_feeds[i_feed].psz_title + p_sys->i_cur_char,
p_sys->p_feeds[i_feed].p_items[i_item+1].psz_title ); // sunqueen modify
else
_snprintf( p_sys->psz_marquee, p_sys->i_length, "%s",
p_sys->p_feeds[i_feed].p_items[i_item].psz_title
+p_sys->i_cur_char ); // sunqueen modify
}
while( strlen( p_sys->psz_marquee ) < (unsigned int)p_sys->i_length )
{
i_item++;
if( i_item == p_sys->p_feeds[i_feed].i_items ) break;
_snprintf( strchr( p_sys->psz_marquee, 0 ),
p_sys->i_length - strlen( p_sys->psz_marquee ),
" - %s",
p_sys->p_feeds[i_feed].p_items[i_item].psz_title ); // sunqueen modify
}
/* Calls to snprintf might split multibyte UTF8 chars ...
* which freetype doesn't like. */
{
char *a = strdup( p_sys->psz_marquee );
char *a2 = a;
char *b = p_sys->psz_marquee;
EnsureUTF8( p_sys->psz_marquee );
/* we want to use ' ' instead of '?' for erroneous chars */
while( *b != '\0' )
{
if( *b != *a ) *b = ' ';
b++;a++;
}
free( a2 );
}
p_spu->p_region->psz_text = strdup(p_sys->psz_marquee);
if( p_sys->p_style->i_font_size > 0 )
p_spu->p_region->fmt.i_visible_height = p_sys->p_style->i_font_size;
p_spu->i_start = date;
p_spu->i_stop = 0;
p_spu->b_ephemer = true;
/* where to locate the string: */
if( p_sys->i_pos < 0 )
{ /* set to an absolute xy */
p_spu->p_region->i_align = SUBPICTURE_ALIGN_LEFT | SUBPICTURE_ALIGN_TOP;
p_spu->b_absolute = true;
}
else
{ /* set to one of the 9 relative locations */
p_spu->p_region->i_align = p_sys->i_pos;
p_spu->b_absolute = false;
}
p_spu->p_region->i_x = p_sys->i_xoff;
p_spu->p_region->i_y = p_sys->i_yoff;
p_spu->p_region->p_style = text_style_Duplicate( p_sys->p_style );
if( p_feed->p_pic )
{
/* Display the feed's image */
picture_t *p_pic = p_feed->p_pic;
video_format_t fmt_out;
memset( &fmt_out, 0, sizeof(video_format_t) );
fmt_out.i_chroma = VLC_CODEC_YUVA;
fmt_out.i_sar_num = fmt_out.i_sar_den = 1;
fmt_out.i_width =
fmt_out.i_visible_width = p_pic->p[Y_PLANE].i_visible_pitch;
fmt_out.i_height =
fmt_out.i_visible_height = p_pic->p[Y_PLANE].i_visible_lines;
p_region = subpicture_region_New( &fmt_out );
if( !p_region )
{
msg_Err( p_filter, "cannot allocate SPU region" );
}
else
{
p_region->i_x = p_spu->p_region->i_x;
p_region->i_y = p_spu->p_region->i_y;
/* FIXME the copy is probably not needed anymore */
picture_Copy( p_region->p_picture, p_pic );
p_spu->p_region->p_next = p_region;
/* Offset text to display right next to the image */
p_spu->p_region->i_x += fmt_out.i_visible_width;
}
}
vlc_mutex_unlock( &p_sys->lock );
return p_spu;
}
/*****************************************************************************
* Render: displays previously rendered output
*****************************************************************************
* This function send the currently rendered image to adjust modified image,
* waits until it is displayed and switch the two rendering buffers, preparing
* next frame.
*****************************************************************************/
static subpicture_t *Filter( filter_t *p_filter, mtime_t date )
{
filter_sys_t *p_sys = p_filter->p_sys;
/* We might need to open these at any time. */
vlc_mutex_lock( &p_sys->lock );
if( p_sys->i_inputfd == -1 )
{
p_sys->i_inputfd = vlc_open( p_sys->psz_inputfile, O_RDONLY | O_NONBLOCK );
if( p_sys->i_inputfd == -1 )
{
msg_Warn( p_filter, "Failed to grab input file: %s (%m)",
p_sys->psz_inputfile );
}
else
{
msg_Info( p_filter, "Grabbed input file: %s",
p_sys->psz_inputfile );
}
}
if( p_sys->i_outputfd == -1 )
{
p_sys->i_outputfd = vlc_open( p_sys->psz_outputfile,
O_WRONLY | O_NONBLOCK );
if( p_sys->i_outputfd == -1 )
{
if( errno != ENXIO )
{
msg_Warn( p_filter, "Failed to grab output file: %s (%m)",
p_sys->psz_outputfile );
}
}
else
{
msg_Info( p_filter, "Grabbed output file: %s",
p_sys->psz_outputfile );
}
}
vlc_mutex_unlock( &p_sys->lock );
/* Read any waiting commands */
if( p_sys->i_inputfd != -1 )
{
char p_buffer[1024];
ssize_t i_len = read( p_sys->i_inputfd, p_buffer, 1024 );
if( i_len == -1 )
{
/* We hit an error */
if( errno != EAGAIN )
{
msg_Warn( p_filter, "Error on input file: %m" );
close( p_sys->i_inputfd );
p_sys->i_inputfd = -1;
}
}
else if( i_len == 0 )
{
/* We hit the end-of-file */
}
else
{
BufferAdd( &p_sys->input, p_buffer, i_len );
}
}
/* Parse any complete commands */
char *p_end, *p_cmd;
while( ( p_end = memchr( p_sys->input.p_begin, '\n',
p_sys->input.i_length ) ) )
{
commanddesc_t *p_cur = NULL;
bool b_found = false;
size_t i_index = 0;
*p_end = '\0';
p_cmd = BufferGetToken( &p_sys->input );
msg_Info( p_filter, "Search command: %s", p_cmd );
for( i_index = 0; i_index < p_sys->i_commands; i_index++ )
{
p_cur = p_sys->pp_commands[i_index];
if( !strncmp( p_cur->psz_command, p_cmd, strlen(p_cur->psz_command) ) )
{
p_cmd[strlen(p_cur->psz_command)] = '\0';
b_found = true;
break;
}
}
if( !b_found )
{
/* No matching command */
msg_Err( p_filter, "Got invalid command: %s", p_cmd );
BufferPrintf( &p_sys->output, "FAILURE: %d Invalid Command\n", VLC_EGENERIC );
}
else
{
msg_Info( p_filter, "Got valid command: %s", p_cmd );
command_t *p_cmddesc = malloc( sizeof( command_t ) );
if( !p_cmddesc )
return NULL;
p_cmd = p_cmd + strlen(p_cur->psz_command) +1;
p_cmddesc->p_command = p_cur;
p_cmddesc->p_command->pf_parser( p_cmd, p_end,
&p_cmddesc->params );
if( p_cmddesc->p_command->b_atomic && p_sys->b_atomic )
QueueEnqueue( &p_sys->atomic, p_cmddesc );
else
QueueEnqueue( &p_sys->pending, p_cmddesc );
}
BufferDel( &p_sys->input, p_end - p_sys->input.p_begin + 1 );
}
/* Process any pending commands */
command_t *p_command = NULL;
while( (p_command = QueueDequeue( &p_sys->pending )) )
{
p_command->i_status =
p_command->p_command->pf_execute( p_filter, &p_command->params,
&p_command->results );
QueueEnqueue( &p_sys->processed, p_command );
}
/* Output any processed commands */
while( (p_command = QueueDequeue( &p_sys->processed )) )
{
if( p_command->i_status == VLC_SUCCESS )
{
const char *psz_success = "SUCCESS:";
const char *psz_nl = "\n";
BufferAdd( &p_sys->output, psz_success, 8 );
p_command->p_command->pf_unparse( &p_command->results,
&p_sys->output );
BufferAdd( &p_sys->output, psz_nl, 1 );
}
else
{
BufferPrintf( &p_sys->output, "FAILURE: %d\n",
p_command->i_status );
}
}
/* Try emptying the output buffer */
if( p_sys->i_outputfd != -1 )
{
ssize_t i_len = write( p_sys->i_outputfd, p_sys->output.p_begin,
p_sys->output.i_length );
if( i_len == -1 )
{
/* We hit an error */
if( errno != EAGAIN )
{
msg_Warn( p_filter, "Error on output file: %m" );
close( p_sys->i_outputfd );
p_sys->i_outputfd = -1;
}
}
else
{
BufferDel( &p_sys->output, i_len );
}
}
if( !p_sys->b_updated )
return NULL;
subpicture_t *p_spu = NULL;
overlay_t *p_overlay = NULL;
p_spu = p_filter->pf_sub_buffer_new( p_filter );
if( !p_spu )
{
msg_Err( p_filter, "cannot allocate subpicture" );
return NULL;
}
p_spu->b_absolute = true;
p_spu->i_start = date;
p_spu->i_stop = 0;
p_spu->b_ephemer = true;
subpicture_region_t **pp_region = &p_spu->p_region;
while( (p_overlay = ListWalk( &p_sys->overlays )) )
{
subpicture_region_t *p_region;
*pp_region = p_region = subpicture_region_New( &p_overlay->format );
if( !p_region )
break;
msg_Dbg( p_filter, "Displaying overlay: %4.4s, %d, %d, %d",
(char*)&p_overlay->format.i_chroma, p_overlay->i_x, p_overlay->i_y,
p_overlay->i_alpha );
if( p_overlay->format.i_chroma == VLC_CODEC_TEXT )
{
p_region->psz_text = strdup( p_overlay->data.p_text );
p_region->p_style = text_style_Duplicate( p_overlay->p_fontstyle );
}
else
{
/* FIXME the copy is probably not needed anymore */
picture_Copy( p_region->p_picture, p_overlay->data.p_pic );
}
p_region->i_x = p_overlay->i_x;
p_region->i_y = p_overlay->i_y;
p_region->i_align = SUBPICTURE_ALIGN_LEFT | SUBPICTURE_ALIGN_TOP;
p_region->i_alpha = p_overlay->i_alpha;
pp_region = &p_region->p_next;
}
p_sys->b_updated = false;
return p_spu;
}
static subpicture_region_t *CreateTextRegion( decoder_t *p_dec,
char *psz_subtitle,
int i_len,
int i_sys_align )
{
decoder_sys_t *p_sys = p_dec->p_sys;
subpicture_region_t *p_text_region;
video_format_t fmt;
/* Create a new subpicture region */
memset( &fmt, 0, sizeof(video_format_t) );
fmt.i_chroma = VLC_CODEC_TEXT;
fmt.i_width = fmt.i_height = 0;
fmt.i_x_offset = fmt.i_y_offset = 0;
p_text_region = subpicture_region_New( &fmt );
if( p_text_region != NULL )
{
ssa_style_t *p_ssa_style = NULL;
p_text_region->psz_text = NULL;
p_text_region->psz_html = strndup( psz_subtitle, i_len );
if( ! p_text_region->psz_html )
{
subpicture_region_Delete( p_text_region );
return NULL;
}
p_ssa_style = ParseStyle( p_sys, p_text_region->psz_html );
if( !p_ssa_style )
{
int i;
for( i = 0; i < p_sys->i_ssa_styles; i++ )
{
if( !strcasecmp( p_sys->pp_ssa_styles[i]->psz_stylename, "Default" ) )
p_ssa_style = p_sys->pp_ssa_styles[i];
}
}
if( p_ssa_style )
{
msg_Dbg( p_dec, "style is: %s", p_ssa_style->psz_stylename );
p_text_region->p_style = text_style_Duplicate( &p_ssa_style->font_style );
p_text_region->i_align = p_ssa_style->i_align;
/* TODO: Setup % based offsets properly, without adversely affecting
* everything else in vlc. Will address with separate patch,
* to prevent this one being any more complicated.
* p_ssa_style->i_margin_percent_h;
* p_ssa_style->i_margin_percent_v;
*/
p_text_region->i_x = p_ssa_style->i_margin_h;
p_text_region->i_y = p_ssa_style->i_margin_v;
}
else
{
p_text_region->i_align = SUBPICTURE_ALIGN_BOTTOM | i_sys_align;
p_text_region->i_x = i_sys_align ? 20 : 0;
p_text_region->i_y = 10;
}
/* Look for position arguments which may override the style-based
* defaults.
*/
SetupPositions( p_text_region, psz_subtitle );
p_text_region->p_next = NULL;
}
return p_text_region;
}
/****************************************************************************
* Filter: the whole thing
****************************************************************************
* This function outputs subpictures at regular time intervals.
****************************************************************************/
static subpicture_t *Filter( filter_t *p_filter, mtime_t date )
{
filter_sys_t *p_sys = p_filter->p_sys;
subpicture_t *p_spu = NULL;
video_format_t fmt;
vlc_mutex_lock( &p_sys->lock );
if( p_sys->last_time + p_sys->i_refresh > date )
goto out;
if( p_sys->filepath != NULL )
{
char *fmt = MarqueeReadFile( p_filter, p_sys->filepath );
if( fmt != NULL )
{
free( p_sys->format );
p_sys->format = fmt;
}
}
char *msg = str_format_time( p_sys->format ? p_sys->format : "" );
if( unlikely( msg == NULL ) )
goto out;
if( p_sys->message != NULL && !strcmp( msg, p_sys->message ) )
{
free( msg );
goto out;
}
free( p_sys->message );
p_sys->message = msg;
p_spu = filter_NewSubpicture( p_filter );
if( !p_spu )
goto out;
memset( &fmt, 0, sizeof(video_format_t) );
fmt.i_chroma = VLC_CODEC_TEXT;
fmt.i_width = fmt.i_height = 0;
fmt.i_x_offset = 0;
fmt.i_y_offset = 0;
p_spu->p_region = subpicture_region_New( &fmt );
if( !p_spu->p_region )
{
p_filter->pf_sub_buffer_del( p_filter, p_spu );
p_spu = NULL;
goto out;
}
p_sys->last_time = date;
p_spu->p_region->psz_text = strdup( msg );
p_spu->i_start = date;
p_spu->i_stop = p_sys->i_timeout == 0 ? 0 : date + p_sys->i_timeout * 1000;
p_spu->b_ephemer = true;
/* where to locate the string: */
if( p_sys->i_pos < 0 )
{ /* set to an absolute xy */
p_spu->p_region->i_align = SUBPICTURE_ALIGN_LEFT | SUBPICTURE_ALIGN_TOP;
p_spu->b_absolute = true;
}
else
{ /* set to one of the 9 relative locations */
p_spu->p_region->i_align = p_sys->i_pos;
p_spu->b_absolute = false;
}
p_spu->p_region->i_x = p_sys->i_xoff;
p_spu->p_region->i_y = p_sys->i_yoff;
p_spu->p_region->p_style = text_style_Duplicate( p_sys->p_style );
out:
vlc_mutex_unlock( &p_sys->lock );
return p_spu;
}
static text_style_t* CurrentStyle( style_stack_t* p_stack )
{
if ( p_stack == NULL )
return text_style_Create( STYLE_NO_DEFAULTS );
return text_style_Duplicate( p_stack->p_style->font_style );
}
/*****************************************************************************
* Decode:
*****************************************************************************/
static int Decode( decoder_t *p_dec, block_t *p_block )
{
subpicture_t *p_spu = NULL;
if( p_block == NULL ) /* No Drain */
return VLCDEC_SUCCESS;
if( ( p_block->i_flags & (BLOCK_FLAG_CORRUPTED) ) ||
p_block->i_buffer < sizeof(uint16_t) )
{
block_Release( p_block );
return VLCDEC_SUCCESS;
}
uint8_t *p_buf = p_block->p_buffer;
/* Read our raw string and create the styled segment for HTML */
uint16_t i_psz_bytelength = GetWBE( p_buf );
const uint8_t *p_pszstart = p_block->p_buffer + sizeof(uint16_t);
char *psz_subtitle;
if ( i_psz_bytelength > 2 &&
( !memcmp( p_pszstart, "\xFE\xFF", 2 ) || !memcmp( p_pszstart, "\xFF\xFE", 2 ) )
)
{
psz_subtitle = FromCharset( "UTF-16", p_pszstart, i_psz_bytelength );
if ( !psz_subtitle )
return VLCDEC_SUCCESS;
}
else
{
psz_subtitle = malloc( i_psz_bytelength + 1 );
if ( !psz_subtitle )
return VLCDEC_SUCCESS;
memcpy( psz_subtitle, p_pszstart, i_psz_bytelength );
psz_subtitle[ i_psz_bytelength ] = '\0';
}
p_buf += i_psz_bytelength + sizeof(uint16_t);
for( uint16_t i=0; i < i_psz_bytelength; i++ )
if ( psz_subtitle[i] == '\r' ) psz_subtitle[i] = '\n';
tx3g_segment_t *p_segment3g = tx3g_segment_New( psz_subtitle );
p_segment3g->i_size = str8len( psz_subtitle );
if ( p_dec->fmt_in.subs.p_style )
p_segment3g->s->style = text_style_Duplicate( p_dec->fmt_in.subs.p_style );
free( psz_subtitle );
if ( !p_segment3g->s->psz_text )
{
text_segment_Delete( p_segment3g->s );
free( p_segment3g );
return VLCDEC_SUCCESS;
}
/* Create the subpicture unit */
p_spu = decoder_NewSubpictureText( p_dec );
if( !p_spu )
{
text_segment_Delete( p_segment3g->s );
free( p_segment3g );
return VLCDEC_SUCCESS;
}
subpicture_updater_sys_t *p_spu_sys = p_spu->updater.p_sys;
/* Parse our styles */
while( (size_t)(p_buf - p_block->p_buffer) + 8 < p_block->i_buffer )
{
uint32_t i_atomsize = GetDWBE( p_buf );
vlc_fourcc_t i_atomtype = VLC_FOURCC(p_buf[4],p_buf[5],p_buf[6],p_buf[7]);
p_buf += 8;
switch( i_atomtype )
{
case VLC_FOURCC('s','t','y','l'):
{
if ( (size_t)(p_buf - p_block->p_buffer) < 14 ) break;
uint16_t i_nbrecords = GetWBE(p_buf);
uint16_t i_cur_record = 0;
p_buf += 2;
while( i_cur_record++ < i_nbrecords )
{
if ( (size_t)(p_buf - p_block->p_buffer) < 12 ) break;
uint16_t i_start = __MIN( GetWBE(p_buf), i_psz_bytelength - 1 );
uint16_t i_end = __MIN( GetWBE(p_buf + 2), i_psz_bytelength - 1 );
text_style_t style;
memset( &style, 0, sizeof(text_style_t) );
style.i_style_flags = ConvertFlags( p_buf[6] );
style.i_font_size = p_buf[7];
style.i_font_color = GetDWBE(p_buf+8) >> 8;// RGBA -> RGB
style.i_font_alpha = GetDWBE(p_buf+8) & 0xFF;
style.i_features = STYLE_HAS_FONT_COLOR | STYLE_HAS_FONT_ALPHA;
ApplySegmentStyle( &p_segment3g, i_start, i_end, &style );
if ( i_nbrecords == 1 )
{
if ( p_buf[6] )
{
if( (p_spu_sys->p_default_style->i_style_flags = ConvertFlags( p_buf[6] )) )
p_spu_sys->p_default_style->i_features |= STYLE_HAS_FLAGS;
}
p_spu_sys->p_default_style->i_font_size = p_buf[7];
p_spu_sys->p_default_style->i_font_color = GetDWBE(p_buf+8) >> 8;// RGBA -> ARGB
p_spu_sys->p_default_style->i_font_alpha = (GetDWBE(p_buf+8) & 0xFF) << 24;
p_spu_sys->p_default_style->i_features |= (STYLE_HAS_FONT_COLOR | STYLE_HAS_FONT_ALPHA);
}
p_buf += 12;
}
} break;
case VLC_FOURCC('d','r','p','o'):
if ( (size_t)(p_buf - p_block->p_buffer) < 4 ) break;
p_spu_sys->p_default_style->i_shadow_width = __MAX( GetWBE(p_buf), GetWBE(p_buf+2) );
break;
case VLC_FOURCC('d','r','p','t'):
if ( (size_t)(p_buf - p_block->p_buffer) < 2 ) break;
p_spu_sys->p_default_style->i_shadow_alpha = GetWBE(p_buf);
p_spu_sys->p_default_style->i_features |= STYLE_HAS_SHADOW_ALPHA;
break;
default:
break;
}
p_buf += i_atomsize;
}
p_spu->i_start = p_block->i_pts;
p_spu->i_stop = p_block->i_pts + p_block->i_length;
p_spu->b_ephemer = (p_block->i_length == 0);
p_spu->b_absolute = false;
p_spu_sys->region.inner_align = SUBPICTURE_ALIGN_BOTTOM;
FontSizeConvert( p_dec->fmt_in.subs.p_style, p_spu_sys->p_default_style );
/* Unwrap */
text_segment_t *p_text_segments = p_segment3g->s;
text_segment_t *p_cur = p_text_segments;
while( p_segment3g )
{
FontSizeConvert( p_dec->fmt_in.subs.p_style, p_segment3g->s->style );
tx3g_segment_t * p_old = p_segment3g;
p_segment3g = p_segment3g->p_next3g;
free( p_old );
if( p_segment3g )
p_cur->p_next = p_segment3g->s;
p_cur = p_cur->p_next;
}
p_spu_sys->region.p_segments = p_text_segments;
block_Release( p_block );
decoder_QueueSub( p_dec, p_spu );
return VLCDEC_SUCCESS;
}