1 /*****************************************************************************
2 * SSA/ASS subtitle decoder using libass.
3 *****************************************************************************
4 * Copyright (C) 2008-2009 VLC authors and VideoLAN
7 * Authors: Laurent Aimar <fenrir@videolan.org>
9 * This program is free software; you can redistribute it and/or modify it
10 * under the terms of the GNU Lesser General Public License as published by
11 * the Free Software Foundation; either version 2.1 of the License, or
12 * (at your option) any later version.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public License
20 * along with this program; if not, write to the Free Software Foundation,
21 * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
22 *****************************************************************************/
24 /*****************************************************************************
26 *****************************************************************************/
37 #include <vlc_common.h>
38 #include <vlc_plugin.h>
39 #include <vlc_codec.h>
40 #include <vlc_input.h>
41 #include <vlc_dialog.h>
46 # include <vlc_charset.h>
49 /*****************************************************************************
51 *****************************************************************************/
52 static int Create ( vlc_object_t
* );
53 static void Destroy( vlc_object_t
* );
56 set_shortname( N_("Subtitles (advanced)"))
57 set_description( N_("Subtitle renderers using libass") )
58 set_capability( "spu decoder", 100 )
59 set_category( CAT_INPUT
)
60 set_subcategory( SUBCAT_INPUT_SCODEC
)
61 set_callbacks( Create
, Destroy
)
64 /*****************************************************************************
66 *****************************************************************************/
67 static int DecodeBlock( decoder_t
*, block_t
* );
68 static void Flush( decoder_t
* );
75 /* The following fields of decoder_sys_t are shared between decoder and spu units */
80 ASS_Library
*p_library
;
81 ASS_Renderer
*p_renderer
;
87 static void DecSysRelease( decoder_sys_t
*p_sys
);
88 static void DecSysHold( decoder_sys_t
*p_sys
);
91 static int SubpictureValidate( subpicture_t
*,
92 bool, const video_format_t
*,
93 bool, const video_format_t
*,
95 static void SubpictureUpdate( subpicture_t
*,
96 const video_format_t
*,
97 const video_format_t
*,
99 static void SubpictureDestroy( subpicture_t
* );
101 struct subpicture_updater_sys_t
103 decoder_sys_t
*p_dec_sys
;
119 static int BuildRegions( rectangle_t
*p_region
, int i_max_region
, ASS_Image
*p_img_list
, int i_width
, int i_height
);
120 static void RegionDraw( subpicture_region_t
*p_region
, ASS_Image
*p_img
);
122 //#define DEBUG_REGION
124 /*****************************************************************************
125 * Create: Open libass decoder.
126 *****************************************************************************/
127 static int Create( vlc_object_t
*p_this
)
129 decoder_t
*p_dec
= (decoder_t
*)p_this
;
130 decoder_sys_t
*p_sys
;
132 if( p_dec
->fmt_in
.i_codec
!= VLC_CODEC_SSA
)
135 p_dec
->pf_decode
= DecodeBlock
;
136 p_dec
->pf_flush
= Flush
;
138 p_dec
->p_sys
= p_sys
= malloc( sizeof( decoder_sys_t
) );
143 vlc_mutex_init( &p_sys
->lock
);
144 p_sys
->i_refcount
= 1;
145 memset( &p_sys
->fmt
, 0, sizeof(p_sys
->fmt
) );
146 p_sys
->i_max_stop
= VLC_TS_INVALID
;
147 p_sys
->p_library
= NULL
;
148 p_sys
->p_renderer
= NULL
;
149 p_sys
->p_track
= NULL
;
151 /* Create libass library */
152 ASS_Library
*p_library
= p_sys
->p_library
= ass_library_init();
155 msg_Warn( p_dec
, "Libass library creation failed" );
156 DecSysRelease( p_sys
);
160 /* load attachments */
161 input_attachment_t
**pp_attachments
;
163 if( decoder_GetInputAttachments( p_dec
, &pp_attachments
, &i_attachments
))
166 pp_attachments
= NULL
;
168 for( int k
= 0; k
< i_attachments
; k
++ )
170 input_attachment_t
*p_attach
= pp_attachments
[k
];
175 if( !strcasecmp( p_attach
->psz_mime
, "application/x-truetype-font" ) )
178 else if( !found
&& strlen( p_attach
->psz_name
) > 4 )
180 char *ext
= p_attach
->psz_name
+ strlen( p_attach
->psz_name
) - 4;
182 if( !strcasecmp( ext
, ".ttf" ) || !strcasecmp( ext
, ".otf" ) || !strcasecmp( ext
, ".ttc" ) )
188 msg_Dbg( p_dec
, "adding embedded font %s", p_attach
->psz_name
);
190 ass_add_font( p_sys
->p_library
, p_attach
->psz_name
, p_attach
->p_data
, p_attach
->i_data
);
192 vlc_input_attachment_Delete( p_attach
);
194 free( pp_attachments
);
196 ass_set_extract_fonts( p_library
, true );
197 ass_set_style_overrides( p_library
, NULL
);
199 /* Create the renderer */
200 ASS_Renderer
*p_renderer
= p_sys
->p_renderer
= ass_renderer_init( p_library
);
203 msg_Warn( p_dec
, "Libass renderer creation failed" );
204 DecSysRelease( p_sys
);
208 ass_set_use_margins( p_renderer
, false);
210 // ass_set_margins( p_renderer, int t, int b, int l, int r);
211 ass_set_font_scale( p_renderer
, 1.0 );
212 ass_set_line_spacing( p_renderer
, 0.0 );
214 #if defined( __ANDROID__ )
215 const char *psz_font
, *psz_family
;
216 const char *psz_font_droid
= "/system/fonts/DroidSans-Bold.ttf";
217 const char *psz_family_droid
= "Droid Sans Bold";
218 const char *psz_font_noto
= "/system/fonts/NotoSansCJK-Regular.ttc";
219 const char *psz_family_noto
= "Noto Sans";
221 // Workaround for Android 5.0+, since libass doesn't parse the XML yet
222 if( access( psz_font_noto
, R_OK
) != -1 )
224 psz_font
= psz_font_noto
;
225 psz_family
= psz_family_noto
;
229 psz_font
= psz_font_droid
;
230 psz_family
= psz_family_droid
;
233 #elif defined( __APPLE__ )
234 const char *psz_font
= NULL
; /* We don't ship a default font with VLC */
235 const char *psz_family
= "Helvetica Neue"; /* Use HN if we can't find anything more suitable - Arial is not on all Apple platforms */
237 const char *psz_font
= NULL
; /* We don't ship a default font with VLC */
238 const char *psz_family
= "Arial"; /* Use Arial if we can't find anything more suitable */
241 #ifdef HAVE_FONTCONFIG
243 vlc_dialog_id
*p_dialog_id
=
244 vlc_dialog_display_progress( p_dec
, true, 0.0, NULL
,
245 _("Building font cache"),
246 _( "Please wait while your font cache is rebuilt.\n"
247 "This should take less than a minute." ) );
249 ass_set_fonts( p_renderer
, psz_font
, psz_family
, ASS_FONTPROVIDER_AUTODETECT
, NULL
, 1 ); // setup default font/family
251 if( p_dialog_id
!= 0 )
252 vlc_dialog_release( p_dec
, p_dialog_id
);
255 ass_set_fonts( p_renderer
, psz_font
, psz_family
, ASS_FONTPROVIDER_AUTODETECT
, NULL
, 0 );
258 /* Anything else than NONE will break smooth img updating.
259 TODO: List and force ASS_HINTING_LIGHT for known problematic fonts */
260 ass_set_hinting( p_renderer
, ASS_HINTING_NONE
);
263 ASS_Track
*p_track
= p_sys
->p_track
= ass_new_track( p_sys
->p_library
);
266 DecSysRelease( p_sys
);
269 ass_process_codec_private( p_track
, p_dec
->fmt_in
.p_extra
, p_dec
->fmt_in
.i_extra
);
271 p_dec
->fmt_out
.i_codec
= VLC_CODEC_RGBA
;
276 /*****************************************************************************
278 *****************************************************************************/
279 static void Destroy( vlc_object_t
*p_this
)
281 decoder_t
*p_dec
= (decoder_t
*)p_this
;
283 DecSysRelease( p_dec
->p_sys
);
286 static void DecSysHold( decoder_sys_t
*p_sys
)
288 vlc_mutex_lock( &p_sys
->lock
);
290 vlc_mutex_unlock( &p_sys
->lock
);
292 static void DecSysRelease( decoder_sys_t
*p_sys
)
295 vlc_mutex_lock( &p_sys
->lock
);
297 if( p_sys
->i_refcount
> 0 )
299 vlc_mutex_unlock( &p_sys
->lock
);
302 vlc_mutex_unlock( &p_sys
->lock
);
303 vlc_mutex_destroy( &p_sys
->lock
);
306 ass_free_track( p_sys
->p_track
);
307 if( p_sys
->p_renderer
)
308 ass_renderer_done( p_sys
->p_renderer
);
309 if( p_sys
->p_library
)
310 ass_library_done( p_sys
->p_library
);
315 /*****************************************************************************
317 *****************************************************************************/
318 static void Flush( decoder_t
*p_dec
)
320 decoder_sys_t
*p_sys
= p_dec
->p_sys
;
322 p_sys
->i_max_stop
= VLC_TS_INVALID
;
325 /****************************************************************************
327 ****************************************************************************/
328 static int DecodeBlock( decoder_t
*p_dec
, block_t
*p_block
)
330 decoder_sys_t
*p_sys
= p_dec
->p_sys
;
332 subpicture_t
*p_spu
= NULL
;
334 if( p_block
== NULL
) /* No Drain */
335 return VLCDEC_SUCCESS
;
337 if( p_block
->i_flags
& BLOCK_FLAG_CORRUPTED
)
340 block_Release( p_block
);
341 return VLCDEC_SUCCESS
;
344 if( p_block
->i_buffer
== 0 || p_block
->p_buffer
[0] == '\0' )
346 block_Release( p_block
);
347 return VLCDEC_SUCCESS
;
350 subpicture_updater_sys_t
*p_spu_sys
= malloc( sizeof(*p_spu_sys
) );
353 block_Release( p_block
);
354 return VLCDEC_SUCCESS
;
357 subpicture_updater_t updater
= {
358 .pf_validate
= SubpictureValidate
,
359 .pf_update
= SubpictureUpdate
,
360 .pf_destroy
= SubpictureDestroy
,
363 p_spu
= decoder_NewSubpicture( p_dec
, &updater
);
366 msg_Warn( p_dec
, "can't get spu buffer" );
368 block_Release( p_block
);
369 return VLCDEC_SUCCESS
;
372 p_spu_sys
->p_img
= NULL
;
373 p_spu_sys
->p_dec_sys
= p_sys
;
374 p_spu_sys
->i_subs_len
= p_block
->i_buffer
;
375 p_spu_sys
->p_subs_data
= malloc( p_block
->i_buffer
);
376 p_spu_sys
->i_pts
= p_block
->i_pts
;
377 if( !p_spu_sys
->p_subs_data
)
379 subpicture_Delete( p_spu
);
380 block_Release( p_block
);
381 return VLCDEC_SUCCESS
;
383 memcpy( p_spu_sys
->p_subs_data
, p_block
->p_buffer
,
386 p_spu
->i_start
= p_block
->i_pts
;
387 p_spu
->i_stop
= __MAX( p_sys
->i_max_stop
, p_block
->i_pts
+ p_block
->i_length
);
388 p_spu
->b_ephemer
= true;
389 p_spu
->b_absolute
= true;
391 p_sys
->i_max_stop
= p_spu
->i_stop
;
393 vlc_mutex_lock( &p_sys
->lock
);
396 ass_process_chunk( p_sys
->p_track
, p_spu_sys
->p_subs_data
, p_spu_sys
->i_subs_len
,
397 p_block
->i_pts
/ 1000, p_block
->i_length
/ 1000 );
399 vlc_mutex_unlock( &p_sys
->lock
);
401 DecSysHold( p_sys
); /* Keep a reference for the returned subpicture */
403 block_Release( p_block
);
405 decoder_QueueSub( p_dec
, p_spu
);
406 return VLCDEC_SUCCESS
;
409 /****************************************************************************
411 ****************************************************************************/
412 static int SubpictureValidate( subpicture_t
*p_subpic
,
413 bool b_fmt_src
, const video_format_t
*p_fmt_src
,
414 bool b_fmt_dst
, const video_format_t
*p_fmt_dst
,
417 decoder_sys_t
*p_sys
= p_subpic
->updater
.p_sys
->p_dec_sys
;
419 vlc_mutex_lock( &p_sys
->lock
);
421 video_format_t fmt
= *p_fmt_dst
;
422 fmt
.i_chroma
= VLC_CODEC_RGBA
;
423 fmt
.i_bits_per_pixel
= 0;
426 if( b_fmt_src
|| b_fmt_dst
)
428 ass_set_frame_size( p_sys
->p_renderer
, fmt
.i_visible_width
, fmt
.i_visible_height
);
429 const double src_ratio
= (double)p_fmt_src
->i_visible_width
/ p_fmt_src
->i_visible_height
;
430 const double dst_ratio
= (double)p_fmt_dst
->i_visible_width
/ p_fmt_dst
->i_visible_height
;
431 ass_set_aspect_ratio( p_sys
->p_renderer
, dst_ratio
/ src_ratio
, 1 );
436 const mtime_t i_stream_date
= p_subpic
->updater
.p_sys
->i_pts
+ (i_ts
- p_subpic
->i_start
);
438 ASS_Image
*p_img
= ass_render_frame( p_sys
->p_renderer
, p_sys
->p_track
,
439 i_stream_date
/1000, &i_changed
);
441 if( !i_changed
&& !b_fmt_src
&& !b_fmt_dst
&&
442 (p_img
!= NULL
) == (p_subpic
->p_region
!= NULL
) )
444 vlc_mutex_unlock( &p_sys
->lock
);
447 p_subpic
->updater
.p_sys
->p_img
= p_img
;
449 /* The lock is released by SubpictureUpdate */
453 static void SubpictureUpdate( subpicture_t
*p_subpic
,
454 const video_format_t
*p_fmt_src
,
455 const video_format_t
*p_fmt_dst
,
458 VLC_UNUSED( p_fmt_src
); VLC_UNUSED( p_fmt_dst
); VLC_UNUSED( i_ts
);
460 decoder_sys_t
*p_sys
= p_subpic
->updater
.p_sys
->p_dec_sys
;
462 video_format_t fmt
= p_sys
->fmt
;
463 ASS_Image
*p_img
= p_subpic
->updater
.p_sys
->p_img
;
466 p_subpic
->i_original_picture_height
= fmt
.i_visible_height
;
467 p_subpic
->i_original_picture_width
= fmt
.i_visible_width
;
469 /* XXX to improve efficiency we merge regions that are close minimizing
471 * libass tends to create a lot of small regions and thus spu engine
472 * reinstanciate a lot the scaler, and as we do not support subpel blending
473 * it looks ugly (text unaligned).
475 const int i_max_region
= 4;
476 rectangle_t region
[i_max_region
];
477 const int i_region
= BuildRegions( region
, i_max_region
, p_img
, fmt
.i_width
, fmt
.i_height
);
481 vlc_mutex_unlock( &p_sys
->lock
);
485 /* Allocate the regions and draw them */
486 subpicture_region_t
**pp_region_last
= &p_subpic
->p_region
;
488 for( int i
= 0; i
< i_region
; i
++ )
490 subpicture_region_t
*r
;
491 video_format_t fmt_region
;
496 fmt_region
.i_visible_width
= region
[i
].x1
- region
[i
].x0
;
497 fmt_region
.i_height
=
498 fmt_region
.i_visible_height
= region
[i
].y1
- region
[i
].y0
;
500 r
= subpicture_region_New( &fmt_region
);
503 r
->i_x
= region
[i
].x0
;
504 r
->i_y
= region
[i
].y0
;
505 r
->i_align
= SUBPICTURE_ALIGN_TOP
| SUBPICTURE_ALIGN_LEFT
;
508 RegionDraw( r
, p_img
);
512 pp_region_last
= &r
->p_next
;
514 vlc_mutex_unlock( &p_sys
->lock
);
517 static void SubpictureDestroy( subpicture_t
*p_subpic
)
519 subpicture_updater_sys_t
*p_sys
= p_subpic
->updater
.p_sys
;
521 DecSysRelease( p_sys
->p_dec_sys
);
522 free( p_sys
->p_subs_data
);
526 static rectangle_t
r_create( int x0
, int y0
, int x1
, int y1
)
528 rectangle_t r
= { x0
, y0
, x1
, y1
};
531 static rectangle_t
r_img( const ASS_Image
*p_img
)
533 return r_create( p_img
->dst_x
, p_img
->dst_y
, p_img
->dst_x
+p_img
->w
, p_img
->dst_y
+p_img
->h
);
535 static void r_add( rectangle_t
*r
, const rectangle_t
*n
)
537 r
->x0
= __MIN( r
->x0
, n
->x0
);
538 r
->y0
= __MIN( r
->y0
, n
->y0
);
539 r
->x1
= __MAX( r
->x1
, n
->x1
);
540 r
->y1
= __MAX( r
->y1
, n
->y1
);
542 static int r_surface( const rectangle_t
*r
)
544 return (r
->x1
-r
->x0
) * (r
->y1
-r
->y0
);
546 static bool r_overlap( const rectangle_t
*a
, const rectangle_t
*b
, int i_dx
, int i_dy
)
548 return __MAX(a
->x0
-i_dx
, b
->x0
) < __MIN( a
->x1
+i_dx
, b
->x1
) &&
549 __MAX(a
->y0
-i_dy
, b
->y0
) < __MIN( a
->y1
+i_dy
, b
->y1
);
552 static int BuildRegions( rectangle_t
*p_region
, int i_max_region
, ASS_Image
*p_img_list
, int i_width
, int i_height
)
558 int64_t i_ck_start
= mdate();
561 for( p_tmp
= p_img_list
, i_count
= 0; p_tmp
!= NULL
; p_tmp
= p_tmp
->next
)
562 if( p_tmp
->w
> 0 && p_tmp
->h
> 0 )
567 ASS_Image
**pp_img
= calloc( i_count
, sizeof(*pp_img
) );
571 for( p_tmp
= p_img_list
, i_count
= 0; p_tmp
!= NULL
; p_tmp
= p_tmp
->next
)
572 if( p_tmp
->w
> 0 && p_tmp
->h
> 0 )
573 pp_img
[i_count
++] = p_tmp
;
576 const int i_w_inc
= __MAX( ( i_width
+ 49 ) / 50, 32 );
577 const int i_h_inc
= __MAX( ( i_height
+ 99 ) / 100, 32 );
578 int i_maxh
= i_w_inc
;
579 int i_maxw
= i_h_inc
;
581 rectangle_t region
[i_max_region
+1];
584 for( int i_used
= 0; i_used
< i_count
; )
587 for( n
= 0; n
< i_count
; n
++ )
592 assert( i_region
< i_max_region
+ 1 );
593 region
[i_region
++] = r_img( pp_img
[n
] );
594 pp_img
[n
] = NULL
; i_used
++;
599 for( n
= 0; n
< i_count
; n
++ )
601 ASS_Image
*p_img
= pp_img
[n
];
604 rectangle_t r
= r_img( p_img
);
608 int i_best_s
= INT_MAX
;
609 for( k
= 0; k
< i_region
; k
++ )
611 if( !r_overlap( ®ion
[k
], &r
, i_maxw
, i_maxh
) )
613 int s
= r_surface( &r
);
622 r_add( ®ion
[i_best
], &r
);
623 pp_img
[n
] = NULL
; i_used
++;
629 if( i_region
> i_max_region
)
633 int i_best_ds
= INT_MAX
;
636 for( int i
= 0; i
< i_region
; i
++ )
638 for( int j
= i
+1; j
< i_region
; j
++ )
640 rectangle_t rect
= region
[i
];
641 r_add( &rect
, ®ion
[j
] );
642 int ds
= r_surface( &rect
) - r_surface( ®ion
[i
] ) - r_surface( ®ion
[j
] );
653 msg_Err( p_spu
, "Merging %d and %d", i_best_i
, i_best_j
);
655 if( i_best_j
>= 0 && i_best_i
>= 0 )
657 r_add( ®ion
[i_best_i
], ®ion
[i_best_j
] );
659 if( i_best_j
+1 < i_region
)
660 memmove( ®ion
[i_best_j
], ®ion
[i_best_j
+1], sizeof(*region
) * ( i_region
- (i_best_j
+1) ) );
667 for( int n
= 0; n
< i_region
; n
++ )
668 p_region
[n
] = region
[n
];
671 int64_t i_ck_time
= mdate() - i_ck_start
;
672 msg_Err( p_spu
, "ASS: %d objects merged into %d region in %d micros", i_count
, i_region
, (int)(i_ck_time
) );
680 static void RegionDraw( subpicture_region_t
*p_region
, ASS_Image
*p_img
)
682 const plane_t
*p
= &p_region
->p_picture
->p
[0];
683 const int i_x
= p_region
->i_x
;
684 const int i_y
= p_region
->i_y
;
685 const int i_width
= p_region
->fmt
.i_width
;
686 const int i_height
= p_region
->fmt
.i_height
;
688 memset( p
->p_pixels
, 0x00, p
->i_pitch
* p
->i_lines
);
689 for( ; p_img
!= NULL
; p_img
= p_img
->next
)
691 if( p_img
->dst_x
< i_x
|| p_img
->dst_x
+ p_img
->w
> i_x
+ i_width
||
692 p_img
->dst_y
< i_y
|| p_img
->dst_y
+ p_img
->h
> i_y
+ i_height
)
695 const unsigned r
= (p_img
->color
>> 24)&0xff;
696 const unsigned g
= (p_img
->color
>> 16)&0xff;
697 const unsigned b
= (p_img
->color
>> 8)&0xff;
698 const unsigned a
= (p_img
->color
)&0xff;
701 for( y
= 0; y
< p_img
->h
; y
++ )
703 for( x
= 0; x
< p_img
->w
; x
++ )
705 const unsigned alpha
= p_img
->bitmap
[y
*p_img
->stride
+x
];
706 const unsigned an
= (255 - a
) * alpha
/ 255;
708 uint8_t *p_rgba
= &p
->p_pixels
[(y
+p_img
->dst_y
-i_y
) * p
->i_pitch
+ 4 * (x
+p_img
->dst_x
-i_x
)];
709 const unsigned ao
= p_rgba
[3];
711 /* Native endianness, but RGBA ordering */
714 /* Optimized but the else{} will produce the same result */
722 p_rgba
[3] = 255 - ( 255 - p_rgba
[3] ) * ( 255 - an
) / 255;
725 p_rgba
[0] = ( p_rgba
[0] * ao
* (255-an
) / 255 + r
* an
) / p_rgba
[3];
726 p_rgba
[1] = ( p_rgba
[1] * ao
* (255-an
) / 255 + g
* an
) / p_rgba
[3];
727 p_rgba
[2] = ( p_rgba
[2] * ao
* (255-an
) / 255 + b
* an
) / p_rgba
[3];
735 /* XXX Draw a box for debug */
736 #define P(x,y) ((uint32_t*)&p->p_pixels[(y)*p->i_pitch + 4*(x)])
737 for( int y
= 0; y
< p
->i_lines
; y
++ )
738 *P(0,y
) = *P(p
->i_visible_pitch
/4-1,y
) = 0xff000000;
739 for( int x
= 0; x
< p
->i_visible_pitch
; x
++ )
740 *P(x
/4,0) = *P(x
/4,p
->i_visible_lines
-1) = 0xff000000;